/*
	File:		QuickTimeComponents.h

	Contains:	xxx put contents here xxx

	Written by:	xxx put writers here xxx

	Copyright:	© 1992 by Apple Computer, Inc., all rights reserved.

	Change History (most recent first):

	   <SM3>	 10/8/92	DH		Update to QuickTime 1.5 header.
	   <SM2>	  9/1/92	DH		Set back to Quicktime 1.0 header.

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

Created: Friday, October 2, 1992 at 11:40 AM
 QuickTimeComponents.h
 C Interface to the Macintosh Libraries


 Copyright Apple Computer, Inc. 1991, 1992
 All rights reserved

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


#ifndef __QUICKTIMECOMPONENTS__
#define __QUICKTIMECOMPONENTS__

#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


	#define clockComponentType 		'clok'
	#define systemTickClock 		'tick'			/* subtype: 60ths since boot		*/
	#define systemSecondClock		'seco'			/* subtype: seconds since 1904		*/
	#define systemMillisecondClock	'mill'			/* subtype: 1000ths since boot		*/
	#define systemMicrosecondClock	'micr'			/* subtype: 1000000ths since boot	*/
	
	enum {
		kClockRateIsLinear = 1,
		kClockImplementsCallBacks = 2
	};
	
	#define ClockGetTime GetClockTime


#ifdef __cplusplus
extern "C" {
#endif __cplusplus

/** These are Clock procedures **/

pascal ComponentResult ClockGetTime (ComponentInstance aClock, TimeRecord *out)  = {0x2F3C,0x4,0x1,0x7000,0xA82A};

pascal QTCallBack ClockNewCallBack (ComponentInstance aClock, TimeBase tb, short callBackType)  = {0x2F3C,0x6,0x2,0x7000,0xA82A};

pascal ComponentResult ClockDisposeCallBack (ComponentInstance aClock, QTCallBack cb)  = {0x2F3C,0x4,0x3,0x7000,0xA82A};

pascal ComponentResult ClockCallMeWhen (ComponentInstance aClock, QTCallBack cb, long param1, long param2, long param3)  = {0x2F3C,0x10,0x4,0x7000,0xA82A};

pascal ComponentResult ClockCancelCallBack (ComponentInstance aClock, QTCallBack cb)  = {0x2F3C,0x4,0x5,0x7000,0xA82A};

pascal ComponentResult ClockRateChanged (ComponentInstance aClock, QTCallBack cb)  = {0x2F3C,0x4,0x6,0x7000,0xA82A};

pascal ComponentResult ClockTimeChanged (ComponentInstance aClock, QTCallBack cb)  = {0x2F3C,0x4,0x7,0x7000,0xA82A};

pascal ComponentResult ClockSetTimeBase (ComponentInstance aClock, TimeBase tb)  = {0x2F3C,0x4,0x8,0x7000,0xA82A};

pascal ComponentResult ClockStartStopChanged (ComponentInstance aClock, QTCallBack cb, Boolean startChanged, Boolean stopChanged)  = {0x2F3C,0x8,0x9,0x7000,0xA82A};

pascal ComponentResult ClockGetRate (ComponentInstance aClock, Fixed *rate)  = {0x2F3C,0x4,0xA,0x7000,0xA82A};

#ifdef __cplusplus
}
#endif __cplusplus
enum {
	kClockGetTimeSelect = 0x1,
	kClockNewCallBackSelect = 0x2,
	kClockDisposeCallBackSelect = 0x3,
	kClockCallMeWhenSelect = 0x4,
	kClockCancelCallBackSelect = 0x5,
	kClockRateChangedSelect = 0x6,
	kClockTimeChangedSelect = 0x7,
	kClockSetTimeBaseSelect = 0x8,
	kClockStartStopChangedSelect = 0x9,
	kClockGetRateSelect = 0xA 
};

	/*
		General Sequence Grab stuff
	*/
	
	typedef ComponentInstance SeqGrabComponent;
	
	typedef ComponentInstance SGChannel;
	
	#define SeqGrabComponentType 'barg'
	#define SeqGrabChannelType 'sgch'
	#define SeqGrabPanelType 'sgpn'

	#define SeqGrabCompressionPanelType 'comp'
	#define SeqGrabSourcePanelType 'sour'

	enum {
		seqGrabToDisk = 1,
		seqGrabToMemory = 2,
		seqGrabDontUseTempMemory = 4,
		seqGrabAppendToFile = 8,
		seqGrabDontAddMovieResource = 16,
		seqGrabDontMakeMovie = 32,
		seqGrabPreExtendFile = 64
	};
	typedef unsigned long SeqGrabDataOutputEnum;

	enum {
		seqGrabRecord = 1,
		seqGrabPreview = 2,
		seqGrabPlayDuringRecord = 4
	};
	typedef unsigned long SeqGrabUsageEnum;

	enum {
		seqGrabHasBounds = 1,
		seqGrabHasVolume = 2,
		seqGrabHasDiscreteSamples = 4
	};
	typedef unsigned long SeqGrabChannelInfoEnum;

	typedef struct seqGrabFrameInfo {
		long		frameOffset;
		long		frameTime;
		long		frameSize;
		SGChannel	frameChannel;
		long		frameRefCon;
	} seqGrabFrameInfo;
	
	enum {
		grabPictOffScreen = 1,
		grabPictIgnoreClip = 2
	};
	#define sgFlagControlledGrab (1)

	typedef pascal OSErr (*SGDataProc)(SGChannel c, Ptr p, long len, long *offset, long chRefCon,
				TimeValue time, short writeType, long refCon);

	typedef struct SGDeviceName {
		Str63			name;
		Handle			icon;
		long			flags;
		long			refCon;
		long			reserved;		// zero
	} SGDeviceName;

	#define sgDeviceNameFlagDeviceUnavailable (1)

	typedef struct SGDeviceListRecord {
		short			count;
		short			selectedIndex;
		long			reserved;		// zero
		SGDeviceName	entry[1];
	} SGDeviceListRecord, *SGDeviceListPtr, **SGDeviceList;

	#define sgDeviceListWithIcons (1)
	#define sgDeviceListDontCheckAvailability (2)

	enum {
		seqGrabWriteAppend,
		seqGrabWriteReserve,
		seqGrabWriteFill
	};

	enum {
		seqGrabUnpause = 0,
		seqGrabPause = 1,
		seqGrabPauseForMenu = 3
	};
	enum {
		channelFlagDontOpenResFile = 2,
		channelFlagHasDependency = 4
	};

	typedef pascal Boolean (*SGModalFilterProcPtr)(DialogPtr theDialog, EventRecord *theEvent,
				short *itemHit, long refCon);

	enum {
		sgPanelFlagForPanel = 1
	};



	#define channelPlayNormal 0
	#define channelPlayFast 1
	#define channelPlayHighQuality 2
	#define channelPlayAllData 4

