开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
QuickTimeComponents.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：297k
源码类别：

多媒体编程

开发平台：

Visual C++

QuickTimeComponents.h：源码内容
  2. EXTERN_API( ComponentResult )
  3. DataHSetFileSize64              (DataHandler            dh,
  4.                                  const wide *           fileSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0032, 0x7000, 0xA82A);
  6. EXTERN_API( ComponentResult )
  7. DataHGetFreeSpace64             (DataHandler            dh,
  8.                                  wide *                 freeSize)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0033, 0x7000, 0xA82A);
  10. EXTERN_API( ComponentResult )
  11. DataHAppend64                   (DataHandler            dh,
  12.                                  void *                 data,
  13.                                  wide *                 fileOffset,
  14.                                  unsigned long          size)                               FIVEWORDINLINE(0x2F3C, 0x000C, 0x0034, 0x7000, 0xA82A);
  16. EXTERN_API( ComponentResult )
  17. DataHReadAsync                  (DataHandler            dh,
  18.                                  void *                 dataPtr,
  19.                                  UInt32                 dataSize,
  20.                                  const wide *           dataOffset,
  21.                                  DataHCompletionUPP     completion,
  22.                                  long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0014, 0x0035, 0x7000, 0xA82A);
  24. EXTERN_API( ComponentResult )
  25. DataHPollRead                   (DataHandler            dh,
  26.                                  void *                 dataPtr,
  27.                                  UInt32 *               dataSizeSoFar)                      FIVEWORDINLINE(0x2F3C, 0x0008, 0x0036, 0x7000, 0xA82A);
  29. EXTERN_API( ComponentResult )
  30. DataHGetDataAvailability        (DataHandler            dh,
  31.                                  long                   offset,
  32.                                  long                   len,
  33.                                  long *                 missing_offset,
  34.                                  long *                 missing_len)                        FIVEWORDINLINE(0x2F3C, 0x0010, 0x0037, 0x7000, 0xA82A);
  36. EXTERN_API( ComponentResult )
  37. DataHGetFileSizeAsync           (DataHandler            dh,
  38.                                  wide *                 fileSize,
  39.                                  DataHCompletionUPP     completionRtn,
  40.                                  long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x003A, 0x7000, 0xA82A);
  42. EXTERN_API( ComponentResult )
  43. DataHGetDataRefAsType           (DataHandler            dh,
  44.                                  OSType                 requestedType,
  45.                                  Handle *               dataRef)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x003B, 0x7000, 0xA82A);
  47. EXTERN_API( ComponentResult )
  48. DataHSetDataRefExtension        (DataHandler            dh,
  49.                                  Handle                 extension,
  50.                                  OSType                 idType)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x003C, 0x7000, 0xA82A);
  52. EXTERN_API( ComponentResult )
  53. DataHGetDataRefExtension        (DataHandler            dh,
  54.                                  Handle *               extension,
  55.                                  OSType                 idType)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x003D, 0x7000, 0xA82A);
  57. EXTERN_API( ComponentResult )
  58. DataHGetMovieWithFlags          (DataHandler            dh,
  59.                                  Movie *                theMovie,
  60.                                  short *                id,
  61.                                  short                  flags)                              FIVEWORDINLINE(0x2F3C, 0x000A, 0x003E, 0x7000, 0xA82A);
  64. EXTERN_API( ComponentResult )
  65. DataHGetFileTypeOrdering        (DataHandler            dh,
  66.                                  DataHFileTypeOrderingHandle * orderingListHandle)          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0040, 0x7000, 0xA82A);
  68. /* flags for DataHCreateFileWithFlags*/
  69. enum {
  70.     kDataHCreateFileButDontCreateResFile = (1L << 0)
  71. };
  73. EXTERN_API( ComponentResult )
  74. DataHCreateFileWithFlags        (DataHandler            dh,
  75.                                  OSType                 creator,
  76.                                  Boolean                deleteExisting,
  77.                                  UInt32                 flags)                              FIVEWORDINLINE(0x2F3C, 0x000A, 0x0041, 0x7000, 0xA82A);
  79. EXTERN_API( ComponentResult )
  80. DataHGetMIMETypeAsync           (DataHandler            dh,
  81.                                  Str255                 mimeType,
  82.                                  DataHCompletionUPP     completionRtn,
  83.                                  long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x0042, 0x7000, 0xA82A);
  85. EXTERN_API( ComponentResult )
  86. DataHGetInfo                    (DataHandler            dh,
  87.                                  OSType                 what,
  88.                                  void *                 info)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x0043, 0x7000, 0xA82A);
  90. EXTERN_API( ComponentResult )
  91. DataHSetIdleManager             (DataHandler            dh,
  92.                                  IdleManager            im)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0044, 0x7000, 0xA82A);
  94. EXTERN_API( ComponentResult )
  95. DataHDeleteFile                 (DataHandler            dh)                                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0045, 0x7000, 0xA82A);
  97. enum {
  98.     kDataHMovieUsageDoAppendMDAT = 1L << 0                      /* if set, datahandler should append wide and mdat atoms in append call*/
  99. };
  101. EXTERN_API( ComponentResult )
  102. DataHSetMovieUsageFlags         (DataHandler            dh,
  103.                                  long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0046, 0x7000, 0xA82A);
  106. enum {
  107.     kDataHTempUseSameDirectory  = 1L << 0,                      /* temp data ref should be in same directory as current data ref (vs. in temporary directory)*/
  108.     kDataHTempUseSameVolume     = 1L << 1,                      /* temp data ref should be on same volume as current data ref (vs. find "best" volume)*/
  109.     kDataHTempCreateFile        = 1L << 2,                      /* create the file*/
  110.     kDataHTempOpenFile          = 1L << 3                       /* open temporary file for write (kDataHTempCreateFile must be passed, too)*/
  111. };
  113. EXTERN_API( ComponentResult )
  114. DataHUseTemporaryDataRef        (DataHandler            dh,
  115.                                  long                   inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0047, 0x7000, 0xA82A);
  117. EXTERN_API( ComponentResult )
  118. DataHGetTemporaryDataRefCapabilities (DataHandler       dh,
  119.                                  long *                 outUnderstoodFlags)                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0048, 0x7000, 0xA82A);
  121. EXTERN_API( ComponentResult )
  122. DataHRenameFile                 (DataHandler            dh,
  123.                                  Handle                 newDataRef)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0049, 0x7000, 0xA82A);
  126. EXTERN_API( ComponentResult )
  127. DataHPlaybackHints              (DataHandler            dh,
  128.                                  long                   flags,
  129.                                  unsigned long          minFileOffset,
  130.                                  unsigned long          maxFileOffset,
  131.                                  long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0010, 0x0103, 0x7000, 0xA82A);
  133. EXTERN_API( ComponentResult )
  134. DataHPlaybackHints64            (DataHandler            dh,
  135.                                  long                   flags,
  136.                                  const wide *           minFileOffset,
  137.                                  const wide *           maxFileOffset,
  138.                                  long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0010, 0x010E, 0x7000, 0xA82A);
  140. /* Symbolic constants for DataHGetDataRate*/
  141. enum {
  142.     kDataHGetDataRateInfiniteRate = 0x7FFFFFFF                  /* all the data arrived instantaneously*/
  143. };
  145. EXTERN_API( ComponentResult )
  146. DataHGetDataRate                (DataHandler            dh,
  147.                                  long                   flags,
  148.                                  long *                 bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0008, 0x0110, 0x7000, 0xA82A);
  150. /* Flags for DataHSetTimeHints*/
  151. enum {
  152.     kDataHSetTimeHintsSkipBandwidthRequest = 1 << 0             /* set if this data handler should use the network without requesting bandwidth*/
  153. };
  155. EXTERN_API( ComponentResult )
  156. DataHSetTimeHints               (DataHandler            dh,
  157.                                  long                   flags,
  158.                                  long                   bandwidthPriority,
  159.                                  TimeScale              scale,
  160.                                  TimeValue              minTime,
  161.                                  TimeValue              maxTime)                            FIVEWORDINLINE(0x2F3C, 0x0014, 0x0111, 0x7000, 0xA82A);
  167. /* Standard type for video digitizers */
  168. enum {
  169.     videoDigitizerComponentType = FOUR_CHAR_CODE('vdig'),
  170.     vdigInterfaceRev            = 2
  171. };
  173. /* Input Format Standards */
  174. enum {
  175.     ntscIn                      = 0,                            /* current input format */
  176.     currentIn                   = 0,                            /* ntsc input format */
  177.     palIn                       = 1,                            /* pal input format */
  178.     secamIn                     = 2,                            /* secam input format */
  179.     ntscReallyIn                = 3                             /* ntsc input format */
  180. };
  182. /* Input Formats */
  183. enum {
  184.     compositeIn                 = 0,                            /* input is composite format */
  185.     sVideoIn                    = 1,                            /* input is sVideo format */
  186.     rgbComponentIn              = 2,                            /* input is rgb component format */
  187.     rgbComponentSyncIn          = 3,                            /* input is rgb component format (sync on green?)*/
  188.     yuvComponentIn              = 4,                            /* input is yuv component format */
  189.     yuvComponentSyncIn          = 5,                            /* input is yuv component format (sync on green?) */
  190.     tvTunerIn                   = 6,
  191.     sdiIn                       = 7
  192. };
  195. /* Video Digitizer PlayThru States */
  196. enum {
  197.     vdPlayThruOff               = 0,
  198.     vdPlayThruOn                = 1
  199. };
  201. /* Input Color Space Modes */
  202. enum {
  203.     vdDigitizerBW               = 0,                            /* black and white */
  204.     vdDigitizerRGB              = 1                             /* rgb color */
  205. };
  207. /* Phase Lock Loop Modes */
  208. enum {
  209.     vdBroadcastMode             = 0,                            /* Broadcast / Laser Disk video mode */
  210.     vdVTRMode                   = 1                             /* VCR / Magnetic media mode */
  211. };
  213. /* Field Select Options */
  214. enum {
  215.     vdUseAnyField               = 0,                            /* Digitizers choice on field use */
  216.     vdUseOddField               = 1,                            /* Use odd field for half size vert and smaller */
  217.     vdUseEvenField              = 2                             /* Use even field for half size vert and smaller */
  218. };
  220. /* vdig types */
  221. enum {
  222.     vdTypeBasic                 = 0,                            /* basic, no clipping */
  223.     vdTypeAlpha                 = 1,                            /* supports clipping with alpha channel */
  224.     vdTypeMask                  = 2,                            /* supports clipping with mask plane */
  225.     vdTypeKey                   = 3                             /* supports clipping with key color(s) */
  226. };
  230. /* Digitizer Input Capability/Current Flags */
  231. enum {
  232.     digiInDoesNTSC              = 1L << 0,                      /* digitizer supports NTSC input format */
  233.     digiInDoesPAL               = 1L << 1,                      /* digitizer supports PAL input format */
  234.     digiInDoesSECAM             = 1L << 2,                      /* digitizer supports SECAM input format */
  235.     digiInDoesGenLock           = 1L << 7,                      /* digitizer does genlock */
  236.     digiInDoesComposite         = 1L << 8,                      /* digitizer supports composite input type */
  237.     digiInDoesSVideo            = 1L << 9,                      /* digitizer supports S-Video input type */
  238.     digiInDoesComponent         = 1L << 10,                     /* digitizer supports component = rgb, input type */
  239.     digiInVTR_Broadcast         = 1L << 11,                     /* digitizer can differentiate between the two */
  240.     digiInDoesColor             = 1L << 12,                     /* digitizer supports color */
  241.     digiInDoesBW                = 1L << 13,                     /* digitizer supports black & white */
  242.                                                                 /* Digitizer Input Current Flags = these are valid only during active operating conditions,   */
  243.     digiInSignalLock            = 1L << 31                      /* digitizer detects input signal is locked, this bit = horiz lock || vertical lock */
  244. };
  247. /* Digitizer Output Capability/Current Flags */
  248. enum {
  249.     digiOutDoes1                = 1L << 0,                      /* digitizer supports 1 bit pixels */
  250.     digiOutDoes2                = 1L << 1,                      /* digitizer supports 2 bit pixels */
  251.     digiOutDoes4                = 1L << 2,                      /* digitizer supports 4 bit pixels */
  252.     digiOutDoes8                = 1L << 3,                      /* digitizer supports 8 bit pixels */
  253.     digiOutDoes16               = 1L << 4,                      /* digitizer supports 16 bit pixels */
  254.     digiOutDoes32               = 1L << 5,                      /* digitizer supports 32 bit pixels */
  255.     digiOutDoesDither           = 1L << 6,                      /* digitizer dithers in indexed modes */
  256.     digiOutDoesStretch          = 1L << 7,                      /* digitizer can arbitrarily stretch */
  257.     digiOutDoesShrink           = 1L << 8,                      /* digitizer can arbitrarily shrink */
  258.     digiOutDoesMask             = 1L << 9,                      /* digitizer can mask to clipping regions */
  259.     digiOutDoesDouble           = 1L << 11,                     /* digitizer can stretch to exactly double size */
  260.     digiOutDoesQuad             = 1L << 12,                     /* digitizer can stretch exactly quadruple size */
  261.     digiOutDoesQuarter          = 1L << 13,                     /* digitizer can shrink to exactly quarter size */
  262.     digiOutDoesSixteenth        = 1L << 14,                     /* digitizer can shrink to exactly sixteenth size */
  263.     digiOutDoesRotate           = 1L << 15,                     /* digitizer supports rotate transformations */
  264.     digiOutDoesHorizFlip        = 1L << 16,                     /* digitizer supports horizontal flips Sx < 0 */
  265.     digiOutDoesVertFlip         = 1L << 17,                     /* digitizer supports vertical flips Sy < 0 */
  266.     digiOutDoesSkew             = 1L << 18,                     /* digitizer supports skew = shear,twist, */
  267.     digiOutDoesBlend            = 1L << 19,
  268.     digiOutDoesWarp             = 1L << 20,
  269.     digiOutDoesHW_DMA           = 1L << 21,                     /* digitizer not constrained to local device */
  270.     digiOutDoesHWPlayThru       = 1L << 22,                     /* digitizer doesn't need time to play thru */
  271.     digiOutDoesILUT             = 1L << 23,                     /* digitizer does inverse LUT for index modes */
  272.     digiOutDoesKeyColor         = 1L << 24,                     /* digitizer does key color functions too */
  273.     digiOutDoesAsyncGrabs       = 1L << 25,                     /* digitizer supports async grabs */
  274.     digiOutDoesUnreadableScreenBits = 1L << 26,                 /* playthru doesn't generate readable bits on screen*/
  275.     digiOutDoesCompress         = 1L << 27,                     /* supports alternate output data types */
  276.     digiOutDoesCompressOnly     = 1L << 28,                     /* can't provide raw frames anywhere */
  277.     digiOutDoesPlayThruDuringCompress = 1L << 29,               /* digi can do playthru while providing compressed data */
  278.     digiOutDoesCompressPartiallyVisible = 1L << 30,             /* digi doesn't need all bits visible on screen to do hardware compress */
  279.     digiOutDoesNotNeedCopyOfCompressData = 1L << 31             /* digi doesn't need any bufferization when providing compressed data */
  280. };
  282. /* Types */
  283. typedef ComponentInstance               VideoDigitizerComponent;
  284. typedef ComponentResult                 VideoDigitizerError;
  286. struct DigitizerInfo {
  287.     short                           vdigType;
  288.     long                            inputCapabilityFlags;
  289.     long                            outputCapabilityFlags;
  290.     long                            inputCurrentFlags;
  291.     long                            outputCurrentFlags;
  292.     short                           slot;                       /* temporary for connection purposes */
  293.     GDHandle                        gdh;                        /* temporary for digitizers that have preferred screen */
  294.     GDHandle                        maskgdh;                    /* temporary for digitizers that have mask planes */
  295.     short                           minDestHeight;              /* Smallest resizable height */
  296.     short                           minDestWidth;               /* Smallest resizable width */
  297.     short                           maxDestHeight;              /* Largest resizable height */
  298.     short                           maxDestWidth;               /* Largest resizable width */
  299.     short                           blendLevels;                /* Number of blend levels supported (2 if 1 bit mask) */
  300.     long                            reserved;                   /* reserved */
  301. };
  302. typedef struct DigitizerInfo            DigitizerInfo;
  304. struct VdigType {
  305.     long                            digType;
  306.     long                            reserved;
  307. };
  308. typedef struct VdigType                 VdigType;
  310. struct VdigTypeList {
  311.     short                           count;
  312.     VdigType                        list[1];
  313. };
  314. typedef struct VdigTypeList             VdigTypeList;
  316. struct VdigBufferRec {
  317.     PixMapHandle                    dest;
  318.     Point                           location;
  319.     long                            reserved;
  320. };
  321. typedef struct VdigBufferRec            VdigBufferRec;
  323. struct VdigBufferRecList {
  324.     short                           count;
  325.     MatrixRecordPtr                 matrix;
  326.     RgnHandle                       mask;
  327.     VdigBufferRec                   list[1];
  328. };
  329. typedef struct VdigBufferRecList        VdigBufferRecList;
  330. typedef VdigBufferRecList *             VdigBufferRecListPtr;
  331. typedef VdigBufferRecListPtr *          VdigBufferRecListHandle;
  332. typedef CALLBACK_API( void , VdigIntProcPtr )(long flags, long refcon);
  333. typedef STACK_UPP_TYPE(VdigIntProcPtr)                          VdigIntUPP;
  335. struct VDCompressionList {
  336.     CodecComponent                  codec;
  337.     CodecType                       cType;
  338.     Str63                           typeName;
  339.     Str63                           name;
  340.     long                            formatFlags;
  341.     long                            compressFlags;
  342.     long                            reserved;
  343. };
  344. typedef struct VDCompressionList        VDCompressionList;
  345. typedef VDCompressionList *             VDCompressionListPtr;
  346. typedef VDCompressionListPtr *          VDCompressionListHandle;
  347. enum {
  348.     dmaDepth1                   = 1,
  349.     dmaDepth2                   = 2,
  350.     dmaDepth4                   = 4,
  351.     dmaDepth8                   = 8,
  352.     dmaDepth16                  = 16,
  353.     dmaDepth32                  = 32,
  354.     dmaDepth2Gray               = 64,
  355.     dmaDepth4Gray               = 128,
  356.     dmaDepth8Gray               = 256
  357. };
  359. enum {
  360.     kVDIGControlledFrameRate    = -1
  361. };
  364. EXTERN_API( VideoDigitizerError )
  365. VDGetMaxSrcRect                 (VideoDigitizerComponent  ci,
  366.                                  short                  inputStd,
  367.                                  Rect *                 maxSrcRect)                         FIVEWORDINLINE(0x2F3C, 0x0006, 0x0001, 0x7000, 0xA82A);
  369. EXTERN_API( VideoDigitizerError )
  370. VDGetActiveSrcRect              (VideoDigitizerComponent  ci,
  371.                                  short                  inputStd,
  372.                                  Rect *                 activeSrcRect)                      FIVEWORDINLINE(0x2F3C, 0x0006, 0x0002, 0x7000, 0xA82A);
  374. EXTERN_API( VideoDigitizerError )
  375. VDSetDigitizerRect              (VideoDigitizerComponent  ci,
  376.                                  Rect *                 digitizerRect)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);
  378. EXTERN_API( VideoDigitizerError )
  379. VDGetDigitizerRect              (VideoDigitizerComponent  ci,
  380.                                  Rect *                 digitizerRect)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);
  382. EXTERN_API( VideoDigitizerError )
  383. VDGetVBlankRect                 (VideoDigitizerComponent  ci,
  384.                                  short                  inputStd,
  385.                                  Rect *                 vBlankRect)                         FIVEWORDINLINE(0x2F3C, 0x0006, 0x0005, 0x7000, 0xA82A);
  387. EXTERN_API( VideoDigitizerError )
  388. VDGetMaskPixMap                 (VideoDigitizerComponent  ci,
  389.                                  PixMapHandle           maskPixMap)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0006, 0x7000, 0xA82A);
  391. EXTERN_API( VideoDigitizerError )
  392. VDGetPlayThruDestination        (VideoDigitizerComponent  ci,
  393.                                  PixMapHandle *         dest,
  394.                                  Rect *                 destRect,
  395.                                  MatrixRecord *         m,
  396.                                  RgnHandle *            mask)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x0008, 0x7000, 0xA82A);
  398. EXTERN_API( VideoDigitizerError )
  399. VDUseThisCLUT                   (VideoDigitizerComponent  ci,
  400.                                  CTabHandle             colorTableHandle)                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0009, 0x7000, 0xA82A);
  402. EXTERN_API( VideoDigitizerError )
  403. VDSetInputGammaValue            (VideoDigitizerComponent  ci,
  404.                                  Fixed                  channel1,
  405.                                  Fixed                  channel2,
  406.                                  Fixed                  channel3)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x000A, 0x7000, 0xA82A);
  408. EXTERN_API( VideoDigitizerError )
  409. VDGetInputGammaValue            (VideoDigitizerComponent  ci,
  410.                                  Fixed *                channel1,
  411.                                  Fixed *                channel2,
  412.                                  Fixed *                channel3)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x000B, 0x7000, 0xA82A);
  414. EXTERN_API( VideoDigitizerError )
  415. VDSetBrightness                 (VideoDigitizerComponent  ci,
  416.                                  unsigned short *       brightness)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A);
  418. EXTERN_API( VideoDigitizerError )
  419. VDGetBrightness                 (VideoDigitizerComponent  ci,
  420.                                  unsigned short *       brightness)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);
  422. EXTERN_API( VideoDigitizerError )
  423. VDSetContrast                   (VideoDigitizerComponent  ci,
  424.                                  unsigned short *       contrast)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x000E, 0x7000, 0xA82A);
  426. EXTERN_API( VideoDigitizerError )
  427. VDSetHue                        (VideoDigitizerComponent  ci,
  428.                                  unsigned short *       hue)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x000F, 0x7000, 0xA82A);
  430. EXTERN_API( VideoDigitizerError )
  431. VDSetSharpness                  (VideoDigitizerComponent  ci,
  432.                                  unsigned short *       sharpness)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0010, 0x7000, 0xA82A);
  434. EXTERN_API( VideoDigitizerError )
  435. VDSetSaturation                 (VideoDigitizerComponent  ci,
  436.                                  unsigned short *       saturation)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0011, 0x7000, 0xA82A);
  438. EXTERN_API( VideoDigitizerError )
  439. VDGetContrast                   (VideoDigitizerComponent  ci,
  440.                                  unsigned short *       contrast)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);
  442. EXTERN_API( VideoDigitizerError )
  443. VDGetHue                        (VideoDigitizerComponent  ci,
  444.                                  unsigned short *       hue)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0013, 0x7000, 0xA82A);
  446. EXTERN_API( VideoDigitizerError )
  447. VDGetSharpness                  (VideoDigitizerComponent  ci,
  448.                                  unsigned short *       sharpness)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A);
  450. EXTERN_API( VideoDigitizerError )
  451. VDGetSaturation                 (VideoDigitizerComponent  ci,
  452.                                  unsigned short *       saturation)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A);
  454. EXTERN_API( VideoDigitizerError )
  455. VDGrabOneFrame                  (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0016, 0x7000, 0xA82A);
  457. EXTERN_API( VideoDigitizerError )
  458. VDGetMaxAuxBuffer               (VideoDigitizerComponent  ci,
  459.                                  PixMapHandle *         pm,
  460.                                  Rect *                 r)                                  FIVEWORDINLINE(0x2F3C, 0x0008, 0x0017, 0x7000, 0xA82A);
  462. EXTERN_API( VideoDigitizerError )
  463. VDGetDigitizerInfo              (VideoDigitizerComponent  ci,
  464.                                  DigitizerInfo *        info)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);
  466. EXTERN_API( VideoDigitizerError )
  467. VDGetCurrentFlags               (VideoDigitizerComponent  ci,
  468.                                  long *                 inputCurrentFlag,
  469.                                  long *                 outputCurrentFlag)                  FIVEWORDINLINE(0x2F3C, 0x0008, 0x001A, 0x7000, 0xA82A);
  471. EXTERN_API( VideoDigitizerError )
  472. VDSetKeyColor                   (VideoDigitizerComponent  ci,
  473.                                  long                   index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);
  475. EXTERN_API( VideoDigitizerError )
  476. VDGetKeyColor                   (VideoDigitizerComponent  ci,
  477.                                  long *                 index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001C, 0x7000, 0xA82A);
  479. EXTERN_API( VideoDigitizerError )
  480. VDAddKeyColor                   (VideoDigitizerComponent  ci,
  481.                                  long *                 index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001D, 0x7000, 0xA82A);
  483. EXTERN_API( VideoDigitizerError )
  484. VDGetNextKeyColor               (VideoDigitizerComponent  ci,
  485.                                  long                   index)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001E, 0x7000, 0xA82A);
  487. EXTERN_API( VideoDigitizerError )
  488. VDSetKeyColorRange              (VideoDigitizerComponent  ci,
  489.                                  RGBColor *             minRGB,
  490.                                  RGBColor *             maxRGB)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x001F, 0x7000, 0xA82A);
  492. EXTERN_API( VideoDigitizerError )
  493. VDGetKeyColorRange              (VideoDigitizerComponent  ci,
  494.                                  RGBColor *             minRGB,
  495.                                  RGBColor *             maxRGB)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0020, 0x7000, 0xA82A);
  497. EXTERN_API( VideoDigitizerError )
  498. VDSetDigitizerUserInterrupt     (VideoDigitizerComponent  ci,
  499.                                  long                   flags,
  500.                                  VdigIntUPP             userInterruptProc,
  501.                                  long                   refcon)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x0021, 0x7000, 0xA82A);
  503. EXTERN_API( VideoDigitizerError )
  504. VDSetInputColorSpaceMode        (VideoDigitizerComponent  ci,
  505.                                  short                  colorSpaceMode)                     FIVEWORDINLINE(0x2F3C, 0x0002, 0x0022, 0x7000, 0xA82A);
  507. EXTERN_API( VideoDigitizerError )
  508. VDGetInputColorSpaceMode        (VideoDigitizerComponent  ci,
  509.                                  short *                colorSpaceMode)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0023, 0x7000, 0xA82A);
  511. EXTERN_API( VideoDigitizerError )
  512. VDSetClipState                  (VideoDigitizerComponent  ci,
  513.                                  short                  clipEnable)                         FIVEWORDINLINE(0x2F3C, 0x0002, 0x0024, 0x7000, 0xA82A);
  515. EXTERN_API( VideoDigitizerError )
  516. VDGetClipState                  (VideoDigitizerComponent  ci,
  517.                                  short *                clipEnable)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0025, 0x7000, 0xA82A);
  519. EXTERN_API( VideoDigitizerError )
  520. VDSetClipRgn                    (VideoDigitizerComponent  ci,
  521.                                  RgnHandle              clipRegion)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0026, 0x7000, 0xA82A);
  523. EXTERN_API( VideoDigitizerError )
  524. VDClearClipRgn                  (VideoDigitizerComponent  ci,
  525.                                  RgnHandle              clipRegion)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0027, 0x7000, 0xA82A);
  527. EXTERN_API( VideoDigitizerError )
  528. VDGetCLUTInUse                  (VideoDigitizerComponent  ci,
  529.                                  CTabHandle *           colorTableHandle)                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0028, 0x7000, 0xA82A);
  531. EXTERN_API( VideoDigitizerError )
  532. VDSetPLLFilterType              (VideoDigitizerComponent  ci,
  533.                                  short                  pllType)                            FIVEWORDINLINE(0x2F3C, 0x0002, 0x0029, 0x7000, 0xA82A);
  535. EXTERN_API( VideoDigitizerError )
  536. VDGetPLLFilterType              (VideoDigitizerComponent  ci,
  537.                                  short *                pllType)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x002A, 0x7000, 0xA82A);
  539. EXTERN_API( VideoDigitizerError )
  540. VDGetMaskandValue               (VideoDigitizerComponent  ci,
  541.                                  unsigned short         blendLevel,
  542.                                  long *                 mask,
  543.                                  long *                 value)                              FIVEWORDINLINE(0x2F3C, 0x000A, 0x002B, 0x7000, 0xA82A);
  545. EXTERN_API( VideoDigitizerError )
  546. VDSetMasterBlendLevel           (VideoDigitizerComponent  ci,
  547.                                  unsigned short *       blendLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x002C, 0x7000, 0xA82A);
  549. EXTERN_API( VideoDigitizerError )
  550. VDSetPlayThruDestination        (VideoDigitizerComponent  ci,
  551.                                  PixMapHandle           dest,
  552.                                  RectPtr                destRect,
  553.                                  MatrixRecordPtr        m,
  554.                                  RgnHandle              mask)                               FIVEWORDINLINE(0x2F3C, 0x0010, 0x002D, 0x7000, 0xA82A);
  556. EXTERN_API( VideoDigitizerError )
  557. VDSetPlayThruOnOff              (VideoDigitizerComponent  ci,
  558.                                  short                  state)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x002E, 0x7000, 0xA82A);
  560. EXTERN_API( VideoDigitizerError )
  561. VDSetFieldPreference            (VideoDigitizerComponent  ci,
  562.                                  short                  fieldFlag)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0x002F, 0x7000, 0xA82A);
  564. EXTERN_API( VideoDigitizerError )
  565. VDGetFieldPreference            (VideoDigitizerComponent  ci,
  566.                                  short *                fieldFlag)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0030, 0x7000, 0xA82A);
  568. EXTERN_API( VideoDigitizerError )
  569. VDPreflightDestination          (VideoDigitizerComponent  ci,
  570.                                  Rect *                 digitizerRect,
  571.                                  PixMap **              dest,
  572.                                  RectPtr                destRect,
  573.                                  MatrixRecordPtr        m)                                  FIVEWORDINLINE(0x2F3C, 0x0010, 0x0032, 0x7000, 0xA82A);
  575. EXTERN_API( VideoDigitizerError )
  576. VDPreflightGlobalRect           (VideoDigitizerComponent  ci,
  577.                                  GrafPtr                theWindow,
  578.                                  Rect *                 globalRect)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0033, 0x7000, 0xA82A);
  580. EXTERN_API( VideoDigitizerError )
  581. VDSetPlayThruGlobalRect         (VideoDigitizerComponent  ci,
  582.                                  GrafPtr                theWindow,
  583.                                  Rect *                 globalRect)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0034, 0x7000, 0xA82A);
  585. EXTERN_API( VideoDigitizerError )
  586. VDSetInputGammaRecord           (VideoDigitizerComponent  ci,
  587.                                  VDGamRecPtr            inputGammaPtr)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0035, 0x7000, 0xA82A);
  589. EXTERN_API( VideoDigitizerError )
  590. VDGetInputGammaRecord           (VideoDigitizerComponent  ci,
  591.                                  VDGamRecPtr *          inputGammaPtr)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0036, 0x7000, 0xA82A);
  593. EXTERN_API( VideoDigitizerError )
  594. VDSetBlackLevelValue            (VideoDigitizerComponent  ci,
  595.                                  unsigned short *       blackLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0037, 0x7000, 0xA82A);
  597. EXTERN_API( VideoDigitizerError )
  598. VDGetBlackLevelValue            (VideoDigitizerComponent  ci,
  599.                                  unsigned short *       blackLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0038, 0x7000, 0xA82A);
  601. EXTERN_API( VideoDigitizerError )
  602. VDSetWhiteLevelValue            (VideoDigitizerComponent  ci,
  603.                                  unsigned short *       whiteLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0039, 0x7000, 0xA82A);
  605. EXTERN_API( VideoDigitizerError )
  606. VDGetWhiteLevelValue            (VideoDigitizerComponent  ci,
  607.                                  unsigned short *       whiteLevel)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x003A, 0x7000, 0xA82A);
  609. EXTERN_API( VideoDigitizerError )
  610. VDGetVideoDefaults              (VideoDigitizerComponent  ci,
  611.                                  unsigned short *       blackLevel,
  612.                                  unsigned short *       whiteLevel,
  613.                                  unsigned short *       brightness,
  614.                                  unsigned short *       hue,
  615.                                  unsigned short *       saturation,
  616.                                  unsigned short *       contrast,
  617.                                  unsigned short *       sharpness)                          FIVEWORDINLINE(0x2F3C, 0x001C, 0x003B, 0x7000, 0xA82A);
  619. EXTERN_API( VideoDigitizerError )
  620. VDGetNumberOfInputs             (VideoDigitizerComponent  ci,
  621.                                  short *                inputs)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x003C, 0x7000, 0xA82A);
  623. EXTERN_API( VideoDigitizerError )
  624. VDGetInputFormat                (VideoDigitizerComponent  ci,
  625.                                  short                  input,
  626.                                  short *                format)                             FIVEWORDINLINE(0x2F3C, 0x0006, 0x003D, 0x7000, 0xA82A);
  628. EXTERN_API( VideoDigitizerError )
  629. VDSetInput                      (VideoDigitizerComponent  ci,
  630.                                  short                  input)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x003E, 0x7000, 0xA82A);
  632. EXTERN_API( VideoDigitizerError )
  633. VDGetInput                      (VideoDigitizerComponent  ci,
  634.                                  short *                input)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x003F, 0x7000, 0xA82A);
  636. EXTERN_API( VideoDigitizerError )
  637. VDSetInputStandard              (VideoDigitizerComponent  ci,
  638.                                  short                  inputStandard)                      FIVEWORDINLINE(0x2F3C, 0x0002, 0x0040, 0x7000, 0xA82A);
  640. EXTERN_API( VideoDigitizerError )
  641. VDSetupBuffers                  (VideoDigitizerComponent  ci,
  642.                                  VdigBufferRecListHandle  bufferList)                       FIVEWORDINLINE(0x2F3C, 0x0004, 0x0041, 0x7000, 0xA82A);
  644. EXTERN_API( VideoDigitizerError )
  645. VDGrabOneFrameAsync             (VideoDigitizerComponent  ci,
  646.                                  short                  buffer)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0042, 0x7000, 0xA82A);
  648. EXTERN_API( VideoDigitizerError )
  649. VDDone                          (VideoDigitizerComponent  ci,
  650.                                  short                  buffer)                             FIVEWORDINLINE(0x2F3C, 0x0002, 0x0043, 0x7000, 0xA82A);
  652. EXTERN_API( VideoDigitizerError )
  653. VDSetCompression                (VideoDigitizerComponent  ci,
  654.                                  OSType                 compressType,
  655.                                  short                  depth,
  656.                                  Rect *                 bounds,
  657.                                  CodecQ                 spatialQuality,
  658.                                  CodecQ                 temporalQuality,
  659.                                  long                   keyFrameRate)                       FIVEWORDINLINE(0x2F3C, 0x0016, 0x0044, 0x7000, 0xA82A);
  661. EXTERN_API( VideoDigitizerError )
  662. VDCompressOneFrameAsync         (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0045, 0x7000, 0xA82A);
  664. /*    Note that UInt8* queuedFrameCount replaces Boolean* done. 0(==false) still means no frames, and 1(==true) one, 
  665.     but if more than one are available the number should be returned here. The value 2 previously meant more than one frame,
  666.     so some VDIGs may return 2 even if more than 2 are available, and some will still return 1 as they are using the original definition */
  667. EXTERN_API( VideoDigitizerError )
  668. VDCompressDone                  (VideoDigitizerComponent  ci,
  669.                                  UInt8 *                queuedFrameCount,
  670.                                  Ptr *                  theData,
  671.                                  long *                 dataSize,
  672.                                  UInt8 *                similarity,
  673.                                  TimeRecord *           t)                                  FIVEWORDINLINE(0x2F3C, 0x0014, 0x0046, 0x7000, 0xA82A);
  675. EXTERN_API( VideoDigitizerError )
  676. VDReleaseCompressBuffer         (VideoDigitizerComponent  ci,
  677.                                  Ptr                    bufferAddr)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0047, 0x7000, 0xA82A);
  679. EXTERN_API( VideoDigitizerError )
  680. VDGetImageDescription           (VideoDigitizerComponent  ci,
  681.                                  ImageDescriptionHandle  desc)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0048, 0x7000, 0xA82A);
  683. EXTERN_API( VideoDigitizerError )
  684. VDResetCompressSequence         (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0049, 0x7000, 0xA82A);
  686. EXTERN_API( VideoDigitizerError )
  687. VDSetCompressionOnOff           (VideoDigitizerComponent  ci,
  688.                                  Boolean                state)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x004A, 0x7000, 0xA82A);
  690. EXTERN_API( VideoDigitizerError )
  691. VDGetCompressionTypes           (VideoDigitizerComponent  ci,
  692.                                  VDCompressionListHandle  h)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x004B, 0x7000, 0xA82A);
  694. EXTERN_API( VideoDigitizerError )
  695. VDSetTimeBase                   (VideoDigitizerComponent  ci,
  696.                                  TimeBase               t)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x004C, 0x7000, 0xA82A);
  698. EXTERN_API( VideoDigitizerError )
  699. VDSetFrameRate                  (VideoDigitizerComponent  ci,
  700.                                  Fixed                  framesPerSecond)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x004D, 0x7000, 0xA82A);
  702. EXTERN_API( VideoDigitizerError )
  703. VDGetDataRate                   (VideoDigitizerComponent  ci,
  704.                                  long *                 milliSecPerFrame,
  705.                                  Fixed *                framesPerSecond,
  706.                                  long *                 bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x000C, 0x004E, 0x7000, 0xA82A);
  708. EXTERN_API( VideoDigitizerError )
  709. VDGetSoundInputDriver           (VideoDigitizerComponent  ci,
  710.                                  Str255                 soundDriverName)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x004F, 0x7000, 0xA82A);
  712. EXTERN_API( VideoDigitizerError )
  713. VDGetDMADepths                  (VideoDigitizerComponent  ci,
  714.                                  long *                 depthArray,
  715.                                  long *                 preferredDepth)                     FIVEWORDINLINE(0x2F3C, 0x0008, 0x0050, 0x7000, 0xA82A);
  717. EXTERN_API( VideoDigitizerError )
  718. VDGetPreferredTimeScale         (VideoDigitizerComponent  ci,
  719.                                  TimeScale *            preferred)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0051, 0x7000, 0xA82A);
  721. EXTERN_API( VideoDigitizerError )
  722. VDReleaseAsyncBuffers           (VideoDigitizerComponent  ci)                               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0052, 0x7000, 0xA82A);
  724. /* 83 is reserved for compatibility reasons */
  725. EXTERN_API( VideoDigitizerError )
  726. VDSetDataRate                   (VideoDigitizerComponent  ci,
  727.                                  long                   bytesPerSecond)                     FIVEWORDINLINE(0x2F3C, 0x0004, 0x0054, 0x7000, 0xA82A);
  729. EXTERN_API( VideoDigitizerError )
  730. VDGetTimeCode                   (VideoDigitizerComponent  ci,
  731.                                  TimeRecord *           atTime,
  732.                                  void *                 timeCodeFormat,
  733.                                  void *                 timeCodeTime)                       FIVEWORDINLINE(0x2F3C, 0x000C, 0x0055, 0x7000, 0xA82A);
  735. EXTERN_API( VideoDigitizerError )
  736. VDUseSafeBuffers                (VideoDigitizerComponent  ci,
  737.                                  Boolean                useSafeBuffers)                     FIVEWORDINLINE(0x2F3C, 0x0002, 0x0056, 0x7000, 0xA82A);
  739. EXTERN_API( VideoDigitizerError )
  740. VDGetSoundInputSource           (VideoDigitizerComponent  ci,
  741.                                  long                   videoInput,
  742.                                  long *                 soundInput)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0057, 0x7000, 0xA82A);
  744. EXTERN_API( VideoDigitizerError )
  745. VDGetCompressionTime            (VideoDigitizerComponent  ci,
  746.                                  OSType                 compressionType,
  747.                                  short                  depth,
  748.                                  Rect *                 srcRect,
  749.                                  CodecQ *               spatialQuality,
  750.                                  CodecQ *               temporalQuality,
  751.                                  unsigned long *        compressTime)                       FIVEWORDINLINE(0x2F3C, 0x0016, 0x0058, 0x7000, 0xA82A);
  753. EXTERN_API( VideoDigitizerError )
  754. VDSetPreferredPacketSize        (VideoDigitizerComponent  ci,
  755.                                  long                   preferredPacketSizeInBytes)         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0059, 0x7000, 0xA82A);
  757. EXTERN_API( VideoDigitizerError )
  758. VDSetPreferredImageDimensions   (VideoDigitizerComponent  ci,
  759.                                  long                   width,
  760.                                  long                   height)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x005A, 0x7000, 0xA82A);
  762. EXTERN_API( VideoDigitizerError )
  763. VDGetPreferredImageDimensions   (VideoDigitizerComponent  ci,
  764.                                  long *                 width,
  765.                                  long *                 height)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x005B, 0x7000, 0xA82A);
  767. EXTERN_API( VideoDigitizerError )
  768. VDGetInputName                  (VideoDigitizerComponent  ci,
  769.                                  long                   videoInput,
  770.                                  Str255                 name)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x005C, 0x7000, 0xA82A);
  772. EXTERN_API( VideoDigitizerError )
  773. VDSetDestinationPort            (VideoDigitizerComponent  ci,
  774.                                  CGrafPtr               destPort)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x005D, 0x7000, 0xA82A);
  776. /*
  777.    The following call is designed to give the VDIG a little more control over how it is presented to the User, to clarify the 
  778.    distinction between Devices and Inputs. Historically, the assumption has been that there is one component registered per device
  779.    and the component name is displayed. This change lets a component choose its name after registration.
  780.    vdDeviceFlagShowInputsAsDevices is meant for components that register once and support multiple devices 
  781.    The UI is clearer if these are presented as device rather than inputs, 
  782.    and this allows a VDIG to present itself this way without huge restructuring
  783.    vdDeviceFlagHideDevice is for the kind of VDIG that registers itself, and then can register a further VDIG for each device. 
  784.    If no hardware is available, returning this flag will omit it from the list. 
  785.    This call being made is also a good time to check for hardware and register further VDIG components if needed, 
  786.    allowing for lazy initialization when the Application needs to find a VDIG rather than on every launch or replug.
  787. */
  789. enum {
  790.     vdDeviceFlagShowInputsAsDevices = (1 << 0),                 /* Tell the Panel to promote Inputs to Devices*/
  791.     vdDeviceFlagHideDevice      = (1 << 1)                      /* Omit this Device entirely from the list*/
  792. };
  794. EXTERN_API( VideoDigitizerError )
  795. VDGetDeviceNameAndFlags         (VideoDigitizerComponent  ci,
  796.                                  Str255                 outName,
  797.                                  UInt32 *               outNameFlags)                       FIVEWORDINLINE(0x2F3C, 0x0008, 0x005E, 0x7000, 0xA82A);
  799. enum {
  800.     vdFlagCaptureStarting       = (1 << 0),                     /* Capture is about to start; allocate bandwidth */
  801.     vdFlagCaptureStopping       = (1 << 1),                     /* Capture is about to stop; stop queuing frames*/
  802.     vdFlagCaptureIsForPreview   = (1 << 2),                     /* Capture is just to screen for preview purposes*/
  803.     vdFlagCaptureIsForRecord    = (1 << 3),                     /* Capture is going to be recorded*/
  804.     vdFlagCaptureLowLatency     = (1 << 4),                     /* Fresh frames are more important than delivering every frame - don't queue too much*/
  805.     vdFlagCaptureAlwaysUseTimeBase = (1 << 5),                  /* Use the timebase for every frame; don't worry about making durations uniform*/
  806.     vdFlagCaptureSetSettingsBegin = (1 << 6),                   /* A series of calls are about to be made to restore settings.*/
  807.     vdFlagCaptureSetSettingsEnd = (1 << 7)                      /* Finished restoring settings; any set calls after this are from the app or UI*/
  808. };
  810. EXTERN_API( VideoDigitizerError )
  811. VDCaptureStateChanging          (VideoDigitizerComponent  ci,
  812.                                  UInt32                 inStateFlags)                       FIVEWORDINLINE(0x2F3C, 0x0004, 0x005F, 0x7000, 0xA82A);
  814. /*
  815.    These UniqueID calls are so that the VDIG can give the SG information enabling it to restore a particular
  816.    configuration - choose a particular device and input from those available.
  817.    For example, restoring the specific camera for a set of several hot-plugged FireWire cameras 
  818.    the caller can pass nil if it is not interested in one of the IDs
  819.    returning 0 in an ID means you don't have one
  820. */
  822. EXTERN_API( VideoDigitizerError )
  823. VDGetUniqueIDs                  (VideoDigitizerComponent  ci,
  824.                                  UInt64 *               outDeviceID,
  825.                                  UInt64 *               outInputID)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0060, 0x7000, 0xA82A);
  827. /*
  828.    Note this is a 'Select' not a 'Set' - the assumption is that the Unique ID is a function of the hardware
  829.    and not modifiable by the calling application. Either a nil pointer or 0 an the ID means don't care.
  830.    return vdDontHaveThatUniqueIDErr if your device doesn't have a match.
  831. */
  833. EXTERN_API( VideoDigitizerError )
  834. VDSelectUniqueIDs               (VideoDigitizerComponent  ci,
  835.                                  const UInt64 *         inDeviceID,
  836.                                  const UInt64 *         inInputID)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x0061, 0x7000, 0xA82A);
  839. /*
  840.    IIDC (Instrumentation & Industrial Digital Camera) Video Digitizers
  841.    Video Digitizers of subtype vdSubtypeIIDC support FireWire cameras which conform to the
  842.    "IIDC 1394-based Digital Camera Specification." 
  843. */
  845. enum {
  846.     vdSubtypeIIDC               = FOUR_CHAR_CODE('iidc')        /* Subtype for IIDC 1394-Digital Camera video digitizer*/
  847. };
  849. /*
  850.    vdIIDCAtomTypeFeature
  851.    Parent node for the QTAtoms which describe a given feature.  
  852. */
  853. enum {
  854.     vdIIDCAtomTypeFeature       = FOUR_CHAR_CODE('feat')
  855. };
  857. /*
  858.    vdIIDCAtomTypeFeatureAtomTypeAndID
  859.    This atom describes the feature's OSType/group/name and QTAtomType & QTAtomID needed to retrieve its settings.
  860.    The contents of this atom is a VDIIDCFeatureAtomTypeAndID structure.  
  861. */
  862. enum {
  863.     vdIIDCAtomTypeFeatureAtomTypeAndID = FOUR_CHAR_CODE('t&id'),
  864.     vdIIDCAtomIDFeatureAtomTypeAndID = 1
  865. };
  868. struct VDIIDCFeatureAtomTypeAndID {
  869.     OSType                          feature;                    /* OSType of feature*/
  870.     OSType                          group;                      /* OSType of group that feature is categorized into*/
  871.     Str255                          name;                       /* Name of this feature*/
  872.     QTAtomType                      atomType;                   /* Atom type which contains feature's settings*/
  873.     QTAtomID                        atomID;                     /* Atom ID which contains feature's settings*/
  874. };
  875. typedef struct VDIIDCFeatureAtomTypeAndID VDIIDCFeatureAtomTypeAndID;
  876. /* IIDC Feature OSTypes*/
  877. enum {
  878.     vdIIDCFeatureHue            = FOUR_CHAR_CODE('hue '),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  879.     vdIIDCFeatureSaturation     = FOUR_CHAR_CODE('satu'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  880.     vdIIDCFeatureContrast       = FOUR_CHAR_CODE('ctst'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  881.     vdIIDCFeatureSharpness      = FOUR_CHAR_CODE('shrp'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  882.     vdIIDCFeatureBlackLevel     = FOUR_CHAR_CODE('blvl'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  883.     vdIIDCFeatureGain           = FOUR_CHAR_CODE('gain'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  884.     vdIIDCFeatureIris           = FOUR_CHAR_CODE('iris'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  885.     vdIIDCFeatureShutter        = FOUR_CHAR_CODE('shtr'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  886.     vdIIDCFeatureExposure       = FOUR_CHAR_CODE('xpsr'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  887.     vdIIDCFeatureWhiteBalanceU  = FOUR_CHAR_CODE('whbu'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  888.     vdIIDCFeatureWhiteBalanceV  = FOUR_CHAR_CODE('whbv'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  889.     vdIIDCFeatureGamma          = FOUR_CHAR_CODE('gmma'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  890.     vdIIDCFeatureTemperature    = FOUR_CHAR_CODE('temp'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  891.     vdIIDCFeatureZoom           = FOUR_CHAR_CODE('zoom'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  892.     vdIIDCFeatureFocus          = FOUR_CHAR_CODE('fcus'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  893.     vdIIDCFeaturePan            = FOUR_CHAR_CODE('pan '),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  894.     vdIIDCFeatureTilt           = FOUR_CHAR_CODE('tilt'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  895.     vdIIDCFeatureOpticalFilter  = FOUR_CHAR_CODE('opft'),       /* Feature's settings handled by VDIIDCFeatureSettings*/
  896.     vdIIDCFeatureTrigger        = FOUR_CHAR_CODE('trgr'),       /* Trigger's setttings handled by VDIIDCTriggerSettings*/
  897.     vdIIDCFeatureCaptureSize    = FOUR_CHAR_CODE('cpsz'),       /* Feature's settings is not defined*/
  898.     vdIIDCFeatureCaptureQuality = FOUR_CHAR_CODE('cpql')        /* Feature's settings is not defined*/
  899. };
  901. /* IIDC Group OSTypes that features are categorized into*/
  902. enum {
  903.     vdIIDCGroupImage            = FOUR_CHAR_CODE('imag'),       /* Feature related to camera's image*/
  904.     vdIIDCGroupColor            = FOUR_CHAR_CODE('colr'),       /* Feature related to camera's color control*/
  905.     vdIIDCGroupMechanics        = FOUR_CHAR_CODE('mech'),       /* Feature related to camera's mechanics*/
  906.     vdIIDCGroupTrigger          = FOUR_CHAR_CODE('trig')        /* Feature related to camera's trigger*/
  907. };
  909. /*
  910.    vdIIDCAtomTypeFeatureSettings
  911.    This atom describes the settings for the majority of features.
  912.    The contents of this atom is a VDIIDCFeatureSettings structure.
  913. */
  914. enum {
  915.     vdIIDCAtomTypeFeatureSettings = FOUR_CHAR_CODE('fstg'),
  916.     vdIIDCAtomIDFeatureSettings = 1
  917. };
  920. struct VDIIDCFeatureCapabilities {
  921.     UInt32                          flags;
  922.     UInt16                          rawMinimum;
  923.     UInt16                          rawMaximum;
  924.     QTFloatSingle                   absoluteMinimum;
  925.     QTFloatSingle                   absoluteMaximum;
  926. };
  927. typedef struct VDIIDCFeatureCapabilities VDIIDCFeatureCapabilities;
  929. struct VDIIDCFeatureState {
  930.     UInt32                          flags;
  931.     QTFloatSingle                   value;
  932. };
  933. typedef struct VDIIDCFeatureState       VDIIDCFeatureState;
  935. struct VDIIDCFeatureSettings {
  936.     VDIIDCFeatureCapabilities       capabilities;
  937.     VDIIDCFeatureState              state;
  938. };
  939. typedef struct VDIIDCFeatureSettings    VDIIDCFeatureSettings;
  940. /*
  941.    Flags for use in VDIIDCFeatureCapabilities.flags & VDIIDCFeatureState.flags
  942.    When indicating capabilities, the flag being set indicates that the feature can be put into the given state.
  943.    When indicating/setting state, the flag represents the current/desired state.
  944.    Note that certain combinations of flags are valid for cababilities (i.e. vdIIDCFeatureFlagOn | vdIIDCFeatureFlagOff)
  945.    but are mutally exclusive for state.
  946. */
  947. enum {
  948.     vdIIDCFeatureFlagOn         = (1 << 0),
  949.     vdIIDCFeatureFlagOff        = (1 << 1),
  950.     vdIIDCFeatureFlagManual     = (1 << 2),
  951.     vdIIDCFeatureFlagAuto       = (1 << 3),
  952.     vdIIDCFeatureFlagTune       = (1 << 4),
  953.     vdIIDCFeatureFlagRawControl = (1 << 5),
  954.     vdIIDCFeatureFlagAbsoluteControl = (1 << 6)
  955. };
  957. /*
  958.    vdIIDCAtomTypeTriggerSettings
  959.    This atom describes the settings for the trigger feature.
  960.    The contents of this atom is a VDIIDCTriggerSettings structure.
  961. */
  962. enum {
  963.     vdIIDCAtomTypeTriggerSettings = FOUR_CHAR_CODE('tstg'),
  964.     vdIIDCAtomIDTriggerSettings = 1
  965. };
  968. struct VDIIDCTriggerCapabilities {
  969.     UInt32                          flags;
  970.     QTFloatSingle                   absoluteMinimum;
  971.     QTFloatSingle                   absoluteMaximum;
  972. };
  973. typedef struct VDIIDCTriggerCapabilities VDIIDCTriggerCapabilities;
  975. struct VDIIDCTriggerState {
  976.     UInt32                          flags;
  977.     UInt16                          mode2TransitionCount;
  978.     UInt16                          mode3FrameRateMultiplier;
  979.     QTFloatSingle                   absoluteValue;
  980. };
  981. typedef struct VDIIDCTriggerState       VDIIDCTriggerState;
  983. struct VDIIDCTriggerSettings {
  984.     VDIIDCTriggerCapabilities       capabilities;
  985.     VDIIDCTriggerState              state;
  986. };
  987. typedef struct VDIIDCTriggerSettings    VDIIDCTriggerSettings;
  988. /*
  989.    Flags for use in VDIIDCTriggerCapabilities.flags & VDIIDCTriggerState.flags
  990.    When indicating capabilities, the flag being set indicates that the trigger can be put into the given state.
  991.    When indicating/setting state, the flag represents the current/desired state.
  992.    Note that certain combinations of flags are valid for cababilities (i.e. vdIIDCTriggerFlagOn | vdIIDCTriggerFlagOff)
  993.    but are mutally exclusive for state.
  994. */
  995. enum {
  996.     vdIIDCTriggerFlagOn         = (1 << 0),
  997.     vdIIDCTriggerFlagOff        = (1 << 1),
  998.     vdIIDCTriggerFlagActiveHigh = (1 << 2),
  999.     vdIIDCTriggerFlagActiveLow  = (1 << 3),
  1000.     vdIIDCTriggerFlagMode0      = (1 << 4),
  1001.     vdIIDCTriggerFlagMode1      = (1 << 5),
  1002.     vdIIDCTriggerFlagMode2      = (1 << 6),
  1003.     vdIIDCTriggerFlagMode3      = (1 << 7),
  1004.     vdIIDCTriggerFlagRawControl = (1 << 8),
  1005.     vdIIDCTriggerFlagAbsoluteControl = (1 << 9)
  1006. };
  1008. /*
  1009.    VDIIDC calls are additional calls for IIDC digitizers (vdSubtypeIIDC)
  1010.    These calls are only valid for video digitizers of subtype vdSubtypeIIDC.
  1011. */
  1012. EXTERN_API( VideoDigitizerError )
  1013. VDIIDCGetFeatures               (VideoDigitizerComponent  ci,
  1014.                                  QTAtomContainer *      container)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0200, 0x7000, 0xA82A);
  1016. EXTERN_API( VideoDigitizerError )
  1017. VDIIDCSetFeatures               (VideoDigitizerComponent  ci,
  1018.                                  QTAtomContainer        container)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0201, 0x7000, 0xA82A);
  1020. EXTERN_API( VideoDigitizerError )
  1021. VDIIDCGetDefaultFeatures        (VideoDigitizerComponent  ci,
  1022.                                  QTAtomContainer *      container)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0202, 0x7000, 0xA82A);
  1024. EXTERN_API( VideoDigitizerError )
  1025. VDIIDCGetCSRData                (VideoDigitizerComponent  ci,
  1026.                                  Boolean                offsetFromRegisterBase,
  1027.                                  UInt32                 offset,
  1028.                                  UInt32 *               data)                               FIVEWORDINLINE(0x2F3C, 0x000A, 0x0203, 0x7000, 0xA82A);
  1030. EXTERN_API( VideoDigitizerError )
  1031. VDIIDCSetCSRData                (VideoDigitizerComponent  ci,
  1032.                                  Boolean                offsetFromRegisterBase,
  1033.                                  UInt32                 offset,
  1034.                                  UInt32                 data)                               FIVEWORDINLINE(0x2F3C, 0x000A, 0x0204, 0x7000, 0xA82A);
  1038. enum {
  1039.     xmlParseComponentType       = FOUR_CHAR_CODE('pars'),
  1040.     xmlParseComponentSubType    = FOUR_CHAR_CODE('xml ')
  1041. };
  1043. enum {
  1044.     xmlIdentifierInvalid        = 0,
  1045.     xmlIdentifierUnrecognized   = (long)0xFFFFFFFF,
  1046.     xmlContentTypeInvalid       = 0,
  1047.     xmlContentTypeElement       = 1,
  1048.     xmlContentTypeCharData      = 2
  1049. };
  1051. enum {
  1052.     elementFlagAlwaysSelfContained = 1L << 0,                   /*    Element doesn't have contents or closing tag even if it doesn't end with />, as in the HTML <img> tag*/
  1053.     elementFlagPreserveWhiteSpace = 1L << 1,                    /*  Preserve whitespace in content, default is to remove it */
  1054.     xmlParseFlagAllowUppercase  = 1L << 0,                      /*    Entities and attributes do not have to be lowercase (strict XML), but can be upper or mixed case as in HTML*/
  1055.     xmlParseFlagAllowUnquotedAttributeValues = 1L << 1,         /*    Attributes values do not have to be enclosed in quotes (strict XML), but can be left unquoted if they contain no spaces*/
  1056.     xmlParseFlagEventParseOnly  = 1L << 2                       /*    Do event parsing only*/
  1057. };
  1059. enum {
  1060.     attributeValueKindCharString = 0,
  1061.     attributeValueKindInteger   = 1L << 0,                      /*    Number*/
  1062.     attributeValueKindPercent   = 1L << 1,                      /*    Number or percent*/
  1063.     attributeValueKindBoolean   = 1L << 2,                      /*    "true" or "false"*/
  1064.     attributeValueKindOnOff     = 1L << 3,                      /*    "on" or "off"*/
  1065.     attributeValueKindColor     = 1L << 4,                      /*    Either "#rrggbb" or a color name*/
  1066.     attributeValueKindEnum      = 1L << 5,                      /*    one of a number of strings; the enum strings are passed as a zero-separated, double-zero-terminated C string in the attributeKindValueInfo param*/
  1067.     attributeValueKindCaseSensEnum = 1L << 6,                   /*    one of a number of strings; the enum strings are passed as for attributeValueKindEnum, but the values are case-sensitive*/
  1068.     MAX_ATTRIBUTE_VALUE_KIND    = attributeValueKindCaseSensEnum
  1069. };
  1071. enum {
  1072.     nameSpaceIDNone             = 0
  1073. };
  1075. /*  A Parsed XML attribute value, one of number/percent, boolean/on-off, color, or enumerated type*/
  1077. union XMLAttributeValue {
  1078.     SInt32                          number;                     /*    The value when valueKind is attributeValueKindInteger or attributeValueKindPercent*/
  1079.     Boolean                         boolean;                    /*    The value when valueKind is attributeValueKindBoolean or attributeValueKindOnOff*/
  1080.     RGBColor                        color;                      /*    The value when valueKind is attributeValueKindColor*/
  1081.     UInt32                          enumType;                   /*    The value when valueKind is attributeValueKindEnum*/
  1082. };
  1083. typedef union XMLAttributeValue         XMLAttributeValue;
  1084. /*  An XML attribute-value pair*/
  1086. struct XMLAttribute {
  1087.     UInt32                          identifier;                 /*    Tokenized identifier, if the attribute name was recognized by the parser*/
  1088.     char *                          name;                       /*    Attribute name, Only present if identifier == xmlIdentifierUnrecognized*/
  1089.     long                            valueKind;                  /*    Type of parsed value, if the value was recognized and parsed; otherwise, attributeValueKindCharString*/
  1090.     XMLAttributeValue               value;                      /*    Parsed attribute value*/
  1091.     char *                          valueStr;                   /*    Always present*/
  1092. };
  1093. typedef struct XMLAttribute             XMLAttribute;
  1094. typedef XMLAttribute *                  XMLAttributePtr;
  1095. /*  Forward struct declarations for recursively-defined tree structure*/
  1096. typedef struct XMLContent               XMLContent;
  1098. typedef XMLContent *                    XMLContentPtr;
  1099. /*
  1100.     An XML Element, i.e.
  1101.         <element attr="value" attr="value" ...> [contents] </element>
  1102.     or
  1103.         <element attr="value" attr="value" .../>
  1104. */
  1106. struct XMLElement {
  1107.     UInt32                          identifier;                 /*    Tokenized identifier, if the element name was recognized by the parser*/
  1108.     char *                          name;                       /*    Element name, only present if identifier == xmlIdentifierUnrecognized*/
  1109.     XMLAttributePtr                 attributes;                 /*    Array of attributes, terminated with an attribute with identifier == xmlIdentifierInvalid*/
  1110.     XMLContentPtr                   contents;                   /*    Array of contents, terminated with a content with kind == xmlIdentifierInvalid*/
  1111. };
  1112. typedef struct XMLElement               XMLElement;
  1113. typedef XMLElement *                    XMLElementPtr;
  1114. /*
  1115.     The content of an XML element is a series of parts, each of which may be either another element
  1116.     or simply character data.
  1117. */
  1119. union XMLElementContent {
  1120.     XMLElement                      element;                    /*    The contents when the content kind is xmlContentTypeElement*/
  1121.     char *                          charData;                   /*    The contents when the content kind is xmlContentTypeCharData*/
  1122. };
  1123. typedef union XMLElementContent         XMLElementContent;
  1125. struct XMLContent {
  1126.     UInt32                          kind;
  1127.     XMLElementContent               actualContent;
  1128. };
  1131. struct XMLDocRecord {
  1132.     void *                          xmlDataStorage;             /*    opaque storage*/
  1133.     XMLElement                      rootElement;
  1134. };
  1135. typedef struct XMLDocRecord             XMLDocRecord;
  1137. typedef XMLDocRecord *                  XMLDoc;
  1138. /*callback routines for event parsing*/
  1139. typedef CALLBACK_API( ComponentResult , StartDocumentHandler )(long refcon);
  1140. typedef CALLBACK_API( ComponentResult , EndDocumentHandler )(long refcon);
  1141. typedef CALLBACK_API( ComponentResult , StartElementHandler )(const char *name, const char *const atts[], long refcon);
  1142. typedef CALLBACK_API( ComponentResult , EndElementHandler )(const char *name, long refcon);
  1143. typedef CALLBACK_API( ComponentResult , CharDataHandler )(const char *charData, long refcon);
  1144. typedef CALLBACK_API( ComponentResult , PreprocessInstructionHandler )(const char *name, const char *const atts[], long refcon);
  1145. typedef CALLBACK_API( ComponentResult , CommentHandler )(const char *comment, long refcon);
  1146. typedef CALLBACK_API( ComponentResult , CDataHandler )(const char *cdata, long refcon);
  1147. typedef STACK_UPP_TYPE(StartDocumentHandler)                    StartDocumentHandlerUPP;
  1148. typedef STACK_UPP_TYPE(EndDocumentHandler)                      EndDocumentHandlerUPP;
  1149. typedef STACK_UPP_TYPE(StartElementHandler)                     StartElementHandlerUPP;
  1150. typedef STACK_UPP_TYPE(EndElementHandler)                       EndElementHandlerUPP;
  1151. typedef STACK_UPP_TYPE(CharDataHandler)                         CharDataHandlerUPP;
  1152. typedef STACK_UPP_TYPE(PreprocessInstructionHandler)            PreprocessInstructionHandlerUPP;
  1153. typedef STACK_UPP_TYPE(CommentHandler)                          CommentHandlerUPP;
  1154. typedef STACK_UPP_TYPE(CDataHandler)                            CDataHandlerUPP;
  1155. /*  Parses the XML file pointed to by dataRef, returning a XMLDoc parse tree*/
  1156. EXTERN_API( ComponentResult )
  1157. XMLParseDataRef                 (ComponentInstance      aParser,
  1158.                                  Handle                 dataRef,
  1159.                                  OSType                 dataRefType,
  1160.                                  long                   parseFlags,
  1161.                                  XMLDoc *               document)                           FIVEWORDINLINE(0x2F3C, 0x0010, 0x0001, 0x7000, 0xA82A);
  1163. /*  Parses the XML file pointed to by fileSpec, returning a XMLDoc parse tree*/
  1164. EXTERN_API( ComponentResult )
  1165. XMLParseFile                    (ComponentInstance      aParser,
  1166.                                  ConstFSSpecPtr         fileSpec,
  1167.                                  long                   parseFlags,
  1168.                                  XMLDoc *               document)                           FIVEWORDINLINE(0x2F3C, 0x000C, 0x0002, 0x7000, 0xA82A);
  1170. /*  Disposes of a XMLDoc parse tree*/
  1171. EXTERN_API( ComponentResult )
  1172. XMLParseDisposeXMLDoc           (ComponentInstance      aParser,
  1173.                                  XMLDoc                 document)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);
  1175. /*
  1176.     Returns a more detailed description of the error and the line in which it occurred, if a
  1177.     file failed to parse properly.
  1178. */
  1179. EXTERN_API( ComponentResult )
  1180. XMLParseGetDetailedParseError   (ComponentInstance      aParser,
  1181.                                  long *                 errorLine,
  1182.                                  StringPtr              errDesc)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A);
  1184. /*
  1185.     Tell the parser of an element to be recognized. The tokenized element unique identifier is
  1186.     passed in *elementID, unless *elementID is zero, whereupon a unique ID is generated and returned.
  1187.     Thus, a valid element identifier can never be zero.
  1188. */
  1189. EXTERN_API( ComponentResult )
  1190. XMLParseAddElement              (ComponentInstance      aParser,
  1191.                                  char *                 elementName,
  1192.                                  UInt32                 nameSpaceID,
  1193.                                  UInt32 *               elementID,
  1194.                                  long                   elementFlags)                       FIVEWORDINLINE(0x2F3C, 0x0010, 0x0005, 0x7000, 0xA82A);
  1196. /*
  1197.     Tells the parser of an attribute for the specified element. The tokenized attribute unique
  1198.     ID is passed in *attributeID, unless *attributeID is zero, whereupon a unique ID is generated and
  1199.     returned. Thus, a valid attribute identifier can never be zero.
  1200. */
  1201. EXTERN_API( ComponentResult )
  1202. XMLParseAddAttribute            (ComponentInstance      aParser,
  1203.                                  UInt32                 elementID,
  1204.                                  UInt32                 nameSpaceID,
  1205.                                  char *                 attributeName,
  1206.                                  UInt32 *               attributeID)                        FIVEWORDINLINE(0x2F3C, 0x0010, 0x0006, 0x7000, 0xA82A);
  1208. /*
  1209.     Tells the parser of several attributes for the specified element. The attributes are passed
  1210.     as a zero-delimited, double-zero-terminated C string in attributeNames, and the attribute
  1211.     IDs are passed in on attributeIDs as an array; if any attributeIDs are zero, unique IDs
  1212.     are generated for those and returned
  1213. */
  1214. EXTERN_API( ComponentResult )
  1215. XMLParseAddMultipleAttributes   (ComponentInstance      aParser,
  1216.                                  UInt32                 elementID,
  1217.                                  UInt32 *               nameSpaceIDs,
  1218.                                  char *                 attributeNames,
  1219.                                  UInt32 *               attributeIDs)                       FIVEWORDINLINE(0x2F3C, 0x0010, 0x0007, 0x7000, 0xA82A);
  1221. /*
  1222.     Tells the parser of an attribute, which may have a particular type of value, for the
  1223.     specified element. Params are as in XMLParseAddAttribute, plus all the kinds of values
  1224.     the attribute may have are passed in attributeValueKind, and optional additional information
  1225.     required to tokenize the particular kind of attribute is passed in attributeValueKindInfo
  1226. */
  1227. EXTERN_API( ComponentResult )
  1228. XMLParseAddAttributeAndValue    (ComponentInstance      aParser,
  1229.                                  UInt32                 elementID,
  1230.                                  UInt32                 nameSpaceID,
  1231.                                  char *                 attributeName,
  1232.                                  UInt32 *               attributeID,
  1233.                                  UInt32                 attributeValueKind,
  1234.                                  void *                 attributeValueKindInfo)             FIVEWORDINLINE(0x2F3C, 0x0018, 0x0008, 0x7000, 0xA82A);
  1236. /*
  1237.     Tells the parser of several attributes, which may have a particular type of value, for the
  1238.     specified element. Params are as in XMLParseAddMultipleAttributes, plus all the kinds of values
  1239.     the attributes may have are passed in attributeValueKinds, and optional additional information
  1240.     required to tokenize the particular kind of attributes is passed in attributeValueKindInfos
  1241. */
  1242. EXTERN_API( ComponentResult )
  1243. XMLParseAddMultipleAttributesAndValues (ComponentInstance  aParser,
  1244.                                  UInt32                 elementID,
  1245.                                  UInt32 *               nameSpaceIDs,
  1246.                                  char *                 attributeNames,
  1247.                                  UInt32 *               attributeIDs,
  1248.                                  UInt32 *               attributeValueKinds,
  1249.                                  void **                attributeValueKindInfos)            FIVEWORDINLINE(0x2F3C, 0x0018, 0x0009, 0x7000, 0xA82A);
  1251. /*
  1252.     Tells the parser that the particular attribute may have an additional kind of
  1253.     value, as specified by attributeValueKind and attributeValueKindInfo
  1254. */
  1255. EXTERN_API( ComponentResult )
  1256. XMLParseAddAttributeValueKind   (ComponentInstance      aParser,
  1257.                                  UInt32                 elementID,
  1258.                                  UInt32                 attributeID,
  1259.                                  UInt32                 attributeValueKind,
  1260.                                  void *                 attributeValueKindInfo)             FIVEWORDINLINE(0x2F3C, 0x0010, 0x000A, 0x7000, 0xA82A);
  1262. /*
  1263.     Tell the parser of a namespace to be recognized. The tokenized namespace unique identifier is
  1264.     passed in *nameSpaceID, unless *nameSpaceID is zero, whereupon a unique ID is generated and returned.
  1265.     Thus, a valid nameSpaceID identifier can never be zero.
  1266. */
  1267. EXTERN_API( ComponentResult )
  1268. XMLParseAddNameSpace            (ComponentInstance      aParser,
  1269.                                  char *                 nameSpaceURL,
  1270.                                  UInt32 *               nameSpaceID)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x000B, 0x7000, 0xA82A);
  1272. /*  Specifies the offset and limit for reading from the dataref to be used when parsing*/
  1273. EXTERN_API( ComponentResult )
  1274. XMLParseSetOffsetAndLimit       (ComponentInstance      aParser,
  1275.                                  UInt32                 offset,
  1276.                                  UInt32                 limit)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x000C, 0x7000, 0xA82A);
  1278. /*  Set the event parse refcon*/
  1279. EXTERN_API( ComponentResult )
  1280. XMLParseSetEventParseRefCon     (ComponentInstance      aParser,
  1281.                                  long                   refcon)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);
  1283. /*  Set the start document handler UPP for event parsing*/
  1284. EXTERN_API( ComponentResult )
  1285. XMLParseSetStartDocumentHandler (ComponentInstance      aParser,
  1286.                                  StartDocumentHandlerUPP  startDocument)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x000E, 0x7000, 0xA82A);
  1288. /*  Set the end document handler UPP for event parsing*/
  1289. EXTERN_API( ComponentResult )
  1290. XMLParseSetEndDocumentHandler   (ComponentInstance      aParser,
  1291.                                  EndDocumentHandlerUPP  endDocument)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x000F, 0x7000, 0xA82A);
  1293. /*  Set the start element handler UPP for event parsing*/
  1294. EXTERN_API( ComponentResult )
  1295. XMLParseSetStartElementHandler  (ComponentInstance      aParser,
  1296.                                  StartElementHandlerUPP  startElement)                      FIVEWORDINLINE(0x2F3C, 0x0004, 0x0010, 0x7000, 0xA82A);
  1298. /*  Set the end element handler UPP for event parsing*/
  1299. EXTERN_API( ComponentResult )
  1300. XMLParseSetEndElementHandler    (ComponentInstance      aParser,
  1301.                                  EndElementHandlerUPP   endElement)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0011, 0x7000, 0xA82A);
  1303. /*  Set the character data handler UPP for event parsing*/
  1304. EXTERN_API( ComponentResult )
  1305. XMLParseSetCharDataHandler      (ComponentInstance      aParser,
  1306.                                  CharDataHandlerUPP     charData)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);
  1308. /*  Set the preprocess instruction handler UPP for event parsing*/
  1309. EXTERN_API( ComponentResult )
  1310. XMLParseSetPreprocessInstructionHandler (ComponentInstance  aParser,
  1311.                                  PreprocessInstructionHandlerUPP  preprocessInstruction)    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0013, 0x7000, 0xA82A);
  1313. /*  Set the comment handler UPP for event parsing*/
  1314. EXTERN_API( ComponentResult )
  1315. XMLParseSetCommentHandler       (ComponentInstance      aParser,
  1316.                                  CommentHandlerUPP      comment)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A);
  1318. /*  Set the cdata handler UPP for event parsing*/
  1319. EXTERN_API( ComponentResult )
  1320. XMLParseSetCDataHandler         (ComponentInstance      aParser,
  1321.                                  CDataHandlerUPP        cdata)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A);
  1323. /*
  1324.     Helper Macros
  1325.     
  1326.         These macros allow you to easily add entities and attributes to the parser
  1327.         in an error free manner when the identifiers are defined in a particular manner.
  1328.         For these to work, you must define the identifiers as follows:
  1329.         
  1330.         For entities, they must be defined as element_elementName, as in:
  1331.         
  1332.             enum
  1333.             {
  1334.                 element_xml =   1,      //  "xml"
  1335.                 element_head,           //  "head"
  1336.                 element_body            //  "body"
  1337.             };
  1338.             
  1339.         If the element name has characters that are illegal in an identifier,
  1340.         some of the macros support that, but the identifier must not contain
  1341.         the illegal characters:
  1342.         
  1343.             enum
  1344.             {
  1345.                 element_rootlayout      //  "root-layout"
  1346.             }
  1347.             
  1348.         For attribute names, similar rules apply except that they must be defined
  1349.         as attr_attributeName, as in:
  1350.             
  1351.             enum
  1352.             {
  1353.                 attr_src    =   1,      //  "src"
  1354.                 attr_href,
  1355.                 attr_width,
  1356.                 attr_height
  1357.             }
  1358.             
  1359.         Finally, the existence of local variables elementID and attributeID is required.
  1360. */
  1361. /*
  1362.     Adds the specified element to the parser, i.e. XML_ADD_ELEMENT(head) adds the element "head" with
  1363.     a unique identifier of element_head
  1364. */
  1366. #define XML_ADD_ELEMENT_NS(elementName,nameSpaceID)        elementID   =   GLUE2(element_,elementName);    XMLParseAddElement(xmlParser, #elementName, nameSpaceID, &elementID, 0)
  1367. #define XML_ADD_ELEMENT(elementName)                    XML_ADD_ELEMENT_NS(elementName,nameSpaceIDNone)
  1369. /*
  1370.     Adds the specified element to the parser, not using the same string to generate the identifier and
  1371.     the element name. Use for element names that contain characters which are illegal in identifiers,
  1372.     i.e XML_ADD_COMPLEX_ELEMENT("root-layout",rootlayout) adds the element "root-layout" with a unique
  1373.     identifier of element_rootlayout
  1374. */
  1376. #define XML_ADD_COMPLEX_ELEMENT_NS(elementName,elemID,nameSpaceID)     elementID   =   GLUE2(element_,elemID);     XMLParseAddElement(xmlParser, #elementName, nameSpaceID, &elementID, 0)
  1377. #define XML_ADD_COMPLEX_ELEMENT(elementName,elemID)                     XML_ADD_COMPLEX_ELEMENT_NS(elementName,elemID,nameSpaceIDNone)
  1379. /*
  1380.     Adds the specified attribute to the current element in the parser, i.e. XML_ADD_ATTRIBUTE(src)
  1381.     adds the attribute "src" to the current element, and identifies it by attr_src
  1382. */
  1384. #define XML_ADD_ATTRIBUTE_NS(attrName,nameSpaceID)     attributeID =   GLUE2(attr_,attrName);      XMLParseAddAttribute(xmlParser, elementID, nameSpaceID, #attrName, &attributeID);
  1385. #define XML_ADD_ATTRIBUTE(attrName)                       XML_ADD_ATTRIBUTE_NS(attrName,nameSpaceIDNone)
  1387. /*
  1388.     Adds the specified attribute to the current element in the parser, i.e. XML_ADD_ATTRIBUTE(element_img, src)
  1389.     adds the attribute "src" to the element_img element, and identifies it by attr_src
  1390.     Adds the specified attribute to the current element in the parser, not using the same string to
  1391.     generate the identifier and the element name. Use for attribute names that contain characters which
  1392.     are illegal in identifiers, i.e XML_ADD_COMPLEX_ATTRIBUTE("http-equiv",httpequiv) adds the element
  1393.     "http-equiv" with a unique identifier of attr_httpequiv
  1394. */
  1396. #define XML_ADD_COMPLEX_ATTRIBUTE_NS(attrName,attrID,nameSpaceID)  attributeID =   GLUE2(attr_,attrID);        XMLParseAddAttribute(xmlParser, elementID, nameSpaceID, #attrName, &attributeID);
  1397. #define XML_ADD_COMPLEX_ATTRIBUTE(attrName,attrID)                    XML_ADD_COMPLEX_ATTRIBUTE_NS(attrName,attrID,nameSpaceIDNone)
  1400. #define XML_ADD_ATTRIBUTE_AND_VALUE_NS(attrName,valueKind,valueKindInfo,nameSpaceID)   attributeID =   GLUE2(attr_,attrName);      XMLParseAddAttributeAndValue(xmlParser, elementID, nameSpaceID, #attrName, &attributeID, valueKind, valueKindInfo);
  1401. #define XML_ADD_ATTRIBUTE_AND_VALUE(attrName,valueKind,valueKindInfo)                   XML_ADD_ATTRIBUTE_AND_VALUE_NS(attrName,valueKind,valueKindInfo,nameSpaceIDNone)
  1404. #define XML_ADD_COMPLEX_ATTRIBUTE_AND_VALUE_NS(attrName,attrID,valueKind,valueKindInfo,nameSpaceID)        attributeID =   GLUE2(attr_,attrID);        XMLParseAddAttributeAndValue(xmlParser, elementID, nameSpaceID, #attrName, &attributeID, valueKind, valueKindInfo);
  1405. #define XML_ADD_COMPLEX_ATTRIBUTE_AND_VALUE(attrName,attrID,valueKind,valueKindInfo)                    XML_ADD_COMPLEX_ATTRIBUTE_AND_VALUE_NS(attrName,attrID,valueKind,valueKindInfo,nameSpaceIDNone)
  1412. /*
  1413.     General Sequence Grab stuff
  1414. */
  1415. typedef ComponentInstance               SeqGrabComponent;
  1416. typedef ComponentInstance               SGChannel;
  1417. enum {
  1418.     SeqGrabComponentType        = FOUR_CHAR_CODE('barg'),
  1419.     SeqGrabChannelType          = FOUR_CHAR_CODE('sgch'),
  1420.     SeqGrabPanelType            = FOUR_CHAR_CODE('sgpn'),
  1421.     SeqGrabCompressionPanelType = FOUR_CHAR_CODE('cmpr'),
  1422.     SeqGrabSourcePanelType      = FOUR_CHAR_CODE('sour')
  1423. };
  1425. enum {
  1426.     seqGrabToDisk               = 1,
  1427.     seqGrabToMemory             = 2,
  1428.     seqGrabDontUseTempMemory    = 4,
  1429.     seqGrabAppendToFile         = 8,
  1430.     seqGrabDontAddMovieResource = 16,
  1431.     seqGrabDontMakeMovie        = 32,
  1432.     seqGrabPreExtendFile        = 64,
  1433.     seqGrabDataProcIsInterruptSafe = 128,
  1434.     seqGrabDataProcDoesOverlappingReads = 256
  1435. };
  1437. typedef unsigned long                   SeqGrabDataOutputEnum;
  1438. enum {
  1439.     seqGrabRecord               = 1,
  1440.     seqGrabPreview              = 2,
  1441.     seqGrabPlayDuringRecord     = 4,
  1442.     seqGrabLowLatencyCapture    = 8,                            /* return the freshest frame possible, for live work (videoconferencing, live broadcast, live image processing) */
  1443.     seqGrabAlwaysUseTimeBase    = 16                            /* Tell VDIGs to use TimebaseTime always, rather than creating uniform frame durations, for more accurate live sync with audio */
  1444. };
  1446. typedef unsigned long                   SeqGrabUsageEnum;
  1447. enum {
  1448.     seqGrabHasBounds            = 1,
  1449.     seqGrabHasVolume            = 2,
  1450.     seqGrabHasDiscreteSamples   = 4,
  1451.     seqGrabDoNotBufferizeData   = 8,
  1452.     seqGrabCanMoveWindowWhileRecording = 16
  1453. };
  1455. typedef unsigned long                   SeqGrabChannelInfoEnum;
  1457. struct SGOutputRecord {
  1458.     long                            data[1];
  1459. };
  1460. typedef struct SGOutputRecord           SGOutputRecord;
  1462. typedef SGOutputRecord *                SGOutput;
  1464. struct SeqGrabFrameInfo {
  1465.     long                            frameOffset;
  1466.     long                            frameTime;
  1467.     long                            frameSize;
  1468.     SGChannel                       frameChannel;
  1469.     long                            frameRefCon;
  1470. };
  1471. typedef struct SeqGrabFrameInfo         SeqGrabFrameInfo;
  1472. typedef SeqGrabFrameInfo *              SeqGrabFrameInfoPtr;
  1474. struct SeqGrabExtendedFrameInfo {
  1475.     wide                            frameOffset;
  1476.     long                            frameTime;
  1477.     long                            frameSize;
  1478.     SGChannel                       frameChannel;
  1479.     long                            frameRefCon;
  1480.     SGOutput                        frameOutput;
  1481. };
  1482. typedef struct SeqGrabExtendedFrameInfo SeqGrabExtendedFrameInfo;
  1483. typedef SeqGrabExtendedFrameInfo *      SeqGrabExtendedFrameInfoPtr;
  1484. enum {
  1485.     grabPictOffScreen           = 1,
  1486.     grabPictIgnoreClip          = 2,
  1487.     grabPictCurrentImage        = 4
  1488. };
  1490. enum {
  1491.     sgFlagControlledGrab        = (1 << 0),
  1492.     sgFlagAllowNonRGBPixMaps    = (1 << 1)
  1493. };
  1495. typedef CALLBACK_API( OSErr , SGDataProcPtr )(SGChannel c, Ptr p, long len, long *offset, long chRefCon, TimeValue time, short writeType, long refCon);
  1496. typedef STACK_UPP_TYPE(SGDataProcPtr)                           SGDataUPP;
  1498. struct SGDeviceInputName {
  1499.     Str63                           name;
  1500.     Handle                          icon;
  1501.     long                            flags;
  1502.     long                            reserved;                   /* zero*/
  1503. };
  1504. typedef struct SGDeviceInputName        SGDeviceInputName;
  1505. enum {
  1506.     sgDeviceInputNameFlagInputUnavailable = (1 << 0)
  1507. };
  1510. struct SGDeviceInputListRecord {
  1511.     short                           count;
  1512.     short                           selectedIndex;
  1513.     long                            reserved;                   /* zero*/
  1514.     SGDeviceInputName               entry[1];
  1515. };
  1516. typedef struct SGDeviceInputListRecord  SGDeviceInputListRecord;
  1518. typedef SGDeviceInputListRecord *       SGDeviceInputListPtr;
  1519. typedef SGDeviceInputListPtr *          SGDeviceInputList;
  1521. struct SGDeviceName {
  1522.     Str63                           name;
  1523.     Handle                          icon;
  1524.     long                            flags;
  1525.     long                            refCon;
  1526.     SGDeviceInputList               inputs;                     /* list of inputs; formerly reserved to 0*/
  1527. };
  1528. typedef struct SGDeviceName             SGDeviceName;
  1529. enum {
  1530.     sgDeviceNameFlagDeviceUnavailable = (1 << 0),
  1531.     sgDeviceNameFlagShowInputsAsDevices = (1 << 1)
  1532. };
  1535. struct SGDeviceListRecord {
  1536.     short                           count;
  1537.     short                           selectedIndex;
  1538.     long                            reserved;                   /* zero*/
  1539.     SGDeviceName                    entry[1];
  1540. };
  1541. typedef struct SGDeviceListRecord       SGDeviceListRecord;
  1543. typedef SGDeviceListRecord *            SGDeviceListPtr;
  1544. typedef SGDeviceListPtr *               SGDeviceList;
  1545. enum {
  1546.     sgDeviceListWithIcons       = (1 << 0),
  1547.     sgDeviceListDontCheckAvailability = (1 << 1),
  1548.     sgDeviceListIncludeInputs   = (1 << 2)
  1549. };
  1551. enum {
  1552.     seqGrabWriteAppend          = 0,
  1553.     seqGrabWriteReserve         = 1,
  1554.     seqGrabWriteFill            = 2
  1555. };
  1557. enum {
  1558.     seqGrabUnpause              = 0,
  1559.     seqGrabPause                = 1,
  1560.     seqGrabPauseForMenu         = 3
  1561. };
  1563. enum {
  1564.     channelFlagDontOpenResFile  = 2,
  1565.     channelFlagHasDependency    = 4
  1566. };
  1568. typedef CALLBACK_API( Boolean , SGModalFilterProcPtr )(DialogRef theDialog, const EventRecord *theEvent, short *itemHit, long refCon);
  1569. typedef STACK_UPP_TYPE(SGModalFilterProcPtr)                    SGModalFilterUPP;
  1570. enum {
  1571.     sgPanelFlagForPanel         = 1
  1572. };
  1574. enum {
  1575.     seqGrabSettingsPreviewOnly  = 1
  1576. };
  1578. enum {
  1579.     channelPlayNormal           = 0,
  1580.     channelPlayFast             = 1,
  1581.     channelPlayHighQuality      = 2,
  1582.     channelPlayAllData          = 4
  1583. };
  1586. EXTERN_API( ComponentResult )
  1587. SGInitialize                    (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0001, 0x7000, 0xA82A);
  1589. EXTERN_API( ComponentResult )
  1590. SGSetDataOutput                 (SeqGrabComponent       s,
  1591.                                  const FSSpec *         movieFile,
  1592.                                  long                   whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0002, 0x7000, 0xA82A);
  1594. EXTERN_API( ComponentResult )
  1595. SGGetDataOutput                 (SeqGrabComponent       s,
  1596.                                  FSSpec *               movieFile,
  1597.                                  long *                 whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x0003, 0x7000, 0xA82A);
  1599. EXTERN_API( ComponentResult )
  1600. SGSetGWorld                     (SeqGrabComponent       s,
  1601.                                  CGrafPtr               gp,
  1602.                                  GDHandle               gd)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A);
  1604. EXTERN_API( ComponentResult )
  1605. SGGetGWorld                     (SeqGrabComponent       s,
  1606.                                  CGrafPtr *             gp,
  1607.                                  GDHandle *             gd)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0005, 0x7000, 0xA82A);
  1609. EXTERN_API( ComponentResult )
  1610. SGNewChannel                    (SeqGrabComponent       s,
  1611.                                  OSType                 channelType,
  1612.                                  SGChannel *            ref)                                FIVEWORDINLINE(0x2F3C, 0x0008, 0x0006, 0x7000, 0xA82A);
  1614. EXTERN_API( ComponentResult )
  1615. SGDisposeChannel                (SeqGrabComponent       s,
  1616.                                  SGChannel              c)                                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);
  1618. EXTERN_API( ComponentResult )
  1619. SGStartPreview                  (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0010, 0x7000, 0xA82A);
  1621. EXTERN_API( ComponentResult )
  1622. SGStartRecord                   (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0011, 0x7000, 0xA82A);
  1624. EXTERN_API( ComponentResult )
  1625. SGIdle                          (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0012, 0x7000, 0xA82A);
  1627. EXTERN_API( ComponentResult )
  1628. SGStop                          (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0013, 0x7000, 0xA82A);
  1630. EXTERN_API( ComponentResult )
  1631. SGPause                         (SeqGrabComponent       s,
  1632.                                  Byte                   pause)                              FIVEWORDINLINE(0x2F3C, 0x0002, 0x0014, 0x7000, 0xA82A);
  1634. EXTERN_API( ComponentResult )
  1635. SGPrepare                       (SeqGrabComponent       s,
  1636.                                  Boolean                prepareForPreview,
  1637.                                  Boolean                prepareForRecord)                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A);
  1639. EXTERN_API( ComponentResult )
  1640. SGRelease                       (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0016, 0x7000, 0xA82A);
  1642. EXTERN_API( Movie )
  1643. SGGetMovie                      (SeqGrabComponent       s)                                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0017, 0x7000, 0xA82A);
  1645. EXTERN_API( ComponentResult )
  1646. SGSetMaximumRecordTime          (SeqGrabComponent       s,
  1647.                                  unsigned long          ticks)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0018, 0x7000, 0xA82A);
  1649. EXTERN_API( ComponentResult )
  1650. SGGetMaximumRecordTime          (SeqGrabComponent       s,
  1651.                                  unsigned long *        ticks)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);
  1653. EXTERN_API( ComponentResult )
  1654. SGGetStorageSpaceRemaining      (SeqGrabComponent       s,
  1655.                                  unsigned long *        bytes)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A);
  1657. EXTERN_API( ComponentResult )
  1658. SGGetTimeRemaining              (SeqGrabComponent       s,
  1659.                                  long *                 ticksLeft)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);
  1661. EXTERN_API( ComponentResult )
  1662. SGGrabPict                      (SeqGrabComponent       s,
  1663.                                  PicHandle *            p,
  1664.                                  const Rect *           bounds,
  1665.                                  short                  offscreenDepth,
  1666.                                  long                   grabPictFlags)                      FIVEWORDINLINE(0x2F3C, 0x000E, 0x001C, 0x7000, 0xA82A);
  1668. EXTERN_API( ComponentResult )
  1669. SGGetLastMovieResID             (SeqGrabComponent       s,
  1670.                                  short *                resID)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x001D, 0x7000, 0xA82A);
  1672. EXTERN_API( ComponentResult )
  1673. SGSetFlags                      (SeqGrabComponent       s,
  1674.                                  long                   sgFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x001E, 0x7000, 0xA82A);
  1676. EXTERN_API( ComponentResult )
  1677. SGGetFlags                      (SeqGrabComponent       s,
  1678.                                  long *                 sgFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x001F, 0x7000, 0xA82A);
  1680. EXTERN_API( ComponentResult )
  1681. SGSetDataProc                   (SeqGrabComponent       s,
  1682.                                  SGDataUPP              proc,
  1683.                                  long                   refCon)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0020, 0x7000, 0xA82A);
  1685. EXTERN_API( ComponentResult )
  1686. SGNewChannelFromComponent       (SeqGrabComponent       s,
  1687.                                  SGChannel *            newChannel,
  1688.                                  Component              sgChannelComponent)                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0021, 0x7000, 0xA82A);
  1690. EXTERN_API( ComponentResult )
  1691. SGDisposeDeviceList             (SeqGrabComponent       s,
  1692.                                  SGDeviceList           list)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0022, 0x7000, 0xA82A);
  1694. EXTERN_API( ComponentResult )
  1695. SGAppendDeviceListToMenu        (SeqGrabComponent       s,
  1696.                                  SGDeviceList           list,
  1697.                                  MenuRef                mh)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0023, 0x7000, 0xA82A);
  1699. EXTERN_API( ComponentResult )
  1700. SGSetSettings                   (SeqGrabComponent       s,
  1701.                                  UserData               ud,
  1702.                                  long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0024, 0x7000, 0xA82A);
  1704. EXTERN_API( ComponentResult )
  1705. SGGetSettings                   (SeqGrabComponent       s,
  1706.                                  UserData *             ud,
  1707.                                  long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x0008, 0x0025, 0x7000, 0xA82A);
  1709. EXTERN_API( ComponentResult )
  1710. SGGetIndChannel                 (SeqGrabComponent       s,
  1711.                                  short                  index,
  1712.                                  SGChannel *            ref,
  1713.                                  OSType *               chanType)                           FIVEWORDINLINE(0x2F3C, 0x000A, 0x0026, 0x7000, 0xA82A);
  1715. EXTERN_API( ComponentResult )
  1716. SGUpdate                        (SeqGrabComponent       s,
  1717.                                  RgnHandle              updateRgn)                          FIVEWORDINLINE(0x2F3C, 0x0004, 0x0027, 0x7000, 0xA82A);
  1719. EXTERN_API( ComponentResult )
  1720. SGGetPause                      (SeqGrabComponent       s,
  1721.                                  Byte *                 paused)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0x0028, 0x7000, 0xA82A);
  1723. typedef const Component *               ConstComponentListPtr;
  1724. EXTERN_API( ComponentResult )
  1725. SGSettingsDialog                (SeqGrabComponent       s,
  1726.                                  SGChannel              c,
  1727.                                  short                  numPanels,
  1728.                                  ConstComponentListPtr  panelList,
  1729.                                  long                   flags,
  1730.                                  SGModalFilterUPP       proc,
  1731.                                  long                   procRefNum)                         FIVEWORDINLINE(0x2F3C, 0x0016, 0x0029, 0x7000, 0xA82A);
  1733. EXTERN_API( ComponentResult )
  1734. SGGetAlignmentProc              (SeqGrabComponent       s,
  1735.                                  ICMAlignmentProcRecordPtr  alignmentProc)                  FIVEWORDINLINE(0x2F3C, 0x0004, 0x002A, 0x7000, 0xA82A);
  1737. EXTERN_API( ComponentResult )
  1738. SGSetChannelSettings            (SeqGrabComponent       s,
  1739.                                  SGChannel              c,
  1740.                                  UserData               ud,
  1741.                                  long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x002B, 0x7000, 0xA82A);
  1743. EXTERN_API( ComponentResult )
  1744. SGGetChannelSettings            (SeqGrabComponent       s,
  1745.                                  SGChannel              c,
  1746.                                  UserData *             ud,
  1747.                                  long                   flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x002C, 0x7000, 0xA82A);
  1749. EXTERN_API( ComponentResult )
  1750. SGGetMode                       (SeqGrabComponent       s,
  1751.                                  Boolean *              previewMode,
  1752.                                  Boolean *              recordMode)                         FIVEWORDINLINE(0x2F3C, 0x0008, 0x002D, 0x7000, 0xA82A);
  1754. EXTERN_API( ComponentResult )
  1755. SGSetDataRef                    (SeqGrabComponent       s,
  1756.                                  Handle                 dataRef,
  1757.                                  OSType                 dataRefType,
  1758.                                  long                   whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x000C, 0x002E, 0x7000, 0xA82A);
  1760. EXTERN_API( ComponentResult )
  1761. SGGetDataRef                    (SeqGrabComponent       s,
  1762.                                  Handle *               dataRef,
  1763.                                  OSType *               dataRefType,
  1764.                                  long *                 whereFlags)                         FIVEWORDINLINE(0x2F3C, 0x000C, 0x002F, 0x7000, 0xA82A);
  1766. EXTERN_API( ComponentResult )
  1767. SGNewOutput                     (SeqGrabComponent       s,
  1768.                                  Handle                 dataRef,
  1769.                                  OSType                 dataRefType,
  1770.                                  long                   whereFlags,
  1771.                                  SGOutput *             sgOut)                              FIVEWORDINLINE(0x2F3C, 0x0010, 0x0030, 0x7000, 0xA82A);
  1773. EXTERN_API( ComponentResult )