Summary of Video Digitizer Components
C Summary
Constants
enum {
videoDigitizerComponentType = 'vdig',/* standard type for video
digitizer components */
/* input format standards */
ntscIn = 0, /* National Television System Committee */
palIn = 1, /* Phase Alternation Line */
secamIn = 2, /* Sequential Color with Memory */
/* input formats */
compositeIn = 0, /* no color separation of channels */
sVideoIn = 1, /* s-video (super VHS) */
rgbComponentIn = 2, /* separate channels for red, green, & blue */
/* video digitizer component PlayThru states */
vdPlayThruOff = 0, /* playthrough off */
vdPlayThruOn = 1, /* playthrough on */
/* field preference options in VDGetFieldPreference function */
vdUseAnyField = 0, /* digitizer component decides which field to use */
vdUseOddField = 1, /* digitizer component uses odd field */
vdUseEvenField = 2, /* digitizer component uses even field */
/* input color space modes */
vdDigitizerBW = 0, /* digitizer component uses black and white */
vdDigitizerRGB = 1, /* digitizer component uses red, green, & blue */
/* phase lock loop modes */
vdBroadcastMode = 0, /* broadcast (laser disk) video mode */
vdVTRMode = 1, /* VCR (magnetic media) mode */
/* video digitizer component types */
vdTypeBasic = 0,/* basic component does not support clipping */
vdTypeAlpha = 1,/* component supports clipping with alpha channel */
vdTypeMask = 2,/* component supports clipping with mask plane */
vdTypeKey = 3, /* component supports clipping with one or more key
colors */
/* digitizer input capability/current flags */
digiInDoesNTSC = (1L<<0), /* NTSC input */
digiInDoesPAL = (1L<<1), /* PAL input */
digiInDoesSECAM = (1L<<2), /* SECAM format */
digiInDoesGenLock = (1L<<7), /* digitizer performs genlock */
digiInDoesComposite = (1L<<8), /* composite input */
digiInDoesSVideo = (1L<<9), /* s-video input type */
digiInDoesComponent = (1L<<10), /* component (RGB) input type */
digiInVTR_Broadcast = (1L<<11),/* differentiates between magnetic
media and broadcast input */
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 locked input signal
- this bit =
horiz lock || vertical lock */
/* digitizer output capability/current flags */
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), /* masks to clipping regions */
digiOutDoesDouble = (1L<<11),/* stretches to exactly double size */
digiOutDoesQuad = (1L<<12),/* stretches to exactly quadruple size */
digiOutDoesQuarter = (1L<<13),/* shrinks to exactly one-quarter size */
digiOutDoesSixteenth = (1L<<14),/* shrinks to exactly one-sixteenth */
digiOutDoesRotate = (1L<<15),/* supports rotation transformations */
digiOutDoesHorizFlip = (1L<<16),/* supports horizontal flips Sx < 0 */
digiOutDoesVertFlip = (1L<<17),/* supports vertical flips Sy < 0 */
digiOutDoesSkew = (1L<<18),/* supports skew (shear,twist) */
digiOutDoesBlend = (1L<<19),/* supports blend operations */
digiOutDoesWarp = (1L<<20),/* supports warp operations */
digiOutDoesHW_DMA = (1L<<21),/* not constrained to local device */
digiOutDoesHWPlayThru= (1L<<22),/* doesn't need time to play */
digiOutDoesILUT = (1L<<23),/* does lookup table for index modes */
digiOutDoesKeyColor = (1L<<24),/* performs key color functions too */
digiOutDoesAsyncGrabs= (1L<<25),/* supports asynchronous grabs */
digiOutDoesUnreadableScreenBits
= (1L<<26),/* playthru doesn't generate readable
bits on screen */
digiOutDoesCompress = (1L<<27),/* supports compressed source devices */
digiOutDoesCompressOnly
= (1L<<28),/* can't draw images */
digiOutDoesPlayThruDuringCompress
= (1L<<29) /* can play while providing compressed
data */
};
enum {
/* video digitizer interface */
kSelectVDGetMaxSrcRect = 0x1,/* VDGetMaxSrcRect (required) */
kSelectVDGetActiveSrcRect = 0x2,/* VDGetActiveSrcRect
(required) */
kSelectVDSetDigitizerRect = 0x3,/* VDSetDigitizerRect
(required) */
kSelectVDGetDigitizerRect = 0x4,/* VDGetDigitizerRect
(required) */
kSelectVDGetVBlankRect = 0x5,/* VDGetVBlankRect (required) */
kSelectVDGetMaskPixMap = 0x6,/* VDGetMaskPixMap */
/* 1 available selector here */
kSelectVDGetPlayThruDestination = 0x8,/* VDGetPlayThruDestination
(required) */
kSelectVDUseThisCLUT = 0x9,/* VDUseThisCLUT */
kSelectVDSetInputGammaValue = 0xA,/* VDSetInputGammaValue */
kSelectVDGetInputGammaValue = 0xB,/* VDGetInputGammaValue */
kSelectVDSetBrightness = 0xC,/* VDSetBrightness */
kSelectVDGetBrightness = 0xD,/* VDGetBrightness */
kSelectVDSetContrast = 0xE,/* VDSetContrast */
kSelectVDSetHue = 0xF,/* VDSetHue */
kSelectVDSetSharpness = 0x10,/* VDSetSharpness */
kSelectVDSetSaturation = 0x11,/* VDSetSaturation */
kSelectVDGetContrast = 0x12,/* VDGetContrast */
kSelectVDGetHue = 0x13,/* VDGetHue */
kSelectVDGetSharpness = 0x14,/* VDGetSharpness */
kSelectVDGetSaturation = 0x15,/* VDGetSaturation */
kSelectVDGrabOneFrame = 0x16,/* VDGrabOneFrame
(required) */
kSelectVDGetMaxAuxBuffer = 0x17,/* VDGetMaxAuxBuffer */
kSelectVDGetDigitizerInfo = 0x19,/* VDGetDigitizerInfo
(required) */
kSelectVDGetCurrentFlags = 0x1A,/* VDGetCurrentFlags
(required) */
kSelectVDSetKeyColor = 0x1B,/* VDSetKeyColor */
kSelectVDGetKeyColor = 0x1C,/* VDGetKeyColor */
kSelectVDAddKeyColor = 0x1D,/* VDAddKeyColor */
kSelectVDGetNextKeyColor = 0x1E,/* VDGetNextKeyColor */
kSelectVDSetKeyColorRange = 0x1F,/* VDSetKeyColorRange */
kSelectVDGetKeyColorRange = 0x20,/* VDGetKeyColorRange */
kSelectVDSetDigitizerUserInterrupt = 0x21,
/* VDSetDigitizerUserInterrupt */
kSelectVDSetInputColorSpaceMode = 0x22,/* VDSetInputColorSpaceMode */
kSelectVDGetInputColorSpaceMode = 0x23,/* VDGetInputColorSpaceMode */
kSelectVDSetClipState = 0x24,/* VDSetClipState */
kSelectVDGetClipState = 0x25,/* VDGetClipState */
kSelectVDSetClipRgn = 0x26,/* VDSetClipRgn */
kSelectVDClearClipRgn = 0x27,/* VDClearClipRgn */
kSelectVDGetCLUTInUse = 0x28,/* VDGetCLUTInUse */
kSelectVDSetPLLFilterType = 0x29,/* VDSetPLLFilterType */
kSelectVDGetPLLFilterType = 0x2A,/* VDGetPLLFilterType */
kSelectVDGetMaskandValue = 0x2B,/* VDGetMaskandValue */
kSelectVDSetMasterBlendLevel = 0x2C,/* VDSetMasterBlendLevel */
kSelectVDSetPlayThruDestination = 0x2D,/* VDSetPlayThruDestination */
kSelectVDSetPlayThruOnOff = 0x2E,/* VDSetPlayThruOnOff */
kSelectVDSetFieldPreference = 0x2F,/* VDSetFieldPreference
(required) */
kSelectVDGetFieldPreference = 0x30,/* VDGetFieldPreference
(required) */
kSelectVDPreflightDestination = 0x32,/* VDPreflightDestination
(required) */
kSelectVDPreflightGlobalRect = 0x33,/* VDPreflightGlobalRect */
kSelectVDSetPlayThruGlobalRect = 0x34,/* VDSetPlayThruGlobalRect */
kSelectVDSetInputGammaRecord = 0x35,/* VDSetInputGammaRecord */
kSelectVDGetInputGammaRecord = 0x36,/* VDGetInputGammaRecord */
kSelectVDSetBlackLevelValue = 0x37,/* VDSetBlackLevelValue */
kSelectVDGetBlackLevelValue = 0x38,/* VDGetBlackLevelValue */
kSelectVDSetWhiteLevelValue = 0x39,/* VDSetWhiteLevelValue */
kSelectVDGetWhiteLevelValue = 0x3A,/* VDGetWhiteLevelValue */
kSelectVDGetVideoDefaults = 0x3B,/* VDGetVideoDefaults */
kSelectVDGetNumberOfInputs = 0x3C,/* VDGetNumberOfInputs */
kSelectVDGetInputFormat = 0x3D,/* VDGetInputFormat */
kSelectVDSetInput = 0x3E,/* VDSetInput */
kSelectVDGetInput = 0x3F,/* VDGetInput */
kSelectVDSetInputStandard = 0x40,/* VDSetInputStandard */
kSelectVDSetupBuffers = 0x41,/* VDSetupBuffers */
kSelectVDGrabOneFrameAsync = 0x42,/* VDGrabOneFrameAsync */
kSelectVDDone = 0x43,/* VDDone */
kSelectVDSetCompression = 0x44,/* VDSetCompression */
kSelectVDCompressOneFrameAsync = 0x45,/* VDCompressOneFrameAsync */
kSelectVDCompressDone = 0x46,/* VDCompressDone */
kSelectVDReleaseCompressBuffer = 0x47,/* VDReleaseCompressBuffer */
kSelectVDGetImageDescription = 0x48,/* VDGetImageDescription */
kSelectVDResetCompressSequence = 0x49,/* VDResetCompressSequence */
kSelectVDSetCompressionOnOff = 0x4A,/* VDSetCompressionOnOff */
kSelectVDGetCompressionTypes = 0x4B,/* VDGetCompressionTypes */
kSelectVDSetTimeBase = 0x4C,/* VDSetTimeBase */
kSelectVDSetFrameRate = 0x4D,/* VDSetFrameRate */
kSelectVDGetDataRate = 0x4E,/* VDGetDataRate */
kSelectVDGetSoundInputDriver = 0x4F,/* VDGetSoundInputDriver */
kSelectVDGetDMADepths = 0x50,/* VDGetDMADepths */
kSelectVDGetPreferredTimeScale = 0x51,/* VDGetPreferredTimeScale */
kSelectVDReleaseAsyncBuffers = 0x52,/* VDReleaseAsyncBuffers */
};
/* flags for VDGetDMADepths depthArray parameter */
enum {
dmaDepth1 = 1, /* supports black and white */
dmaDepth2 = 2, /* supports 2-bit color */
dmaDepth4 = 4, /* supports 4-bit color */
dmaDepth8 = 8, /* supports 8-bit color */
dmaDepth16 = 16, /* supports 16-bit color */
dmaDepth32 = 32, /* supports 32-bit color */
dmaDepth2Gray = 64, /* supports 2-bit grayscale */
dmaDepth4Gray = 128, /* supports 4-bit grayscale */
dmaDepth8Gray = 256 /* supports 8-bit grayscale */
};
Data Types
typedef ComponentInstance VideoDigitizerComponent;/* video digitizer
component */
typedef ComponentResult VideoDigitizerError; /* video digitizer error */
struct DigitizerInfo {
short vdigType; /* type of digitizer component */
long inputCapabilityFlags;/* input video signal features */
long outputCapabilityFlags;/* output digitized video data features
of digitizer component */
long inputCurrentFlags; /* status of input video signal */
long outputCurrentFlags; /* status of output digitized video data */
short slot; /* temporary for connection purposes */
GDHandle gdh; /* temporary for digitizers with
preferred screen */
GDHandle maskgdh; /* temporary for digitizers with
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 Private; /* reserved--set to 0 */
};
typedef struct DigitizerInfo DigitizerInfo;
struct VdigBufferRecList {
short count; /* # of buffers defined by this structure */
MatrixRecordPtr matrix; /* tranformation matrix applied to dest rects
before video image is displayed */
RgnHandle mask; /* clip region applied to dest rect before
video image is displayed */
VdigBufferRec list[1]; /* array of output buffer specifications */
};
typedef struct {
PixMapHandle dest; /* handle to pixel map for destination buffer */
Point location;/* location of video destination in pixel map */
long reserved;/* reserved--set to 0 */
} VdigBufferRec;
typedef struct VDCompressionList {
CodecComponent codec; /* component ID */
CodecType cType; /* compressor type */
Str63 typeName; /* compression algorithm */
Str63 name; /* compressor name string */
long formatFlags; /* data format flags */
long compressFlags; /* capabilities flags */
long reserved; /* set to 0 */
} VDCompressionList, *VDCompressionListPtr, **VDCompressionListHandle;
Video Digitizer Component Functions
Getting Information About Video Digitizer Components
pascal VideoDigitizerError VDGetDigitizerInfo
(VideoDigitizerComponent ci,
DigitizerInfo *info);
pascal VideoDigitizerError VDGetCurrentFlags
(VideoDigitizerComponent ci,
long *inputCurrentFlag,
long *outputCurrentFlag);
Setting Source Characteristics
pascal VideoDigitizerError VDGetMaxSrcRect
(VideoDigitizerComponent ci, short inputStd,
Rect *maxSrcRect);
pascal VideoDigitizerError VDGetActiveSrcRect
(VideoDigitizerComponent ci,
short inputStd, Rect *activeSrcRect);
pascal VideoDigitizerError VDGetVBlankRect
(VideoDigitizerComponent ci,
short inputStd, Rect *vBlankRect);
pascal VideoDigitizerError VDSetDigitizerRect
(VideoDigitizerComponent ci,
Rect *digitizerRect);
pascal VideoDigitizerError VDGetDigitizerRect
(VideoDigitizerComponent ci,
Rect *digitizerRect);
Selecting an Input Source
pascal VideoDigitizerError VDGetNumberOfInputs
(VideoDigitizerComponent ci, short *inputs);
pascal VideoDigitizerError VDSetInput
(VideoDigitizerComponent ci, short input);
pascal VideoDigitizerError VDGetInput
(VideoDigitizerComponent ci, short *input);
pascal VideoDigitizerError VDGetInputFormat
(VideoDigitizerComponent ci, short input,
short *format);
pascal VideoDigitizerError VDSetInputStandard
(VideoDigitizerComponent ci,
short inputStandard);
Setting Video Destinations
pascal VideoDigitizerError VDSetPlayThruDestination
(VideoDigitizerComponent ci,
PixMapHandle dest, Rect *destRect,
MatrixRecord *m, RgnHandle mask);
pascal VideoDigitizerError VDPreflightDestination
(VideoDigitizerComponent ci,
Rect *digitizerRect, PixMapHandle dest,
Rect *destRect, MatrixRecord *m);
pascal VideoDigitizerError VDGetPlayThruDestination
(VideoDigitizerComponent ci,
PixMapHandle *dest, Rect *destRect, MatrixRecord *m, RgnHandle *mask);
pascal VideoDigitizerError VDSetPlayThruGlobalRect
(VideoDigitizerComponent ci,
GrafPtr theWindow, Rect *globalRect);
pascal VideoDigitizerError VDPreflightGlobalRect
(VideoDigitizerComponent ci,
GrafPtr theWindow, Rect *globalRect);
pascal VideoDigitizerError VDGetMaxAuxBuffer
(VideoDigitizerComponent ci,
PixMapHandle *pm, Rect *r);
Controlling Compressed Source Devices
pascal VideoDigitizerError VDGetCompressionTypes
(VideoDigitizerComponent ci, VDCompressionListHandle h);
pascal VideoDigitizerError VDSetCompression
(VideoDigitizerComponent ci,
OSType compressType, short depth,
Rect *bounds, CodecQ spatialQuality,
CodecQ temporalQuality, long keyFrameRate);
pascal VideoDigitizerError VDSetCompressionOnOff
(VideoDigitizerComponent ci, Boolean state);
pascal VideoDigitizerError VDCompressOneFrameAsync
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDCompressDone
(VideoDigitizerComponent ci, Boolean *done,
Ptr *theData, long *dataSize,
unsigned char *similarity, TimeRecord *t);
pascal VideoDigitizerError VDReleaseCompressBuffer
(VideoDigitizerComponent ci, Ptr bufferAddr);
pascal VideoDigitizerError VDGetImageDescription
(VideoDigitizerComponent ci, ImageDescriptionHandle desc);
pascal VideoDigitizerError VDResetCompressSequence
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDSetTimeBase
(VideoDigitizerComponent ci, TimeBase t);
Controlling Digitization
pascal VideoDigitizerError VDSetPlayThruOnOff
(VideoDigitizerComponent ci, short state);
pascal VideoDigitizerError VDGrabOneFrame
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDSetupBuffers
(VideoDigitizerComponent ci,
VdigBufferRecListHandle bufferList);
pascal VideoDigitizerError VDReleaseAsyncBuffers
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDGrabOneFrameAsync
(VideoDigitizerComponent ci, short buffer);
pascal long VDDone(VideoDigitizerComponent ci, short buffer);
pascal VideoDigitizerError VDSetFrameRate
(VideoDigitizerComponent ci,
Fixed framesPerSecond);
pascal VideoDigitizerError VDGetDataRate
(VideoDigitizerComponent ci,
long *milliSecPerFrame,
Fixed *framesPerSecond, long *bytesPerSecond);
Controlling Color
pascal VideoDigitizerError VDUseThisCLUT
(VideoDigitizerComponent ci,
CTabHandle colorTableHandle);
pascal VideoDigitizerError VDGetCLUTInUse
(VideoDigitizerComponent ci,
CTabHandle *colorTableHandle);
pascal VideoDigitizerError VDSetInputColorSpaceMode
(VideoDigitizerComponent ci,
short colorSpaceMode);
pascal VideoDigitizerError VDGetInputColorSpaceMode
(VideoDigitizerComponent ci,
short *colorSpaceMode);
pascal VideoDigitizerError VDGetDMADepths
(VideoDigitizerComponent ci,
long *depthArray, long *preferredDepth);
Controlling Analog Video
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);
pascal VideoDigitizerError VDSetBlackLevelValue
(VideoDigitizerComponent ci,
unsigned short *blackLevel);
pascal VideoDigitizerError VDGetBlackLevelValue
(VideoDigitizerComponent ci,
unsigned short *blackLevel);
pascal VideoDigitizerError VDSetWhiteLevelValue
(VideoDigitizerComponent ci,
unsigned short *whiteLevel);
pascal VideoDigitizerError VDGetWhiteLevelValue
(VideoDigitizerComponent ci,
unsigned short *whiteLevel);
pascal VideoDigitizerError VDSetHue
(VideoDigitizerComponent ci,
unsigned short *hue);
pascal VideoDigitizerError VDGetHue
(VideoDigitizerComponent ci,
unsigned short *hue);
pascal VideoDigitizerError VDSetSaturation
(VideoDigitizerComponent ci,
unsigned short *saturation);
pascal VideoDigitizerError VDGetSaturation
(VideoDigitizerComponent ci,
unsigned short *saturation);
pascal VideoDigitizerError VDSetBrightness
(VideoDigitizerComponent ci,
unsigned short *brightness);
pascal VideoDigitizerError VDGetBrightness
(VideoDigitizerComponent ci,
unsigned short *brightness);
pascal VideoDigitizerError VDSetContrast
(VideoDigitizerComponent ci,
unsigned short *contrast);
pascal VideoDigitizerError VDGetContrast
(VideoDigitizerComponent ci,
unsigned short *contrast);
pascal VideoDigitizerError VDSetSharpness
(VideoDigitizerComponent ci,
unsigned short *sharpness);
pascal VideoDigitizerError VDGetSharpness
(VideoDigitizerComponent ci,
unsigned short *sharpness);
pascal VideoDigitizerError VDSetInputGammaRecord
(VideoDigitizerComponent ci,
VDGamRecPtr inputGammaPtr);
pascal VideoDigitizerError VDGetInputGammaRecord
(VideoDigitizerComponent ci,
VDGamRecPtr *inputGammaPtr);
pascal VideoDigitizerError VDSetInputGammaValue
(VideoDigitizerComponent ci,
Fixed channel1, Fixed channel2,
Fixed channel3);
pascal VideoDigitizerError VDGetInputGammaValue
(VideoDigitizerComponent ci,
Fixed *channel1, Fixed *channel2,
Fixed *channel3);
Selectively Displaying Video
pascal VideoDigitizerError VDSetKeyColor
(VideoDigitizerComponent ci,long index);
pascal VideoDigitizerError VDGetKeyColor
(VideoDigitizerComponent ci, long *index);
pascal VideoDigitizerError VDSetKeyColorRange
(VideoDigitizerComponent ci,
RGBColor *minRGB, RGBColor *maxRGB);
pascal VideoDigitizerError VDAddKeyColor
(VideoDigitizerComponent ci, long *index);
pascal VideoDigitizerError VDGetKeyColorRange
(VideoDigitizerComponent ci,
RGBColor *minRGB, RGBColor *maxRGB);
pascal VideoDigitizerError VDGetNextKeyColor
(VideoDigitizerComponent ci, long index);
pascal VideoDigitizerError VDSetMasterBlendLevel
(VideoDigitizerComponent ci,
unsigned short *blendLevel);
pascal VideoDigitizerError VDGetMaskandValue
(VideoDigitizerComponent ci,
unsigned short blendLevel, long *mask,
long *value);
pascal VideoDigitizerError VDGetMaskPixMap
(VideoDigitizerComponent ci,
PixMapHandle maskPixMap);
Clipping
pascal VideoDigitizerError VDSetClipRgn
(VideoDigitizerComponent ci,
RgnHandle clipRegion);
pascal VideoDigitizerError VDClearClipRgn
(VideoDigitizerComponent ci,
RgnHandle clipRegion);
pascal VideoDigitizerError VDSetClipState
(VideoDigitizerComponent ci, short clipEnable);
pascal VideoDigitizerError VDGetClipState
(VideoDigitizerComponent ci, short *clipEnable);
Utility Functions
pascal VideoDigitizerError VDSetPLLFilterType
(VideoDigitizerComponent ci, short pllType);
pascal VideoDigitizerError VDGetPLLFilterType
(VideoDigitizerComponent ci, short *pllType);
pascal VideoDigitizerError VDSetFieldPreference
(VideoDigitizerComponent ci, short fieldFlag);
pascal VideoDigitizerError VDGetFieldPreference
(VideoDigitizerComponent ci, short *fieldFlag);
pascal VideoDigitizerError VDSetDigitizerUserInterrupt
(VideoDigitizerComponent ci, long flags, VdigIntProc userInterruptProc, long refcon);
pascal VideoDigitizerError VDGetSoundInputDriver
(VideoDigitizerComponent ci,
Str255 soundDriverName);
pascal VideoDigitizerError VDGetPreferredTimeScale
(VideoDigitizerComponent ci,
TimeScale *preferred);
Application-Defined Function
pascal void MyInterruptProc (long flags, long refcon);
Pascal Summary
Constants
CONST
videoDigitizerComponentType = 'vdig'; {standard type for video }
{ digitizer components}
{input format standards}
ntscIn = 0; {National Television System Committee}
palIn = 1; {Phase Alternation Line}
secamIn = 2; {Sequential Color with Memory}
{input formats}
compositeIn = 0; {no color separation of channels}
sVideoIn = 1; {s-video (Super VHS)}
rgbComponentIn = 2; {separate channels for red, green, & blue}
{video digitizer PlayThru states}
vdPlayThruOff = 0; {playthrough off}
vdPlayThruOn = 1; {playthrough on}
{field preference options in VDGetFieldPreference function}
vdUseAnyField = 0; {digitizer component decides which field to use}
vdUseOddField = 1; {digitizer component uses odd field}
vdUseEvenField = 2; {digitizer component uses even field}
{input color space modes}
vdDigitizerBW = 0; {digitizer component uses black and white}
vdDigitizerRGB = 1; {digitizer component uses red, green, and blue}
{phase lock loop modes}
vdBroadcastMode = 0; {broadcast or laser disk video mode}
vdVTRMode = 1; {video cassette recorder or magnetic media mode}
{video digitizer component types}
vdTypeBasic = 0; {basic component does not support clipping}
vdTypeAlpha = 1; {component supports clipping with alpha channel}
vdTypeMask = 2; {component supports clipping with mask plane}
vdTypeKey = 3; {supports clipping with one or more key colors}
{digitizer input capability/current flags}
digiInDoesNTSC = $1; {digitizer supports NTSC input}
digiInDoesPAL = $2; {digitizer supports PAL input}
digiInDoesSECAM = $4; {digitizer supports SECAM input}
digiInDoesGenLock = $80; {digitizer supports genlock}
digiInDoesComposite = $100; {digitizer supports composite input type}
digiInDoesSVideo = $200; {digitizer supports s-video input type}
digiInDoesComponent = $400; {digitizer supports component input type}
digiInVTR_Broadcast = $800; {digitizer can differentiate between }
{ magnetic media & broadcast}
digiInDoesColor = $1000; {digitizer supports color}
digiInDoesBW = $2000; {digitizer supports black and white}
{digitizer input current flag (valid only during active operating }
{ conditions)}
digiInSignalLock = $80000000;{digitizer detects input signal is }
{ locked--this bit equals }
{ horiz lock || vertical lock}
{digitizer output capability/current flags}
digiOutDoes1 = $1; {digitizer supports 1-bit pixels}
digiOutDoes2 = $2; {digitizer supports 2-bit pixels}
digiOutDoes4 = $4; {digitizer supports 4-bit pixels}
digiOutDoes8 = $8; {digitizer supports 8-bit pixels}
digiOutDoes16 = $10; {digitizer supports 16-bit pixels}
digiOutDoes32 = $20; {digitizer supports 32-bit pixels}
digiOutDoesDither = $40; {digitizer dithers in indexed modes}
digiOutDoesStretch = $80; {digitizer can arbitrarily stretch}
digiOutDoesShrink = $100; {digitizer can arbitrarily shrink}
digiOutDoesMask = $200; {digitizer can mask to clipping }
{ regions}
digiOutDoesDouble = $800; {can stretch to exactly double size}
digiOutDoesQuad = $1000; {can stretch to exactly quadruple }
{ size}
digiOutDoesQuarter = $2000; {can shrink to exactly 1/4 size}
digiOutDoesSixteenth = $4000; {can shrink to exactly 1/16 size}
digiOutDoesRotate = $8000; {supports rotation transformations}
digiOutDoesHorizFlip = $10000; {supports horizontal flips Sx < 0}
digiOutDoesVertFlip = $20000; {supports vertical flips Sy < 0}
digiOutDoesSkew = $40000; {supports skew (shear, twist)}
digiOutDoesBlend = $80000; {digitizer performs blend operations}
digiOutDoesWarp = $100000; {digitizer performs warp operations}
digiOutDoesHW_DMA = $200000; {not constrained to logical device}
digiOutDoesHWPlayThru= $400000; {doesn't need time to play through}
digiOutDoesILUT = $800000; {does lookup for index modes}
digiOutDoesKeyColor = $1000000; {performs key color functions too}
digiOutDoesAsyncGrabs= $2000000; {performs asynchronous grabs}
digiOutDoesUnreadableScreenBits
= $4000000; {playthru doesn't generate readable }
{ bits on screen}
digiOutDoesCompress = $8000000; {supports compressed source devices}
digiOutDoesCompressOnly
= $10000000; {can't draw images}
digiOutDoesPlayThruDuringCompress
= $2000000; {can play while providing compressed }
{ data}
{video digitizer interface}
kSelectVDGetMaxSrcRect = $1; {VDGetMaxSrcRect (required)}
kSelectVDGetActiveSrcRect = $2; {VDGetActiveSrcRect (required)}
kSelectVDSetDigitizerRect = $3; {VDSetDigitizerRect (required)}
kSelectVDGetDigitizerRect = $4; {VDGetDigitizerRect (required)}
kSelectVDGetVBlankRect = $5; {VDGetVBlankRect (required)}
kSelectVDGetMaskPixMap = $6; {VDGetMaskPixMap}
kSelectVDGetPlayThruDestination = $8; {VDGetPlayThruDestination }
{ (required)}
kSelectVDUseThisCLUT = $9; {VDUseThisCLUT}
kSelectVDSetInputGammaValue = $A; {VDSetInputGammaValue}
kSelectVDGetInputGammaValue = $B; {VDGetInputGammaValue}
kSelectVDSetBrightness = $C; {VDSetBrightness}
kSelectVDGetBrightness = $D; {VDGetBrightness}
kSelectVDSetContrast = $E; {VDSetContrast}
kSelectVDSetHue = $F; {VDSetHue}
kSelectVDSetSharpness = $10;{VDSetSharpness}
kSelectVDSetSaturation = $11;{VDSetSaturation}
kSelectVDGetContrast = $12;{VDGetContrast}
kSelectVDGetHue = $13;{VDGetHue}
kSelectVDGetSharpness = $14;{VDGetSharpness}
kSelectVDGetSaturation = $15;{VDGetSaturation}
kSelectVDGrabOneFrame = $16;{VDGrabOneFrame (required)}
kSelectVDGetMaxAuxBuffer = $17;{VDGetMaxAuxBuffer}
kSelectVDGetDigitizerInfo = $19;{VDGetDigitizerInfo}
kSelectVDGetCurrentFlags = $1A;{VDGetCurrentFlags}
kSelectVDSetKeyColor = $1B;{VDSetKeyColor}
kSelectVDGetKeyColor = $1C;{VDGetKeyColor}
kSelectVDAddKeyColor = $1D;{VDAddKeyColor}
kSelectVDGetNextKeyColor = $1E;{VDGetNextKeyColor}
kSelectVDSetKeyColorRange = $1F;{VDSetKeyColorRange}
kSelectVDGetKeyColorRange = $20;{VDGetKeyColorRange}
kSelectVDSetDigitizerUserInterrupt
= $21;{VDSetDigitizerUserInterrupt}
kSelectVDSetInputColorSpaceMode = $22;{VDSetInputColorSpaceMode}
kSelectVDGetInputColorSpaceMode = $23;{VDGetInputColorSpaceMode}
kSelectVDSetClipState = $24;{VDSetClipState}
kSelectVDGetClipState = $25;{VDGetClipState}
kSelectVDSetClipRgn = $26;{VDSetClipRgn}
kSelectVDClearClipRgn = $27;{VDClearClipRgn}
kSelectVDGetCLUTInUse = $28;{VDGetCLUTInUse}
kSelectVDSetPLLFilterType = $29;{VDSetPLLFilterType}
kSelectVDGetPLLFilterType = $2A;{VDGetPLLFilterType}
kSelectVDGetMaskandValue = $2B;{VDGetMaskandValue}
kSelectVDSetMasterBlendLevel = $2C;{VDSetMasterBlendLevel}
kSelectVDSetPlayThruDestination = $2D;{VDSetPlayThruDestination}
kSelectVDSetPlayThruOnOff = $2E;{VDSetPlayThruOnOff}
kSelectVDSetFieldPreference = $2F;{VDSetFieldPreference }
{ (required)}
kSelectVDGetFieldPreference = $30;{VDGetFieldPreference }
{ (required)}
kSelectVDPreflightDestination = $32;{VDPreflightDestination }
{ (required)}
kSelectVDPreflightGlobalRect = $33;{VDPreflightGlobalRect}
kSelectVDSetPlayThruGlobalRect = $34;{VDSetPlayThruGlobalRect}
kSelectVDSetInputGammaRecord = $35;{VDSetInputGammaRecord}
kSelectVDGetInputGammaRecord = $36;{VDGetInputGammaRecord}
kSelectVDSetBlackLevelValue = $37;{VDSetBlackLevelValue}
kSelectVDGetBlackLevelValue = $38;{VDGetBlackLevelValue}
kSelectVDSetWhiteLevelValue = $39;{VDSetWhiteLevelValue}
kSelectVDGetWhiteLevelValue = $3A;{VDGetWhiteLevelValue}
kSelectVDGetVideoDefaults = $3B;{VDGetVideoDefaults}
kSelectVDGetNumberOfInputs = $3C;{VDGetNumberOfInputs}
kSelectVDGetInputFormat = $3D;{VDGetInputFormat}
kSelectVDSetInput = $3E;{VDSetInput}
kSelectVDGetInput = $3F;{VDGetInput}
kSelectVDSetInputStandard = $40;{VDSetInputStandard}
kSelectVDSetupBuffers = $41;{VDSetupBuffers}
kSelectVDGrabOneFrameAsync = $42;{VDGrabOneFrameAsync}
kSelectVDDone = $43;{VDDone}
kSelectVDSetCompression = $44;{VDSetCompression}
kSelectVDCompressOneFrameAsync = $45;{VDCompressOneFrameAsync}
kSelectVDCompressDone = $46;{VDCompressDone}
kSelectVDReleaseCompressBuffer = $47;{VDReleaseCompressBuffer}
kSelectVDGetImageDescription = $48;{VDGetImageDescription}
kSelectVDResetCompressSequence = $49;{VDResetCompressSequence}
kSelectVDSetCompressionOnOff = $4A;{VDSetCompressionOnOff}
kSelectVDGetCompressionTypes = $4B;{VDGetCompressionTypes}
kSelectVDSetTimeBase = $4C;{VDSetTimeBase}
kSelectVDSetFrameRate = $4D;{VDSetFrameRate}
kSelectVDGetDataRate = $4E;{VDGetDataRate}
kSelectVDGetSoundInputDriver = $4F;{VDGetSoundInputDriver}
kSelectVDGetDMADepths = $50;{VDGetDMADepths}
kSelectVDGetPreferredTimeScale = $51;{VDGetPreferredTimeScale}
kSelectVDReleaseAsyncBuffers = $52;{VDReleaseAsyncBuffers}
Data Types
TYPE
VideoDigitizerComponent = ComponentInstance; {video digitizer }
{ component}
VideoDigitizerError = ComponentResult; {video digitizer }
{ error}
VdigIntProc = ComponentResult;
DigitizerInfo =
RECORD
vdigType: Integer; {type of digitizer component}
inputCapabilityFlags: LongInt; {input video signal features}
outputCapabilityFlags: LongInt; {output digitized video data features}
inputCurrentFlags: LongInt; {status of input video signal}
outputCurrentFlags: LongInt; {status of output digitized data}
slot: Integer; {temporary for connection purposes}
gdh: GDHandle;{temporary for digitizers with }
{ preferred screen}
maskgdh: GDHandle;{temporary for digitizers }
{ with mask planes}
minDestHeight: Integer; {smallest resizable height}
minDestWidth: Integer; {smallest resizable width}
maxDestHeight: Integer; {largest resizable height}
maxDestWidth: Integer; {largest resizable width}
blendLevels: Integer; {number of blend levels supported (2 }
{ if 1 bit mask)}
Private: LongInt; {reserved--set to 0}
END;
VdigBufferRec =
RECORD
dest: PixMapHandle; {handle to pixel map for destination buffer}
location: Point; {location of video destination in pixel map}
reserved: LongInt; {reserved--set to 0}
END;
VdigBufferRecListPtr = ^VdigBufferRecList;
VdigBufferRecListHandle = ^VdigBufferRecListPtr;
VdigBufferRecList =
RECORD
count: Integer; {buffers defined by this record}
matrix: MatrixRecordPtr ; {transformation matrix applied to }
{ dest rect before image displayed}
mask: RgnHandle; {clip rgn applied to dest rect }
{ before image displayed}
list: ARRAY[0..0] OF VdigBufferRec;
{array of output buffer specs}
END;
VDCompressionListHandle = ^VDCompressionListPtr;
VDCompressionList =
RECORD
codec: CodecComponent; {component ID}
cType: CodecType; {compressor type}
typeName: Str63; {compression algorithm}
name: Str63; {compressor name string}
formatFlags: LongInt; {data format flags}
compressFlags: LongInt; {capabilities flags}
reserved: LongInt; {set to 0}
END;
Video Digitizer Component Routines
Getting Information About Video Digitizer Components
FUNCTION VDGetDigitizerInfo
(ci: VideoDigitizerComponent;
VAR info: DigitizerInfo): VideoDigitizerError;
FUNCTION VDGetCurrentFlags (ci: VideoDigitizerComponent;
VAR inputCurrentFlag: LongInt;
VAR outputCurrentFlag: LongInt):
VideoDigitizerError;
Setting Source Characteristics
FUNCTION VDGetMaxSrcRect (ci: VideoDigitizerComponent;
VAR maxSrcRect: Rect): VideoDigitizerError;
FUNCTION VDGetActiveSrcRect
(ci: VideoDigitizerComponent; inputStd: Integer;
VAR activeSrcRect: Rect): VideoDigitizerError;
FUNCTION VDGetVBlankRect (ci: VideoDigitizerComponent;
VAR vBlankRect: Rect): VideoDigitizerError;
FUNCTION VDSetDigitizerRect
(ci: VideoDigitizerComponent;
VAR digitizerRect: Rect): VideoDigitizerError;
FUNCTION VDGetDigitizerRect
(ci: VideoDigitizerComponent;
VAR digitizerRect: Rect): VideoDigitizerError;
Selecting an Input Source
FUNCTION VDGetNumberOfInputs
(ci: VideoDigitizerComponent;
VAR inputs: Integer): VideoDigitizerError;
FUNCTION VDSetInput (ci: VideoDigitizerComponent;
input: Integer): VideoDigitizerError;
FUNCTION VDGetInput (ci: VideoDigitizerComponent;
VAR input: Integer): VideoDigitizerError;
FUNCTION VDGetInputFormat (ci: VideoDigitizerComponent; input: Integer;
VAR format: Integer): VideoDigitizerError;
FUNCTION VDSetInputStandard
(ci: VideoDigitizerComponent;
inputStandard: Integer): VideoDigitizerError;
Setting Video Destinations
FUNCTION VDSetPlayThruDestination
(ci: VideoDigitizerComponent;
dest: PixMapHandle; VAR destRect: Rect;
VAR m: MatrixRecord;
mask: RgnHandle): VideoDigitizerError;
FUNCTION VDPreflightDestination
(ci: VideoDigitizerComponent;
VAR digitizerRect: Rect; dest: PixMapHandle; VAR destRect: Rect;
VAR m: MatrixRecord): VideoDigitizerError;
FUNCTION VDGetPlayThruDestination
(ci: VideoDigitizerComponent;
VAR dest: PixMapHandle; VAR destRect: Rect; VAR m: MatrixRecord;
VAR mask: RgnHandle): VideoDigitizerError;
FUNCTION VDSetPlayThruGlobalRect
(ci: VideoDigitizerComponent;
theWindow: GrafPtr; VAR globalRect: Rect): VideoDigitizerError;
FUNCTION VDPreflightGlobalRect
(ci: VideoDigitizerComponent;
theWindow: GrafPtr; VAR globalRect: Rect): VideoDigitizerError;
FUNCTION VDGetMaxAuxBuffer (ci: VideoDigitizerComponent;
VAR pm: PixMapHandle; VAR r: Rect):
VideoDigitizerError;
Controlling Compressed Source Devices
FUNCTION VDGetCompressionTypes
(ci: VideoDigitizerComponent;
h: VDCompressionListHandle): VideoDigitizerError;
FUNCTION VDSetCompression(ci: VideoDigitizerComponent;
compressType: OSType; depth: Integer;
VAR bounds: Rect; spatialQuality: CodecQ;
temporalQuality: CodecQ;
keyFrameRate: LongInt): VideoDigitizerError;
FUNCTION VDSetCompressionOnOff
(ci: VideoDigitizerComponent; state: Boolean): VideoDigitizerError;
FUNCTION VDGrabOneFrameAsync
(ci: VideoDigitizerComponent; buffer: Integer): VideoDigitizerError;
FUNCTION VDCompressDone(ci: VideoDigitizerComponent;
VAR done: Boolean; VAR theData: Ptr;
VAR dataSize: LongInt; VAR similarity: Byte;
VAR t: TimeRecord): VideoDigitizerError;
FUNCTION VDReleaseCompressBuffer
(ci: VideoDigitizerComponent;
bufferAddr: Ptr): VideoDigitizerError;
FUNCTION VDGetImageDescription
(ci: VideoDigitizerComponent;
desc: ImageDescriptionHandle): VideoDigitizerError;
FUNCTION VDResetCompressSequence
(ci: VideoDigitizerComponent): VideoDigitizerError;
FUNCTION VDSetTimeBase(ci: VideoDigitizerComponent; t: TimeBase):
VideoDigitizerError;
Controlling Digitization
FUNCTION VDSetPlayThruOnOff (ci: VideoDigitizerComponent;
state: Integer): VideoDigitizerError;
FUNCTION VDGrabOneFrame (ci: VideoDigitizerComponent):
VideoDigitizerError;
FUNCTION VDSetupBuffers (ci: VideoDigitizerComponent;
bufferList: VdigBufferRecListHandle):
VideoDigitizerError;
FUNCTION VDReleaseAsyncBuffers
(ci: VideoDigitizerComponent): VideoDigitizerError;
FUNCTION VDGrabOneFrameAsync
(ci: VideoDigitizerComponent;
nextBuffer: Integer): VideoDigitizerError;
FUNCTION VDDone (ci: VideoDigitizerComponent,
buffer: Integer): LongInt;
FUNCTION VDSetFrameRate(ci: VideoDigitizerComponent;
framesPerSecond: Fixed): VideoDigitizerError;
FUNCTION VDGetDataRate(ci: VideoDigitizerComponent;
VAR milliSecPerFrame: LongInt;
VAR framesPerSecond: Fixed;
VAR bytesPerSecond: LongInt):
VideoDigitizerError;
Controlling Color
FUNCTION VDUseThisCLUT (ci: VideoDigitizerComponent;
colorTableHandle: CTabHandle):
VideoDigitizerError;
FUNCTION VDGetCLUTInUse (ci: VideoDigitizerComponent;
VAR colorTableHandle: CTabHandle):
VideoDigitizerError;
FUNCTION VDSetInputColorSpaceMode
(ci: VideoDigitizerComponent;
colorSpaceMode: Integer): VideoDigitizerError;
FUNCTION VDGetInputColorSpaceMode
(ci: VideoDigitizerComponent;
VAR colorSpaceMode: Integer): VideoDigitizerError;
FUNCTION VDGetDMADepths(ci: VideoDigitizerComponent;
VAR depthArray: LongInt; VAR preferredDepth:
LongInt): VideoDigitizerError;
Controlling Analog Video
FUNCTION VDGetVideoDefaults (ci: VideoDigitizerComponent;
VAR blackLevel: Integer;
VAR whiteLevel: Integer;
VAR brightness: Integer; VAR hue: Integer;
VAR saturation: Integer; VAR contrast: Integer;
VAR sharpness: Integer): VideoDigitizerError;
FUNCTION VDSetBlackLevelValue
(ci: VideoDigitizerComponent;
VAR blackLevel: Integer): VideoDigitizerError;
FUNCTION VDGetBlackLevelValue
(ci: VideoDigitizerComponent;
VAR blackLevel: Integer): VideoDigitizerError;
FUNCTION VDSetWhiteLevelValue
(ci: VideoDigitizerComponent;
VAR whiteLevel: Integer): VideoDigitizerError;
FUNCTION VDGetWhiteLevelValue
(ci: VideoDigitizerComponent;
VAR whiteLevel: Integer): VideoDigitizerError;
FUNCTION VDSetHue (ci: VideoDigitizerComponent;
VAR hue: Integer): VideoDigitizerError;
FUNCTION VDGetHue (ci: VideoDigitizerComponent;
VAR hue: Integer): VideoDigitizerError;
FUNCTION VDSetSaturation (ci: VideoDigitizerComponent;
VAR saturation: Integer): VideoDigitizerError;
FUNCTION VDGetSaturation (ci: VideoDigitizerComponent;
VAR saturation: Integer): VideoDigitizerError;
FUNCTION VDSetBrightness (ci: VideoDigitizerComponent;
VAR brightness: Integer): VideoDigitizerError;
FUNCTION VDGetBrightness (ci: VideoDigitizerComponent;
VAR brightness: Integer): VideoDigitizerError;
FUNCTION VDSetContrast (ci: VideoDigitizerComponent;
VAR contrast: Integer): VideoDigitizerError;
FUNCTION VDGetContrast (ci: VideoDigitizerComponent;
VAR contrast: Integer): VideoDigitizerError;
FUNCTION VDSetSharpness (ci: VideoDigitizerComponent;
VAR sharpness: Integer): VideoDigitizerError;
FUNCTION VDGetSharpness (ci: VideoDigitizerComponent;
VAR sharpness: Integer): VideoDigitizerError;
FUNCTION VDSetInputGammaRecord
(ci: VideoDigitizerComponent;
inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
FUNCTION VDGetInputGammaRecord
(ci: VideoDigitizerComponent;
VAR inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
FUNCTION VDSetInputGammaValue
(ci: VideoDigitizerComponent; channel1: Fixed; channel2: Fixed; channel3: Fixed): VideoDigitizerError;
FUNCTION VDGetInputGammaValue
(ci: VideoDigitizerComponent;
VAR channel1: Fixed; VAR channel2: Fixed;
VAR channel3: Fixed): VideoDigitizerError;
Selectively Displaying Video
FUNCTION VDSetKeyColor (ci: VideoDigitizerComponent;
index: LongInt): VideoDigitizerError;
FUNCTION VDGetKeyColor (ci: VideoDigitizerComponent;
VAR index: LongInt): VideoDigitizerError;
FUNCTION VDSetKeyColorRange
(ci: VideoDigitizerComponent;
VAR minRGB: RGBColor; VAR maxRGB: RGBColor): VideoDigitizerError;
FUNCTION VDAddKeyColor (ci: VideoDigitizerComponent;
VAR index: LongInt): VideoDigitizerError;
FUNCTION VDGetKeyColorRange
(ci: VideoDigitizerComponent;
VAR minRGB: RGBColor; VAR maxRGB: RGBColor): VideoDigitizerError;
FUNCTION VDGetNextKeyColor (ci: VideoDigitizerComponent;
index: LongInt): VideoDigitizerError;
FUNCTION VDSetMasterBlendLevel
(ci: VideoDigitizerComponent;
VAR blendLevel: Integer): VideoDigitizerError;
FUNCTION VDGetMaskandValue (ci: VideoDigitizerComponent;
blendLevel: Integer; VAR mask: LongInt;
VAR value: LongInt): VideoDigitizerError;
FUNCTION VDGetMaskPixMap (ci: VideoDigitizerComponent;
maskPixMap: PixMapHandle): VideoDigitizerError;
Clipping
FUNCTION VDSetClipRgn (ci: VideoDigitizerComponent;
clipRegion: RgnHandle): VideoDigitizerError;
FUNCTION VDClearClipRgn (ci: VideoDigitizerComponent;
clipRegion: RgnHandle): VideoDigitizerError;
FUNCTION VDSetClipState (ci: VideoDigitizerComponent;
clipEnable: Integer): VideoDigitizerError;
FUNCTION VDGetClipState (ci: VideoDigitizerComponent;
VAR clipEnable: Integer): VideoDigitizerError;
Utility Functions
FUNCTION VDSetPLLFilterType
(ci: VideoDigitizerComponent;
pllType: Integer): VideoDigitizerError;
FUNCTION VDGetPLLFilterType
(ci: VideoDigitizerComponent;
VAR pllType: Integer): VideoDigitizerError;
FUNCTION VDSetFieldPreference
(ci: VideoDigitizerComponent;
fieldFlag: Integer): VideoDigitizerError;
FUNCTION VDGetFieldPreference
(ci: VideoDigitizerComponent;
VAR fieldFlag: Integer): VideoDigitizerError;
FUNCTION VDSetDigitizerUserInterrupt
(ci: VideoDigitizerComponent;
flags: LongInt; userInterruptProc: ProcPtr;
refcon: LongInt): VideoDigitizerError;
FUNCTION VDGetSoundInputDriver
(ci: VideoDigitizerComponent;
soundDriverName: Str255): VideoDigitizerError;
FUNCTION VDGetPreferredTimeScale
(ci: VideoDigitizerComponent;
preferred: TimeScale): VideoDigitizerError;
Application-Defined Routine
PROCEDURE MyInterruptProc (flags: LongInt; refcon: LongInt);
Result Codes