#ifdef __cplusplus
extern "C" {
#endif __cplusplus
pascal ComponentResult SGInitialize (SeqGrabComponent s)  = {0x2F3C,0,0x1,0x7000,0xA82A};

pascal ComponentResult SGSetDataOutput (SeqGrabComponent s, FSSpec *movieFile, long whereFlags)  = {0x2F3C,0x8,0x2,0x7000,0xA82A};
	
pascal ComponentResult SGGetDataOutput (SeqGrabComponent s, FSSpec *movieFile, long *whereFlags)  = {0x2F3C,0x8,0x3,0x7000,0xA82A};

pascal ComponentResult SGSetGWorld (SeqGrabComponent s, CGrafPtr gp, GDHandle gd)  = {0x2F3C,0x8,0x4,0x7000,0xA82A};
pascal ComponentResult SGGetGWorld (SeqGrabComponent s, CGrafPtr *gp, GDHandle *gd)  = {0x2F3C,0x8,0x5,0x7000,0xA82A};

pascal ComponentResult SGNewChannel (SeqGrabComponent s, OSType channelType, SGChannel *ref)  = {0x2F3C,0x8,0x6,0x7000,0xA82A};
pascal ComponentResult SGDisposeChannel (SeqGrabComponent s, SGChannel c)  = {0x2F3C,0x4,0x7,0x7000,0xA82A};

pascal ComponentResult SGStartPreview (SeqGrabComponent s)  = {0x2F3C,0,0x10,0x7000,0xA82A};
pascal ComponentResult SGStartRecord (SeqGrabComponent s)  = {0x2F3C,0,0x11,0x7000,0xA82A};
pascal ComponentResult SGIdle (SeqGrabComponent s)  = {0x2F3C,0,0x12,0x7000,0xA82A};
pascal ComponentResult SGStop (SeqGrabComponent s)  = {0x2F3C,0,0x13,0x7000,0xA82A};

pascal ComponentResult SGPause (SeqGrabComponent s, Byte pause)  = {0x2F3C,0x2,0x14,0x7000,0xA82A};

pascal ComponentResult SGPrepare (SeqGrabComponent s, Boolean prepareForPreview, Boolean prepareForRecord)  = {0x2F3C,0x4,0x15,0x7000,0xA82A};
pascal ComponentResult SGRelease (SeqGrabComponent s)  = {0x2F3C,0,0x16,0x7000,0xA82A};

pascal Movie SGGetMovie (SeqGrabComponent s)  = {0x2F3C,0,0x17,0x7000,0xA82A};

pascal ComponentResult SGSetMaximumRecordTime (SeqGrabComponent s, unsigned long ticks)  = {0x2F3C,0x4,0x18,0x7000,0xA82A};
pascal ComponentResult SGGetMaximumRecordTime (SeqGrabComponent s, unsigned long *ticks)  = {0x2F3C,0x4,0x19,0x7000,0xA82A};

pascal ComponentResult SGGetStorageSpaceRemaining (SeqGrabComponent s, unsigned long *bytes)  = {0x2F3C,0x4,0x1A,0x7000,0xA82A};
pascal ComponentResult SGGetTimeRemaining (SeqGrabComponent s, long *ticksLeft)  = {0x2F3C,0x4,0x1B,0x7000,0xA82A};

pascal ComponentResult SGGrabPict (SeqGrabComponent s, PicHandle *p, const Rect *bounds,
				short offscreenDepth, long grabPictFlags)  = {0x2F3C,0xE,0x1C,0x7000,0xA82A};

pascal ComponentResult SGGetLastMovieResID (SeqGrabComponent s, short *resID)  = {0x2F3C,0x4,0x1D,0x7000,0xA82A};

pascal ComponentResult SGSetFlags (SeqGrabComponent s, long sgFlags)  = {0x2F3C,0x4,0x1E,0x7000,0xA82A};

pascal ComponentResult SGGetFlags (SeqGrabComponent s, long *sgFlags)  = {0x2F3C,0x4,0x1F,0x7000,0xA82A};

pascal ComponentResult SGSetDataProc (SeqGrabComponent s, SGDataProc proc, long refCon)  = {0x2F3C,0x8,0x20,0x7000,0xA82A};

pascal ComponentResult SGNewChannelFromComponent (SeqGrabComponent s, SGChannel *newChannel, Component sgChannelComponent)  = {0x2F3C,0x8,0x21,0x7000,0xA82A};

pascal ComponentResult SGDisposeDeviceList (SeqGrabComponent s, SGDeviceList list)  = {0x2F3C,0x4,0x22,0x7000,0xA82A};

pascal ComponentResult SGAppendDeviceListToMenu (SeqGrabComponent s, SGDeviceList list, MenuHandle mh)  = {0x2F3C,0x8,0x23,0x7000,0xA82A};

pascal ComponentResult SGSetSettings (SeqGrabComponent s, UserData ud, long flags)  = {0x2F3C,0x8,0x24,0x7000,0xA82A};

pascal ComponentResult SGGetSettings (SeqGrabComponent s, UserData *ud, long flags)  = {0x2F3C,0x8,0x25,0x7000,0xA82A};

pascal ComponentResult SGGetIndChannel (SeqGrabComponent s, short index, SGChannel *ref, OSType *chanType)  = {0x2F3C,0xA,0x26,0x7000,0xA82A};

pascal ComponentResult SGUpdate (SeqGrabComponent s, RgnHandle updateRgn)  = {0x2F3C,0x4,0x27,0x7000,0xA82A};

pascal ComponentResult SGGetPause (SeqGrabComponent s, Byte *paused)  = {0x2F3C,0x4,0x28,0x7000,0xA82A};

pascal ComponentResult SGSettingsDialog (SeqGrabComponent s, SGChannel c, short numPanels, Component *panelList, long flags, SGModalFilterProcPtr proc, long procRefNum)  = {0x2F3C,0x16,0x29,0x7000,0xA82A};

pascal ComponentResult SGGetAlignmentProc (SeqGrabComponent s, AlignmentProcRecordPtr alignmentProc)  = {0x2F3C,0x4,0x2A,0x7000,0xA82A};

pascal ComponentResult SGSetChannelSettings (SeqGrabComponent s, SGChannel c, UserData ud, long flags)  = {0x2F3C,0xC,0x2B,0x7000,0xA82A};

pascal ComponentResult SGGetChannelSettings (SeqGrabComponent s, SGChannel c, UserData *ud, long flags)  = {0x2F3C,0xC,0x2C,0x7000,0xA82A};



/*
	calls from Channel to seqGrab
*/

pascal ComponentResult SGWriteMovieData (SeqGrabComponent s, SGChannel c, Ptr p, long len, long *offset)  = {0x2F3C,0x10,0x100,0x7000,0xA82A};
pascal ComponentResult SGAddFrameReference (SeqGrabComponent s, seqGrabFrameInfo *frameInfo)  = {0x2F3C,0x4,0x101,0x7000,0xA82A};
pascal ComponentResult SGGetNextFrameReference (SeqGrabComponent s, seqGrabFrameInfo *frameInfo,
					TimeValue *frameDuration, long *frameNumber)  = {0x2F3C,0xC,0x102,0x7000,0xA82A};
pascal ComponentResult SGGetTimeBase (SeqGrabComponent s, TimeBase *tb)  = {0x2F3C,0x4,0x103,0x7000,0xA82A};
pascal ComponentResult SGSortDeviceList (SeqGrabComponent s, SGDeviceList list)  = {0x2F3C,0x4,0x104,0x7000,0xA82A};
pascal ComponentResult SGAddMovieData (SeqGrabComponent s, SGChannel c, Ptr p, long len, long *offset, long chRefCon, TimeValue time, short writeType)  = {0x2F3C,0x1A,0x105,0x7000,0xA82A};
pascal ComponentResult SGChangedSource (SeqGrabComponent s, SGChannel c)  = {0x2F3C,0x4,0x106,0x7000,0xA82A};


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

pascal ComponentResult SGSetChannelUsage (SGChannel c, long usage)  = {0x2F3C,0x4,0x80,0x7000,0xA82A};
pascal ComponentResult SGGetChannelUsage (SGChannel c, long *usage)  = {0x2F3C,0x4,0x81,0x7000,0xA82A};

pascal ComponentResult SGSetChannelBounds (SGChannel c, const Rect *bounds)  = {0x2F3C,0x4,0x82,0x7000,0xA82A};
pascal ComponentResult SGGetChannelBounds (SGChannel c, Rect *bounds)  = {0x2F3C,0x4,0x83,0x7000,0xA82A};

pascal ComponentResult SGSetChannelVolume (SGChannel c, short volume)  = {0x2F3C,0x2,0x84,0x7000,0xA82A};
pascal ComponentResult SGGetChannelVolume (SGChannel c, short *volume)  = {0x2F3C,0x4,0x85,0x7000,0xA82A};

pascal ComponentResult SGGetChannelInfo (SGChannel c, long *channelInfo)  = {0x2F3C,0x4,0x86,0x7000,0xA82A};

pascal ComponentResult SGSetChannelPlayFlags (SGChannel c, long playFlags)  = {0x2F3C,0x4,0x87,0x7000,0xA82A};
pascal ComponentResult SGGetChannelPlayFlags (SGChannel c, long *playFlags)  = {0x2F3C,0x4,0x88,0x7000,0xA82A};

pascal ComponentResult SGSetChannelMaxFrames (SGChannel c, long frameCount)  = {0x2F3C,0x4,0x89,0x7000,0xA82A};
pascal ComponentResult SGGetChannelMaxFrames (SGChannel c, long *frameCount)  = {0x2F3C,0x4,0x8A,0x7000,0xA82A};

pascal ComponentResult SGSetChannelRefCon (SGChannel c, long refCon)  = {0x2F3C,0x4,0x8B,0x7000,0xA82A};

pascal ComponentResult SGSetChannelClip (SGChannel c, RgnHandle theClip)  = {0x2F3C,0x4,0x8C,0x7000,0xA82A};

pascal ComponentResult SGGetChannelClip (SGChannel c, RgnHandle *theClip)  = {0x2F3C,0x4,0x8D,0x7000,0xA82A};

pascal ComponentResult SGGetChannelSampleDescription (SGChannel c, Handle sampleDesc)  = {0x2F3C,0x4,0x8E,0x7000,0xA82A};

pascal ComponentResult SGGetChannelDeviceList (SGChannel c, long selectionFlags, SGDeviceList *list)  = {0x2F3C,0x8,0x8F,0x7000,0xA82A};

pascal ComponentResult SGSetChannelDevice (SGChannel c, StringPtr name)  = {0x2F3C,0x4,0x90,0x7000,0xA82A};

pascal ComponentResult SGSetChannelMatrix (SGChannel c, const MatrixRecord *m)  = {0x2F3C,0x4,0x91,0x7000,0xA82A};

pascal ComponentResult SGGetChannelMatrix (SGChannel c, MatrixRecord *m)  = {0x2F3C,0x4,0x92,0x7000,0xA82A};

pascal ComponentResult SGGetChannelTimeScale (SGChannel c, TimeScale *scale)  = {0x2F3C,0x4,0x93,0x7000,0xA82A};

/*
	calls from seqGrab to Channel
*/

pascal ComponentResult SGInitChannel (SGChannel c, SeqGrabComponent owner)  = {0x2F3C,0x4,0x180,0x7000,0xA82A};
pascal ComponentResult SGWriteSamples (SGChannel c, Movie m, AliasHandle theFile)  = {0x2F3C,0x8,0x181,0x7000,0xA82A};
pascal ComponentResult SGGetDataRate (SGChannel c, long *bytesPerSecond)  = {0x2F3C,0x4,0x182,0x7000,0xA82A};
pascal ComponentResult SGAlignChannelRect (SGChannel c, Rect *r)  = {0x2F3C,0x4,0x183,0x7000,0xA82A};

/*
	Dorky dialog panel calls
*/

pascal ComponentResult SGPanelGetDitl (SeqGrabComponent s, Handle *ditl)  = {0x2F3C,0x4,0x200,0x7000,0xA82A};
pascal ComponentResult SGPanelGetTitle (SeqGrabComponent s, Str255 title)  = {0x2F3C,0x4,0x201,0x7000,0xA82A};
pascal ComponentResult SGPanelCanRun (SeqGrabComponent s, SGChannel c)  = {0x2F3C,0x4,0x202,0x7000,0xA82A};
pascal ComponentResult SGPanelInstall (SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset)  = {0x2F3C,0xA,0x203,0x7000,0xA82A};
pascal ComponentResult SGPanelEvent (SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset,
		EventRecord *theEvent, short *itemHit, Boolean *handled)  = {0x2F3C,0x16,0x204,0x7000,0xA82A};
pascal ComponentResult SGPanelItem (SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, short itemNum)  = {0x2F3C,0xC,0x205,0x7000,0xA82A};
pascal ComponentResult SGPanelRemove (SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset)  = {0x2F3C,0xA,0x206,0x7000,0xA82A};
pascal ComponentResult SGPanelSetGrabber (SeqGrabComponent s, SeqGrabComponent sg)  = {0x2F3C,0x4,0x207,0x7000,0xA82A};
pascal ComponentResult SGPanelSetResFile (SeqGrabComponent s, short resRef)  = {0x2F3C,0x2,0x208,0x7000,0xA82A};
pascal ComponentResult SGPanelGetSettings (SeqGrabComponent s, SGChannel c, UserData *ud, long flags)  = {0x2F3C,0xC,0x209,0x7000,0xA82A};
pascal ComponentResult SGPanelSetSettings (SeqGrabComponent s, SGChannel c, UserData ud, long flags)  = {0x2F3C,0xC,0x20A,0x7000,0xA82A};
pascal ComponentResult SGPanelValidateInput (SeqGrabComponent s, Boolean *ok)  = {0x2F3C,0x4,0x20B,0x7000,0xA82A};
#ifdef __cplusplus
}
#endif __cplusplus


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

