/*
     File:       QuickTimeComponents.h
 
     Contains:   QuickTime Interfaces.
 
     Version:    Technology: QuickTime 5.0
                 Release:    QuickTime 5.0.1
 
     Copyright:  (c) 1990-2001 by Apple Computer, Inc., all rights reserved
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://developer.apple.com/bugreporter/
 
*/
#ifndef __QUICKTIMECOMPONENTS__
#define __QUICKTIMECOMPONENTS__

#ifndef __MACTYPES__
#include <MacTypes.h>
#endif

#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif

#ifndef __COMPONENTS__
#include <Components.h>
#endif

#ifndef __IMAGECOMPRESSION__
#include <ImageCompression.h>
#endif

#ifndef __MOVIES__
#include <Movies.h>
#endif

#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif

#ifndef __VIDEO__
#include <Video.h>
#endif

#ifndef __SOUND__
#include <Sound.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'),       /* subtype: 60ths since boot   */
    systemSecondClock           = FOUR_CHAR_CODE('seco'),       /* subtype: seconds since 1904       */
    systemMillisecondClock      = FOUR_CHAR_CODE('mill'),       /* subtype: 1000ths since boot       */
    systemMicrosecondClock      = FOUR_CHAR_CODE('micr')        /* subtype: 1000000ths since boot */
};

enum {
    kClockRateIsLinear          = 1,
    kClockImplementsCallBacks   = 2,
    kClockCanHandleIntermittentSound = 4                        /* sound clocks only */
};

#if OLDROUTINENAMES
#define GetClockTime(aClock, out) ClockGetTime(aClock, out)
#endif
/** These are Clock procedures **/
EXTERN_API( ComponentResult )
ClockGetTime                    (ComponentInstance      aClock,
                                 TimeRecord *           out)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A);