/*
	Video stuff
*/

	typedef struct SGCompressInfo {
		Ptr				buffer;
		unsigned long	bufferSize;
		unsigned char	similarity;
		unsigned char	reserved;
	} SGCompressInfo;

typedef pascal ComponentResult (*GrabProc)(SGChannel c, short bufferNum, long refCon);
typedef pascal ComponentResult (*GrabCompleteProc)(SGChannel c, short bufferNum, Boolean *done, long refCon);

typedef pascal ComponentResult (*DisplayProc)(SGChannel c, short bufferNum, MatrixRecord *mp, RgnHandle clipRgn, long refCon);

typedef pascal ComponentResult (*CompressProc)(SGChannel c, short bufferNum, long refCon);
typedef pascal ComponentResult (*CompressCompleteProc)(SGChannel c, short bufferNum,
										Boolean *done, SGCompressInfo *ci, long refCon);

typedef pascal ComponentResult (*AddFrameProc)(SGChannel c, short bufferNum, TimeValue atTime, TimeScale scale,
							const SGCompressInfo *ci, long refCon);

typedef pascal ComponentResult (*TransferFrameProc)(SGChannel c, short bufferNum, MatrixRecord *mp, RgnHandle clipRgn, long refCon);

typedef pascal ComponentResult (*GrabCompressCompleteProc)(SGChannel c, Boolean *done, SGCompressInfo *ci, TimeRecord *t, long refCon);
typedef pascal ComponentResult (*DisplayCompressProc)(SGChannel c, Ptr dataPtr, ImageDescriptionHandle desc, MatrixRecord *mp, RgnHandle clipRgn, long refCon);

	struct VideoBottles {
		short						procCount;
		GrabProc					grabProc;
		GrabCompleteProc			grabCompleteProc;
		DisplayProc					displayProc;
		CompressProc				compressProc;
		CompressCompleteProc		compressCompleteProc;
		AddFrameProc				addFrameProc;
		TransferFrameProc			transferFrameProc;
		GrabCompressCompleteProc	grabCompressCompleteProc;
		DisplayCompressProc			displayCompressProc;
	};
	typedef struct VideoBottles VideoBottles;


#ifdef __cplusplus
extern "C" {
#endif __cplusplus

pascal ComponentResult SGGetSrcVideoBounds (SGChannel c, Rect *r)  = {0x2F3C,0x4,0x100,0x7000,0xA82A};
pascal ComponentResult SGSetVideoRect (SGChannel c, Rect *r)  = {0x2F3C,0x4,0x101,0x7000,0xA82A};
pascal ComponentResult SGGetVideoRect (SGChannel c, Rect *r)  = {0x2F3C,0x4,0x102,0x7000,0xA82A};

pascal ComponentResult SGGetVideoCompressorType (SGChannel c, OSType *compressorType)  = {0x2F3C,0x4,0x103,0x7000,0xA82A};
pascal ComponentResult SGSetVideoCompressorType (SGChannel c, OSType compressorType)  = {0x2F3C,0x4,0x104,0x7000,0xA82A};

pascal ComponentResult SGSetVideoCompressor (SGChannel c, short depth, CompressorComponent compressor,
			CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate)  = {0x2F3C,0x12,0x105,0x7000,0xA82A};
pascal ComponentResult SGGetVideoCompressor (SGChannel c, short *depth, CompressorComponent *compressor,
			CodecQ *spatialQuality, CodecQ *temporalQuality, long *keyFrameRate)  = {0x2F3C,0x14,0x106,0x7000,0xA82A};

pascal ComponentInstance SGGetVideoDigitizerComponent (SGChannel c)  = {0x2F3C,0,0x107,0x7000,0xA82A};
pascal ComponentResult SGSetVideoDigitizerComponent (SGChannel c, ComponentInstance vdig)  = {0x2F3C,0x4,0x108,0x7000,0xA82A};
pascal ComponentResult SGVideoDigitizerChanged (SGChannel c)  = {0x2F3C,0,0x109,0x7000,0xA82A};

pascal ComponentResult SGSetVideoBottlenecks (SGChannel c, VideoBottles *vb)  = {0x2F3C,0x4,0x10A,0x7000,0xA82A};
pascal ComponentResult SGGetVideoBottlenecks (SGChannel c, VideoBottles *vb)  = {0x2F3C,0x4,0x10B,0x7000,0xA82A};

pascal ComponentResult SGGrabFrame (SGChannel c, short bufferNum)  = {0x2F3C,0x2,0x10C,0x7000,0xA82A};
pascal ComponentResult SGGrabFrameComplete (SGChannel c, short bufferNum, Boolean *done)  = {0x2F3C,0x6,0x10D,0x7000,0xA82A};
pascal ComponentResult SGDisplayFrame (SGChannel c, short bufferNum, MatrixRecord *mp, RgnHandle clipRgn)  = {0x2F3C,0xA,0x10E,0x7000,0xA82A};

pascal ComponentResult SGCompressFrame (SGChannel c, short bufferNum)  = {0x2F3C,0x2,0x10F,0x7000,0xA82A};
pascal ComponentResult SGCompressFrameComplete (SGChannel c, short bufferNum, Boolean *done, SGCompressInfo *ci)  = {0x2F3C,0xA,0x110,0x7000,0xA82A};

pascal ComponentResult SGAddFrame (SGChannel c, short bufferNum, TimeValue atTime, TimeScale scale, const SGCompressInfo *ci)  = {0x2F3C,0xE,0x111,0x7000,0xA82A};

pascal ComponentResult SGTransferFrameForCompress (SGChannel c, short bufferNum, MatrixRecord *mp, RgnHandle clipRgn)  = {0x2F3C,0xA,0x112,0x7000,0xA82A};

pascal ComponentResult SGSetCompressBuffer (SGChannel c, short depth, const Rect *compressSize)  = {0x2F3C,0x6,0x113,0x7000,0xA82A};

pascal ComponentResult SGGetCompressBuffer (SGChannel c, short *depth, Rect *compressSize)  = {0x2F3C,0x8,0x114,0x7000,0xA82A};

pascal ComponentResult SGGetBufferInfo (SGChannel c, short bufferNum, 
					PixMapHandle *bufferPM, Rect *bufferRect,
					GWorldPtr *compressBuffer, Rect *compressBufferRect)  = {0x2F3C,0x12,0x115,0x7000,0xA82A};

pascal ComponentResult SGSetUseScreenBuffer (SGChannel c, Boolean useScreenBuffer)  = {0x2F3C,0x2,0x116,0x7000,0xA82A};

pascal ComponentResult SGGetUseScreenBuffer (SGChannel c, Boolean *useScreenBuffer)  = {0x2F3C,0x4,0x117,0x7000,0xA82A};

pascal ComponentResult SGGrabCompressComplete (SGChannel c, Boolean *done, SGCompressInfo *ci, TimeRecord *tr)  = {0x2F3C,0xC,0x118,0x7000,0xA82A};
pascal ComponentResult SGDisplayCompress (SGChannel c, Ptr dataPtr, ImageDescriptionHandle desc, MatrixRecord *mp, RgnHandle clipRgn)  = {0x2F3C,0x10,0x119,0x7000,0xA82A};

pascal ComponentResult SGSetFrameRate (SGChannel c, Fixed frameRate)  = {0x2F3C,0x4,0x11A,0x7000,0xA82A};

pascal ComponentResult SGGetFrameRate (SGChannel c, Fixed *frameRate)  = {0x2F3C,0x4,0x11B,0x7000,0xA82A};
#ifdef __cplusplus
}
#endif __cplusplus


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


/*
	Sound stuff
*/

#ifdef __cplusplus
extern "C" {
#endif __cplusplus

pascal ComponentResult SGSetSoundInputDriver (SGChannel c, const Str255 driverName)  = {0x2F3C,0x4,0x100,0x7000,0xA82A};
pascal long SGGetSoundInputDriver (SGChannel c)  = {0x2F3C,0,0x101,0x7000,0xA82A};
pascal ComponentResult SGSoundInputDriverChanged (SGChannel c)  = {0x2F3C,0,0x102,0x7000,0xA82A};

pascal ComponentResult SGSetSoundRecordChunkSize (SGChannel c, long seconds)  = {0x2F3C,0x4,0x103,0x7000,0xA82A};
pascal long SGGetSoundRecordChunkSize (SGChannel c)  = {0x2F3C,0,0x104,0x7000,0xA82A};

pascal ComponentResult SGSetSoundInputRate (SGChannel c, Fixed rate)  = {0x2F3C,0x4,0x105,0x7000,0xA82A};
pascal Fixed SGGetSoundInputRate (SGChannel c)  = {0x2F3C,0,0x106,0x7000,0xA82A};

pascal ComponentResult SGSetSoundInputParameters (SGChannel c, short sampleSize, short numChannels,
						OSType compressionType)  = {0x2F3C,0x8,0x107,0x7000,0xA82A};
pascal ComponentResult SGGetSoundInputParameters (SGChannel c, short *sampleSize, short *numChannels,
						OSType *compressionType)  = {0x2F3C,0xC,0x108,0x7000,0xA82A};
#ifdef __cplusplus
}
#endif __cplusplus


#define sgChannelAtom 'chan'

#define sgChannelSettingsAtom 'ctom'
#define sgChannelDescription 'cdsc'
#define sgChannelSettings 'cset'

#define sgDeviceNameType 'name'
#define sgUsageType 'use '
#define sgPlayFlagsType 'plyf'
#define sgClipType 'clip'
#define sgMatrixType 'mtrx'
#define sgVolumeType 'volu'

#define sgPanelSettingsAtom 'ptom'
#define sgPanelDescription 'pdsc'
#define sgPanelSettings 'pset'

#define sgcSoundCompressionType 'scmp'
#define sgcSoundSampleRateType 'srat'
#define sgcSoundChannelCountType 'schn'
#define sgcSoundSampleSizeType 'ssiz'
#define sgcSoundInputType 'sinp'
#define sgcSoundGainType 'gain'

#define sgcVideoHueType 'hue '
#define sgcVideoSaturationType 'satr'
#define sgcVideoContrastType 'trst'
#define sgcVideoSharpnessType 'shrp'
#define sgcVideoBrigtnessType 'brit'
#define sgcVideoBlackLevelType 'blkl'
#define sgcVideoWhiteLevelType 'whtl'

#define sgcVideoInputType 'vinp'
#define sgcVideoFormatType 'vstd'
#define sgcVideoFilterType 'vflt'

#define sgcVideoRectType 'vrct'
#define sgVideoDigitizerType 'vdig'

enum {
	noDeviceForChannel = -9400,
	grabTimeComplete = -9401,
	cantDoThatInCurrentMode = -9402,
	notEnoughMemoryToGrab = -9403,
	notEnoughDiskSpaceToGrab = -9404,
	couldntGetRequiredComponent = -9405,
	badSGChannel = -9406,
	seqGrabInfoNotAvailable = -9407,
	deviceCantMeetRequest = -9408
};


enum {
	kSGInitializeSelect = 0x1,
	kSGSetDataOutputSelect = 0x2,
	kSGGetDataOutputSelect = 0x3,
	kSGSetGWorldSelect = 0x4,
	kSGGetGWorldSelect = 0x5,
	kSGNewChannelSelect = 0x6,
	kSGDisposeChannelSelect = 0x7,
	kSGStartPreviewSelect = 0x10,
	kSGStartRecordSelect = 0x11,
	kSGIdleSelect = 0x12,
	kSGStopSelect = 0x13,
	kSGPauseSelect = 0x14,
	kSGPrepareSelect = 0x15,
	kSGReleaseSelect = 0x16,
	kSGGetMovieSelect = 0x17,
	kSGSetMaximumRecordTimeSelect = 0x18,
	kSGGetMaximumRecordTimeSelect = 0x19,
	kSGGetStorageSpaceRemainingSelect = 0x1A,
	kSGGetTimeRemainingSelect = 0x1B,
	kSGGrabPictSelect = 0x1C,
	kSGGetLastMovieResIDSelect = 0x1D,
	kSGSetFlagsSelect = 0x1E,
	kSGGetFlagsSelect = 0x1F,
	kSGSetDataProcSelect = 0x20,
	kSGNewChannelFromComponentSelect = 0x21,
	kSGDisposeDeviceListSelect = 0x22,
	kSGAppendDeviceListToMenuSelect = 0x23,
	kSGSetSettingsSelect = 0x24,
	kSGGetSettingsSelect = 0x25,
	kSGGetIndChannelSelect = 0x26,
	kSGUpdateSelect = 0x27,
	kSGGetPauseSelect = 0x28,
	kSGSettingsDialogSelect = 0x29,
	kSGGetAlignmentProcSelect = 0x2A,
	kSGSetChannelSettingsSelect = 0x2B,
	kSGGetChannelSettingsSelect = 0x2C,
	kSGWriteMovieDataSelect = 0x100,
	kSGAddFrameReferenceSelect = 0x101,
	kSGGetNextFrameReferenceSelect = 0x102,
	kSGGetTimeBaseSelect = 0x103,
	kSGSortDeviceListSelect = 0x104,
	kSGAddMovieDataSelect = 0x105,
	kSGChangedSourceSelect = 0x106,
	kSGCSetChannelUsageSelect = 0x80,
	kSGCGetChannelUsageSelect = 0x81,
	kSGCSetChannelBoundsSelect = 0x82,
	kSGCGetChannelBoundsSelect = 0x83,
	kSGCSetChannelVolumeSelect = 0x84,
	kSGCGetChannelVolumeSelect = 0x85,
	kSGCGetChannelInfoSelect = 0x86,
	kSGCSetChannelPlayFlagsSelect = 0x87,
	kSGCGetChannelPlayFlagsSelect = 0x88,
	kSGCSetChannelMaxFramesSelect = 0x89,
	kSGCGetChannelMaxFramesSelect = 0x8A,
	kSGCSetChannelRefConSelect = 0x8B,
	kSGCSetChannelClipSelect = 0x8C,
	kSGCGetChannelClipSelect = 0x8D,
	kSGCGetChannelSampleDescriptionSelect = 0x8E,
	kSGCGetChannelDeviceListSelect = 0x8F,
	kSGCSetChannelDeviceSelect = 0x90,
	kSGCSetChannelMatrixSelect = 0x91,
	kSGCGetChannelMatrixSelect = 0x92,
	kSGCGetChannelTimeScaleSelect = 0x93,
	kSGCInitChannelSelect = 0x180,
	kSGCWriteSamplesSelect = 0x181,
	kSGCGetDataRateSelect = 0x182,
	kSGCAlignChannelRectSelect = 0x183,
	kSGCPanelGetDitlSelect = 0x200,
	kSGCPanelGetTitleSelect = 0x201,
	kSGCPanelCanRunSelect = 0x202,
	kSGCPanelInstallSelect = 0x203,
	kSGCPanelEventSelect = 0x204,
	kSGCPanelItemSelect = 0x205,
	kSGCPanelRemoveSelect = 0x206,
	kSGCPanelSetGrabberSelect = 0x207,
	kSGCPanelSetResFileSelect = 0x208,
	kSGCPanelGetSettingsSelect = 0x209,
	kSGCPanelSetSettingsSelect = 0x20A,
	kSGCPanelValidateInputSelect = 0x20B,
	kSGCGetSrcVideoBoundsSelect = 0x100,
	kSGCSetVideoRectSelect = 0x101,
	kSGCGetVideoRectSelect = 0x102,
	kSGCGetVideoCompressorTypeSelect = 0x103,
	kSGCSetVideoCompressorTypeSelect = 0x104,
	kSGCSetVideoCompressorSelect = 0x105,
	kSGCGetVideoCompressorSelect = 0x106,
	kSGCGetVideoDigitizerComponentSelect = 0x107,
	kSGCSetVideoDigitizerComponentSelect = 0x108,
	kSGCVideoDigitizerChangedSelect = 0x109,
	kSGCSetVideoBottlenecksSelect = 0x10A,
	kSGCGetVideoBottlenecksSelect = 0x10B,
	kSGCGrabFrameSelect = 0x10C,
	kSGCGrabFrameCompleteSelect = 0x10D,
	kSGCDisplayFrameSelect = 0x10E,
	kSGCCompressFrameSelect = 0x10F,
	kSGCCompressFrameCompleteSelect = 0x110,
	kSGCAddFrameSelect = 0x111,
	kSGCTransferFrameForCompressSelect = 0x112,
	kSGCSetCompressBufferSelect = 0x113,
	kSGCGetCompressBufferSelect = 0x114,
	kSGCGetBufferInfoSelect = 0x115,
	kSGCSetUseScreenBufferSelect = 0x116,
	kSGCGetUseScreenBufferSelect = 0x117,
	kSGCGrabCompressCompleteSelect = 0x118,
	kSGCDisplayCompressSelect = 0x119,
	kSGCSetFrameRateSelect = 0x11A,
	kSGCGetFrameRateSelect = 0x11B,
	kSGCSetSoundInputDriverSelect = 0x100,
	kSGCGetSoundInputDriverSelect = 0x101,
	kSGCSoundInputDriverChangedSelect = 0x102,
	kSGCSetSoundRecordChunkSizeSelect = 0x103,
	kSGCGetSoundRecordChunkSizeSelect = 0x104,
	kSGCSetSoundInputRateSelect = 0x105,
	kSGCGetSoundInputRateSelect = 0x106,
	kSGCSetSoundInputParametersSelect = 0x107,
	kSGCGetSoundInputParametersSelect = 0x108 
};

/* Standard type for video digitizers */

#define	videoDigitizerComponentType		'vdig'		
#define vdigInterfaceRev				2L

/* Input Format Standards */

#define	ntscIn			0				/* current input format */
#define	currentIn		0				/* ntsc input format */
#define	palIn			1				/* pal input format */
#define	secamIn			2				/* secam input format */
#define	ntscReallyIn	3				/* ntsc input format */

/* Input Formats */

#define	compositeIn		0				/* input is composite format */
#define	sVideoIn		1				/* input is sVideo format */
#define rgbComponentIn	2				/* input is rgb component format */

/* Video Digitizer PlayThru States */

#define vdPlayThruOff		0
#define vdPlayThruOn		1

/* Input Color Space Modes */

#define vdDigitizerBW		0			/* black and white */
#define vdDigitizerRGB		1			/* rgb color */

/* Phase Lock Loop Modes */

#define vdBroadcastMode		0			/* Broadcast / Laser Disk video mode */
#define vdVTRMode			1			/* VCR / Magnetic media mode */

/* Field Select Options */
#define vdUseAnyField 0					/* Digitizers choice on field use */
#define vdUseOddField 1					/* Use odd field for half size vert and smaller */
#define vdUseEvenField 2				/* Use even field for half size vert and smaller */

/* vdig types */

#define vdTypeBasic			0			/* basic, no clipping */
#define vdTypeAlpha			1			/* supports clipping with alpha channel */
#define vdTypeMask			2			/* supports clipping with mask plane */
#define vdTypeKey			3			/* supports clipping with key color(s) */