EXTERN_API( QTCallBack )
ClockNewCallBack                (ComponentInstance      aClock,
                                 TimeBase               tb,
                                 short                  callBackType)                       FIVEWORDINLINE(0x2F3C, 0x0006, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockDisposeCallBack            (ComponentInstance      aClock,
                                 QTCallBack             cb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockCallMeWhen                 (ComponentInstance      aClock,
                                 QTCallBack             cb,
                                 long                   param1,
                                 long                   param2,
                                 long                   param3)                             FIVEWORDINLINE(0x2F3C, 0x0010, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockCancelCallBack             (ComponentInstance      aClock,
                                 QTCallBack             cb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockRateChanged                (ComponentInstance      aClock,
                                 QTCallBack             cb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0006, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockTimeChanged                (ComponentInstance      aClock,
                                 QTCallBack             cb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockSetTimeBase                (ComponentInstance      aClock,
                                 TimeBase               tb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0008, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockStartStopChanged           (ComponentInstance      aClock,
                                 QTCallBack             cb,
                                 Boolean                startChanged,
                                 Boolean                stopChanged)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0009, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
ClockGetRate                    (ComponentInstance      aClock,
                                 Fixed *                rate)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x000A, 0x7000, 0xA82A);




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;
/*  Preference flags.*/
enum {
    scListEveryCodec            = 1L << 1,
    scAllowZeroFrameRate        = 1L << 2,
    scAllowZeroKeyFrameRate     = 1L << 3,
    scShowBestDepth             = 1L << 4,
    scUseMovableModal           = 1L << 5,
    scDisableFrameRateItem      = 1L << 6,
    scShowDataRateAsKilobits    = 1L << 7
};


/*  Possible test flags for setting test image.*/
enum {
    scPreferCropping            = 1 << 0,
    scPreferScaling             = 1 << 1,
    scPreferScalingAndCropping  = scPreferScaling | scPreferCropping,
    scDontDetermineSettingsFromTestImage = 1 << 2
};


/*  Dimensions of the image preview box.*/
enum {
    scTestImageWidth            = 80,
    scTestImageHeight           = 80
};

/*  Possible items returned by hookProc.*/
enum {
    scOKItem                    = 1,
    scCancelItem                = 2,
    scCustomItem                = 3
};

/*  Result returned when user cancelled.*/
enum {
    scUserCancelled             = 1
};



/* Component selectors*/
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
};

/*  Get/SetInfo structures.*/


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;
/*  Get/SetInfo selectors*/
enum {
    scSpatialSettingsType       = FOUR_CHAR_CODE('sptl'),       /* pointer to SCSpatialSettings struct*/
    scTemporalSettingsType      = FOUR_CHAR_CODE('tprl'),       /* pointer to SCTemporalSettings struct*/
    scDataRateSettingsType      = FOUR_CHAR_CODE('drat'),       /* pointer to SCDataRateSettings struct*/
    scColorTableType            = FOUR_CHAR_CODE('clut'),       /* pointer to CTabHandle*/
    scProgressProcType          = FOUR_CHAR_CODE('prog'),       /* pointer to ProgressRecord struct*/
    scExtendedProcsType         = FOUR_CHAR_CODE('xprc'),       /* pointer to SCExtendedProcs struct*/
    scPreferenceFlagsType       = FOUR_CHAR_CODE('pref'),       /* pointer to long*/
    scSettingsStateType         = FOUR_CHAR_CODE('ssta'),       /* pointer to Handle*/
    scSequenceIDType            = FOUR_CHAR_CODE('sequ'),       /* pointer to ImageSequence*/
    scWindowPositionType        = FOUR_CHAR_CODE('wndw'),       /* pointer to Point*/
    scCodecFlagsType            = FOUR_CHAR_CODE('cflg'),       /* pointer to CodecFlags*/
    scCodecSettingsType         = FOUR_CHAR_CODE('cdec'),       /* pointer to Handle*/
    scForceKeyValueType         = FOUR_CHAR_CODE('ksim'),       /* pointer to long*/
    scSoundSampleRateType       = FOUR_CHAR_CODE('ssrt'),       /* pointer to UnsignedFixed*/
    scSoundSampleSizeType       = FOUR_CHAR_CODE('ssss'),       /* pointer to short*/
    scSoundChannelCountType     = FOUR_CHAR_CODE('sscc'),       /* pointer to short*/
    scSoundCompressionType      = FOUR_CHAR_CODE('ssct'),       /* pointer to OSType*/
    scCompressionListType       = FOUR_CHAR_CODE('ctyl'),       /* pointer to OSType Handle*/
    scCodecManufacturerType     = FOUR_CHAR_CODE('cmfr')        /* pointer to OSType*/
};

/*  scTypeNotFoundErr returned by Get/SetInfo when type cannot be found.*/



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
};

/* QTAtomTypes for atoms found in settings atom containers*/
enum {
    kQTSettingsVideo            = FOUR_CHAR_CODE('vide'),       /* Container for video/image compression related atoms (Get/SetInfo selectors)*/
    kQTSettingsSound            = FOUR_CHAR_CODE('soun'),       /* Container for sound compression related atoms (Get/SetInfo selectors)*/
    kQTSettingsComponentVersion = FOUR_CHAR_CODE('vers')        /* . Version of component that wrote settings (QTSettingsVersionAtomRecord)*/
};

/* Format of 'vers' atom found in settings atom containers*/

struct QTSettingsVersionAtomRecord {
    long                            componentVersion;           /* standard compression component version*/
    short                           flags;                      /* low bit is 1 if little endian platform, 0 if big endian platform*/
    short                           reserved;                   /* should be 0*/
};
typedef struct QTSettingsVersionAtomRecord QTSettingsVersionAtomRecord;
#define SCGetCompression(ci, params, where) SCGetCompressionExtended(ci,params,where,0,0,0,0)
/** These are Progress procedures **/
EXTERN_API( ComponentResult )
SCGetCompressionExtended        (ComponentInstance      ci,
                                 SCParams *             params,
                                 Point                  where,
                                 SCModalFilterUPP       filterProc,
                                 SCModalHookUPP         hookProc,
                                 long                   refcon,
                                 StringPtr              customName)                         FIVEWORDINLINE(0x2F3C, 0x0018, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCPositionRect                  (ComponentInstance      ci,
                                 Rect *                 rp,
                                 Point *                where)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCPositionDialog                (ComponentInstance      ci,
                                 short                  id,
                                 Point *                where)                              FIVEWORDINLINE(0x2F3C, 0x0006, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCSetTestImagePictHandle        (ComponentInstance      ci,
                                 PicHandle              testPict,
                                 Rect *                 testRect,
                                 short                  testFlags)                          FIVEWORDINLINE(0x2F3C, 0x000A, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCSetTestImagePictFile          (ComponentInstance      ci,
                                 short                  testFileRef,
                                 Rect *                 testRect,
                                 short                  testFlags)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0005, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCSetTestImagePixMap            (ComponentInstance      ci,
                                 PixMapHandle           testPixMap,
                                 Rect *                 testRect,
                                 short                  testFlags)                          FIVEWORDINLINE(0x2F3C, 0x000A, 0x0006, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCGetBestDeviceRect             (ComponentInstance      ci,
                                 Rect *                 r)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);


EXTERN_API( ComponentResult )
SCRequestImageSettings          (ComponentInstance      ci)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x000A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCCompressImage                 (ComponentInstance      ci,
                                 PixMapHandle           src,
                                 const Rect *           srcRect,
                                 ImageDescriptionHandle * desc,
                                 Handle *               data)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x000B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCCompressPicture               (ComponentInstance      ci,
                                 PicHandle              srcPicture,
                                 PicHandle              dstPicture)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x000C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCCompressPictureFile           (ComponentInstance      ci,
                                 short                  srcRefNum,
                                 short                  dstRefNum)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCRequestSequenceSettings       (ComponentInstance      ci)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x000E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCCompressSequenceBegin         (ComponentInstance      ci,
                                 PixMapHandle           src,
                                 const Rect *           srcRect,
                                 ImageDescriptionHandle * desc)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x000F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCCompressSequenceFrame         (ComponentInstance      ci,
                                 PixMapHandle           src,
                                 const Rect *           srcRect,
                                 Handle *               data,
                                 long *                 dataSize,
                                 short *                notSyncFlag)                        FIVEWORDINLINE(0x2F3C, 0x0014, 0x0010, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCCompressSequenceEnd           (ComponentInstance      ci)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0011, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCDefaultPictHandleSettings     (ComponentInstance      ci,
                                 PicHandle              srcPicture,
                                 short                  motion)                             FIVEWORDINLINE(0x2F3C, 0x0006, 0x0012, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCDefaultPictFileSettings       (ComponentInstance      ci,
                                 short                  srcRef,
                                 short                  motion)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0013, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCDefaultPixMapSettings         (ComponentInstance      ci,
                                 PixMapHandle           src,
                                 short                  motion)                             FIVEWORDINLINE(0x2F3C, 0x0006, 0x0014, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCGetInfo                       (ComponentInstance      ci,
                                 OSType                 infoType,
                                 void *                 info)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x0015, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCSetInfo                       (ComponentInstance      ci,
                                 OSType                 infoType,
                                 void *                 info)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x0016, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCNewGWorld                     (ComponentInstance      ci,
                                 GWorldPtr *            gwp,
                                 Rect *                 rp,
                                 GWorldFlags            flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x0017, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCSetCompressFlags              (ComponentInstance      ci,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0018, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCGetCompressFlags              (ComponentInstance      ci,
                                 long *                 flags)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCGetSettingsAsText             (ComponentInstance      ci,
                                 Handle *               text)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCGetSettingsAsAtomContainer    (ComponentInstance      ci,
                                 QTAtomContainer *      settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCSetSettingsFromAtomContainer  (ComponentInstance      ci,
                                 QTAtomContainer        settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x001C, 0x7000, 0xA82A);

/* Note: if you're using SCCompressSequenceFrameAsync with a scForceKeyValue setting, you must call SCAsyncIdle occasionally at main task time. */
EXTERN_API( ComponentResult )
SCCompressSequenceFrameAsync    (ComponentInstance      ci,
                                 PixMapHandle           src,
                                 const Rect *           srcRect,
                                 Handle *               data,
                                 long *                 dataSize,
                                 short *                notSyncFlag,
                                 ICMCompletionProcRecordPtr  asyncCompletionProc)           FIVEWORDINLINE(0x2F3C, 0x0018, 0x001D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SCAsyncIdle                     (ComponentInstance      ci)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x001E, 0x7000, 0xA82A);




enum {
    TweenComponentType          = FOUR_CHAR_CODE('twen')
};


typedef ComponentInstance               TweenerComponent;
EXTERN_API( ComponentResult )
TweenerInitialize               (TweenerComponent       tc,
                                 QTAtomContainer        container,
                                 QTAtom                 tweenAtom,
                                 QTAtom                 dataAtom)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
TweenerDoTween                  (TweenerComponent       tc,
                                 TweenRecord *          tr)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
TweenerReset                    (TweenerComponent       tc)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0003, 0x7000, 0xA82A);



enum {
    TCSourceRefNameType         = FOUR_CHAR_CODE('name')
};

enum {
    tcDropFrame                 = 1 << 0,
    tc24HourMax                 = 1 << 1,
    tcNegTimesOK                = 1 << 2,
    tcCounter                   = 1 << 3
};


struct TimeCodeDef {
    long                            flags;                      /* drop-frame, etc.*/
    TimeScale                       fTimeScale;                 /* time scale of frameDuration (eg. 2997)*/
    TimeValue                       frameDuration;              /* duration of each frame (eg. 100)*/
    UInt8                           numFrames;                  /* frames/sec for timecode (eg. 30) OR frames/tick for counter mode*/
    UInt8                           padding;                    /* unused padding byte*/
};
typedef struct TimeCodeDef              TimeCodeDef;
enum {
    tctNegFlag                  = 0x80                          /* negative bit is in minutes*/
};


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;                   /* standard sample description header*/
    long                            dataFormat;
    long                            resvd1;
    short                           resvd2;
    short                           dataRefIndex;
    long                            flags;                      /* timecode specific stuff*/
    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;                        /* let's make it longword aligned - thanks.. */
    RGBColor                        foreColor;
    RGBColor                        backColor;
};
typedef struct TCTextOptions            TCTextOptions;
typedef TCTextOptions *                 TCTextOptionsPtr;
EXTERN_API( HandlerError )
TCGetCurrentTimeCode            (MediaHandler           mh,
                                 long *                 frameNum,
                                 TimeCodeDef *          tcdef,
                                 TimeCodeRecord *       tcrec,
                                 UserData *             srcRefH)                            FIVEWORDINLINE(0x2F3C, 0x0010, 0x0101, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCGetTimeCodeAtTime             (MediaHandler           mh,
                                 TimeValue              mediaTime,
                                 long *                 frameNum,
                                 TimeCodeDef *          tcdef,
                                 TimeCodeRecord *       tcdata,
                                 UserData *             srcRefH)                            FIVEWORDINLINE(0x2F3C, 0x0014, 0x0102, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCTimeCodeToString              (MediaHandler           mh,
                                 TimeCodeDef *          tcdef,
                                 TimeCodeRecord *       tcrec,
                                 StringPtr              tcStr)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x0103, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCTimeCodeToFrameNumber         (MediaHandler           mh,
                                 TimeCodeDef *          tcdef,
                                 TimeCodeRecord *       tcrec,
                                 long *                 frameNumber)                        FIVEWORDINLINE(0x2F3C, 0x000C, 0x0104, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCFrameNumberToTimeCode         (MediaHandler           mh,
                                 long                   frameNumber,
                                 TimeCodeDef *          tcdef,
                                 TimeCodeRecord *       tcrec)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x0105, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCGetSourceRef                  (MediaHandler           mh,
                                 TimeCodeDescriptionHandle  tcdH,
                                 UserData *             srefH)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0106, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCSetSourceRef                  (MediaHandler           mh,
                                 TimeCodeDescriptionHandle  tcdH,
                                 UserData               srefH)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0107, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCSetTimeCodeFlags              (MediaHandler           mh,
                                 long                   flags,
                                 long                   flagsMask)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0108, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCGetTimeCodeFlags              (MediaHandler           mh,
                                 long *                 flags)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0109, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCSetDisplayOptions             (MediaHandler           mh,
                                 TCTextOptionsPtr       textOptions)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x010A, 0x7000, 0xA82A);

EXTERN_API( HandlerError )
TCGetDisplayOptions             (MediaHandler           mh,
                                 TCTextOptionsPtr       textOptions)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x010B, 0x7000, 0xA82A);




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),                    /* the MIME type(s) is(are) new or has changed since the last time*/
                                                                /*  someone asked about it*/
    kQTMediaFileInfoHasChanged  = (1L << 2),                    /* the file extension(s) is(are) new or has changed since the last time*/
                                                                /*  anyone asked about it*/
    kQTMediaConfigCanUseApp     = (1L << 18),                   /* this MIME type can be configured to use app*/
    kQTMediaConfigCanUsePlugin  = (1L << 19),                   /* this MIME type can be configured to use plug-in*/
    kQTMediaConfigUNUSED        = (1L << 20),                   /* currently unused*/
    kQTMediaConfigBinaryFile    = (1L << 23),                   /* file should be transfered in binary mode*/
    kQTMediaConfigTextFile      = 0,                            /* not a bit, defined for clarity*/
    kQTMediaConfigMacintoshFile = (1L << 24),                   /* file's resource fork is significant*/
    kQTMediaConfigAssociateByDefault = (1L << 27),              /* take this file association by default*/
    kQTMediaConfigUseAppByDefault = (1L << 28),                 /* use the app by default for this MIME type*/
    kQTMediaConfigUsePluginByDefault = (1L << 29),              /* use the plug-in by default for this MIME type*/
    kQTMediaConfigDefaultsMask  = (kQTMediaConfigUseAppByDefault | kQTMediaConfigUsePluginByDefault),
    kQTMediaConfigDefaultsShift = 12                            /* ((flags & kQTMediaConfigDefaultsMask) >> kQTMediaConfigDefaultsShift) to get default setting*/
};


/* mime type group constants for groupID field of 'mcfg' resource*/
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')
};

/* file type group constants for groupID field of 'mcfg' resource*/
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')
};

/* QTAtomTypes for atoms in import/export settings containers*/
enum {
    kQTSettingsDVExportNTSC     = FOUR_CHAR_CODE('dvcv'),       /* True is export as NTSC, false is export as PAL. (Boolean)*/
    kQTSettingsDVExportLockedAudio = FOUR_CHAR_CODE('lock'),    /* True if audio locked to video. (Boolean)*/
    kQTSettingsEffect           = FOUR_CHAR_CODE('effe'),       /* Parent atom whose contents are atoms of an effects description*/
    kQTSettingsGraphicsFileImportSequence = FOUR_CHAR_CODE('sequ'), /* Parent atom of graphic file movie import component*/
    kQTSettingsGraphicsFileImportSequenceEnabled = FOUR_CHAR_CODE('enab'), /* . If true, import numbered image sequence (Boolean)*/
    kQTSettingsMovieExportEnableVideo = FOUR_CHAR_CODE('envi'), /* Enable exporting of video track (Boolean)*/
    kQTSettingsMovieExportEnableSound = FOUR_CHAR_CODE('enso'), /* Enable exporting of sound track (Boolean)*/
    kQTSettingsMovieExportSaveOptions = FOUR_CHAR_CODE('save'), /* Parent atom of save options*/
    kQTSettingsMovieExportSaveForInternet = FOUR_CHAR_CODE('fast'), /* . Save for Internet*/
    kQTSettingsMovieExportSaveCompressedMovie = FOUR_CHAR_CODE('cmpm'), /* . Save compressed movie resource*/
    kQTSettingsMIDI             = FOUR_CHAR_CODE('MIDI'),       /* MIDI import related container*/
    kQTSettingsMIDISettingFlags = FOUR_CHAR_CODE('sttg'),       /* . MIDI import settings (UInt32)*/
    kQTSettingsText             = FOUR_CHAR_CODE('text'),       /* Text related container*/
    kQTSettingsTextDescription  = FOUR_CHAR_CODE('desc'),       /* . Text import settings (TextDescription record)*/
    kQTSettingsTextSize         = FOUR_CHAR_CODE('size'),       /* . Width/height to create during import (FixedPoint)*/
    kQTSettingsTextSettingFlags = FOUR_CHAR_CODE('sttg'),       /* . Text export settings (UInt32)*/
    kQTSettingsTextTimeFraction = FOUR_CHAR_CODE('timf'),       /* . Movie time fraction for export (UInt32)*/
    kQTSettingsTime             = FOUR_CHAR_CODE('time'),       /* Time related container*/
    kQTSettingsTimeDuration     = FOUR_CHAR_CODE('dura'),       /* . Time related container*/
    kQTSettingsAudioCDTrack     = FOUR_CHAR_CODE('trak'),       /* Audio CD track related container*/
    kQTSettingsAudioCDTrackRateShift = FOUR_CHAR_CODE('rshf')   /* . Rate shift to be performed (SInt16)*/
};





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;                  /* unique key for this preset in presetsArray */
    UInt32                          presetFlags;                /* flags about this preset */
    OSType                          settingsResourceType;       /* resource type of settings resource */
    SInt16                          settingsResourceID;         /* resource id of settings resource */
    SInt16                          padding1;
    SInt16                          nameStringListID;           /* name string list resource id */
    SInt16                          nameStringIndex;            /* name string index */
    SInt16                          infoStringListID;           /* info string list resource id */
    SInt16                          infoStringIndex;            /* info string index */
};
typedef struct QTPresetInfo             QTPresetInfo;

struct QTPresetListRecord {
    UInt32                          flags;                      /* flags for whole list */
    UInt32                          count;                      /* number of elements in presetsArray */
    UInt32                          reserved;
    QTPresetInfo                    presetsArray[1];            /* info about each preset */
};
typedef struct QTPresetListRecord       QTPresetListRecord;
enum {
    kQTMovieExportSourceInfoResourceType = FOUR_CHAR_CODE('src#'),
    kQTMovieExportSourceInfoIsMediaType = 1L << 0,
    kQTMovieExportSourceInfoIsMediaCharacteristic = 1L << 1,
    kQTMovieExportSourceInfoIsSourceType = 1L << 2
};


struct QTMovieExportSourceInfo {
    OSType                          mediaType;                  /* Media type of source */
    UInt16                          minCount;                   /* min number of sources of this kind required, zero if none required */
    UInt16                          maxCount;                   /* max number of sources of this kind allowed, -1 if unlimited allowed */
    long                            flags;                      /* reserved for 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;
#if OPAQUE_UPP_TYPES
    EXTERN_API(SCModalFilterUPP)
    NewSCModalFilterUPP            (SCModalFilterProcPtr    userRoutine);

    EXTERN_API(SCModalHookUPP)
    NewSCModalHookUPP              (SCModalHookProcPtr      userRoutine);

    EXTERN_API(MovieExportGetDataUPP)
    NewMovieExportGetDataUPP       (MovieExportGetDataProcPtr userRoutine);

    EXTERN_API(MovieExportGetPropertyUPP)
    NewMovieExportGetPropertyUPP    (MovieExportGetPropertyProcPtr userRoutine);

    EXTERN_API(void)
    DisposeSCModalFilterUPP        (SCModalFilterUPP        userUPP);

    EXTERN_API(void)
    DisposeSCModalHookUPP          (SCModalHookUPP          userUPP);

    EXTERN_API(void)
    DisposeMovieExportGetDataUPP    (MovieExportGetDataUPP  userUPP);

    EXTERN_API(void)
    DisposeMovieExportGetPropertyUPP    (MovieExportGetPropertyUPP userUPP);

    EXTERN_API(Boolean)
    InvokeSCModalFilterUPP         (DialogRef               theDialog,
                                    EventRecord *           theEvent,
                                    short *                 itemHit,
                                    long                    refcon,
                                    SCModalFilterUPP        userUPP);

    EXTERN_API(short)
    InvokeSCModalHookUPP           (DialogRef               theDialog,
                                    short                   itemHit,
                                    void *                  params,
                                    long                    refcon,
                                    SCModalHookUPP          userUPP);

    EXTERN_API(OSErr)
    InvokeMovieExportGetDataUPP    (void *                  refCon,
                                    MovieExportGetDataParams * params,
                                    MovieExportGetDataUPP   userUPP);

    EXTERN_API(OSErr)
    InvokeMovieExportGetPropertyUPP    (void *              refcon,
                                    long                    trackID,
                                    OSType                  propertyType,
                                    void *                  propertyValue,
                                    MovieExportGetPropertyUPP userUPP);

#else
    enum { uppSCModalFilterProcInfo = 0x00003FD0 };                 /* pascal 1_byte Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSCModalHookProcInfo = 0x00003EE0 };                   /* pascal 2_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes) */
    enum { uppMovieExportGetDataProcInfo = 0x000003E0 };            /* pascal 2_bytes Func(4_bytes, 4_bytes) */
    enum { uppMovieExportGetPropertyProcInfo = 0x00003FE0 };        /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
    #define NewSCModalFilterUPP(userRoutine)                        (SCModalFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSCModalFilterProcInfo, GetCurrentArchitecture())
    #define NewSCModalHookUPP(userRoutine)                          (SCModalHookUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSCModalHookProcInfo, GetCurrentArchitecture())
    #define NewMovieExportGetDataUPP(userRoutine)                   (MovieExportGetDataUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMovieExportGetDataProcInfo, GetCurrentArchitecture())
    #define NewMovieExportGetPropertyUPP(userRoutine)               (MovieExportGetPropertyUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMovieExportGetPropertyProcInfo, GetCurrentArchitecture())
    #define DisposeSCModalFilterUPP(userUPP)                        DisposeRoutineDescriptor(userUPP)
    #define DisposeSCModalHookUPP(userUPP)                          DisposeRoutineDescriptor(userUPP)
    #define DisposeMovieExportGetDataUPP(userUPP)                   DisposeRoutineDescriptor(userUPP)
    #define DisposeMovieExportGetPropertyUPP(userUPP)               DisposeRoutineDescriptor(userUPP)
    #define InvokeSCModalFilterUPP(theDialog, theEvent, itemHit, refcon, userUPP)  (Boolean)CALL_FOUR_PARAMETER_UPP((userUPP), uppSCModalFilterProcInfo, (theDialog), (theEvent), (itemHit), (refcon))
    #define InvokeSCModalHookUPP(theDialog, itemHit, params, refcon, userUPP)  (short)CALL_FOUR_PARAMETER_UPP((userUPP), uppSCModalHookProcInfo, (theDialog), (itemHit), (params), (refcon))
    #define InvokeMovieExportGetDataUPP(refCon, params, userUPP)    (OSErr)CALL_TWO_PARAMETER_UPP((userUPP), uppMovieExportGetDataProcInfo, (refCon), (params))
    #define InvokeMovieExportGetPropertyUPP(refcon, trackID, propertyType, propertyValue, userUPP)  (OSErr)CALL_FOUR_PARAMETER_UPP((userUPP), uppMovieExportGetPropertyProcInfo, (refcon), (trackID), (propertyType), (propertyValue))
#endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
#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)
EXTERN_API( ComponentResult )
MovieImportHandle               (MovieImportComponent   ci,
                                 Handle                 dataH,
                                 Movie                  theMovie,
                                 Track                  targetTrack,
                                 Track *                usedTrack,
                                 TimeValue              atTime,
                                 TimeValue *            addedDuration,
                                 long                   inFlags,
                                 long *                 outFlags)                           FIVEWORDINLINE(0x2F3C, 0x0020, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportFile                 (MovieImportComponent   ci,
                                 const FSSpec *         theFile,
                                 Movie                  theMovie,
                                 Track                  targetTrack,
                                 Track *                usedTrack,
                                 TimeValue              atTime,
                                 TimeValue *            addedDuration,
                                 long                   inFlags,
                                 long *                 outFlags)                           FIVEWORDINLINE(0x2F3C, 0x0020, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetSampleDuration    (MovieImportComponent   ci,
                                 TimeValue              duration,
                                 TimeScale              scale)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetSampleDescription (MovieImportComponent   ci,
                                 SampleDescriptionHandle  desc,
                                 OSType                 mediaType)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetMediaFile         (MovieImportComponent   ci,
                                 AliasHandle            alias)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetDimensions        (MovieImportComponent   ci,
                                 Fixed                  width,
                                 Fixed                  height)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0006, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetChunkSize         (MovieImportComponent   ci,
                                 long                   chunkSize)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetProgressProc      (MovieImportComponent   ci,
                                 MovieProgressUPP       proc,
                                 long                   refcon)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0008, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetAuxiliaryData     (MovieImportComponent   ci,
                                 Handle                 data,
                                 OSType                 handleType)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0009, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetFromScrap         (MovieImportComponent   ci,
                                 Boolean                fromScrap)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0x000A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportDoUserDialog         (MovieImportComponent   ci,
                                 const FSSpec *         theFile,
                                 Handle                 theData,
                                 Boolean *              canceled)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x000B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetDuration          (MovieImportComponent   ci,
                                 TimeValue              duration)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetAuxiliaryDataType (MovieImportComponent   ci,
                                 OSType *               auxType)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportValidate             (MovieImportComponent   ci,
                                 const FSSpec *         theFile,
                                 Handle                 theData,
                                 Boolean *              valid)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x000E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetFileType          (MovieImportComponent   ci,
                                 OSType *               fileType)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x000F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportDataRef              (MovieImportComponent   ci,
                                 Handle                 dataRef,
                                 OSType                 dataRefType,
                                 Movie                  theMovie,
                                 Track                  targetTrack,
                                 Track *                usedTrack,
                                 TimeValue              atTime,
                                 TimeValue *            addedDuration,
                                 long                   inFlags,
                                 long *                 outFlags)                           FIVEWORDINLINE(0x2F3C, 0x0024, 0x0010, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetSampleDescription (MovieImportComponent   ci,
                                 SampleDescriptionHandle * desc,
                                 OSType *               mediaType)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0011, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetMIMETypeList      (MovieImportComponent   ci,
                                 QTAtomContainer *      mimeInfo)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetOffsetAndLimit    (MovieImportComponent   ci,
                                 unsigned long          offset,
                                 unsigned long          limit)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0013, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetSettingsAsAtomContainer (MovieImportComponent  ci,
                                 QTAtomContainer *      settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetSettingsFromAtomContainer (MovieImportComponent  ci,
                                 QTAtomContainer        settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetOffsetAndLimit64  (MovieImportComponent   ci,
                                 const wide *           offset,
                                 const wide *           limit)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0016, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportIdle                 (MovieImportComponent   ci,
                                 long                   inFlags,
                                 long *                 outFlags)                           FIVEWORDINLINE(0x2F3C, 0x0008, 0x0017, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportValidateDataRef      (MovieImportComponent   ci,
                                 Handle                 dataRef,
                                 OSType                 dataRefType,
                                 UInt8 *                valid)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x0018, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetLoadState         (MovieImportComponent   ci,
                                 long *                 importerLoadState)                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetMaxLoadedTime     (MovieImportComponent   ci,
                                 TimeValue *            time)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportEstimateCompletionTime (MovieImportComponent  ci,
                                 TimeRecord *           time)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportSetDontBlock         (MovieImportComponent   ci,
                                 Boolean                dontBlock)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0x001C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieImportGetDontBlock         (MovieImportComponent   ci,
                                 Boolean *              willBlock)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x001D, 0x7000, 0xA82A);


EXTERN_API( ComponentResult )
MovieExportToHandle             (MovieExportComponent   ci,
                                 Handle                 dataH,
                                 Movie                  theMovie,
                                 Track                  onlyThisTrack,
                                 TimeValue              startTime,
                                 TimeValue              duration)                           FIVEWORDINLINE(0x2F3C, 0x0014, 0x0080, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportToFile               (MovieExportComponent   ci,
                                 const FSSpec *         theFile,
                                 Movie                  theMovie,
                                 Track                  onlyThisTrack,
                                 TimeValue              startTime,
                                 TimeValue              duration)                           FIVEWORDINLINE(0x2F3C, 0x0014, 0x0081, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportGetAuxiliaryData     (MovieExportComponent   ci,
                                 Handle                 dataH,
                                 OSType *               handleType)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0083, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportSetProgressProc      (MovieExportComponent   ci,
                                 MovieProgressUPP       proc,
                                 long                   refcon)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0084, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportSetSampleDescription (MovieExportComponent   ci,
                                 SampleDescriptionHandle  desc,
                                 OSType                 mediaType)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0085, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportDoUserDialog         (MovieExportComponent   ci,
                                 Movie                  theMovie,
                                 Track                  onlyThisTrack,
                                 TimeValue              startTime,
                                 TimeValue              duration,
                                 Boolean *              canceled)                           FIVEWORDINLINE(0x2F3C, 0x0014, 0x0086, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportGetCreatorType       (MovieExportComponent   ci,
                                 OSType *               creator)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0087, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportToDataRef            (MovieExportComponent   ci,
                                 Handle                 dataRef,
                                 OSType                 dataRefType,
                                 Movie                  theMovie,
                                 Track                  onlyThisTrack,
                                 TimeValue              startTime,
                                 TimeValue              duration)                           FIVEWORDINLINE(0x2F3C, 0x0018, 0x0088, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportFromProceduresToDataRef (MovieExportComponent  ci,
                                 Handle                 dataRef,
                                 OSType                 dataRefType)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0089, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportAddDataSource        (MovieExportComponent   ci,
                                 OSType                 trackType,
                                 TimeScale              scale,
                                 long *                 trackID,
                                 MovieExportGetPropertyUPP  getPropertyProc,
                                 MovieExportGetDataUPP  getDataProc,
                                 void *                 refCon)                             FIVEWORDINLINE(0x2F3C, 0x0018, 0x008A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportValidate             (MovieExportComponent   ci,
                                 Movie                  theMovie,
                                 Track                  onlyThisTrack,
                                 Boolean *              valid)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x008B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportGetSettingsAsAtomContainer (MovieExportComponent  ci,
                                 QTAtomContainer *      settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x008C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportSetSettingsFromAtomContainer (MovieExportComponent  ci,
                                 QTAtomContainer        settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x008D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportGetFileNameExtension (MovieExportComponent   ci,
                                 OSType *               extension)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x008E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportGetShortFileTypeString (MovieExportComponent  ci,
                                 Str255                 typeString)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x008F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportGetSourceMediaType   (MovieExportComponent   ci,
                                 OSType *               mediaType)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0090, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportSetGetMoviePropertyProc (MovieExportComponent  ci,
                                 MovieExportGetPropertyUPP  getPropertyProc,
                                 void *                 refCon)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0091, 0x7000, 0xA82A);

/* Text Export Display Info data structure*/

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;
EXTERN_API( ComponentResult )
TextExportGetDisplayData        (TextExportComponent    ci,
                                 TextDisplayData *      textDisplay)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
TextExportGetTimeFraction       (TextExportComponent    ci,
                                 long *                 movieTimeFraction)                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
TextExportSetTimeFraction       (TextExportComponent    ci,
                                 long                   movieTimeFraction)                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0102, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
TextExportGetSettings           (TextExportComponent    ci,
                                 long *                 setting)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0103, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
TextExportSetSettings           (TextExportComponent    ci,
                                 long                   setting)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0104, 0x7000, 0xA82A);


EXTERN_API( ComponentResult )
MIDIImportGetSettings           (TextExportComponent    ci,
                                 long *                 setting)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MIDIImportSetSettings           (TextExportComponent    ci,
                                 long                   setting)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportNewGetDataAndPropertiesProcs (MovieExportComponent  ci,
                                 OSType                 trackType,
                                 TimeScale *            scale,
                                 Movie                  theMovie,
                                 Track                  theTrack,
                                 TimeValue              startTime,
                                 TimeValue              duration,
                                 MovieExportGetPropertyUPP * getPropertyProc,
                                 MovieExportGetDataUPP * getDataProc,
                                 void **                refCon)                             FIVEWORDINLINE(0x2F3C, 0x0024, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
MovieExportDisposeGetDataAndPropertiesProcs (MovieExportComponent  ci,
                                 MovieExportGetPropertyUPP  getPropertyProc,
                                 MovieExportGetDataUPP  getDataProc,
                                 void *                 refCon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x0101, 0x7000, 0xA82A);

enum {
    movieExportUseConfiguredSettings = FOUR_CHAR_CODE('ucfg'),  /* pointer to Boolean*/
    movieExportWidth            = FOUR_CHAR_CODE('wdth'),       /* pointer to Fixed*/
    movieExportHeight           = FOUR_CHAR_CODE('hegt'),       /* pointer to Fixed*/
    movieExportDuration         = FOUR_CHAR_CODE('dura'),       /* pointer to TimeRecord*/
    movieExportVideoFilter      = FOUR_CHAR_CODE('iflt'),       /* pointer to QTAtomContainer*/
    movieExportTimeScale        = FOUR_CHAR_CODE('tmsc')        /* pointer to TimeScale*/
};

EXTERN_API( ComponentResult )
GraphicsImageImportSetSequenceEnabled (GraphicImageMovieImportComponent  ci,
                                 Boolean                enable)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
GraphicsImageImportGetSequenceEnabled (GraphicImageMovieImportComponent  ci,
                                 Boolean *              enable)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);












/***************

    File Preview Components

***************/
typedef ComponentInstance               pnotComponent;
enum {
    pnotComponentWantsEvents    = 1,
    pnotComponentNeedsNoCache   = 2
};

enum {
    ShowFilePreviewComponentType = FOUR_CHAR_CODE('pnot'),
    CreateFilePreviewComponentType = FOUR_CHAR_CODE('pmak')
};

EXTERN_API( ComponentResult )
PreviewShowData                 (pnotComponent          p,
                                 OSType                 dataType,
                                 Handle                 data,
                                 const Rect *           inHere)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
PreviewMakePreview              (pnotComponent          p,
                                 OSType *               previewType,
                                 Handle *               previewResult,
                                 const FSSpec *         sourceFile,
                                 ICMProgressProcRecordPtr  progress)                        FIVEWORDINLINE(0x2F3C, 0x0010, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
PreviewMakePreviewReference     (pnotComponent          p,
                                 OSType *               previewType,
                                 short *                resID,
                                 const FSSpec *         sourceFile)                         FIVEWORDINLINE(0x2F3C, 0x000C, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
PreviewEvent                    (pnotComponent          p,
                                 EventRecord *          e,
                                 Boolean *              handledEvent)                       FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A);



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 **/
EXTERN_API( ComponentResult )
DataCodecDecompress             (DataCodecComponent     dc,
                                 void *                 srcData,
                                 UInt32                 srcSize,
                                 void *                 dstData,
                                 UInt32                 dstBufferSize)                      FIVEWORDINLINE(0x2F3C, 0x0010, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataCodecGetCompressBufferSize  (DataCodecComponent     dc,
                                 UInt32                 srcSize,
                                 UInt32 *               dstSize)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataCodecCompress               (DataCodecComponent     dc,
                                 void *                 srcData,
                                 UInt32                 srcSize,
                                 void *                 dstData,
                                 UInt32                 dstBufferSize,
                                 UInt32 *               actualDstSize,
                                 UInt32 *               decompressSlop)                     FIVEWORDINLINE(0x2F3C, 0x0018, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataCodecBeginInterruptSafe     (DataCodecComponent     dc,
                                 unsigned long          maxSrcSize)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataCodecEndInterruptSafe       (DataCodecComponent     dc)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0005, 0x7000, 0xA82A);

EXTERN_API( 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)                          FIVEWORDINLINE(0x2F3C, 0x001C, 0x0006, 0x7000, 0xA82A);

EXTERN_API( 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)                          FIVEWORDINLINE(0x2F3C, 0x001E, 0x0007, 0x7000, 0xA82A);




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
};

/* Data reference records for specific data ref types*/

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;
/* Data reference extensions*/
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'),
    kDataRefExtensionQuickTimeMediaType = FOUR_CHAR_CODE('mtyp')
};

enum {
    kDataHChokeToMovieDataRate  = 1 << 0,                       /* param is 0*/
    kDataHChokeToParam          = 1 << 1                        /* param is bytes per second*/
};


struct DataHChokeAtomRecord {
    long                            flags;                      /* one of kDataHChokeTo constants*/
    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;                 /* always is kDataHExtendedSchedule*/
    long                            extendedVers;               /* always set to 0*/
    Fixed                           priority;                   /* 100.0 or more means must have. lower numbers...*/
};
typedef struct DataHScheduleRecord      DataHScheduleRecord;

typedef DataHScheduleRecord *           DataHSchedulePtr;
/* Flags for DataHGetInfoFlags*/
enum {
    kDataHInfoFlagNeverStreams  = 1 << 0,                       /* set if this data handler doesn't stream*/
    kDataHInfoFlagCanUpdateDataRefs = 1 << 1,                   /* set if this data handler might update data reference*/
    kDataHInfoFlagNeedsNetworkBandwidth = 1 << 2                /* set if this data handler may need to occupy the network*/
};


/* Types for DataHGetFileTypeOrdering*/
enum {
    kDataHFileTypeMacOSFileType = FOUR_CHAR_CODE('ftyp'),
    kDataHFileTypeExtension     = FOUR_CHAR_CODE('fext'),
    kDataHFileTypeMIME          = FOUR_CHAR_CODE('mime')
};

typedef OSType *                        DataHFileTypeOrderingPtr;
typedef DataHFileTypeOrderingPtr *      DataHFileTypeOrderingHandle;

EXTERN_API( ComponentResult )
DataHGetData                    (DataHandler            dh,
                                 Handle                 h,
                                 long                   hOffset,
                                 long                   offset,
                                 long                   size)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHPutData                    (DataHandler            dh,
                                 Handle                 h,
                                 long                   hOffset,
                                 long *                 offset,
                                 long                   size)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHFlushData                  (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHOpenForWrite               (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0005, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHCloseForWrite              (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0006, 0x7000, 0xA82A);


EXTERN_API( ComponentResult )
DataHOpenForRead                (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0008, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHCloseForRead               (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0009, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetDataRef                 (DataHandler            dh,
                                 Handle                 dataRef)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x000A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDataRef                 (DataHandler            dh,
                                 Handle *               dataRef)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x000B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHCompareDataRef             (DataHandler            dh,
                                 Handle                 dataRef,
                                 Boolean *              equal)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x000C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHTask                       (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x000D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHScheduleData               (DataHandler            dh,
                                 Ptr                    PlaceToPutDataPtr,
                                 long                   FileOffset,
                                 long                   DataSize,
                                 long                   RefCon,
                                 DataHSchedulePtr       scheduleRec,
                                 DataHCompletionUPP     CompletionRtn)                      FIVEWORDINLINE(0x2F3C, 0x0018, 0x000E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHFinishData                 (DataHandler            dh,
                                 Ptr                    PlaceToPutDataPtr,
                                 Boolean                Cancel)                             FIVEWORDINLINE(0x2F3C, 0x0006, 0x000F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHFlushCache                 (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0010, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHResolveDataRef             (DataHandler            dh,
                                 Handle                 theDataRef,
                                 Boolean *              wasChanged,
                                 Boolean                userInterfaceAllowed)               FIVEWORDINLINE(0x2F3C, 0x000A, 0x0011, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetFileSize                (DataHandler            dh,
                                 long *                 fileSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHCanUseDataRef              (DataHandler            dh,
                                 Handle                 dataRef,
                                 long *                 useFlags)                           FIVEWORDINLINE(0x2F3C, 0x0008, 0x0013, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetVolumeList              (DataHandler            dh,
                                 DataHVolumeList *      volumeList)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHWrite                      (DataHandler            dh,
                                 Ptr                    data,
                                 long                   offset,
                                 long                   size,
                                 DataHCompletionUPP     completion,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0014, 0x0015, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHPreextend                  (DataHandler            dh,
                                 unsigned long          maxToAdd,
                                 unsigned long *        spaceAdded)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0016, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetFileSize                (DataHandler            dh,
                                 long                   fileSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0017, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetFreeSpace               (DataHandler            dh,
                                 unsigned long *        freeSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0018, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHCreateFile                 (DataHandler            dh,
                                 OSType                 creator,
                                 Boolean                deleteExisting)                     FIVEWORDINLINE(0x2F3C, 0x0006, 0x0019, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetPreferredBlockSize      (DataHandler            dh,
                                 long *                 blockSize)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDeviceIndex             (DataHandler            dh,
                                 long *                 deviceIndex)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHIsStreamingDataHandler     (DataHandler            dh,
                                 Boolean *              yes)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x001C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDataInBuffer            (DataHandler            dh,
                                 long                   startOffset,
                                 long *                 size)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x001D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetScheduleAheadTime       (DataHandler            dh,
                                 long *                 millisecs)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x001E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetCacheSizeLimit          (DataHandler            dh,
                                 Size                   cacheSizeLimit)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x001F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetCacheSizeLimit          (DataHandler            dh,
                                 Size *                 cacheSizeLimit)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0020, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetMovie                   (DataHandler            dh,
                                 Movie *                theMovie,
                                 short *                id)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0021, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHAddMovie                   (DataHandler            dh,
                                 Movie                  theMovie,
                                 short *                id)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0022, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHUpdateMovie                (DataHandler            dh,
                                 Movie                  theMovie,
                                 short                  id)                                 FIVEWORDINLINE(0x2F3C, 0x0006, 0x0023, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHDoesBuffer                 (DataHandler            dh,
                                 Boolean *              buffersReads,
                                 Boolean *              buffersWrites)                      FIVEWORDINLINE(0x2F3C, 0x0008, 0x0024, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetFileName                (DataHandler            dh,
                                 Str255                 str)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0025, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetAvailableFileSize       (DataHandler            dh,
                                 long *                 fileSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0026, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetMacOSFileType           (DataHandler            dh,
                                 OSType *               fileType)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0027, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetMIMEType                (DataHandler            dh,
                                 Str255                 mimeType)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0028, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetDataRefWithAnchor       (DataHandler            dh,
                                 Handle                 anchorDataRef,
                                 OSType                 dataRefType,
                                 Handle                 dataRef)                            FIVEWORDINLINE(0x2F3C, 0x000C, 0x0029, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDataRefWithAnchor       (DataHandler            dh,
                                 Handle                 anchorDataRef,
                                 OSType                 dataRefType,
                                 Handle *               dataRef)                            FIVEWORDINLINE(0x2F3C, 0x000C, 0x002A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetMacOSFileType           (DataHandler            dh,
                                 OSType                 fileType)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x002B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetTimeBase                (DataHandler            dh,
                                 TimeBase               tb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x002C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetInfoFlags               (DataHandler            dh,
                                 UInt32 *               flags)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x002D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHScheduleData64             (DataHandler            dh,
                                 Ptr                    PlaceToPutDataPtr,
                                 const wide *           FileOffset,
                                 long                   DataSize,
                                 long                   RefCon,
                                 DataHSchedulePtr       scheduleRec,
                                 DataHCompletionUPP     CompletionRtn)                      FIVEWORDINLINE(0x2F3C, 0x0018, 0x002E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHWrite64                    (DataHandler            dh,
                                 Ptr                    data,
                                 const wide *           offset,
                                 long                   size,
                                 DataHCompletionUPP     completion,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0014, 0x002F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetFileSize64              (DataHandler            dh,
                                 wide *                 fileSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0030, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHPreextend64                (DataHandler            dh,
                                 const wide *           maxToAdd,
                                 wide *                 spaceAdded)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0031, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetFileSize64              (DataHandler            dh,
                                 const wide *           fileSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0032, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetFreeSpace64             (DataHandler            dh,
                                 wide *                 freeSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0033, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHAppend64                   (DataHandler            dh,
                                 void *                 data,
                                 wide *                 fileOffset,
                                 unsigned long          size)                               FIVEWORDINLINE(0x2F3C, 0x000C, 0x0034, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHReadAsync                  (DataHandler            dh,
                                 void *                 dataPtr,
                                 UInt32                 dataSize,
                                 const wide *           dataOffset,
                                 DataHCompletionUPP     completion,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0014, 0x0035, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHPollRead                   (DataHandler            dh,
                                 void *                 dataPtr,
                                 UInt32 *               dataSizeSoFar)                      FIVEWORDINLINE(0x2F3C, 0x0008, 0x0036, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDataAvailability        (DataHandler            dh,
                                 long                   offset,
                                 long                   len,
                                 long *                 missing_offset,
                                 long *                 missing_len)                        FIVEWORDINLINE(0x2F3C, 0x0010, 0x0037, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetFileSizeAsync           (DataHandler            dh,
                                 wide *                 fileSize,
                                 DataHCompletionUPP     completionRtn,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x003A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDataRefAsType           (DataHandler            dh,
                                 OSType                 requestedType,
                                 Handle *               dataRef)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x003B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHSetDataRefExtension        (DataHandler            dh,
                                 Handle                 extension,
                                 OSType                 idType)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x003C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetDataRefExtension        (DataHandler            dh,
                                 Handle *               extension,
                                 OSType                 idType)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x003D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetMovieWithFlags          (DataHandler            dh,
                                 Movie *                theMovie,
                                 short *                id,
                                 short                  flags)                              FIVEWORDINLINE(0x2F3C, 0x000A, 0x003E, 0x7000, 0xA82A);


EXTERN_API( ComponentResult )
DataHGetFileTypeOrdering        (DataHandler            dh,
                                 DataHFileTypeOrderingHandle * orderingListHandle)          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0040, 0x7000, 0xA82A);

/* flags for DataHCreateFileWithFlags*/
enum {
    kDataHCreateFileButDontCreateResFile = (1L << 0)
};

EXTERN_API( ComponentResult )
DataHCreateFileWithFlags        (DataHandler            dh,
                                 OSType                 creator,
                                 Boolean                deleteExisting,
                                 UInt32                 flags)                              FIVEWORDINLINE(0x2F3C, 0x000A, 0x0041, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetMIMETypeAsync           (DataHandler            dh,
                                 Str255                 mimeType,
                                 DataHCompletionUPP     completionRtn,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x0042, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHGetInfo                    (DataHandler            dh,
                                 OSType                 what,
                                 void *                 info)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x0043, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHPlaybackHints              (DataHandler            dh,
                                 long                   flags,
                                 unsigned long          minFileOffset,
                                 unsigned long          maxFileOffset,
                                 long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0010, 0x0103, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
DataHPlaybackHints64            (DataHandler            dh,
                                 long                   flags,
                                 const wide *           minFileOffset,
                                 const wide *           maxFileOffset,
                                 long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0010, 0x010E, 0x7000, 0xA82A);

/* Symbolic constants for DataHGetDataRate*/
enum {
    kDataHGetDataRateInfiniteRate = 0x7FFFFFFF                  /* all the data arrived instantaneously*/
};

EXTERN_API( ComponentResult )
DataHGetDataRate                (DataHandler            dh,
                                 long                   flags,
                                 long *                 bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0008, 0x0110, 0x7000, 0xA82A);

/* Flags for DataHSetTimeHints*/
enum {
    kDataHSetTimeHintsSkipBandwidthRequest = 1 << 0             /* set if this data handler should use the network without requesting bandwidth*/
};

EXTERN_API( ComponentResult )
DataHSetTimeHints               (DataHandler            dh,
                                 long                   flags,
                                 long                   bandwidthPriority,
                                 TimeScale              scale,
                                 TimeValue              minTime,
                                 TimeValue              maxTime)                            FIVEWORDINLINE(0x2F3C, 0x0014, 0x0111, 0x7000, 0xA82A);





/* Standard type for video digitizers */
enum {
    videoDigitizerComponentType = FOUR_CHAR_CODE('vdig'),
    vdigInterfaceRev            = 2
};

/* Input Format Standards */
enum {
    ntscIn                      = 0,                            /* current input format */
    currentIn                   = 0,                            /* ntsc input format */
    palIn                       = 1,                            /* pal input format */
    secamIn                     = 2,                            /* secam input format */
    ntscReallyIn                = 3                             /* ntsc input format */
};

/* Input Formats */
enum {
    compositeIn                 = 0,                            /* input is composite format */
    sVideoIn                    = 1,                            /* input is sVideo format */
    rgbComponentIn              = 2,                            /* input is rgb component format */
    rgbComponentSyncIn          = 3,                            /* input is rgb component format (sync on green?)*/
    yuvComponentIn              = 4,                            /* input is yuv component format */
    yuvComponentSyncIn          = 5,                            /* input is yuv component format (sync on green?) */
    tvTunerIn                   = 6,
    sdiIn                       = 7
};


/* Video Digitizer PlayThru States */
enum {
    vdPlayThruOff               = 0,
    vdPlayThruOn                = 1
};

/* Input Color Space Modes */
enum {
    vdDigitizerBW               = 0,                            /* black and white */
    vdDigitizerRGB              = 1                             /* rgb color */
};

/* Phase Lock Loop Modes */
enum {
    vdBroadcastMode             = 0,                            /* Broadcast / Laser Disk video mode */
    vdVTRMode                   = 1                             /* VCR / Magnetic media mode */
};

/* Field Select Options */
enum {
    vdUseAnyField               = 0,                            /* Digitizers choice on field use */
    vdUseOddField               = 1,                            /* Use odd field for half size vert and smaller */
    vdUseEvenField              = 2                             /* Use even field for half size vert and smaller */
};

/* vdig types */
enum {
    vdTypeBasic                 = 0,                            /* basic, no clipping */
    vdTypeAlpha                 = 1,                            /* supports clipping with alpha channel */
    vdTypeMask                  = 2,                            /* supports clipping with mask plane */
    vdTypeKey                   = 3                             /* supports clipping with key color(s) */
};



/* Digitizer Input Capability/Current Flags */
enum {
    digiInDoesNTSC              = 1L << 0,                      /* digitizer supports NTSC input format */
    digiInDoesPAL               = 1L << 1,                      /* digitizer supports PAL input format */
    digiInDoesSECAM             = 1L << 2,                      /* digitizer supports SECAM input format */
    digiInDoesGenLock           = 1L << 7,                      /* digitizer does genlock */
    digiInDoesComposite         = 1L << 8,                      /* digitizer supports composite input type */
    digiInDoesSVideo            = 1L << 9,                      /* digitizer supports S-Video input type */
    digiInDoesComponent         = 1L << 10,                     /* digitizer supports component = rgb, input type */
    digiInVTR_Broadcast         = 1L << 11,                     /* digitizer can differentiate between the two */
    digiInDoesColor             = 1L << 12,                     /* digitizer supports color */
    digiInDoesBW                = 1L << 13,                     /* digitizer supports black & white */
                                                                /* Digitizer Input Current Flags = these are valid only during active operating conditions,   */
    digiInSignalLock            = 1L << 31                      /* digitizer detects input signal is locked, this bit = horiz lock || vertical lock */
};


/* Digitizer Output Capability/Current Flags */
enum {
    digiOutDoes1                = 1L << 0,                      /* digitizer supports 1 bit pixels */
    digiOutDoes2                = 1L << 1,                      /* digitizer supports 2 bit pixels */
    digiOutDoes4                = 1L << 2,                      /* digitizer supports 4 bit pixels */
    digiOutDoes8                = 1L << 3,                      /* digitizer supports 8 bit pixels */
    digiOutDoes16               = 1L << 4,                      /* digitizer supports 16 bit pixels */
    digiOutDoes32               = 1L << 5,                      /* digitizer supports 32 bit pixels */
    digiOutDoesDither           = 1L << 6,                      /* digitizer dithers in indexed modes */
    digiOutDoesStretch          = 1L << 7,                      /* digitizer can arbitrarily stretch */
    digiOutDoesShrink           = 1L << 8,                      /* digitizer can arbitrarily shrink */
    digiOutDoesMask             = 1L << 9,                      /* digitizer can mask to clipping regions */
    digiOutDoesDouble           = 1L << 11,                     /* digitizer can stretch to exactly double size */
    digiOutDoesQuad             = 1L << 12,                     /* digitizer can stretch exactly quadruple size */
    digiOutDoesQuarter          = 1L << 13,                     /* digitizer can shrink to exactly quarter size */
    digiOutDoesSixteenth        = 1L << 14,                     /* digitizer can shrink to exactly sixteenth size */
    digiOutDoesRotate           = 1L << 15,                     /* digitizer supports rotate transformations */
    digiOutDoesHorizFlip        = 1L << 16,                     /* digitizer supports horizontal flips Sx < 0 */
    digiOutDoesVertFlip         = 1L << 17,                     /* digitizer supports vertical flips Sy < 0 */
    digiOutDoesSkew             = 1L << 18,                     /* digitizer supports skew = shear,twist, */
    digiOutDoesBlend            = 1L << 19,
    digiOutDoesWarp             = 1L << 20,
    digiOutDoesHW_DMA           = 1L << 21,                     /* digitizer not constrained to local device */
    digiOutDoesHWPlayThru       = 1L << 22,                     /* digitizer doesn't need time to play thru */
    digiOutDoesILUT             = 1L << 23,                     /* digitizer does inverse LUT for index modes */
    digiOutDoesKeyColor         = 1L << 24,                     /* digitizer does key color functions too */
    digiOutDoesAsyncGrabs       = 1L << 25,                     /* digitizer supports async grabs */
    digiOutDoesUnreadableScreenBits = 1L << 26,                 /* playthru doesn't generate readable bits on screen*/
    digiOutDoesCompress         = 1L << 27,                     /* supports alternate output data types */
    digiOutDoesCompressOnly     = 1L << 28,                     /* can't provide raw frames anywhere */
    digiOutDoesPlayThruDuringCompress = 1L << 29,               /* digi can do playthru while providing compressed data */
    digiOutDoesCompressPartiallyVisible = 1L << 30,             /* digi doesn't need all bits visible on screen to do hardware compress */
    digiOutDoesNotNeedCopyOfCompressData = 1L << 31             /* digi doesn't need any bufferization when providing compressed data */
};

/* Types */
typedef ComponentInstance               VideoDigitizerComponent;
typedef ComponentResult                 VideoDigitizerError;

struct DigitizerInfo {
    short                           vdigType;
    long                            inputCapabilityFlags;
    long                            outputCapabilityFlags;
    long                            inputCurrentFlags;
    long                            outputCurrentFlags;
    short                           slot;                       /* temporary for connection purposes */
    GDHandle                        gdh;                        /* temporary for digitizers that have preferred screen */
    GDHandle                        maskgdh;                    /* temporary for digitizers that have mask planes */
    short                           minDestHeight;              /* Smallest resizable height */
    short                           minDestWidth;               /* Smallest resizable width */
    short                           maxDestHeight;              /* Largest resizable height */
    short                           maxDestWidth;               /* Largest resizable width */
    short                           blendLevels;                /* Number of blend levels supported (2 if 1 bit mask) */
    long                            reserved;                   /* 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
};


EXTERN_API( VideoDigitizerError )
VDGetMaxSrcRect                 (VideoDigitizerComponent  ci,
                                 short                  inputStd,
                                 Rect *                 maxSrcRect)                         FIVEWORDINLINE(0x2F3C, 0x0006, 0x0001, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetActiveSrcRect              (VideoDigitizerComponent  ci,
                                 short                  inputStd,
                                 Rect *                 activeSrcRect)                      FIVEWORDINLINE(0x2F3C, 0x0006, 0x0002, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetDigitizerRect              (VideoDigitizerComponent  ci,
                                 Rect *                 digitizerRect)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetDigitizerRect              (VideoDigitizerComponent  ci,
                                 Rect *                 digitizerRect)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetVBlankRect                 (VideoDigitizerComponent  ci,
                                 short                  inputStd,
                                 Rect *                 vBlankRect)                         FIVEWORDINLINE(0x2F3C, 0x0006, 0x0005, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetMaskPixMap                 (VideoDigitizerComponent  ci,
                                 PixMapHandle           maskPixMap)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0006, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetPlayThruDestination        (VideoDigitizerComponent  ci,
                                 PixMapHandle *         dest,
                                 Rect *                 destRect,
                                 MatrixRecord *         m,
                                 RgnHandle *            mask)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x0008, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDUseThisCLUT                   (VideoDigitizerComponent  ci,
                                 CTabHandle             colorTableHandle)                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0009, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetInputGammaValue            (VideoDigitizerComponent  ci,
                                 Fixed                  channel1,
                                 Fixed                  channel2,
                                 Fixed                  channel3)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x000A, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetInputGammaValue            (VideoDigitizerComponent  ci,
                                 Fixed *                channel1,
                                 Fixed *                channel2,
                                 Fixed *                channel3)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x000B, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetBrightness                 (VideoDigitizerComponent  ci,
                                 unsigned short *       brightness)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetBrightness                 (VideoDigitizerComponent  ci,
                                 unsigned short *       brightness)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetContrast                   (VideoDigitizerComponent  ci,
                                 unsigned short *       contrast)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x000E, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetHue                        (VideoDigitizerComponent  ci,
                                 unsigned short *       hue)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x000F, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetSharpness                  (VideoDigitizerComponent  ci,
                                 unsigned short *       sharpness)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0010, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetSaturation                 (VideoDigitizerComponent  ci,
                                 unsigned short *       saturation)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0011, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetContrast                   (VideoDigitizerComponent  ci,
                                 unsigned short *       contrast)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetHue                        (VideoDigitizerComponent  ci,
                                 unsigned short *       hue)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0013, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetSharpness                  (VideoDigitizerComponent  ci,
                                 unsigned short *       sharpness)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetSaturation                 (VideoDigitizerComponent  ci,
                                 unsigned short *       saturation)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGrabOneFrame                  (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0016, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetMaxAuxBuffer               (VideoDigitizerComponent  ci,
                                 PixMapHandle *         pm,
                                 Rect *                 r)                                  FIVEWORDINLINE(0x2F3C, 0x0008, 0x0017, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetDigitizerInfo              (VideoDigitizerComponent  ci,
                                 DigitizerInfo *        info)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetCurrentFlags               (VideoDigitizerComponent  ci,
                                 long *                 inputCurrentFlag,
                                 long *                 outputCurrentFlag)                  FIVEWORDINLINE(0x2F3C, 0x0008, 0x001A, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetKeyColor                   (VideoDigitizerComponent  ci,
                                 long                   index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetKeyColor                   (VideoDigitizerComponent  ci,
                                 long *                 index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001C, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDAddKeyColor                   (VideoDigitizerComponent  ci,
                                 long *                 index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001D, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetNextKeyColor               (VideoDigitizerComponent  ci,
                                 long                   index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001E, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetKeyColorRange              (VideoDigitizerComponent  ci,
                                 RGBColor *             minRGB,
                                 RGBColor *             maxRGB)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x001F, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetKeyColorRange              (VideoDigitizerComponent  ci,
                                 RGBColor *             minRGB,
                                 RGBColor *             maxRGB)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0020, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetDigitizerUserInterrupt     (VideoDigitizerComponent  ci,
                                 long                   flags,
                                 VdigIntUPP             userInterruptProc,
                                 long                   refcon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x0021, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetInputColorSpaceMode        (VideoDigitizerComponent  ci,
                                 short                  colorSpaceMode)                     FIVEWORDINLINE(0x2F3C, 0x0002, 0x0022, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetInputColorSpaceMode        (VideoDigitizerComponent  ci,
                                 short *                colorSpaceMode)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0023, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetClipState                  (VideoDigitizerComponent  ci,
                                 short                  clipEnable)                         FIVEWORDINLINE(0x2F3C, 0x0002, 0x0024, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetClipState                  (VideoDigitizerComponent  ci,
                                 short *                clipEnable)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0025, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetClipRgn                    (VideoDigitizerComponent  ci,
                                 RgnHandle              clipRegion)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0026, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDClearClipRgn                  (VideoDigitizerComponent  ci,
                                 RgnHandle              clipRegion)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0027, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetCLUTInUse                  (VideoDigitizerComponent  ci,
                                 CTabHandle *           colorTableHandle)                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0028, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetPLLFilterType              (VideoDigitizerComponent  ci,
                                 short                  pllType)                            FIVEWORDINLINE(0x2F3C, 0x0002, 0x0029, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetPLLFilterType              (VideoDigitizerComponent  ci,
                                 short *                pllType)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x002A, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetMaskandValue               (VideoDigitizerComponent  ci,
                                 unsigned short         blendLevel,
                                 long *                 mask,
                                 long *                 value)                              FIVEWORDINLINE(0x2F3C, 0x000A, 0x002B, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetMasterBlendLevel           (VideoDigitizerComponent  ci,
                                 unsigned short *       blendLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x002C, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetPlayThruDestination        (VideoDigitizerComponent  ci,
                                 PixMapHandle           dest,
                                 RectPtr                destRect,
                                 MatrixRecordPtr        m,
                                 RgnHandle              mask)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x002D, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetPlayThruOnOff              (VideoDigitizerComponent  ci,
                                 short                  state)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x002E, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetFieldPreference            (VideoDigitizerComponent  ci,
                                 short                  fieldFlag)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0x002F, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetFieldPreference            (VideoDigitizerComponent  ci,
                                 short *                fieldFlag)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0030, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDPreflightDestination          (VideoDigitizerComponent  ci,
                                 Rect *                 digitizerRect,
                                 PixMap **              dest,
                                 RectPtr                destRect,
                                 MatrixRecordPtr        m)                                  FIVEWORDINLINE(0x2F3C, 0x0010, 0x0032, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDPreflightGlobalRect           (VideoDigitizerComponent  ci,
                                 GrafPtr                theWindow,
                                 Rect *                 globalRect)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0033, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetPlayThruGlobalRect         (VideoDigitizerComponent  ci,
                                 GrafPtr                theWindow,
                                 Rect *                 globalRect)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0034, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetInputGammaRecord           (VideoDigitizerComponent  ci,
                                 VDGamRecPtr            inputGammaPtr)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0035, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetInputGammaRecord           (VideoDigitizerComponent  ci,
                                 VDGamRecPtr *          inputGammaPtr)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0036, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetBlackLevelValue            (VideoDigitizerComponent  ci,
                                 unsigned short *       blackLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0037, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetBlackLevelValue            (VideoDigitizerComponent  ci,
                                 unsigned short *       blackLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0038, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetWhiteLevelValue            (VideoDigitizerComponent  ci,
                                 unsigned short *       whiteLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0039, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetWhiteLevelValue            (VideoDigitizerComponent  ci,
                                 unsigned short *       whiteLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x003A, 0x7000, 0xA82A);

EXTERN_API( 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)                          FIVEWORDINLINE(0x2F3C, 0x001C, 0x003B, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetNumberOfInputs             (VideoDigitizerComponent  ci,
                                 short *                inputs)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x003C, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetInputFormat                (VideoDigitizerComponent  ci,
                                 short                  input,
                                 short *                format)                             FIVEWORDINLINE(0x2F3C, 0x0006, 0x003D, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetInput                      (VideoDigitizerComponent  ci,
                                 short                  input)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x003E, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetInput                      (VideoDigitizerComponent  ci,
                                 short *                input)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x003F, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetInputStandard              (VideoDigitizerComponent  ci,
                                 short                  inputStandard)                      FIVEWORDINLINE(0x2F3C, 0x0002, 0x0040, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetupBuffers                  (VideoDigitizerComponent  ci,
                                 VdigBufferRecListHandle  bufferList)                       FIVEWORDINLINE(0x2F3C, 0x0004, 0x0041, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGrabOneFrameAsync             (VideoDigitizerComponent  ci,
                                 short                  buffer)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0042, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDDone                          (VideoDigitizerComponent  ci,
                                 short                  buffer)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0043, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetCompression                (VideoDigitizerComponent  ci,
                                 OSType                 compressType,
                                 short                  depth,
                                 Rect *                 bounds,
                                 CodecQ                 spatialQuality,
                                 CodecQ                 temporalQuality,
                                 long                   keyFrameRate)                       FIVEWORDINLINE(0x2F3C, 0x0016, 0x0044, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDCompressOneFrameAsync         (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0045, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDCompressDone                  (VideoDigitizerComponent  ci,
                                 Boolean *              done,
                                 Ptr *                  theData,
                                 long *                 dataSize,
                                 UInt8 *                similarity,
                                 TimeRecord *           t)                                  FIVEWORDINLINE(0x2F3C, 0x0014, 0x0046, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDReleaseCompressBuffer         (VideoDigitizerComponent  ci,
                                 Ptr                    bufferAddr)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0047, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetImageDescription           (VideoDigitizerComponent  ci,
                                 ImageDescriptionHandle  desc)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0048, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDResetCompressSequence         (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0049, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetCompressionOnOff           (VideoDigitizerComponent  ci,
                                 Boolean                state)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x004A, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetCompressionTypes           (VideoDigitizerComponent  ci,
                                 VDCompressionListHandle  h)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x004B, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetTimeBase                   (VideoDigitizerComponent  ci,
                                 TimeBase               t)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x004C, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetFrameRate                  (VideoDigitizerComponent  ci,
                                 Fixed                  framesPerSecond)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x004D, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetDataRate                   (VideoDigitizerComponent  ci,
                                 long *                 milliSecPerFrame,
                                 Fixed *                framesPerSecond,
                                 long *                 bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x000C, 0x004E, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetSoundInputDriver           (VideoDigitizerComponent  ci,
                                 Str255                 soundDriverName)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x004F, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetDMADepths                  (VideoDigitizerComponent  ci,
                                 long *                 depthArray,
                                 long *                 preferredDepth)                     FIVEWORDINLINE(0x2F3C, 0x0008, 0x0050, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetPreferredTimeScale         (VideoDigitizerComponent  ci,
                                 TimeScale *            preferred)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0051, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDReleaseAsyncBuffers           (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0052, 0x7000, 0xA82A);

/* 83 is reserved for compatibility reasons */
EXTERN_API( VideoDigitizerError )
VDSetDataRate                   (VideoDigitizerComponent  ci,
                                 long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0054, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetTimeCode                   (VideoDigitizerComponent  ci,
                                 TimeRecord *           atTime,
                                 void *                 timeCodeFormat,
                                 void *                 timeCodeTime)                       FIVEWORDINLINE(0x2F3C, 0x000C, 0x0055, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDUseSafeBuffers                (VideoDigitizerComponent  ci,
                                 Boolean                useSafeBuffers)                     FIVEWORDINLINE(0x2F3C, 0x0002, 0x0056, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetSoundInputSource           (VideoDigitizerComponent  ci,
                                 long                   videoInput,
                                 long *                 soundInput)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0057, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetCompressionTime            (VideoDigitizerComponent  ci,
                                 OSType                 compressionType,
                                 short                  depth,
                                 Rect *                 srcRect,
                                 CodecQ *               spatialQuality,
                                 CodecQ *               temporalQuality,
                                 unsigned long *        compressTime)                       FIVEWORDINLINE(0x2F3C, 0x0016, 0x0058, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetPreferredPacketSize        (VideoDigitizerComponent  ci,
                                 long                   preferredPacketSizeInBytes)         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0059, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetPreferredImageDimensions   (VideoDigitizerComponent  ci,
                                 long                   width,
                                 long                   height)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x005A, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetPreferredImageDimensions   (VideoDigitizerComponent  ci,
                                 long *                 width,
                                 long *                 height)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x005B, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDGetInputName                  (VideoDigitizerComponent  ci,
                                 long                   videoInput,
                                 Str255                 name)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x005C, 0x7000, 0xA82A);

EXTERN_API( VideoDigitizerError )
VDSetDestinationPort            (VideoDigitizerComponent  ci,
                                 CGrafPtr               destPort)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x005D, 0x7000, 0xA82A);



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,                   /*    Element doesn't have contents or closing tag even if it doesn't end with />, as in the HTML <img> tag*/
    elementFlagPreserveWhiteSpace = 1L << 1,                    /*  Preserve whitespace in content, default is to remove it */
    xmlParseFlagAllowUppercase  = 1L << 0,                      /*    Entities and attributes do not have to be lowercase (strict XML), but can be upper or mixed case as in HTML*/
    xmlParseFlagAllowUnquotedAttributeValues = 1L << 1,         /*    Attributes values do not have to be enclosed in quotes (strict XML), but can be left unquoted if they contain no spaces*/
    xmlParseFlagEventParseOnly  = 1L << 2                       /*    Do event parsing only*/
};

enum {
    attributeValueKindCharString = 0,
    attributeValueKindInteger   = 1L << 0,                      /*    Number*/
    attributeValueKindPercent   = 1L << 1,                      /*    Number or percent*/
    attributeValueKindBoolean   = 1L << 2,                      /*    "true" or "false"*/
    attributeValueKindOnOff     = 1L << 3,                      /*    "on" or "off"*/
    attributeValueKindColor     = 1L << 4,                      /*    Either "#rrggbb" or a color name*/
    attributeValueKindEnum      = 1L << 5,                      /*    one of a number of strings; the enum strings are passed as a zero-separated, double-zero-terminated C string in the attributeKindValueInfo param*/
    attributeValueKindCaseSensEnum = 1L << 6,                   /*    one of a number of strings; the enum strings are passed as for attributeValueKindEnum, but the values are case-sensitive*/
    MAX_ATTRIBUTE_VALUE_KIND    = attributeValueKindCaseSensEnum
};

enum {
    nameSpaceIDNone             = 0
};

/*  A Parsed XML attribute value, one of number/percent, boolean/on-off, color, or enumerated type*/

union XMLAttributeValue {
    SInt32                          number;                     /*    The value when valueKind is attributeValueKindInteger or attributeValueKindPercent*/
    Boolean                         boolean;                    /*    The value when valueKind is attributeValueKindBoolean or attributeValueKindOnOff*/
    RGBColor                        color;                      /*    The value when valueKind is attributeValueKindColor*/
    UInt32                          enumType;                   /*    The value when valueKind is attributeValueKindEnum*/
};
typedef union XMLAttributeValue         XMLAttributeValue;
/*  An XML attribute-value pair*/

struct XMLAttribute {
    UInt32                          identifier;                 /*    Tokenized identifier, if the attribute name was recognized by the parser*/
    char *                          name;                       /*    Attribute name, Only present if identifier == xmlIdentifierUnrecognized*/
    long                            valueKind;                  /*    Type of parsed value, if the value was recognized and parsed; otherwise, attributeValueKindCharString*/
    XMLAttributeValue               value;                      /*    Parsed attribute value*/
    char *                          valueStr;                   /*    Always present*/
};
typedef struct XMLAttribute             XMLAttribute;
typedef XMLAttribute *                  XMLAttributePtr;
/*  Forward struct declarations for recursively-defined tree structure*/
typedef struct XMLContent               XMLContent;

typedef XMLContent *                    XMLContentPtr;
/*
    An XML Element, i.e.
        <element attr="value" attr="value" ...> [contents] </element>
    or
        <element attr="value" attr="value" .../>
*/

struct XMLElement {
    UInt32                          identifier;                 /*    Tokenized identifier, if the element name was recognized by the parser*/
    char *                          name;                       /*    Element name, only present if identifier == xmlIdentifierUnrecognized*/
    XMLAttributePtr                 attributes;                 /*    Array of attributes, terminated with an attribute with identifier == xmlIdentifierInvalid*/
    XMLContentPtr                   contents;                   /*    Array of contents, terminated with a content with kind == xmlIdentifierInvalid*/
};
typedef struct XMLElement               XMLElement;
typedef XMLElement *                    XMLElementPtr;
/*
    The content of an XML element is a series of parts, each of which may be either another element
    or simply character data.
*/

union XMLElementContent {
    XMLElement                      element;                    /*    The contents when the content kind is xmlContentTypeElement*/
    char *                          charData;                   /*    The contents when the content kind is xmlContentTypeCharData*/
};
typedef union XMLElementContent         XMLElementContent;

struct XMLContent {
    UInt32                          kind;
    XMLElementContent               actualContent;
};


struct XMLDocRecord {
    void *                          xmlDataStorage;             /*    opaque storage*/
    XMLElement                      rootElement;
};
typedef struct XMLDocRecord             XMLDocRecord;

typedef XMLDocRecord *                  XMLDoc;
/*callback routines for event parsing*/
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;
EXTERN_API( ComponentResult )
XMLParseDataRef                 (ComponentInstance      aParser,
                                 Handle                 dataRef,
                                 OSType                 dataRefType,
                                 long                   parseFlags,
                                 XMLDoc *               document)                           FIVEWORDINLINE(0x2F3C, 0x0010, 0x0001, 0x7000, 0xA82A);

/*  Parses the XML file pointed to by dataRef, returning a XMLDoc parse tree*/
EXTERN_API( ComponentResult )
XMLParseFile                    (ComponentInstance      aParser,
                                 ConstFSSpecPtr         fileSpec,
                                 long                   parseFlags,
                                 XMLDoc *               document)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x0002, 0x7000, 0xA82A);

/*  Parses the XML file pointed to by fileSpec, returning a XMLDoc parse tree*/
EXTERN_API( ComponentResult )
XMLParseDisposeXMLDoc           (ComponentInstance      aParser,
                                 XMLDoc                 document)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);

/*  Disposes of a XMLDoc parse tree*/
EXTERN_API( ComponentResult )
XMLParseGetDetailedParseError   (ComponentInstance      aParser,
                                 long *                 errorLine,
                                 StringPtr              errDesc)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A);

/*
    Returns a more detailed description of the error and the line in which it occurred, if a
    file failed to parse properly.
*/
EXTERN_API( ComponentResult )
XMLParseAddElement              (ComponentInstance      aParser,
                                 char *                 elementName,
                                 UInt32                 nameSpaceID,
                                 UInt32 *               elementID,
                                 long                   elementFlags)                       FIVEWORDINLINE(0x2F3C, 0x0010, 0x0005, 0x7000, 0xA82A);

/*
    Tell the parser of an element to be recognized. The tokenized element unique identifier is
    passed in *elementID, unless *elementID is zero, whereupon a unique ID is generated and returned.
    Thus, a valid element identifier can never be zero.
*/
EXTERN_API( ComponentResult )
XMLParseAddAttribute            (ComponentInstance      aParser,
                                 UInt32                 elementID,
                                 UInt32                 nameSpaceID,
                                 char *                 attributeName,
                                 UInt32 *               attributeID)                        FIVEWORDINLINE(0x2F3C, 0x0010, 0x0006, 0x7000, 0xA82A);

/*
    Tells the parser of an attribute for the specified element. The tokenized attribute unique
    ID is passed in *attributeID, unless *attributeID is zero, whereupon a unique ID is generated and
    returned. Thus, a valid attribute identifier can never be zero.
*/
EXTERN_API( ComponentResult )
XMLParseAddMultipleAttributes   (ComponentInstance      aParser,
                                 UInt32                 elementID,
                                 UInt32 *               nameSpaceIDs,
                                 char *                 attributeNames,
                                 UInt32 *               attributeIDs)                       FIVEWORDINLINE(0x2F3C, 0x0010, 0x0007, 0x7000, 0xA82A);

/*
    Tells the parser of several attributes for the specified element. The attributes are passed
    as a zero-delimited, double-zero-terminated C string in attributeNames, and the attribute
    IDs are passed in on attributeIDs as an array; if any attributeIDs are zero, unique IDs
    are generated for those and returned
*/
EXTERN_API( ComponentResult )
XMLParseAddAttributeAndValue    (ComponentInstance      aParser,
                                 UInt32                 elementID,
                                 UInt32                 nameSpaceID,
                                 char *                 attributeName,
                                 UInt32 *               attributeID,
                                 UInt32                 attributeValueKind,
                                 void *                 attributeValueKindInfo)             FIVEWORDINLINE(0x2F3C, 0x0018, 0x0008, 0x7000, 0xA82A);

/*
    Tells the parser of an attribute, which may have a particular type of value, for the
    specified element. Params are as in XMLParseAddAttribute, plus all the kinds of values
    the attribute may have are passed in attributeValueKind, and optional additional information
    required to tokenize the particular kind of attribute is passed in attributeValueKindInfo
*/
EXTERN_API( ComponentResult )
XMLParseAddMultipleAttributesAndValues (ComponentInstance  aParser,
                                 UInt32                 elementID,
                                 UInt32 *               nameSpaceIDs,
                                 char *                 attributeNames,
                                 UInt32 *               attributeIDs,
                                 UInt32 *               attributeValueKinds,
                                 void **                attributeValueKindInfos)            FIVEWORDINLINE(0x2F3C, 0x0018, 0x0009, 0x7000, 0xA82A);

/*
    Tells the parser of several attributes, which may have a particular type of value, for the
    specified element. Params are as in XMLParseAddMultipleAttributes, plus all the kinds of values
    the attributes may have are passed in attributeValueKinds, and optional additional information
    required to tokenize the particular kind of attributes is passed in attributeValueKindInfos
*/
EXTERN_API( ComponentResult )
XMLParseAddAttributeValueKind   (ComponentInstance      aParser,
                                 UInt32                 elementID,
                                 UInt32                 attributeID,
                                 UInt32                 attributeValueKind,
                                 void *                 attributeValueKindInfo)             FIVEWORDINLINE(0x2F3C, 0x0010, 0x000A, 0x7000, 0xA82A);

/*
    Tells the parser that the particular attribute may have an additional kind of
    value, as specified by attributeValueKind and attributeValueKindInfo
*/
EXTERN_API( ComponentResult )
XMLParseAddNameSpace            (ComponentInstance      aParser,
                                 char *                 nameSpaceURL,
                                 UInt32 *               nameSpaceID)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x000B, 0x7000, 0xA82A);

/*
    Tell the parser of a namespace to be recognized. The tokenized namespace unique identifier is
    passed in *nameSpaceID, unless *nameSpaceID is zero, whereupon a unique ID is generated and returned.
    Thus, a valid nameSpaceID identifier can never be zero.
*/
EXTERN_API( ComponentResult )
XMLParseSetOffsetAndLimit       (ComponentInstance      aParser,
                                 UInt32                 offset,
                                 UInt32                 limit)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x000C, 0x7000, 0xA82A);

/*  Specifies the offset and limit for reading from the dataref to be used when parsing*/
EXTERN_API( ComponentResult )
XMLParseSetEventParseRefCon     (ComponentInstance      aParser,
                                 long                   refcon)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);

/*  Set the event parse refcon*/
EXTERN_API( ComponentResult )
XMLParseSetStartDocumentHandler (ComponentInstance      aParser,
                                 StartDocumentHandlerUPP  startDocument)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x000E, 0x7000, 0xA82A);

/*  Set the start document handler UPP for event parsing*/
EXTERN_API( ComponentResult )
XMLParseSetEndDocumentHandler   (ComponentInstance      aParser,
                                 EndDocumentHandlerUPP  endDocument)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x000F, 0x7000, 0xA82A);

/*  Set the end document handler UPP for event parsing*/
EXTERN_API( ComponentResult )
XMLParseSetStartElementHandler  (ComponentInstance      aParser,
                                 StartElementHandlerUPP  startElement)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0010, 0x7000, 0xA82A);

/*  Set the start element handler UPP for event parsing*/
EXTERN_API( ComponentResult )
XMLParseSetEndElementHandler    (ComponentInstance      aParser,
                                 EndElementHandlerUPP   endElement)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0011, 0x7000, 0xA82A);

/*  Set the end element handler UPP for event parsing*/
EXTERN_API( ComponentResult )
XMLParseSetCharDataHandler      (ComponentInstance      aParser,
                                 CharDataHandlerUPP     charData)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);

/*  Set the character data handler UPP for event parsing*/
EXTERN_API( ComponentResult )
XMLParseSetPreprocessInstructionHandler (ComponentInstance  aParser,
                                 PreprocessInstructionHandlerUPP  preprocessInstruction)    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0013, 0x7000, 0xA82A);

/*  Set the preprocess instruction handler UPP for event parsing*/
EXTERN_API( ComponentResult )
XMLParseSetCommentHandler       (ComponentInstance      aParser,
                                 CommentHandlerUPP      comment)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A);

/*  Set the comment handler UPP for event parsing*/
/*
    Helper Macros
    
        These macros allow you to easily add entities and attributes to the parser
        in an error free manner when the identifiers are defined in a particular manner.
        For these to work, you must define the identifiers as follows:
        
        For entities, they must be defined as element_elementName, as in:
        
            enum
            {
                element_xml =   1,      //  "xml"
                element_head,           //  "head"
                element_body            //  "body"
            };
            
        If the element name has characters that are illegal in an identifier,
        some of the macros support that, but the identifier must not contain
        the illegal characters:
        
            enum
            {
                element_rootlayout      //  "root-layout"
            }
            
        For attribute names, similar rules apply except that they must be defined
        as attr_attributeName, as in:
            
            enum
            {
                attr_src    =   1,      //  "src"
                attr_href,
                attr_width,
                attr_height
            }
            
        Finally, the existence of local variables elementID and attributeID is required.
*/

#define XML_ADD_ELEMENT_NS(elementName,nameSpaceID)        elementID   =   cdh_GLUE2(element_,elementName);    XMLParseAddElement(xmlParser, #elementName, nameSpaceID, &elementID, 0)
#define XML_ADD_ELEMENT(elementName)                    XML_ADD_ELEMENT_NS(elementName,nameSpaceIDNone)

/*
    Adds the specified element to the parser, i.e. XML_ADD_ELEMENT(head) adds the element "head" with
    a unique identifier of element_head
*/

#define XML_ADD_COMPLEX_ELEMENT_NS(elementName,elemID,nameSpaceID)     elementID   =   cdh_GLUE2(element_,elemID);     XMLParseAddElement(xmlParser, #elementName, nameSpaceID, &elementID, 0)
#define XML_ADD_COMPLEX_ELEMENT(elementName,elemID)                     XML_ADD_COMPLEX_ELEMENT_NS(elementName,elemID,nameSpaceIDNone)

/*
    Adds the specified element to the parser, not using the same string to generate the identifier and
    the element name. Use for element names that contain characters which are illegal in identifiers,
    i.e XML_ADD_COMPLEX_ELEMENT("root-layout",rootlayout) adds the element "root-layout" with a unique
    identifier of element_rootlayout
*/

#define XML_ADD_ATTRIBUTE_NS(attrName,nameSpaceID)     attributeID =   cdh_GLUE2(attr_,attrName);      XMLParseAddAttribute(xmlParser, elementID, nameSpaceID, #attrName, &attributeID);
#define XML_ADD_ATTRIBUTE(attrName)                       XML_ADD_ATTRIBUTE_NS(attrName,nameSpaceIDNone)

/*
    Adds the specified attribute to the current element in the parser, i.e. XML_ADD_ATTRIBUTE(src)
    adds the attribute "src" to the current element, and identifies it by attr_src
*/

#define XML_ADD_COMPLEX_ATTRIBUTE_NS(attrName,attrID,nameSpaceID)  attributeID =   cdh_GLUE2(attr_,attrID);        XMLParseAddAttribute(xmlParser, elementID, nameSpaceID, #attrName, &attributeID);
#define XML_ADD_COMPLEX_ATTRIBUTE(attrName,attrID)                    XML_ADD_COMPLEX_ATTRIBUTE_NS(attrName,attrID,nameSpaceIDNone)

/*
    Adds the specified attribute to the current element in the parser, i.e. XML_ADD_ATTRIBUTE(element_img, src)
    adds the attribute "src" to the element_img element, and identifies it by attr_src
    Adds the specified attribute to the current element in the parser, not using the same string to
    generate the identifier and the element name. Use for attribute names that contain characters which
    are illegal in identifiers, i.e XML_ADD_COMPLEX_ATTRIBUTE("http-equiv",httpequiv) adds the element
    "http-equiv" with a unique identifier of attr_httpequiv
*/

#define XML_ADD_ATTRIBUTE_AND_VALUE_NS(attrName,valueKind,valueKindInfo,nameSpaceID)   attributeID =   cdh_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 =   cdh_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)






/*
    General Sequence Grab stuff
*/
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;                   /* zero*/
};
typedef struct SGDeviceName             SGDeviceName;
enum {
    sgDeviceNameFlagDeviceUnavailable = (1 << 0)
};


struct SGDeviceListRecord {
    short                           count;
    short                           selectedIndex;
    long                            reserved;                   /* zero*/
    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
};


EXTERN_API( ComponentResult )
SGInitialize                    (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetDataOutput                 (SeqGrabComponent       s,
                                 const FSSpec *         movieFile,
                                 long                   whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetDataOutput                 (SeqGrabComponent       s,
                                 FSSpec *               movieFile,
                                 long *                 whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetGWorld                     (SeqGrabComponent       s,
                                 CGrafPtr               gp,
                                 GDHandle               gd)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetGWorld                     (SeqGrabComponent       s,
                                 CGrafPtr *             gp,
                                 GDHandle *             gd)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0005, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGNewChannel                    (SeqGrabComponent       s,
                                 OSType                 channelType,
                                 SGChannel *            ref)                                FIVEWORDINLINE(0x2F3C, 0x0008, 0x0006, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGDisposeChannel                (SeqGrabComponent       s,
                                 SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGStartPreview                  (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0010, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGStartRecord                   (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0011, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGIdle                          (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0012, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGStop                          (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0013, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPause                         (SeqGrabComponent       s,
                                 Byte                   pause)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x0014, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPrepare                       (SeqGrabComponent       s,
                                 Boolean                prepareForPreview,
                                 Boolean                prepareForRecord)                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGRelease                       (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0016, 0x7000, 0xA82A);

EXTERN_API( Movie )
SGGetMovie                      (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0017, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetMaximumRecordTime          (SeqGrabComponent       s,
                                 unsigned long          ticks)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0018, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetMaximumRecordTime          (SeqGrabComponent       s,
                                 unsigned long *        ticks)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetStorageSpaceRemaining      (SeqGrabComponent       s,
                                 unsigned long *        bytes)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetTimeRemaining              (SeqGrabComponent       s,
                                 long *                 ticksLeft)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGrabPict                      (SeqGrabComponent       s,
                                 PicHandle *            p,
                                 const Rect *           bounds,
                                 short                  offscreenDepth,
                                 long                   grabPictFlags)                      FIVEWORDINLINE(0x2F3C, 0x000E, 0x001C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetLastMovieResID             (SeqGrabComponent       s,
                                 short *                resID)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetFlags                      (SeqGrabComponent       s,
                                 long                   sgFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x001E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetFlags                      (SeqGrabComponent       s,
                                 long *                 sgFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x001F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetDataProc                   (SeqGrabComponent       s,
                                 SGDataUPP              proc,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0020, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGNewChannelFromComponent       (SeqGrabComponent       s,
                                 SGChannel *            newChannel,
                                 Component              sgChannelComponent)                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0021, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGDisposeDeviceList             (SeqGrabComponent       s,
                                 SGDeviceList           list)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0022, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAppendDeviceListToMenu        (SeqGrabComponent       s,
                                 SGDeviceList           list,
                                 MenuRef                mh)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0023, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetSettings                   (SeqGrabComponent       s,
                                 UserData               ud,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0024, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetSettings                   (SeqGrabComponent       s,
                                 UserData *             ud,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0025, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetIndChannel                 (SeqGrabComponent       s,
                                 short                  index,
                                 SGChannel *            ref,
                                 OSType *               chanType)                           FIVEWORDINLINE(0x2F3C, 0x000A, 0x0026, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGUpdate                        (SeqGrabComponent       s,
                                 RgnHandle              updateRgn)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0027, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetPause                      (SeqGrabComponent       s,
                                 Byte *                 paused)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0028, 0x7000, 0xA82A);

typedef const Component *               ConstComponentListPtr;
EXTERN_API( ComponentResult )
SGSettingsDialog                (SeqGrabComponent       s,
                                 SGChannel              c,
                                 short                  numPanels,
                                 ConstComponentListPtr  panelList,
                                 long                   flags,
                                 SGModalFilterUPP       proc,
                                 long                   procRefNum)                         FIVEWORDINLINE(0x2F3C, 0x0016, 0x0029, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetAlignmentProc              (SeqGrabComponent       s,
                                 ICMAlignmentProcRecordPtr  alignmentProc)                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x002A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelSettings            (SeqGrabComponent       s,
                                 SGChannel              c,
                                 UserData               ud,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x002B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelSettings            (SeqGrabComponent       s,
                                 SGChannel              c,
                                 UserData *             ud,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x002C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetMode                       (SeqGrabComponent       s,
                                 Boolean *              previewMode,
                                 Boolean *              recordMode)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x002D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetDataRef                    (SeqGrabComponent       s,
                                 Handle                 dataRef,
                                 OSType                 dataRefType,
                                 long                   whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x000C, 0x002E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetDataRef                    (SeqGrabComponent       s,
                                 Handle *               dataRef,
                                 OSType *               dataRefType,
                                 long *                 whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x000C, 0x002F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGNewOutput                     (SeqGrabComponent       s,
                                 Handle                 dataRef,
                                 OSType                 dataRefType,
                                 long                   whereFlags,
                                 SGOutput *             sgOut)                              FIVEWORDINLINE(0x2F3C, 0x0010, 0x0030, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGDisposeOutput                 (SeqGrabComponent       s,
                                 SGOutput               sgOut)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0031, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetOutputFlags                (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 long                   whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0032, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelOutput              (SeqGrabComponent       s,
                                 SGChannel              c,
                                 SGOutput               sgOut)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0033, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetDataOutputStorageSpaceRemaining (SeqGrabComponent  s,
                                 SGOutput               sgOut,
                                 unsigned long *        space)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0034, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGHandleUpdateEvent             (SeqGrabComponent       s,
                                 const EventRecord *    event,
                                 Boolean *              handled)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0035, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetOutputNextOutput           (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 SGOutput               nextOut)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0036, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetOutputNextOutput           (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 SGOutput *             nextOut)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0037, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetOutputMaximumOffset        (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 const wide *           maxOffset)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0038, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetOutputMaximumOffset        (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 wide *                 maxOffset)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0039, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetOutputDataReference        (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 Handle *               dataRef,
                                 OSType *               dataRefType)                        FIVEWORDINLINE(0x2F3C, 0x000C, 0x003A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGWriteExtendedMovieData        (SeqGrabComponent       s,
                                 SGChannel              c,
                                 Ptr                    p,
                                 long                   len,
                                 wide *                 offset,
                                 SGOutput *             sgOut)                              FIVEWORDINLINE(0x2F3C, 0x0014, 0x003B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetStorageSpaceRemaining64    (SeqGrabComponent       s,
                                 wide *                 bytes)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x003C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetDataOutputStorageSpaceRemaining64 (SeqGrabComponent  s,
                                 SGOutput               sgOut,
                                 wide *                 space)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x003D, 0x7000, 0xA82A);

/*
    calls from Channel to seqGrab
*/
EXTERN_API( ComponentResult )
SGWriteMovieData                (SeqGrabComponent       s,
                                 SGChannel              c,
                                 Ptr                    p,
                                 long                   len,
                                 long *                 offset)                             FIVEWORDINLINE(0x2F3C, 0x0010, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAddFrameReference             (SeqGrabComponent       s,
                                 SeqGrabFrameInfoPtr    frameInfo)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetNextFrameReference         (SeqGrabComponent       s,
                                 SeqGrabFrameInfoPtr    frameInfo,
                                 TimeValue *            frameDuration,
                                 long *                 frameNumber)                        FIVEWORDINLINE(0x2F3C, 0x000C, 0x0102, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetTimeBase                   (SeqGrabComponent       s,
                                 TimeBase *             tb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0103, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSortDeviceList                (SeqGrabComponent       s,
                                 SGDeviceList           list)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0104, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAddMovieData                  (SeqGrabComponent       s,
                                 SGChannel              c,
                                 Ptr                    p,
                                 long                   len,
                                 long *                 offset,
                                 long                   chRefCon,
                                 TimeValue              time,
                                 short                  writeType)                          FIVEWORDINLINE(0x2F3C, 0x001A, 0x0105, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChangedSource                 (SeqGrabComponent       s,
                                 SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0106, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAddExtendedFrameReference     (SeqGrabComponent       s,
                                 SeqGrabExtendedFrameInfoPtr  frameInfo)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0107, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetNextExtendedFrameReference (SeqGrabComponent       s,
                                 SeqGrabExtendedFrameInfoPtr  frameInfo,
                                 TimeValue *            frameDuration,
                                 long *                 frameNumber)                        FIVEWORDINLINE(0x2F3C, 0x000C, 0x0108, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAddExtendedMovieData          (SeqGrabComponent       s,
                                 SGChannel              c,
                                 Ptr                    p,
                                 long                   len,
                                 wide *                 offset,
                                 long                   chRefCon,
                                 TimeValue              time,
                                 short                  writeType,
                                 SGOutput *             whichOutput)                        FIVEWORDINLINE(0x2F3C, 0x001E, 0x0109, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAddOutputDataRefToMedia       (SeqGrabComponent       s,
                                 SGOutput               sgOut,
                                 Media                  theMedia,
                                 SampleDescriptionHandle  desc)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x010A, 0x7000, 0xA82A);



/*** Sequence Grab CHANNEL Component Stuff ***/

EXTERN_API( ComponentResult )
SGSetChannelUsage               (SGChannel              c,
                                 long                   usage)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0080, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelUsage               (SGChannel              c,
                                 long *                 usage)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0081, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelBounds              (SGChannel              c,
                                 const Rect *           bounds)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0082, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelBounds              (SGChannel              c,
                                 Rect *                 bounds)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0083, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelVolume              (SGChannel              c,
                                 short                  volume)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0084, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelVolume              (SGChannel              c,
                                 short *                volume)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0085, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelInfo                (SGChannel              c,
                                 long *                 channelInfo)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0086, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelPlayFlags           (SGChannel              c,
                                 long                   playFlags)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0087, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelPlayFlags           (SGChannel              c,
                                 long *                 playFlags)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0088, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelMaxFrames           (SGChannel              c,
                                 long                   frameCount)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0089, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelMaxFrames           (SGChannel              c,
                                 long *                 frameCount)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x008A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelRefCon              (SGChannel              c,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x008B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelClip                (SGChannel              c,
                                 RgnHandle              theClip)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x008C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelClip                (SGChannel              c,
                                 RgnHandle *            theClip)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x008D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelSampleDescription   (SGChannel              c,
                                 Handle                 sampleDesc)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x008E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelDeviceList          (SGChannel              c,
                                 long                   selectionFlags,
                                 SGDeviceList *         list)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x008F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelDevice              (SGChannel              c,
                                 StringPtr              name)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0090, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetChannelMatrix              (SGChannel              c,
                                 const MatrixRecord *   m)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0091, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelMatrix              (SGChannel              c,
                                 MatrixRecord *         m)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0092, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelTimeScale           (SGChannel              c,
                                 TimeScale *            scale)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0093, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelPutPicture             (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0094, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelSetRequestedDataRate   (SGChannel              c,
                                 long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0095, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelGetRequestedDataRate   (SGChannel              c,
                                 long *                 bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0096, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelSetDataSourceName      (SGChannel              c,
                                 ConstStr255Param       name,
                                 ScriptCode             scriptTag)                          FIVEWORDINLINE(0x2F3C, 0x0006, 0x0097, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelGetDataSourceName      (SGChannel              c,
                                 Str255                 name,
                                 ScriptCode *           scriptTag)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0098, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelSetCodecSettings       (SGChannel              c,
                                 Handle                 settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0099, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGChannelGetCodecSettings       (SGChannel              c,
                                 Handle *               settings)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x009A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetChannelTimeBase            (SGChannel              c,
                                 TimeBase *             tb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x009B, 0x7000, 0xA82A);

/*
    calls from seqGrab to Channel
*/
EXTERN_API( ComponentResult )
SGInitChannel                   (SGChannel              c,
                                 SeqGrabComponent       owner)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0180, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGWriteSamples                  (SGChannel              c,
                                 Movie                  m,
                                 AliasHandle            theFile)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0181, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetDataRate                   (SGChannel              c,
                                 long *                 bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0182, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAlignChannelRect              (SGChannel              c,
                                 Rect *                 r)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0183, 0x7000, 0xA82A);

/*
    Dorky dialog panel calls
*/
EXTERN_API( ComponentResult )
SGPanelGetDitl                  (SeqGrabComponent       s,
                                 Handle *               ditl)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0200, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelGetTitle                 (SeqGrabComponent       s,
                                 Str255                 title)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0201, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelCanRun                   (SeqGrabComponent       s,
                                 SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0202, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelInstall                  (SeqGrabComponent       s,
                                 SGChannel              c,
                                 DialogRef              d,
                                 short                  itemOffset)                         FIVEWORDINLINE(0x2F3C, 0x000A, 0x0203, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelEvent                    (SeqGrabComponent       s,
                                 SGChannel              c,
                                 DialogRef              d,
                                 short                  itemOffset,
                                 const EventRecord *    theEvent,
                                 short *                itemHit,
                                 Boolean *              handled)                            FIVEWORDINLINE(0x2F3C, 0x0016, 0x0204, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelItem                     (SeqGrabComponent       s,
                                 SGChannel              c,
                                 DialogRef              d,
                                 short                  itemOffset,
                                 short                  itemNum)                            FIVEWORDINLINE(0x2F3C, 0x000C, 0x0205, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelRemove                   (SeqGrabComponent       s,
                                 SGChannel              c,
                                 DialogRef              d,
                                 short                  itemOffset)                         FIVEWORDINLINE(0x2F3C, 0x000A, 0x0206, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelSetGrabber               (SeqGrabComponent       s,
                                 SeqGrabComponent       sg)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0207, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelSetResFile               (SeqGrabComponent       s,
                                 short                  resRef)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0208, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelGetSettings              (SeqGrabComponent       s,
                                 SGChannel              c,
                                 UserData *             ud,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x0209, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelSetSettings              (SeqGrabComponent       s,
                                 SGChannel              c,
                                 UserData               ud,
                                 long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x020A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelValidateInput            (SeqGrabComponent       s,
                                 Boolean *              ok)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x020B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGPanelSetEventFilter           (SeqGrabComponent       s,
                                 SGModalFilterUPP       proc,
                                 long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x020C, 0x7000, 0xA82A);


/*** Sequence Grab VIDEO CHANNEL Component Stuff ***/
/*
    Video 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;
EXTERN_API( ComponentResult )
SGGetSrcVideoBounds             (SGChannel              c,
                                 Rect *                 r)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetVideoRect                  (SGChannel              c,
                                 const Rect *           r)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetVideoRect                  (SGChannel              c,
                                 Rect *                 r)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0102, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetVideoCompressorType        (SGChannel              c,
                                 OSType *               compressorType)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0103, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetVideoCompressorType        (SGChannel              c,
                                 OSType                 compressorType)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0104, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetVideoCompressor            (SGChannel              c,
                                 short                  depth,
                                 CompressorComponent    compressor,
                                 CodecQ                 spatialQuality,
                                 CodecQ                 temporalQuality,
                                 long                   keyFrameRate)                       FIVEWORDINLINE(0x2F3C, 0x0012, 0x0105, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetVideoCompressor            (SGChannel              c,
                                 short *                depth,
                                 CompressorComponent *  compressor,
                                 CodecQ *               spatialQuality,
                                 CodecQ *               temporalQuality,
                                 long *                 keyFrameRate)                       FIVEWORDINLINE(0x2F3C, 0x0014, 0x0106, 0x7000, 0xA82A);

EXTERN_API( ComponentInstance )
SGGetVideoDigitizerComponent    (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0107, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetVideoDigitizerComponent    (SGChannel              c,
                                 ComponentInstance      vdig)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0108, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGVideoDigitizerChanged         (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0109, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetVideoBottlenecks           (SGChannel              c,
                                 VideoBottles *         vb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x010A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetVideoBottlenecks           (SGChannel              c,
                                 VideoBottles *         vb)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x010B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGrabFrame                     (SGChannel              c,
                                 short                  bufferNum)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0x010C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGrabFrameComplete             (SGChannel              c,
                                 short                  bufferNum,
                                 Boolean *              done)                               FIVEWORDINLINE(0x2F3C, 0x0006, 0x010D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGDisplayFrame                  (SGChannel              c,
                                 short                  bufferNum,
                                 const MatrixRecord *   mp,
                                 RgnHandle              clipRgn)                            FIVEWORDINLINE(0x2F3C, 0x000A, 0x010E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGCompressFrame                 (SGChannel              c,
                                 short                  bufferNum)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0x010F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGCompressFrameComplete         (SGChannel              c,
                                 short                  bufferNum,
                                 Boolean *              done,
                                 SGCompressInfo *       ci)                                 FIVEWORDINLINE(0x2F3C, 0x000A, 0x0110, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGAddFrame                      (SGChannel              c,
                                 short                  bufferNum,
                                 TimeValue              atTime,
                                 TimeScale              scale,
                                 const SGCompressInfo * ci)                                 FIVEWORDINLINE(0x2F3C, 0x000E, 0x0111, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGTransferFrameForCompress      (SGChannel              c,
                                 short                  bufferNum,
                                 const MatrixRecord *   mp,
                                 RgnHandle              clipRgn)                            FIVEWORDINLINE(0x2F3C, 0x000A, 0x0112, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetCompressBuffer             (SGChannel              c,
                                 short                  depth,
                                 const Rect *           compressSize)                       FIVEWORDINLINE(0x2F3C, 0x0006, 0x0113, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetCompressBuffer             (SGChannel              c,
                                 short *                depth,
                                 Rect *                 compressSize)                       FIVEWORDINLINE(0x2F3C, 0x0008, 0x0114, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetBufferInfo                 (SGChannel              c,
                                 short                  bufferNum,
                                 PixMapHandle *         bufferPM,
                                 Rect *                 bufferRect,
                                 GWorldPtr *            compressBuffer,
                                 Rect *                 compressBufferRect)                 FIVEWORDINLINE(0x2F3C, 0x0012, 0x0115, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetUseScreenBuffer            (SGChannel              c,
                                 Boolean                useScreenBuffer)                    FIVEWORDINLINE(0x2F3C, 0x0002, 0x0116, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetUseScreenBuffer            (SGChannel              c,
                                 Boolean *              useScreenBuffer)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0117, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGrabCompressComplete          (SGChannel              c,
                                 Boolean *              done,
                                 SGCompressInfo *       ci,
                                 TimeRecord *           tr)                                 FIVEWORDINLINE(0x2F3C, 0x000C, 0x0118, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGDisplayCompress               (SGChannel              c,
                                 Ptr                    dataPtr,
                                 ImageDescriptionHandle  desc,
                                 MatrixRecord *         mp,
                                 RgnHandle              clipRgn)                            FIVEWORDINLINE(0x2F3C, 0x0010, 0x0119, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetFrameRate                  (SGChannel              c,
                                 Fixed                  frameRate)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x011A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetFrameRate                  (SGChannel              c,
                                 Fixed *                frameRate)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x011B, 0x7000, 0xA82A);


EXTERN_API( ComponentResult )
SGSetPreferredPacketSize        (SGChannel              c,
                                 long                   preferredPacketSizeInBytes)         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0121, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetPreferredPacketSize        (SGChannel              c,
                                 long *                 preferredPacketSizeInBytes)         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0122, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetUserVideoCompressorList    (SGChannel              c,
                                 Handle                 compressorTypes)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0123, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetUserVideoCompressorList    (SGChannel              c,
                                 Handle *               compressorTypes)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0124, 0x7000, 0xA82A);

/*** Sequence Grab SOUND CHANNEL Component Stuff ***/

/*
    Sound stuff
*/
EXTERN_API( ComponentResult )
SGSetSoundInputDriver           (SGChannel              c,
                                 ConstStr255Param       driverName)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0100, 0x7000, 0xA82A);

EXTERN_API( long )
SGGetSoundInputDriver           (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0101, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSoundInputDriverChanged       (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0102, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetSoundRecordChunkSize       (SGChannel              c,
                                 long                   seconds)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0103, 0x7000, 0xA82A);

EXTERN_API( long )
SGGetSoundRecordChunkSize       (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0104, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetSoundInputRate             (SGChannel              c,
                                 Fixed                  rate)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0105, 0x7000, 0xA82A);

EXTERN_API( Fixed )
SGGetSoundInputRate             (SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0106, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetSoundInputParameters       (SGChannel              c,
                                 short                  sampleSize,
                                 short                  numChannels,
                                 OSType                 compressionType)                    FIVEWORDINLINE(0x2F3C, 0x0008, 0x0107, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetSoundInputParameters       (SGChannel              c,
                                 short *                sampleSize,
                                 short *                numChannels,
                                 OSType *               compressionType)                    FIVEWORDINLINE(0x2F3C, 0x000C, 0x0108, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetAdditionalSoundRates       (SGChannel              c,
                                 Handle                 rates)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0109, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetAdditionalSoundRates       (SGChannel              c,
                                 Handle *               rates)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x010A, 0x7000, 0xA82A);

/*
    Text stuff
*/
EXTERN_API( ComponentResult )
SGSetFontName                   (SGChannel              c,
                                 StringPtr              pstr)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetFontSize                   (SGChannel              c,
                                 short                  fontSize)                           FIVEWORDINLINE(0x2F3C, 0x0002, 0x0101, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetTextForeColor              (SGChannel              c,
                                 RGBColor *             theColor)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0102, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetTextBackColor              (SGChannel              c,
                                 RGBColor *             theColor)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0103, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetJustification              (SGChannel              c,
                                 short                  just)                               FIVEWORDINLINE(0x2F3C, 0x0002, 0x0104, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGGetTextReturnToSpaceValue     (SGChannel              c,
                                 short *                rettospace)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0105, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetTextReturnToSpaceValue     (SGChannel              c,
                                 short                  rettospace)                         FIVEWORDINLINE(0x2F3C, 0x0002, 0x0106, 0x7000, 0xA82A);

/*
    Music stuff
*/
EXTERN_API( ComponentResult )
SGGetInstrument                 (SGChannel              c,
                                 ToneDescription *      td)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0100, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
SGSetInstrument                 (SGChannel              c,
                                 ToneDescription *      td)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);


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;
/* Component type and subtype enumerations*/
enum {
    QTVideoOutputComponentType  = FOUR_CHAR_CODE('vout'),
    QTVideoOutputComponentBaseSubType = FOUR_CHAR_CODE('base')
};


/* QTVideoOutput Component flags*/

enum {
    kQTVideoOutputDontDisplayToUser = 1L << 0
};

/* Display mode atom types*/

enum {
    kQTVODisplayModeItem        = FOUR_CHAR_CODE('qdmi'),
    kQTVODimensions             = FOUR_CHAR_CODE('dimn'),       /* atom contains two longs - pixel count - width, height*/
    kQTVOResolution             = FOUR_CHAR_CODE('resl'),       /* atom contains two Fixed - hRes, vRes in dpi*/
    kQTVORefreshRate            = FOUR_CHAR_CODE('refr'),       /* atom contains one Fixed - refresh rate in Hz*/
    kQTVOPixelType              = FOUR_CHAR_CODE('pixl'),       /* atom contains one OSType - pixel format of mode*/
    kQTVOName                   = FOUR_CHAR_CODE('name'),       /* atom contains string (no length byte) - name of mode for display to user*/
    kQTVODecompressors          = FOUR_CHAR_CODE('deco'),       /* atom contains other atoms indicating supported decompressors*/
                                                                /* kQTVODecompressors sub-atoms*/
    kQTVODecompressorType       = FOUR_CHAR_CODE('dety'),       /* atom contains one OSType - decompressor type code*/
    kQTVODecompressorContinuous = FOUR_CHAR_CODE('cont'),       /* atom contains one Boolean - true if this type is displayed continuously*/
    kQTVODecompressorComponent  = FOUR_CHAR_CODE('cmpt')        /* atom contains one Component - component id of decompressor*/
};

/** These are QTVideoOutput procedures **/
EXTERN_API( ComponentResult )
QTVideoOutputGetDisplayModeList (QTVideoOutputComponent  vo,
                                 QTAtomContainer *      outputs)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetCurrentClientName (QTVideoOutputComponent  vo,
                                 Str255                 str)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0002, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputSetClientName      (QTVideoOutputComponent  vo,
                                 ConstStr255Param       str)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetClientName      (QTVideoOutputComponent  vo,
                                 Str255                 str)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputBegin              (QTVideoOutputComponent  vo)                                FIVEWORDINLINE(0x2F3C, 0x0000, 0x0005, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputEnd                (QTVideoOutputComponent  vo)                                FIVEWORDINLINE(0x2F3C, 0x0000, 0x0006, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputSetDisplayMode     (QTVideoOutputComponent  vo,
                                 long                   displayModeID)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetDisplayMode     (QTVideoOutputComponent  vo,
                                 long *                 displayModeID)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0008, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputCustomConfigureDisplay (QTVideoOutputComponent  vo,
                                 ModalFilterUPP         filter)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0009, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputSaveState          (QTVideoOutputComponent  vo,
                                 QTAtomContainer *      state)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x000A, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputRestoreState       (QTVideoOutputComponent  vo,
                                 QTAtomContainer        state)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x000B, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetGWorld          (QTVideoOutputComponent  vo,
                                 GWorldPtr *            gw)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetGWorldParameters (QTVideoOutputComponent  vo,
                                 Ptr *                  baseAddr,
                                 long *                 rowBytes,
                                 CTabHandle *           colorTable)                         FIVEWORDINLINE(0x2F3C, 0x000C, 0x000D, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetIndSoundOutput  (QTVideoOutputComponent  vo,
                                 long                   index,
                                 Component *            outputComponent)                    FIVEWORDINLINE(0x2F3C, 0x0008, 0x000E, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetClock           (QTVideoOutputComponent  vo,
                                 ComponentInstance *    clock)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x000F, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputSetEchoPort        (QTVideoOutputComponent  vo,
                                 CGrafPtr               echoPort)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0010, 0x7000, 0xA82A);

EXTERN_API( ComponentResult )
QTVideoOutputGetIndImageDecompressor (QTVideoOutputComponent  vo,
                                 long                   index,
                                 Component *            codec)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0011, 0x7000, 0xA82A);

/* UPP call backs */
#if OPAQUE_UPP_TYPES
    EXTERN_API(DataHCompletionUPP)
    NewDataHCompletionUPP          (DataHCompletionProcPtr  userRoutine);

    EXTERN_API(VdigIntUPP)
    NewVdigIntUPP                  (VdigIntProcPtr          userRoutine);

    EXTERN_API(StartDocumentHandlerUPP)
    NewStartDocumentHandlerUPP     (StartDocumentHandler    userRoutine);

    EXTERN_API(EndDocumentHandlerUPP)
    NewEndDocumentHandlerUPP       (EndDocumentHandler      userRoutine);

    EXTERN_API(StartElementHandlerUPP)
    NewStartElementHandlerUPP      (StartElementHandler     userRoutine);

    EXTERN_API(EndElementHandlerUPP)
    NewEndElementHandlerUPP        (EndElementHandler       userRoutine);

    EXTERN_API(CharDataHandlerUPP)
    NewCharDataHandlerUPP          (CharDataHandler         userRoutine);

    EXTERN_API(PreprocessInstructionHandlerUPP)
    NewPreprocessInstructionHandlerUPP    (PreprocessInstructionHandler userRoutine);

    EXTERN_API(CommentHandlerUPP)
    NewCommentHandlerUPP           (CommentHandler          userRoutine);

    EXTERN_API(SGDataUPP)
    NewSGDataUPP                   (SGDataProcPtr           userRoutine);

    EXTERN_API(SGModalFilterUPP)
    NewSGModalFilterUPP            (SGModalFilterProcPtr    userRoutine);

    EXTERN_API(SGGrabBottleUPP)
    NewSGGrabBottleUPP             (SGGrabBottleProcPtr     userRoutine);

    EXTERN_API(SGGrabCompleteBottleUPP)
    NewSGGrabCompleteBottleUPP     (SGGrabCompleteBottleProcPtr userRoutine);

    EXTERN_API(SGDisplayBottleUPP)
    NewSGDisplayBottleUPP          (SGDisplayBottleProcPtr  userRoutine);

    EXTERN_API(SGCompressBottleUPP)
    NewSGCompressBottleUPP         (SGCompressBottleProcPtr userRoutine);

    EXTERN_API(SGCompressCompleteBottleUPP)
    NewSGCompressCompleteBottleUPP    (SGCompressCompleteBottleProcPtr userRoutine);

    EXTERN_API(SGAddFrameBottleUPP)
    NewSGAddFrameBottleUPP         (SGAddFrameBottleProcPtr userRoutine);

    EXTERN_API(SGTransferFrameBottleUPP)
    NewSGTransferFrameBottleUPP    (SGTransferFrameBottleProcPtr userRoutine);

    EXTERN_API(SGGrabCompressCompleteBottleUPP)
    NewSGGrabCompressCompleteBottleUPP    (SGGrabCompressCompleteBottleProcPtr userRoutine);

    EXTERN_API(SGDisplayCompressBottleUPP)
    NewSGDisplayCompressBottleUPP    (SGDisplayCompressBottleProcPtr userRoutine);

    EXTERN_API(void)
    DisposeDataHCompletionUPP      (DataHCompletionUPP      userUPP);

    EXTERN_API(void)
    DisposeVdigIntUPP              (VdigIntUPP              userUPP);

    EXTERN_API(void)
    DisposeStartDocumentHandlerUPP    (StartDocumentHandlerUPP userUPP);

    EXTERN_API(void)
    DisposeEndDocumentHandlerUPP    (EndDocumentHandlerUPP  userUPP);

    EXTERN_API(void)
    DisposeStartElementHandlerUPP    (StartElementHandlerUPP userUPP);

    EXTERN_API(void)
    DisposeEndElementHandlerUPP    (EndElementHandlerUPP    userUPP);

    EXTERN_API(void)
    DisposeCharDataHandlerUPP      (CharDataHandlerUPP      userUPP);

    EXTERN_API(void)
    DisposePreprocessInstructionHandlerUPP    (PreprocessInstructionHandlerUPP userUPP);

    EXTERN_API(void)
    DisposeCommentHandlerUPP       (CommentHandlerUPP       userUPP);

    EXTERN_API(void)
    DisposeSGDataUPP               (SGDataUPP               userUPP);

    EXTERN_API(void)
    DisposeSGModalFilterUPP        (SGModalFilterUPP        userUPP);

    EXTERN_API(void)
    DisposeSGGrabBottleUPP         (SGGrabBottleUPP         userUPP);

    EXTERN_API(void)
    DisposeSGGrabCompleteBottleUPP    (SGGrabCompleteBottleUPP userUPP);

    EXTERN_API(void)
    DisposeSGDisplayBottleUPP      (SGDisplayBottleUPP      userUPP);

    EXTERN_API(void)
    DisposeSGCompressBottleUPP     (SGCompressBottleUPP     userUPP);

    EXTERN_API(void)
    DisposeSGCompressCompleteBottleUPP    (SGCompressCompleteBottleUPP userUPP);

    EXTERN_API(void)
    DisposeSGAddFrameBottleUPP     (SGAddFrameBottleUPP     userUPP);

    EXTERN_API(void)
    DisposeSGTransferFrameBottleUPP    (SGTransferFrameBottleUPP userUPP);

    EXTERN_API(void)
    DisposeSGGrabCompressCompleteBottleUPP    (SGGrabCompressCompleteBottleUPP userUPP);

    EXTERN_API(void)
    DisposeSGDisplayCompressBottleUPP    (SGDisplayCompressBottleUPP userUPP);

    EXTERN_API(void)
    InvokeDataHCompletionUPP       (Ptr                     request,
                                    long                    refcon,
                                    OSErr                   err,
                                    DataHCompletionUPP      userUPP);

    EXTERN_API(void)
    InvokeVdigIntUPP               (long                    flags,
                                    long                    refcon,
                                    VdigIntUPP              userUPP);

    EXTERN_API(ComponentResult)
    InvokeStartDocumentHandlerUPP    (long                  refcon,
                                    StartDocumentHandlerUPP userUPP);

    EXTERN_API(ComponentResult)
    InvokeEndDocumentHandlerUPP    (long                    refcon,
                                    EndDocumentHandlerUPP   userUPP);

    EXTERN_API(ComponentResult)
    InvokeStartElementHandlerUPP    (const char *           name,
                                    const char **           atts,
                                    long                    refcon,
                                    StartElementHandlerUPP  userUPP);

    EXTERN_API(ComponentResult)
    InvokeEndElementHandlerUPP     (const char *            name,
                                    long                    refcon,
                                    EndElementHandlerUPP    userUPP);

    EXTERN_API(ComponentResult)
    InvokeCharDataHandlerUPP       (const char *            charData,
                                    long                    refcon,
                                    CharDataHandlerUPP      userUPP);

    EXTERN_API(ComponentResult)
    InvokePreprocessInstructionHandlerUPP    (const char *  name,
                                    const char **           atts,
                                    long                    refcon,
                                    PreprocessInstructionHandlerUPP userUPP);

    EXTERN_API(ComponentResult)
    InvokeCommentHandlerUPP        (const char *            comment,
                                    long                    refcon,
                                    CommentHandlerUPP       userUPP);

    EXTERN_API(OSErr)
    InvokeSGDataUPP                (SGChannel               c,
                                    Ptr                     p,
                                    long                    len,
                                    long *                  offset,
                                    long                    chRefCon,
                                    TimeValue               time,
                                    short                   writeType,
                                    long                    refCon,
                                    SGDataUPP               userUPP);

    EXTERN_API(Boolean)
    InvokeSGModalFilterUPP         (DialogRef               theDialog,
                                    const EventRecord *     theEvent,
                                    short *                 itemHit,
                                    long                    refCon,
                                    SGModalFilterUPP        userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGGrabBottleUPP          (SGChannel               c,
                                    short                   bufferNum,
                                    long                    refCon,
                                    SGGrabBottleUPP         userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGGrabCompleteBottleUPP    (SGChannel             c,
                                    short                   bufferNum,
                                    Boolean *               done,
                                    long                    refCon,
                                    SGGrabCompleteBottleUPP userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGDisplayBottleUPP       (SGChannel               c,
                                    short                   bufferNum,
                                    MatrixRecord *          mp,
                                    RgnHandle               clipRgn,
                                    long                    refCon,
                                    SGDisplayBottleUPP      userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGCompressBottleUPP      (SGChannel               c,
                                    short                   bufferNum,
                                    long                    refCon,
                                    SGCompressBottleUPP     userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGCompressCompleteBottleUPP    (SGChannel         c,
                                    short                   bufferNum,
                                    Boolean *               done,
                                    SGCompressInfo *        ci,
                                    long                    refCon,
                                    SGCompressCompleteBottleUPP userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGAddFrameBottleUPP      (SGChannel               c,
                                    short                   bufferNum,
                                    TimeValue               atTime,
                                    TimeScale               scale,
                                    const SGCompressInfo *  ci,
                                    long                    refCon,
                                    SGAddFrameBottleUPP     userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGTransferFrameBottleUPP    (SGChannel            c,
                                    short                   bufferNum,
                                    MatrixRecord *          mp,
                                    RgnHandle               clipRgn,
                                    long                    refCon,
                                    SGTransferFrameBottleUPP userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGGrabCompressCompleteBottleUPP    (SGChannel     c,
                                    Boolean *               done,
                                    SGCompressInfo *        ci,
                                    TimeRecord *            t,
                                    long                    refCon,
                                    SGGrabCompressCompleteBottleUPP userUPP);

    EXTERN_API(ComponentResult)
    InvokeSGDisplayCompressBottleUPP    (SGChannel          c,
                                    Ptr                     dataPtr,
                                    ImageDescriptionHandle  desc,
                                    MatrixRecord *          mp,
                                    RgnHandle               clipRgn,
                                    long                    refCon,
                                    SGDisplayCompressBottleUPP userUPP);

#else
    enum { uppDataHCompletionProcInfo = 0x00000BC0 };               /* pascal no_return_value Func(4_bytes, 4_bytes, 2_bytes) */
    enum { uppVdigIntProcInfo = 0x000003C0 };                       /* pascal no_return_value Func(4_bytes, 4_bytes) */
    enum { uppStartDocumentHandlerProcInfo = 0x000000F0 };          /* pascal 4_bytes Func(4_bytes) */
    enum { uppEndDocumentHandlerProcInfo = 0x000000F0 };            /* pascal 4_bytes Func(4_bytes) */
    enum { uppStartElementHandlerProcInfo = 0x00000FF0 };           /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes) */
    enum { uppEndElementHandlerProcInfo = 0x000003F0 };             /* pascal 4_bytes Func(4_bytes, 4_bytes) */
    enum { uppCharDataHandlerProcInfo = 0x000003F0 };               /* pascal 4_bytes Func(4_bytes, 4_bytes) */
    enum { uppPreprocessInstructionHandlerProcInfo = 0x00000FF0 };  /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes) */
    enum { uppCommentHandlerProcInfo = 0x000003F0 };                /* pascal 4_bytes Func(4_bytes, 4_bytes) */
    enum { uppSGDataProcInfo = 0x003BFFE0 };                        /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 2_bytes, 4_bytes) */
    enum { uppSGModalFilterProcInfo = 0x00003FD0 };                 /* pascal 1_byte Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSGGrabBottleProcInfo = 0x00000EF0 };                  /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes) */
    enum { uppSGGrabCompleteBottleProcInfo = 0x00003EF0 };          /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes) */
    enum { uppSGDisplayBottleProcInfo = 0x0000FEF0 };               /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSGCompressBottleProcInfo = 0x00000EF0 };              /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes) */
    enum { uppSGCompressCompleteBottleProcInfo = 0x0000FEF0 };      /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSGAddFrameBottleProcInfo = 0x0003FEF0 };              /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSGTransferFrameBottleProcInfo = 0x0000FEF0 };         /* pascal 4_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSGGrabCompressCompleteBottleProcInfo = 0x0000FFF0 };  /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
    enum { uppSGDisplayCompressBottleProcInfo = 0x0003FFF0 };       /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
    #define NewDataHCompletionUPP(userRoutine)                      (DataHCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppDataHCompletionProcInfo, GetCurrentArchitecture())
    #define NewVdigIntUPP(userRoutine)                              (VdigIntUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppVdigIntProcInfo, GetCurrentArchitecture())
    #define NewStartDocumentHandlerUPP(userRoutine)                 (StartDocumentHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppStartDocumentHandlerProcInfo, GetCurrentArchitecture())
    #define NewEndDocumentHandlerUPP(userRoutine)                   (EndDocumentHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppEndDocumentHandlerProcInfo, GetCurrentArchitecture())
    #define NewStartElementHandlerUPP(userRoutine)                  (StartElementHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppStartElementHandlerProcInfo, GetCurrentArchitecture())
    #define NewEndElementHandlerUPP(userRoutine)                    (EndElementHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppEndElementHandlerProcInfo, GetCurrentArchitecture())
    #define NewCharDataHandlerUPP(userRoutine)                      (CharDataHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCharDataHandlerProcInfo, GetCurrentArchitecture())
    #define NewPreprocessInstructionHandlerUPP(userRoutine)         (PreprocessInstructionHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppPreprocessInstructionHandlerProcInfo, GetCurrentArchitecture())
    #define NewCommentHandlerUPP(userRoutine)                       (CommentHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCommentHandlerProcInfo, GetCurrentArchitecture())
    #define NewSGDataUPP(userRoutine)                               (SGDataUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGDataProcInfo, GetCurrentArchitecture())
    #define NewSGModalFilterUPP(userRoutine)                        (SGModalFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGModalFilterProcInfo, GetCurrentArchitecture())
    #define NewSGGrabBottleUPP(userRoutine)                         (SGGrabBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGGrabBottleProcInfo, GetCurrentArchitecture())
    #define NewSGGrabCompleteBottleUPP(userRoutine)                 (SGGrabCompleteBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGGrabCompleteBottleProcInfo, GetCurrentArchitecture())
    #define NewSGDisplayBottleUPP(userRoutine)                      (SGDisplayBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGDisplayBottleProcInfo, GetCurrentArchitecture())
    #define NewSGCompressBottleUPP(userRoutine)                     (SGCompressBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGCompressBottleProcInfo, GetCurrentArchitecture())
    #define NewSGCompressCompleteBottleUPP(userRoutine)             (SGCompressCompleteBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGCompressCompleteBottleProcInfo, GetCurrentArchitecture())
    #define NewSGAddFrameBottleUPP(userRoutine)                     (SGAddFrameBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGAddFrameBottleProcInfo, GetCurrentArchitecture())
    #define NewSGTransferFrameBottleUPP(userRoutine)                (SGTransferFrameBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGTransferFrameBottleProcInfo, GetCurrentArchitecture())
    #define NewSGGrabCompressCompleteBottleUPP(userRoutine)         (SGGrabCompressCompleteBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGGrabCompressCompleteBottleProcInfo, GetCurrentArchitecture())
    #define NewSGDisplayCompressBottleUPP(userRoutine)              (SGDisplayCompressBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGDisplayCompressBottleProcInfo, GetCurrentArchitecture())
    #define DisposeDataHCompletionUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
    #define DisposeVdigIntUPP(userUPP)                              DisposeRoutineDescriptor(userUPP)
    #define DisposeStartDocumentHandlerUPP(userUPP)                 DisposeRoutineDescriptor(userUPP)
    #define DisposeEndDocumentHandlerUPP(userUPP)                   DisposeRoutineDescriptor(userUPP)
    #define DisposeStartElementHandlerUPP(userUPP)                  DisposeRoutineDescriptor(userUPP)
    #define DisposeEndElementHandlerUPP(userUPP)                    DisposeRoutineDescriptor(userUPP)
    #define DisposeCharDataHandlerUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
    #define DisposePreprocessInstructionHandlerUPP(userUPP)         DisposeRoutineDescriptor(userUPP)
    #define DisposeCommentHandlerUPP(userUPP)                       DisposeRoutineDescriptor(userUPP)
    #define DisposeSGDataUPP(userUPP)                               DisposeRoutineDescriptor(userUPP)
    #define DisposeSGModalFilterUPP(userUPP)                        DisposeRoutineDescriptor(userUPP)
    #define DisposeSGGrabBottleUPP(userUPP)                         DisposeRoutineDescriptor(userUPP)
    #define DisposeSGGrabCompleteBottleUPP(userUPP)                 DisposeRoutineDescriptor(userUPP)
    #define DisposeSGDisplayBottleUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
    #define DisposeSGCompressBottleUPP(userUPP)                     DisposeRoutineDescriptor(userUPP)
    #define DisposeSGCompressCompleteBottleUPP(userUPP)             DisposeRoutineDescriptor(userUPP)
    #define DisposeSGAddFrameBottleUPP(userUPP)                     DisposeRoutineDescriptor(userUPP)
    #define DisposeSGTransferFrameBottleUPP(userUPP)                DisposeRoutineDescriptor(userUPP)
    #define DisposeSGGrabCompressCompleteBottleUPP(userUPP)         DisposeRoutineDescriptor(userUPP)
    #define DisposeSGDisplayCompressBottleUPP(userUPP)              DisposeRoutineDescriptor(userUPP)
    #define InvokeDataHCompletionUPP(request, refcon, err, userUPP)  CALL_THREE_PARAMETER_UPP((userUPP), uppDataHCompletionProcInfo, (request), (refcon), (err))
    #define InvokeVdigIntUPP(flags, refcon, userUPP)                CALL_TWO_PARAMETER_UPP((userUPP), uppVdigIntProcInfo, (flags), (refcon))
    #define InvokeStartDocumentHandlerUPP(refcon, userUPP)          (ComponentResult)CALL_ONE_PARAMETER_UPP((userUPP), uppStartDocumentHandlerProcInfo, (refcon))
    #define InvokeEndDocumentHandlerUPP(refcon, userUPP)            (ComponentResult)CALL_ONE_PARAMETER_UPP((userUPP), uppEndDocumentHandlerProcInfo, (refcon))
    #define InvokeStartElementHandlerUPP(name, atts, refcon, userUPP)  (ComponentResult)CALL_THREE_PARAMETER_UPP((userUPP), uppStartElementHandlerProcInfo, (name), (atts), (refcon))
    #define InvokeEndElementHandlerUPP(name, refcon, userUPP)       (ComponentResult)CALL_TWO_PARAMETER_UPP((userUPP), uppEndElementHandlerProcInfo, (name), (refcon))
    #define InvokeCharDataHandlerUPP(charData, refcon, userUPP)     (ComponentResult)CALL_TWO_PARAMETER_UPP((userUPP), uppCharDataHandlerProcInfo, (charData), (refcon))
    #define InvokePreprocessInstructionHandlerUPP(name, atts, refcon, userUPP)  (ComponentResult)CALL_THREE_PARAMETER_UPP((userUPP), uppPreprocessInstructionHandlerProcInfo, (name), (atts), (refcon))
    #define InvokeCommentHandlerUPP(comment, refcon, userUPP)       (ComponentResult)CALL_TWO_PARAMETER_UPP((userUPP), uppCommentHandlerProcInfo, (comment), (refcon))
    #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))
    #define InvokeSGModalFilterUPP(theDialog, theEvent, itemHit, refCon, userUPP)  (Boolean)CALL_FOUR_PARAMETER_UPP((userUPP), uppSGModalFilterProcInfo, (theDialog), (theEvent), (itemHit), (refCon))
    #define InvokeSGGrabBottleUPP(c, bufferNum, refCon, userUPP)    (ComponentResult)CALL_THREE_PARAMETER_UPP((userUPP), uppSGGrabBottleProcInfo, (c), (bufferNum), (refCon))
    #define InvokeSGGrabCompleteBottleUPP(c, bufferNum, done, refCon, userUPP)  (ComponentResult)CALL_FOUR_PARAMETER_UPP((userUPP), uppSGGrabCompleteBottleProcInfo, (c), (bufferNum), (done), (refCon))
    #define InvokeSGDisplayBottleUPP(c, bufferNum, mp, clipRgn, refCon, userUPP)  (ComponentResult)CALL_FIVE_PARAMETER_UPP((userUPP), uppSGDisplayBottleProcInfo, (c), (bufferNum), (mp), (clipRgn), (refCon))
    #define InvokeSGCompressBottleUPP(c, bufferNum, refCon, userUPP)  (ComponentResult)CALL_THREE_PARAMETER_UPP((userUPP), uppSGCompressBottleProcInfo, (c), (bufferNum), (refCon))
    #define InvokeSGCompressCompleteBottleUPP(c, bufferNum, done, ci, refCon, userUPP)  (ComponentResult)CALL_FIVE_PARAMETER_UPP((userUPP), uppSGCompressCompleteBottleProcInfo, (c), (bufferNum), (done), (ci), (refCon))
    #define InvokeSGAddFrameBottleUPP(c, bufferNum, atTime, scale, ci, refCon, userUPP)  (ComponentResult)CALL_SIX_PARAMETER_UPP((userUPP), uppSGAddFrameBottleProcInfo, (c), (bufferNum), (atTime), (scale), (ci), (refCon))
    #define InvokeSGTransferFrameBottleUPP(c, bufferNum, mp, clipRgn, refCon, userUPP)  (ComponentResult)CALL_FIVE_PARAMETER_UPP((userUPP), uppSGTransferFrameBottleProcInfo, (c), (bufferNum), (mp), (clipRgn), (refCon))
    #define InvokeSGGrabCompressCompleteBottleUPP(c, done, ci, t, refCon, userUPP)  (ComponentResult)CALL_FIVE_PARAMETER_UPP((userUPP), uppSGGrabCompressCompleteBottleProcInfo, (c), (done), (ci), (t), (refCon))
    #define InvokeSGDisplayCompressBottleUPP(c, dataPtr, desc, mp, clipRgn, refCon, userUPP)  (ComponentResult)CALL_SIX_PARAMETER_UPP((userUPP), uppSGDisplayCompressBottleProcInfo, (c), (dataPtr), (desc), (mp), (clipRgn), (refCon))
#endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
#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)

/* selectors for component calls */
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 /* __QUICKTIMECOMPONENTS__ */