/* Digitizer Error Codes */

#define	digiUnimpErr	-2201 			/* feature unimplemented */
#define	qtParamErr		-2202			/* bad input parameter (out of range, etc) */
#define	matrixErr		-2203			/* bad matrix, digitizer did nothing */
#define	notExactMatrix	-2204			/* warning of bad matrix, digitizer did its best */
#define	noMoreKeyColors	-2205			/* all key indexes in use */
#define	notExactSize	-2206			/* CanŐt do exact size requested */
#define	badDepth		-2207			/* CanŐt digitize into this depth */
#define	noDMA			-2208			/* CanŐt do DMA digitizing (i.e. can't go to requested dest */
#define badCallOrder	-2209			/* Usually due to a status call being called prior to being setup first */

/* Digitizer Input Capability/Current Flags	*/

#define	digiInDoesNTSC		(1L<<0)		/* digitizer supports NTSC input format */
#define	digiInDoesPAL		(1L<<1)		/* digitizer supports PAL input format */
#define	digiInDoesSECAM		(1L<<2)		/* digitizer supports SECAM input format */
#define digiInDoesGenLock	(1L<<7)		/* digitizer does genlock */

#define	digiInDoesComposite	(1L<<8)		/* digitizer supports composite input type */
#define	digiInDoesSVideo	(1L<<9)		/* digitizer supports S-Video input type */
#define digiInDoesComponent (1L<<10)	/* digitizer supports component (rgb) input type */
#define	digiInVTR_Broadcast	(1L<<11)	/* digitizer can differentiate between the two */

#define	digiInDoesColor		(1L<<12)	/* digitizer supports color */
#define	digiInDoesBW		(1L<<13)	/* digitizer supports black & white */

/* Digitizer Input Current Flags (these are valid only during active operating conditions)	*/

#define	digiInSignalLock	(1L<<31)	/* digitizer detects input signal is locked */
										/* this bit = horiz lock || vertical lock */

/* Digitizer Output Capability/Current Flags */

#define	digiOutDoes1			(1L<<0)		/* digitizer supports 1 bit pixels */
#define	digiOutDoes2			(1L<<1)		/* digitizer supports 2 bit pixels */
#define	digiOutDoes4			(1L<<2)		/* digitizer supports 4 bit pixels */
#define	digiOutDoes8			(1L<<3)		/* digitizer supports 8 bit pixels */
#define	digiOutDoes16			(1L<<4)		/* digitizer supports 16 bit pixels */
#define	digiOutDoes32			(1L<<5)		/* digitizer supports 32 bit pixels */
#define	digiOutDoesDither		(1L<<6)		/* digitizer dithers in indexed modes */
#define	digiOutDoesStretch		(1L<<7)		/* digitizer can arbitrarily stretch */
#define	digiOutDoesShrink		(1L<<8)		/* digitizer can arbitrarily shrink */
#define	digiOutDoesMask			(1L<<9)		/* digitizer can mask to clipping regions */

#define	digiOutDoesDouble		(1L<<11)	/* digitizer can stretch to exactly double size */
#define	digiOutDoesQuad			(1L<<12)	/* digitizer can stretch exactly quadruple size */
#define	digiOutDoesQuarter		(1L<<13)	/* digitizer can shrink to exactly quarter size */
#define	digiOutDoesSixteenth	(1L<<14)	/* digitizer can shrink to exactly sixteenth size */

#define	digiOutDoesRotate		(1L<<15)	/* digitizer supports rotate transformations */
#define	digiOutDoesHorizFlip	(1L<<16)	/* digitizer supports horizontal flips Sx < 0 */
#define	digiOutDoesVertFlip		(1L<<17)	/* digitizer supports vertical flips Sy < 0 */
#define	digiOutDoesSkew			(1L<<18)	/* digitizer supports skew (shear,twist) */
#define	digiOutDoesBlend		(1L<<19)
#define	digiOutDoesWarp			(1L<<20)

#define	digiOutDoesHW_DMA		(1L<<21)	/* digitizer not constrained to local device */
#define digiOutDoesHWPlayThru	(1L<<22)	/* digitizer doesn't need time to play thru */
#define	digiOutDoesILUT			(1L<<23)	/* digitizer does inverse LUT for index modes */
#define	digiOutDoesKeyColor		(1L<<24)	/* digitizer does key color functions too */
#define digiOutDoesAsyncGrabs	(1L<<25)	/* digitizer supports async grabs */
#define digiOutDoesUnreadableScreenBits (1L<<26)	/* playthru doesn't generate readable bits on screen*/
#define digiOutDoesCompress		(1L<<27)	/* supports alternate output data types */
#define digiOutDoesCompressOnly	(1L<<28)	/* can't provide raw frames anywhere */
#define digiOutDoesPlayThruDuringCompress (1L<<29)	/* digi can do playthru while providing compressed data */

/* Types */

typedef ComponentInstance VideoDigitizerComponent;
typedef ComponentResult VideoDigitizerError;

typedef struct {
	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 height */
	short		blendLevels;			/* Number of blend levels supported (2 if 1 bit mask) */
	long		reserved;				/* reserved */
} DigitizerInfo;

typedef struct {
	long		type;
	long		reserved;
} VdigType;

typedef struct {
	short		count;
	VdigType	list[1];
} VdigTypeList;

typedef struct {
	PixMapHandle	dest;
	Point			location;
	long			reserved;
} VdigBufferRec;

typedef struct {
	short			count;
	MatrixRecordPtr	matrix;
	RgnHandle		mask;
	VdigBufferRec	list[1];
} VdigBufferRecList;

typedef VdigBufferRecList *VdigBufferRecListPtr, **VdigBufferRecListHandle;

typedef pascal void (*VdigIntProc)(long flags, long refcon);

typedef struct VDCompressionList {
	CodecComponent		codec;
	CodecType			cType;
	Str63				typeName;
	Str63				name;
	long				formatFlags;
	long				compressFlags;
	long				reserved;
} VDCompressionList, *VDCompressionListPtr, **VDCompressionListHandle;

enum {
	dmaDepth1 = 1,
	dmaDepth2 = 2,
	dmaDepth4 = 4 ,
	dmaDepth8 = 8,
	dmaDepth16 = 16,
	dmaDepth32 = 32,
	dmaDepth2Gray = 64,
	dmaDepth4Gray = 128,
	dmaDepth8Gray = 256
};



// number of vdig calls
enum {
	kvdigSelectors = 82
};

#ifdef __cplusplus
extern "C" {
#endif __cplusplus
pascal VideoDigitizerError VDGetMaxSrcRect(VideoDigitizerComponent ci, short inputStd, Rect *maxSrcRect) 	= {0x2F3C,0x6,0x1,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetActiveSrcRect(VideoDigitizerComponent ci, short inputStd, Rect *activeSrcRect) 	= {0x2F3C,0x6,0x2,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetDigitizerRect(VideoDigitizerComponent ci, Rect *digitizerRect) 	= {0x2F3C,0x4,0x3,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetDigitizerRect(VideoDigitizerComponent ci, Rect *digitizerRect) 	= {0x2F3C,0x4,0x4,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetVBlankRect(VideoDigitizerComponent ci, short inputStd, Rect *vBlankRect) 	= {0x2F3C,0x6,0x5,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetMaskPixMap(VideoDigitizerComponent ci, PixMapHandle maskPixMap) 	= {0x2F3C,0x4,0x6,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetPlayThruDestination(VideoDigitizerComponent ci, PixMapHandle *dest, Rect *destRect,
			 MatrixRecord *m, RgnHandle *mask) 	= {0x2F3C,0x10,0x8,0x7000,0xA82A};
	
pascal VideoDigitizerError VDUseThisCLUT(VideoDigitizerComponent ci, CTabHandle colorTableHandle) 	= {0x2F3C,0x4,0x9,0x7000,0xA82A};		
	
pascal VideoDigitizerError VDSetInputGammaValue(VideoDigitizerComponent ci, Fixed channel1, Fixed channel2, Fixed channel3) 	= {0x2F3C,0xC,0xA,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetInputGammaValue(VideoDigitizerComponent ci, Fixed *channel1, Fixed *channel2, Fixed *channel3) 	= {0x2F3C,0xC,0xB,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetBrightness(VideoDigitizerComponent ci, unsigned short *brightness) 	= {0x2F3C,0x4,0xC,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetBrightness(VideoDigitizerComponent ci, unsigned short *brightness) 	= {0x2F3C,0x4,0xD,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetContrast(VideoDigitizerComponent ci, unsigned short *contrast) 	= {0x2F3C,0x4,0xE,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetHue(VideoDigitizerComponent ci, unsigned short *hue) 	= {0x2F3C,0x4,0xF,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetSharpness(VideoDigitizerComponent ci, unsigned short *sharpness) 	= {0x2F3C,0x4,0x10,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetSaturation(VideoDigitizerComponent ci, unsigned short *saturation) 	= {0x2F3C,0x4,0x11,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetContrast(VideoDigitizerComponent ci, unsigned short *contrast) 	= {0x2F3C,0x4,0x12,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetHue(VideoDigitizerComponent ci, unsigned short *hue) 	= {0x2F3C,0x4,0x13,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetSharpness(VideoDigitizerComponent ci, unsigned short *sharpness) 	= {0x2F3C,0x4,0x14,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetSaturation(VideoDigitizerComponent ci, unsigned short *saturation) 	= {0x2F3C,0x4,0x15,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGrabOneFrame(VideoDigitizerComponent ci) 	= {0x2F3C,0,0x16,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetMaxAuxBuffer(VideoDigitizerComponent ci, PixMapHandle *pm, Rect *r) 	= {0x2F3C,0x8,0x17,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetDigitizerInfo(VideoDigitizerComponent ci, DigitizerInfo *info) 	= {0x2F3C,0x4,0x19,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetCurrentFlags(VideoDigitizerComponent ci, long *inputCurrentFlag, long *outputCurrentFlag) 	= {0x2F3C,0x8,0x1A,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetKeyColor(VideoDigitizerComponent ci, long index) 	= {0x2F3C,0x4,0x1B,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetKeyColor(VideoDigitizerComponent ci, long *index) 	= {0x2F3C,0x4,0x1C,0x7000,0xA82A};
	
pascal VideoDigitizerError VDAddKeyColor(VideoDigitizerComponent ci, long *index) 	= {0x2F3C,0x4,0x1D,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetNextKeyColor(VideoDigitizerComponent ci, long index) 	= {0x2F3C,0x4,0x1E,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetKeyColorRange(VideoDigitizerComponent ci, RGBColor *minRGB, RGBColor *maxRGB) 	= {0x2F3C,0x8,0x1F,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetKeyColorRange(VideoDigitizerComponent ci, RGBColor *minRGB, RGBColor *maxRGB) 	= {0x2F3C,0x8,0x20,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetDigitizerUserInterrupt(VideoDigitizerComponent ci, long flags, VdigIntProc userInterruptProc, long refcon) 	= {0x2F3C,0xC,0x21,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetInputColorSpaceMode(VideoDigitizerComponent ci, short colorSpaceMode) 	= {0x2F3C,0x2,0x22,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetInputColorSpaceMode(VideoDigitizerComponent ci, short *colorSpaceMode) 	= {0x2F3C,0x4,0x23,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetClipState(VideoDigitizerComponent ci, short clipEnable) 	= {0x2F3C,0x2,0x24,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetClipState(VideoDigitizerComponent ci, short *clipEnable) 	= {0x2F3C,0x4,0x25,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetClipRgn(VideoDigitizerComponent ci, RgnHandle clipRegion) 	= {0x2F3C,0x4,0x26,0x7000,0xA82A};
	
pascal VideoDigitizerError VDClearClipRgn(VideoDigitizerComponent ci, RgnHandle clipRegion) 	= {0x2F3C,0x4,0x27,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetCLUTInUse(VideoDigitizerComponent ci, CTabHandle *colorTableHandle) 	= {0x2F3C,0x4,0x28,0x7000,0xA82A};		
	
pascal VideoDigitizerError VDSetPLLFilterType(VideoDigitizerComponent ci, short pllType) 	= {0x2F3C,0x2,0x29,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetPLLFilterType(VideoDigitizerComponent ci, short *pllType) 	= {0x2F3C,0x4,0x2A,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetMaskandValue(VideoDigitizerComponent ci, unsigned short blendLevel, long *mask, long *value ) 	= {0x2F3C,0xA,0x2B,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetMasterBlendLevel(VideoDigitizerComponent ci, unsigned short *blendLevel) 	= {0x2F3C,0x4,0x2C,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetPlayThruDestination(VideoDigitizerComponent ci, PixMapHandle dest, Rect *destRect,
								MatrixRecord *m, RgnHandle mask) 	= {0x2F3C,0x10,0x2D,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetPlayThruOnOff(VideoDigitizerComponent ci, short state) 	= {0x2F3C,0x2,0x2E,0x7000,0xA82A};

pascal VideoDigitizerError VDSetFieldPreference(VideoDigitizerComponent ci, short fieldFlag) 	= {0x2F3C,0x2,0x2F,0x7000,0xA82A};

pascal VideoDigitizerError VDGetFieldPreference(VideoDigitizerComponent ci, short *fieldFlag) 	= {0x2F3C,0x4,0x30,0x7000,0xA82A};
	
pascal VideoDigitizerError VDPreflightDestination(VideoDigitizerComponent ci, Rect *digitizerRect, PixMap **dest, 
								Rect *destRect, MatrixRecord *m) 	= {0x2F3C,0x10,0x32,0x7000,0xA82A};
	
pascal VideoDigitizerError VDPreflightGlobalRect(VideoDigitizerComponent ci, GrafPtr theWindow, Rect *globalRect) 	= {0x2F3C,0x8,0x33,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetPlayThruGlobalRect(VideoDigitizerComponent ci, GrafPtr theWindow, Rect *globalRect) 	= {0x2F3C,0x8,0x34,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetInputGammaRecord(VideoDigitizerComponent ci, VDGamRecPtr inputGammaPtr) 	= {0x2F3C,0x4,0x35,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetInputGammaRecord(VideoDigitizerComponent ci, VDGamRecPtr *inputGammaPtr) 	= {0x2F3C,0x4,0x36,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetBlackLevelValue(VideoDigitizerComponent ci, unsigned short *blackLevel) 	= {0x2F3C,0x4,0x37,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetBlackLevelValue(VideoDigitizerComponent ci, unsigned short *blackLevel) 	= {0x2F3C,0x4,0x38,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetWhiteLevelValue(VideoDigitizerComponent ci, unsigned short *whiteLevel) 	= {0x2F3C,0x4,0x39,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetWhiteLevelValue(VideoDigitizerComponent ci, unsigned short *whiteLevel) 	= {0x2F3C,0x4,0x3A,0x7000,0xA82A};
	
pascal 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) 	= {0x2F3C,0x1C,0x3B,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetNumberOfInputs(VideoDigitizerComponent ci, short *inputs) 	= {0x2F3C,0x4,0x3C,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetInputFormat(VideoDigitizerComponent ci, short input, short *format) 	= {0x2F3C,0x6,0x3D,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetInput(VideoDigitizerComponent ci, short input) 	= {0x2F3C,0x2,0x3E,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGetInput(VideoDigitizerComponent ci, short *input) 	= {0x2F3C,0x4,0x3F,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetInputStandard(VideoDigitizerComponent ci, short inputStandard) 	= {0x2F3C,0x2,0x40,0x7000,0xA82A};
	
pascal VideoDigitizerError VDSetupBuffers(VideoDigitizerComponent ci, VdigBufferRecListHandle bufferList) 	= {0x2F3C,0x4,0x41,0x7000,0xA82A};
	
pascal VideoDigitizerError VDGrabOneFrameAsync(VideoDigitizerComponent ci, short buffer) 	= {0x2F3C,0x2,0x42,0x7000,0xA82A};
	
pascal VideoDigitizerError VDDone(VideoDigitizerComponent ci, short buffer) 	= {0x2F3C,0x2,0x43,0x7000,0xA82A};

pascal VideoDigitizerError VDSetCompression(VideoDigitizerComponent ci, OSType compressType, short depth, Rect *bounds,
			CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) 	= {0x2F3C,0x16,0x44,0x7000,0xA82A};

pascal VideoDigitizerError VDCompressOneFrameAsync(VideoDigitizerComponent ci ) 	= {0x2F3C,0,0x45,0x7000,0xA82A};

pascal VideoDigitizerError VDCompressDone(VideoDigitizerComponent ci, Boolean *done, Ptr *theData, long *dataSize, unsigned char *similarity, TimeRecord *t) 	= {0x2F3C,0x14,0x46,0x7000,0xA82A};

pascal VideoDigitizerError VDReleaseCompressBuffer(VideoDigitizerComponent ci, Ptr bufferAddr) 	= {0x2F3C,0x4,0x47,0x7000,0xA82A};

pascal VideoDigitizerError VDGetImageDescription(VideoDigitizerComponent ci, ImageDescriptionHandle desc) 	= {0x2F3C,0x4,0x48,0x7000,0xA82A};

pascal VideoDigitizerError VDResetCompressSequence(VideoDigitizerComponent ci ) 	= {0x2F3C,0,0x49,0x7000,0xA82A};

pascal VideoDigitizerError VDSetCompressionOnOff(VideoDigitizerComponent ci, Boolean state) 	= {0x2F3C,0x2,0x4A,0x7000,0xA82A};

pascal VideoDigitizerError VDGetCompressionTypes(VideoDigitizerComponent ci, VDCompressionListHandle h) 	= {0x2F3C,0x4,0x4B,0x7000,0xA82A};

pascal VideoDigitizerError VDSetTimeBase(VideoDigitizerComponent ci, TimeBase t) 	= {0x2F3C,0x4,0x4C,0x7000,0xA82A};

pascal VideoDigitizerError VDSetFrameRate(VideoDigitizerComponent ci, Fixed framesPerSecond) 	= {0x2F3C,0x4,0x4D,0x7000,0xA82A};

pascal VideoDigitizerError VDGetDataRate(VideoDigitizerComponent ci, long *milliSecPerFrame, Fixed *framesPerSecond, long *bytesPerSecond) 	= {0x2F3C,0xC,0x4E,0x7000,0xA82A};

pascal VideoDigitizerError VDGetSoundInputDriver(VideoDigitizerComponent ci, Str255 soundDriverName) 	= {0x2F3C,0x4,0x4F,0x7000,0xA82A};

pascal VideoDigitizerError VDGetDMADepths(VideoDigitizerComponent ci, long *depthArray, long *preferredDepth) 	= {0x2F3C,0x8,0x50,0x7000,0xA82A};

pascal VideoDigitizerError VDGetPreferredTimeScale(VideoDigitizerComponent ci, TimeScale *preferred) 	= {0x2F3C,0x4,0x51,0x7000,0xA82A};

pascal VideoDigitizerError VDReleaseAsyncBuffers(VideoDigitizerComponent ci) 	= {0x2F3C,0,0x52,0x7000,0xA82A};

#ifdef __cplusplus
}
#endif __cplusplus

enum {
	kSelectVDGetMaxSrcRect = 0x1,
	kSelectVDGetActiveSrcRect = 0x2,
	kSelectVDSetDigitizerRect = 0x3,
	kSelectVDGetDigitizerRect = 0x4,
	kSelectVDGetVBlankRect = 0x5,
	kSelectVDGetMaskPixMap = 0x6,
	kSelectVDGetPlayThruDestination = 0x8,
	kSelectVDUseThisCLUT = 0x9,		
	kSelectVDSetInputGammaValue = 0xA,
	kSelectVDGetInputGammaValue = 0xB,
	kSelectVDSetBrightness = 0xC,
	kSelectVDGetBrightness = 0xD,
	kSelectVDSetContrast = 0xE,
	kSelectVDSetHue = 0xF,
	kSelectVDSetSharpness = 0x10,
	kSelectVDSetSaturation = 0x11,
	kSelectVDGetContrast = 0x12,
	kSelectVDGetHue = 0x13,
	kSelectVDGetSharpness = 0x14,
	kSelectVDGetSaturation = 0x15,
	kSelectVDGrabOneFrame = 0x16,
	kSelectVDGetMaxAuxBuffer = 0x17,
	kSelectVDGetDigitizerInfo = 0x19,
	kSelectVDGetCurrentFlags = 0x1A,
	kSelectVDSetKeyColor = 0x1B,
	kSelectVDGetKeyColor = 0x1C,
	kSelectVDAddKeyColor = 0x1D,
	kSelectVDGetNextKeyColor = 0x1E,
	kSelectVDSetKeyColorRange = 0x1F,
	kSelectVDGetKeyColorRange = 0x20,
	kSelectVDSetDigitizerUserInterrupt = 0x21,
	kSelectVDSetInputColorSpaceMode = 0x22,
	kSelectVDGetInputColorSpaceMode = 0x23,
	kSelectVDSetClipState = 0x24,
	kSelectVDGetClipState = 0x25,
	kSelectVDSetClipRgn = 0x26,
	kSelectVDClearClipRgn = 0x27,
	kSelectVDGetCLUTInUse = 0x28,		
	kSelectVDSetPLLFilterType = 0x29,
	kSelectVDGetPLLFilterType = 0x2A,
	kSelectVDGetMaskandValue = 0x2B,
	kSelectVDSetMasterBlendLevel = 0x2C,
	kSelectVDSetPlayThruDestination = 0x2D,
	kSelectVDSetPlayThruOnOff = 0x2E,
	kSelectVDSetFieldPreference = 0x2F,
	kSelectVDGetFieldPreference = 0x30,
	kSelectVDPreflightDestination = 0x32,
	kSelectVDPreflightGlobalRect = 0x33,
	kSelectVDSetPlayThruGlobalRect = 0x34,
	kSelectVDSetInputGammaRecord = 0x35,
	kSelectVDGetInputGammaRecord = 0x36,
	kSelectVDSetBlackLevelValue = 0x37,
	kSelectVDGetBlackLevelValue = 0x38,
	kSelectVDSetWhiteLevelValue = 0x39,
	kSelectVDGetWhiteLevelValue = 0x3A,
	kSelectVDGetVideoDefaults = 0x3B,
	kSelectVDGetNumberOfInputs = 0x3C,
	kSelectVDGetInputFormat = 0x3D,
	kSelectVDSetInput = 0x3E,
	kSelectVDGetInput = 0x3F,
	kSelectVDSetInputStandard = 0x40,
	kSelectVDSetupBuffers = 0x41,
	kSelectVDGrabOneFrameAsync = 0x42,
	kSelectVDDone = 0x43,
	kSelectVDSetCompression = 0x44,
	kSelectVDCompressOneFrameAsync = 0x45,
	kSelectVDCompressDone = 0x46,
	kSelectVDReleaseCompressBuffer = 0x47,
	kSelectVDGetImageDescription = 0x48,
	kSelectVDResetCompressSequence = 0x49,
	kSelectVDSetCompressionOnOff = 0x4A,
	kSelectVDGetCompressionTypes = 0x4B,
	kSelectVDSetTimeBase = 0x4C,
	kSelectVDSetFrameRate = 0x4D,
	kSelectVDGetDataRate = 0x4E,
	kSelectVDGetSoundInputDriver = 0x4F,
	kSelectVDGetDMADepths = 0x50,
	kSelectVDGetPreferredTimeScale = 0x51,
	kSelectVDReleaseAsyncBuffers = 0x52 
};
#define	StandardCompressionType		'scdi'
#define	StandardCompressionSubType	'imag'


typedef pascal Boolean (*SCModalFilterProcPtr)(DialogPtr theDialog,
	EventRecord *theEvent, short *itemHit, long refcon);

typedef pascal short (*SCModalHookProcPtr)(DialogPtr theDialog,
	short itemHit, void *params, long refcon);


//	Preference flags.

#define	scListEveryCodec		(1L<<1)
#define	scAllowZeroFrameRate	(1L<<2)
#define	scAllowZeroKeyFrameRate	(1L<<3)
#define	scShowBestDepth			(1L<<4)
#define	scUseMovableModal		(1L<<5)


//	Possible test flags for setting test image.

#define	scPreferCropping			(1<<0)
#define	scPreferScaling				(1<<1)
#define scPreferScalingAndCropping	(scPreferScaling + scPreferCropping)


//	Dimensions of the image preview box.

#define	scTestImageWidth	80
#define	scTestImageHeight	80


//	Possible items returned by hookProc.

#define	scOKItem				1
#define	scCancelItem			2
#define	scCustomItem			3

//	Result returned when user cancelled.

#define	scUserCancelled			1


// Component selectors

#define	scPositionRect				2
#define	scPositionDialog			3
#define	scSetTestImagePictHandle	4
#define	scSetTestImagePictFile		5
#define	scSetTestImagePixMap		6
#define	scGetBestDeviceRect			7

#define	scRequestImageSettings		10
#define	scCompressImage				11
#define	scCompressPicture			12
#define	scCompressPictureFile		13
#define	scRequestSequenceSettings	14
#define	scCompressSequenceBegin		15
#define	scCompressSequenceFrame		16
#define	scCompressSequenceEnd		17
#define	scDefaultPictHandleSettings	18
#define	scDefaultPictFileSettings	19
#define	scDefaultPixMapSettings		20
#define	scGetInfo					21
#define	scSetInfo					22
#define	scNewGWorld					23


//	Get/SetInfo structures.

typedef struct {
	CodecType		codecType;
	CodecComponent	codec;
	short			depth;
	CodecQ			spatialQuality;
} SCSpatialSettings;

typedef struct {
	CodecQ			temporalQuality;
	Fixed			frameRate;
	long			keyFrameRate;
} SCTemporalSettings;

typedef struct {
	long			dataRate;
	long			frameDuration;
	CodecQ			minSpatialQuality;
	CodecQ			minTemporalQuality;
} SCDataRateSettings;

typedef struct {
	SCModalFilterProcPtr	filterProc;
	SCModalHookProcPtr		hookProc;
	long					refcon;
	Str31					customName;
} SCExtendedProcs;


//	Get/SetInfo selectors

#define	scSpatialSettingsType	'sptl'		// pointer to SCSpatialSettings struct
#define	scTemporalSettingsType	'tprl'		// pointer to SCTemporalSettings struct
#define	scDataRateSettingsType	'drat'		// pointer to SCDataRateSettings struct
#define	scColorTableType		'clut'		// pointer to CTabHandle
#define	scProgressProcType		'prog'		// pointer to ProgressRecord struct
#define	scExtendedProcsType		'xprc'		// pointer to SCExtendedProcs struct
#define	scPreferenceFlagsType	'pref'		// pointer to long
#define	scSettingsStateType		'ssta'		// pointer to Handle
#define	scSequenceIDType		'sequ'		// pointer to ImageSequence
#define	scWindowPositionType	'wndw'		// pointer to Point
#define	scCodecFlagsType		'cflg'		// pointer to CodecFlags


//	Result returned by Get/SetInfo when type cannot be found.

#define	scTypeNotFoundErr		-8971		// same number as codecExtensionNotFoundErr



#ifdef __cplusplus
extern "C" {
#endif

pascal ComponentResult
SCPositionRect(ComponentInstance ci,Rect *rp,Point *where)
	= {0x2F3C,0x8,0x2,0x7000,0xA82A};

pascal ComponentResult
SCPositionDialog(ComponentInstance ci,short id,Point *where)
	= {0x2F3C,0x6,0x3,0x7000,0xA82A};

pascal ComponentResult
SCSetTestImagePictHandle(ComponentInstance ci, PicHandle testPict, Rect *testRect, short testFlags)
	= {0x2F3C,0xA,0x4,0x7000,0xA82A};

pascal ComponentResult
SCSetTestImagePictFile(ComponentInstance ci, short testFileRef, Rect *testRect, short testFlags)
	= {0x2F3C,0x8,0x5,0x7000,0xA82A};

pascal ComponentResult
SCSetTestImagePixMap(ComponentInstance ci, PixMapHandle testPixMap, Rect *testRect, short testFlags)
	= {0x2F3C,0xA,0x6,0x7000,0xA82A};

pascal ComponentResult
SCGetBestDeviceRect(ComponentInstance ci, Rect *r) 
 	= {0x2F3C,0x4,0x7,0x7000,0xA82A};



pascal ComponentResult
SCRequestImageSettings(ComponentInstance ci)
	= {0x2F3C,0,0xA,0x7000,0xA82A};

pascal ComponentResult
SCCompressImage(ComponentInstance ci,PixMapHandle src,Rect *srcRect,ImageDescriptionHandle *desc,Handle *data)
	= {0x2F3C,0x10,0xB,0x7000,0xA82A};

pascal ComponentResult
SCCompressPicture(ComponentInstance ci,PicHandle srcPicture,PicHandle dstPicture)
	= {0x2F3C,0x8,0xC,0x7000,0xA82A};

pascal ComponentResult
SCCompressPictureFile(ComponentInstance ci,short srcRefNum,short dstRefNum)
	= {0x2F3C,0x4,0xD,0x7000,0xA82A};

pascal ComponentResult
SCRequestSequenceSettings(ComponentInstance ci)
	= {0x2F3C,0,0xE,0x7000,0xA82A};

pascal ComponentResult
SCCompressSequenceBegin(ComponentInstance ci,PixMapHandle src,Rect *srcRect,ImageDescriptionHandle *desc)
	= {0x2F3C,0xC,0xF,0x7000,0xA82A};

pascal ComponentResult
SCCompressSequenceFrame(ComponentInstance ci,PixMapHandle src,Rect *srcRect,Handle *data,long *dataSize,short *notSyncFlag)
	= {0x2F3C,0x14,0x10,0x7000,0xA82A};

pascal ComponentResult
SCCompressSequenceEnd(ComponentInstance ci)
	= {0x2F3C,0,0x11,0x7000,0xA82A};

pascal ComponentResult
SCDefaultPictHandleSettings(ComponentInstance ci,PicHandle srcPicture, short motion)
	= {0x2F3C,0x6,0x12,0x7000,0xA82A};

pascal ComponentResult
SCDefaultPictFileSettings(ComponentInstance ci,short srcRef, short motion)
	= {0x2F3C,0x4,0x13,0x7000,0xA82A};

pascal ComponentResult
SCDefaultPixMapSettings(ComponentInstance ci,PixMapHandle src, short motion)
	= {0x2F3C,0x6,0x14,0x7000,0xA82A};

pascal ComponentResult
SCGetInfo(ComponentInstance ci,OSType type,void *info)
	= {0x2F3C,0x8,0x15,0x7000,0xA82A};

pascal ComponentResult
SCSetInfo(ComponentInstance ci,OSType type,void *info)
	= {0x2F3C,0x8,0x16,0x7000,0xA82A};

pascal ComponentResult
SCNewGWorld(ComponentInstance ci,GWorldPtr *gwp,Rect *rp,GWorldFlags flags)
	= {0x2F3C,0xC,0x17,0x7000,0xA82A};

#ifdef __cplusplus
}
#endif





// For compatibility with earlier linked StdCompression.

typedef struct {
	long			flags;
	CodecType		theCodecType;
	CodecComponent	theCodec;
	CodecQ			spatialQuality;
	CodecQ			temporalQuality;
	short			depth;
	Fixed			frameRate;
	long			keyFrameRate;
	long			reserved1;
	long			reserved2;
} SCParams;


#define	scGetCompression		1

#define	scShowMotionSettings	(1L<<0)

#define	scSettingsChangedItem	-1


#ifdef __cplusplus
extern "C" {
#endif

pascal ComponentInstance OpenStdCompression(void);

pascal ComponentResult
SCGetCompressionExtended(ComponentInstance ci,SCParams *params,Point where,
	SCModalFilterProcPtr filterProc,SCModalHookProcPtr hookProc,long refcon,StringPtr customName)
	= {0x2F3C,0x18,0x1,0x7000,0xA82A};

pascal ComponentResult
SCGetCompression(ComponentInstance ci,SCParams *params,Point where)
	= {0x42A7,0x42A7,0x42A7,0x42A7,0x2F3C,0x18,0x1,0x7000,0xA82A};

#ifdef __cplusplus
}
#endif




typedef ComponentInstance MovieImportComponent, MovieExportComponent;

#define MovieImportType 'eat '
#define MovieExportType 'spit'

enum {
	canMovieImportHandles = 1,
	canMovieImportFiles = 2,
	hasMovieImportUserInterface = 4,
	canMovieExportHandles = 8,
	canMovieExportFiles = 16,
	hasMovieExportUserInterface = 32,
	dontAutoFileMovieImport = 64
};

enum {
	kMovieImportExportOpenSelect = kComponentOpenSelect,
	kMovieImportExportCloseSelect = kComponentCloseSelect,
	kMovieImportExportCanDoSelect = kComponentCanDoSelect,
	kMovieImportExportVersionSelect = kComponentVersionSelect, 

	kMovieImportHandleSelect = 1,
	kMovieImportFileSelect = 2,
	kMovieImportSetFrameDurationSelect = 3,
	kMovieImportSetSampleDescriptionSelect = 4,
	kMovieImportSetMediaFileSelect = 5,
	kMovieImportSetDimensionsSelect = 6,
	kMovieImportSetChunkSizeSelect = 7,
	kMovieImportSetProgressProcSelect = 8,
	kMovieImportSetAuxiliaryDataSelect = 9,
	kMovieImportSetFromScrapSelect = 10,
	kMovieImportDoUserDialogSelect = 11,
	kMovieImportSetDurationSelect = 12,
	
	kMovieExportToHandleSelect = 128,
	kMovieExportToFileSelect = 129,
	kMovieExportDoUserDialogSelect = 130,
	kMovieExportGetAuxiliaryDataSelect = 131,
	kMovieExportSetProgressProcSelect = 132
};

enum {
	movieImportCreateTrack = 1,
	movieImportInParallel = 2,
	movieImportMustUseTrack = 4
};

enum {
	movieImportResultUsedMultipleTracks = 8
};

#ifdef __cplusplus
extern "C" {
#endif __cplusplus

pascal ComponentResult MovieImportHandle(MovieImportComponent ci, Handle dataH,
		Movie theMovie, Track targetTrack, Track *usedTrack, TimeValue atTime, TimeValue *addedDuration,
		long inFlags, long *outFlags) = {0x2F3C,0x20,0x1,0x7000,0xA82A};

pascal ComponentResult MovieImportFile(MovieImportComponent ci, const FSSpec *theFile,
		Movie theMovie, Track targetTrack, Track *usedTrack, TimeValue atTime, TimeValue *addedDuration,
		long inFlags, long *outFlags) = {0x2F3C,0x20,0x2,0x7000,0xA82A};

pascal ComponentResult MovieImportSetSampleDuration(MovieImportComponent ci, TimeValue duration, TimeScale scale) = {0x2F3C,0x8,0x3,0x7000,0xA82A};

pascal ComponentResult MovieImportSetSampleDescription(MovieImportComponent ci, SampleDescriptionHandle desc, OSType mediaType) = {0x2F3C,0x8,0x4,0x7000,0xA82A};

pascal ComponentResult MovieImportSetMediaFile(MovieImportComponent ci, AliasHandle alias) = {0x2F3C,0x4,0x5,0x7000,0xA82A};

pascal ComponentResult MovieImportSetDimensions(MovieImportComponent ci, Fixed width, Fixed height) = {0x2F3C,0x8,0x6,0x7000,0xA82A};

pascal ComponentResult MovieImportSetChunkSize(MovieImportComponent ci, long chunkSize) = {0x2F3C,0x4,0x7,0x7000,0xA82A};

pascal ComponentResult MovieImportSetProgressProc(MovieImportComponent ci, MovieProgressProcPtr proc, long refcon) = {0x2F3C,0x8,0x8,0x7000,0xA82A};

pascal ComponentResult MovieImportSetAuxiliaryData(MovieImportComponent ci, Handle data, OSType handleType) = {0x2F3C,0x8,0x9,0x7000,0xA82A};

pascal ComponentResult MovieImportSetFromScrap(MovieImportComponent ci, Boolean fromScrap) = {0x2F3C,0x2,0xA,0x7000,0xA82A};

pascal ComponentResult MovieImportDoUserDialog(MovieImportComponent ci, const FSSpec *theFile, Handle theData, Boolean *canceled) = {0x2F3C,0xC,0xB,0x7000,0xA82A};

pascal ComponentResult MovieImportSetDuration(MovieImportComponent ci, TimeValue duration) = {0x2F3C,0x4,0xC,0x7000,0xA82A};


pascal ComponentResult MovieExportToHandle(MovieExportComponent ci, Handle dataH, Movie theMovie, Track onlyThisTrack, TimeValue startTime,
	TimeValue duration) = {0x2F3C,0x14,0x80,0x7000,0xA82A};

pascal ComponentResult MovieExportToFile(MovieExportComponent ci, const FSSpec *theFile, Movie theMovie, Track onlyThisTrack, TimeValue startTime,
	TimeValue duration) = {0x2F3C,0x14,0x81,0x7000,0xA82A};

pascal ComponentResult MovieExportDoUserDialog(MovieExportComponent ci, const FSSpec *theFile, Handle theData, Boolean *canceled) = {0x2F3C,0xC,0x82,0x7000,0xA82A};

pascal ComponentResult MovieExportGetAuxiliaryData(MovieExportComponent ci, Handle dataH, OSType *handleType) = {0x2F3C,0x8,0x83,0x7000,0xA82A};

pascal ComponentResult MovieExportSetProgressProc(MovieExportComponent ci, MovieProgressProcPtr proc, long refcon) = {0x2F3C,0x8,0x84,0x7000,0xA82A};

#ifdef __cplusplus
}
#endif __cplusplus

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

	File Preview Components

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

typedef ComponentInstance pnotComponent;

enum {
	pnotComponentWantsEvents = 1,
	pnotComponentNeedsNoCache = 2
};

enum {
	kPreviewOpenSelector = 0,
	kPreviewCloseSelector = -1,
	kPreviewCanDoSelector = -2,
	kPreviewVersionSelector = -3, 

	kPreviewShowDataSelector = 1,
	kPreviewMakePreviewSelector = 2,
	kPreviewMakePreviewReferenceSelector = 3,
	kPreviewEventSelector = 4
};

#define ShowFilePreviewComponentType 'pnot'
#define CreateFilePreviewrComponentType 'pmak'

#ifdef __cplusplus
extern "C" {
#endif __cplusplus

pascal ComponentResult PreviewShowData(pnotComponent p, OSType dataType, Handle data,
		const Rect *inHere) = {0x2F3C,0xC,0x1,0x7000,0xA82A};

pascal ComponentResult PreviewMakePreview(pnotComponent p, OSType *previewType, Handle *previewResult,
			const FSSpec *sourceFile, ProgressProcRecordPtr progress) = {0x2F3C,0x10,0x2,0x7000,0xA82A};

pascal ComponentResult PreviewMakePreviewReference(pnotComponent p, OSType *previewType, short *resID,
			const FSSpec *sourceFile) = {0x2F3C,0xC,0x3,0x7000,0xA82A};

pascal ComponentResult PreviewEvent(pnotComponent p, EventRecord *e, Boolean *handledEvent) = {0x2F3C,0x8,0x4,0x7000,0xA82A};
#ifdef __cplusplus
}
#endif __cplusplus
#endif __QUICKTIMECOMPONENTS__
