home *** CD-ROM | disk | FTP | other *** search
/ QuickTime - The Beta Release / QuickTime - The Beta Release.iso / Programming Stuff / Interfaces / Movies Interfaces / QuickTimeComponents.p < prev   
Encoding:
Text File  |  1991-09-06  |  32.4 KB  |  846 lines  |  [TEXT/MPS ]
  1.  
  2. {
  3. Created: Saturday, August 17, 1991 at 10:25 AM
  4.  QuickTimeComponents.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.  Copyright Apple Computer, Inc. 1991
  8.  All rights reserved
  9. }
  10.  
  11.  
  12. {$IFC UNDEFINED UsingIncludes}
  13. {$SETC UsingIncludes := 0}
  14. {$ENDC}
  15.  
  16. {$IFC NOT UsingIncludes}
  17.  UNIT QuickTimeComponents;
  18.  INTERFACE
  19. {$ENDC}
  20.  
  21. {$IFC UNDEFINED UsingQuickTimeComponents}
  22. {$SETC UsingQuickTimeComponents := 1}
  23.  
  24. {$I+}
  25. {$SETC QuickTimeComponentsIncludes := UsingIncludes}
  26. {$SETC UsingIncludes := 1}
  27. {$IFC UNDEFINED UsingComponents}
  28. {$I $$Shell(PInterfaces)Components.p}
  29. {$ENDC}
  30. {$IFC UNDEFINED UsingImageCompression}
  31. {$I $$Shell(PInterfaces)ImageCompression.p}
  32. {$ENDC}
  33. {$IFC UNDEFINED UsingMovies}
  34. {$I $$Shell(PInterfaces)Movies.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED UsingQuickDraw}
  37. {$I $$Shell(PInterfaces)QuickDraw.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED UsingVideo}
  40. {$I $$Shell(PInterfaces)Video.p}
  41. {$ENDC}
  42. {$SETC UsingIncludes := QuickTimeComponentsIncludes}
  43.  
  44. CONST
  45.  
  46. {****
  47.  
  48.  Clock Component
  49.  
  50. ****}
  51. clockComponentType = 'clok';
  52. systemTickClock = 'tick';            { subtype: 60ths since boot }
  53. systemSecondClock = 'seco';            { subtype: seconds since 1904 }
  54. systemMillisecondClock = 'mill';    { subtype: 1000ths since boot }
  55. systemMicrosecondClock = 'micr';    { subtype: 1000000ths since boot }
  56.  
  57. kClockRateIsLinear = 1;
  58. kClockImplementsCallBacks = 2;
  59.  
  60. kClockGetClockTimeSelect = 1;
  61. kClockSetClockTimeSelect = 2;
  62. kClockNewCallBackSelect = 3;
  63. kClockDisposeCallBackSelect = 4;
  64. kClockCallMeWhenSelect = 5;
  65. kClockCancelCallBackSelect = 6;
  66. kClockRateChangedSelect = 7;
  67. kClockTimeChangedSelect = 8;
  68. kClockSetTimeBaseSelect = 9;
  69.  
  70. FUNCTION GetClockTime(aClock: ComponentInstance;VAR out: TimeRecord): ComponentResult;
  71.  INLINE $2F3C,$4,$1,$7000,$A82A;
  72. FUNCTION ClockNewCallBack(aClock: ComponentInstance;tb: TimeBase;callBackType: INTEGER): QTCallBack;
  73.  INLINE $2F3C,$6,$1,$7000,$A82A;
  74. FUNCTION ClockDisposeCallBack(aClock: ComponentInstance;cb: QTCallBack): ComponentResult;
  75.  INLINE $2F3C,$4,$1,$7000,$A82A;
  76. FUNCTION ClockCallMeWhen(clock: ComponentInstance;cb: QTCallBack;param1: LONGINT;
  77.  param2: LONGINT;param3: LONGINT): ComponentResult;
  78.  INLINE $2F3C,$10,$1,$7000,$A82A;
  79. FUNCTION ClockCancelCallBack(clock: ComponentInstance;cb: QTCallBack): ComponentResult;
  80.  INLINE $2F3C,$4,$1,$7000,$A82A;
  81. FUNCTION ClockRateChanged(clock: ComponentInstance;cb: QTCallBack): ComponentResult;
  82.  INLINE $2F3C,$4,$1,$7000,$A82A;
  83. FUNCTION ClockTimeChanged(clock: ComponentInstance;cb: QTCallBack): ComponentResult;
  84.  INLINE $2F3C,$4,$1,$7000,$A82A;
  85. FUNCTION ClockSetTimeBase(clock: ComponentInstance;tb: TimeBase): ComponentResult;
  86.  INLINE $2F3C,$4,$1,$7000,$A82A;
  87.  
  88.  
  89. CONST
  90.  
  91. {
  92.  Video Digitizer Component
  93.  
  94.  
  95.   Standard type for video digitizers }
  96. videoDigitizerComponentType = 'vdig';
  97. vdigInterfaceRev = 2;
  98.  
  99. { Input Format Standards }
  100. ntscIn = 0;                            { ntsc input format }
  101. palIn = 1;                            { pal input format }
  102. secamIn = 2;                        { secam input format }
  103. autoDetectIn = 3;                    { auto detect }
  104.  
  105.  
  106. { Input Formats }
  107. compositeIn = 0;                    { input is composite format }
  108. sVideoIn = 1;                        { input is sVideo format }
  109. rgbComponentIn = 2;                    { input is rgb component format }
  110.  
  111.  
  112. { Video Digitizer PlayThru States }
  113. vdPlayThruOff = 0;
  114. vdPlayThruOn = 1;
  115.  
  116.  
  117. { Input Color Space Modes }
  118. vdDigitizerBW = 0;                    { black and white }
  119. vdDigitizerRGB = 1;                    { rgb color }
  120.  
  121.  
  122. { Phase Lock Loop Modes }
  123. vdBroadcastMode = 0;                { Broadcast / Laser Disk video mode }
  124. vdVTRMode = 1;                        { VCR / Magnetic media mode }
  125.  
  126.  
  127. { vdig types }
  128. vdTypeBasic = 0;                    { basic, no clipping }
  129. vdTypeAlpha = 1;                    { supports clipping with alpha channel }
  130. vdTypeMask = 2;                        { supports clipping with mask plane }
  131. vdTypeKey = 3;                        { supports clipping with key color(s) }
  132.  
  133.  
  134. { Digitizer Error Codes }
  135. digiUnimpErr = -2201;                { feature unimplemented }
  136. qtParamErr = -2202;                    { bad input parameter ( out of range, etc ) }
  137. matrixErr = -2203;                    { bad matrix, digitizer did nothing }
  138. notExactMatrix = -2204;                { warning of bad matrix, digitizer did its best }
  139. noMoreKeyColors = -2205;            { all key indexes in use }
  140. notExactSize = -2206;                { Can’t do exact size requested }
  141. badDepth = -2207;                    { Can’t digitize into this depth }
  142. noDMA = -2208;                        { Can’t do DMA digitizing ( i.e. can't go to requested dest }
  143.  
  144.  
  145. { Digitizer Input Capability/Current Flags }
  146. digiInDoesNTSC = $1;                { digitizer supports NTSC input format }
  147. digiInDoesPAL = $2;                    { digitizer supports PAL input format }
  148. digiInDoesSECAM = $4;                { digitizer supports SECAM input format }
  149. digiInDoesGenLock = $80;            { digitizer does genlock }
  150.  
  151. digiInDoesComposite = $100;            { digitizer supports composite input type }
  152. digiInDoesSVideo = $200;            { digitizer supports S-Video input type }
  153. digiInDoesComponent = $400;            { digitizer supports component (rgb) input type }
  154. digiInVTR_Broadcast = $800;            { digitizer can differentiate between the two }
  155.  
  156. digiInDoesColor = $1000;            { digitizer supports color }
  157. digiInDoesBW = $2000;                { digitizer supports black & white }
  158.  
  159.  
  160. { Digitizer Input Current Flags (these are valid only during active operating conditions) }
  161. digiInGenLocked = $40000000;        { digitizer signal is in genlock mode }
  162. digiInSignalLock = $80000000;        { digitizer detects input signal is locked - this bit = horiz lock || vertical lock }
  163.  
  164.  
  165. { Digitizer Output Capability/Current Flags }
  166. digiOutDoes1 = $1;                    { digitizer supports 1 bit pixels }
  167. digiOutDoes2 = $2;                    { digitizer supports 2 bit pixels }
  168. digiOutDoes4 = $4;                    { digitizer supports 4 bit pixels }
  169. digiOutDoes8 = $8;                    { digitizer supports 8 bit pixels }
  170. digiOutDoes16 = $10;                { digitizer supports 16 bit pixels }
  171. digiOutDoes32 = $20;                { digitizer supports 32 bit pixels }
  172. digiOutDoesDither = $40;            { digitizer dithers in indexed modes }
  173. digiOutDoesStretch = $80;            { digitizer can arbitrarily stretch }
  174. digiOutDoesShrink = $100;            { digitizer can arbitrarily shrink }
  175. digiOutDoesMask = $200;                { digitizer can mask to clipping regions }
  176.  
  177. digiOutDoesDouble = $800;            { digitizer can stretch to exactly double size }
  178. digiOutDoesQuad = $1000;            { digitizer can stretch exactly quadruple size }
  179. digiOutDoesQuarter = $2000;            { digitizer can shrink to exactly quarter size }
  180. digiOutDoesSixteenth = $4000;        { digitizer can shrink to exactly sixteenth size }
  181.  
  182. digiOutDoesRotate = $8000;            { digitizer supports rotate transformations }
  183. digiOutDoesHorizFlip = $10000;        { digitizer supports horizontal flips Sx < 0 }
  184. digiOutDoesVertFlip = $20000;        { digitizer supports vertical flips Sy < 0 }
  185. digiOutDoesSkew = $40000;            { digitizer supports skew (shear, twist) }
  186. digiOutDoesBlend = $80000;
  187. digiOutDoesWarp = $100000;
  188.  
  189. digiOutDoesHW_DMA = $200000;        { digitizer not constrained to local device }
  190. digiOutDoesHWPlayThru = $400000;    { digitizer doesn't need time to play thru }
  191. digiOutDoesILUT = $800000;            { digitizer does inverse LUT for index modes }
  192. digiOutDoesKeyColor = $1000000;        { digitizer does key color functions too }
  193. digiOutDoesAsyncGrabs = $2000000;    { digitizer supports async grabs }
  194.  
  195. TYPE
  196. VideoDigitizerThing = ComponentInstance;
  197. VideoDigitizerError = ComponentResult;
  198.  
  199. { Types }
  200. DigitizerInfo = RECORD
  201.  vdigType: INTEGER;
  202.  inputCapabilityFlags: LONGINT;
  203.  outputCapabilityFlags: LONGINT;
  204.  inputCurrentFlags: LONGINT;
  205.  outputCurrentFlags: LONGINT;
  206.  slot: INTEGER;                        { temporary for connection purposes }
  207.  gdh: GDHandle;                        { temporary for digitizers that have preferred screen }
  208.  maskgdh: GDHandle;                    { temporary for digitizers that have mask planes }
  209.  minDestHeight: INTEGER;            { Smallest resizable height }
  210.  minDestWidth: INTEGER;                { Smallest resizable width }
  211.  maxDestHeight: INTEGER;            { Largest resizable height }
  212.  maxDestWidth: INTEGER;                { Largest resizable height }
  213.  blendLevels: INTEGER;                { Number of blend levels supported (2 if 1 bit mask) }
  214.  Private: LONGINT;                    { reserved }
  215.  END;
  216.  
  217. VdigType = RECORD
  218.  digType: LONGINT;
  219.  Private: LONGINT;
  220.  END;
  221.  
  222. VdigTypeListPtr = ^VdigTypeList;
  223. VdigTypeListHandle = ^VdigTypeListPtr;
  224. VdigTypeList = RECORD
  225.  count: INTEGER;
  226.  list: ARRAY [0..0] OF VdigType;
  227.  END;
  228.  
  229. VdigBufferRec = RECORD
  230.     dest: PixMapHandle;
  231.     location: Point;
  232.     reserved: LONGINT;
  233.     END;
  234.  
  235. VdigBufferRecListPtr = ^VdigBufferRecList;
  236. VdigBufferRecListHandle = ^VdigBufferRecListPtr;
  237. VdigBufferRecList = RECORD
  238.     count: INTEGER;
  239.     matrix: MatrixRecordPtr ;
  240.     mask: RgnHandle;
  241.     list: ARRAY [0..0] OF VdigBufferRec;
  242.     END;
  243.  
  244.  
  245. CONST
  246.  
  247. { Video Digitizer Interface }
  248. kSelectVDGetMaxSrcRect = 1;
  249. kSelectVDGetActiveSrcRect = 2;
  250. kSelectVDSetDigitizerRect = 3;
  251. kSelectVDGetDigitizerRect = 4;
  252. kSelectVDGetVBlankRect = 5;
  253. kSelectVDGetMaskPixMap = 6;
  254. kSelectVDDone = 7;
  255. kSelectVDGetPlayThruDestination = 8;
  256. kSelectVDUseThisCLUT = 9;
  257. kSelectVDSetInputGammaValue = 10;
  258. kSelectVDGetInputGammaValue = 11;
  259. kSelectVDSetBrightness = 12;
  260. kSelectVDGetBrightness = 13;
  261. kSelectVDSetContrast = 14;
  262. kSelectVDSetHue = 15;
  263. kSelectVDSetSharpness = 16;
  264. kSelectVDSetSaturation = 17;
  265. kSelectVDGetContrast = 18;
  266. kSelectVDGetHue = 19;
  267. kSelectVDGetSharpness = 20;
  268. kSelectVDGetSaturation = 21;
  269. kSelectVDGrabOneFrame = 22;
  270. kSelectVDGetMaxAuxBuffer = 23;
  271. kSelectVDGrabOneFrameAsync = 24;
  272. kSelectVDGetDigitizerInfo = 25;
  273. kSelectVDGetCurrentFlags = 26;
  274. kSelectVDSetKeyColor = 27;
  275. kSelectVDGetKeyColor = 28;
  276. kSelectVDAddKeyColor = 29;
  277. kSelectVDGetNextKeyColor = 30;
  278. kSelectVDSetKeyColorRange = 31;
  279. kSelectVDGetKeyColorRange = 32;
  280. kSelectVDSetDigitizerUserInterrupt = 33;
  281. kSelectVDSetInputColorSpaceMode = 34;
  282. kSelectVDGetInputColorSpaceMode = 35;
  283. kSelectVDSetClipState = 36;
  284. kSelectVDGetClipState = 37;
  285. kSelectVDSetClipRgn = 38;
  286. kSelectVDClearClipRgn = 39;
  287. kSelectVDGetCLUTInUse = 40;
  288. kSelectVDSetPLLFilterType = 41;
  289. kSelectVDGetPLLFilterType = 42;
  290. kSelectVDGetMaskandValue = 43;
  291. kSelectVDSetMasterBlendLevel = 44;
  292. kSelectVDSetPlayThruDestination = 45;
  293. kSelectVDSetPlayThruOnOff = 46;
  294. kSelectVDGetAltDataTypes = 47;
  295. kSelectVDSetAltDataDestination = 48;
  296. kSelectVDSetAltDataOnOff = 49;
  297. kSelectVDPreflightDestination = 50;
  298. kSelectVDPreflightGlobalRect = 51;
  299. kSelectVDSetPlayThruGlobalRect = 52;
  300. kSelectVDSetInputGammaRecord = 53;
  301. kSelectVDGetInputGammaRecord = 54;
  302. kSelectVDSetBlackLevelValue = 55;
  303. kSelectVDGetBlackLevelValue = 56;
  304. kSelectVDSetWhiteLevelValue = 57;
  305. kSelectVDGetWhiteLevelValue = 58;
  306. kSelectVDGetVideoDefaults = 59;
  307. kSelectVDGetNumberOfInputs = 60;
  308. kSelectVDGetInputFormat = 61;
  309. kSelectVDSetInput = 62;
  310. kSelectVDGetInput = 63;
  311. kSelectVDSetInputStandard = 64;
  312. kSelectVDSetupBuffers = 65;
  313. kSelectVDGrabOneFrameAsync2 = 66;
  314. kSelectVDDone2 = 67;
  315.  
  316. kvdigSelectors = 67;
  317.  
  318. FUNCTION VDGetMaxSrcRect(ti: VideoDigitizerThing;inputStd: INTEGER;VAR maxSrcRect: Rect): VideoDigitizerError;
  319.  INLINE $2F3C,$6,$1,$7000,$A82A;
  320. FUNCTION VDGetActiveSrcRect(ti: VideoDigitizerThing;inputStd: INTEGER;VAR activeSrcRect: Rect): VideoDigitizerError;
  321.  INLINE $2F3C,$6,$2,$7000,$A82A;
  322. FUNCTION VDSetDigitizerRect(ti: VideoDigitizerThing;VAR digitizerRect: Rect): VideoDigitizerError;
  323.  INLINE $2F3C,$4,$3,$7000,$A82A;
  324. FUNCTION VDGetDigitizerRect(ti: VideoDigitizerThing;VAR digitizerRect: Rect): VideoDigitizerError;
  325.  INLINE $2F3C,$4,$4,$7000,$A82A;
  326. FUNCTION VDGetVBlankRect(ti: VideoDigitizerThing;inputStd: INTEGER;VAR vBlankRect: Rect): VideoDigitizerError;
  327.  INLINE $2F3C,$6,$5,$7000,$A82A;
  328. FUNCTION VDGetMaskPixMap(ti: VideoDigitizerThing;maskPixMap: PixMapHandle): VideoDigitizerError;
  329.  INLINE $2F3C,$4,$6,$7000,$A82A;
  330. FUNCTION VDGetPlayThruDestination(ti: VideoDigitizerThing;VAR dest: PixMapHandle;
  331.  VAR destRect: Rect;VAR m: MatrixRecord;VAR mask: RgnHandle): VideoDigitizerError;
  332.  INLINE $2F3C,$10,$8,$7000,$A82A;
  333. FUNCTION VDUseThisCLUT(ti: VideoDigitizerThing;colorTableHandle: CTabHandle): VideoDigitizerError;
  334.  INLINE $2F3C,$4,$9,$7000,$A82A;
  335. FUNCTION VDSetInputGammaValue(ti: VideoDigitizerThing;channel1: Fixed;channel2: Fixed;
  336.  channel3: Fixed): VideoDigitizerError;
  337.  INLINE $2F3C,$C,$A,$7000,$A82A;
  338. FUNCTION VDGetInputGammaValue(ti: VideoDigitizerThing;VAR channel1: Fixed;
  339.  VAR channel2: Fixed;VAR channel3: Fixed): VideoDigitizerError;
  340.  INLINE $2F3C,$C,$B,$7000,$A82A;
  341. FUNCTION VDSetBrightness(ti: VideoDigitizerThing;VAR brightness: INTEGER): VideoDigitizerError;
  342.  INLINE $2F3C,$4,$C,$7000,$A82A;
  343. FUNCTION VDGetBrightness(ti: VideoDigitizerThing;VAR brightness: INTEGER): VideoDigitizerError;
  344.  INLINE $2F3C,$4,$D,$7000,$A82A;
  345. FUNCTION VDSetContrast(ti: VideoDigitizerThing;VAR contrast: INTEGER): VideoDigitizerError;
  346.  INLINE $2F3C,$4,$E,$7000,$A82A;
  347. FUNCTION VDSetHue(ti: VideoDigitizerThing;VAR hue: INTEGER): VideoDigitizerError;
  348.  INLINE $2F3C,$4,$F,$7000,$A82A;
  349. FUNCTION VDSetSharpness(ti: VideoDigitizerThing;VAR sharpness: INTEGER): VideoDigitizerError;
  350.  INLINE $2F3C,$4,$10,$7000,$A82A;
  351. FUNCTION VDSetSaturation(ti: VideoDigitizerThing;VAR saturation: INTEGER): VideoDigitizerError;
  352.  INLINE $2F3C,$4,$11,$7000,$A82A;
  353. FUNCTION VDGetContrast(ti: VideoDigitizerThing;VAR contrast: INTEGER): VideoDigitizerError;
  354.  INLINE $2F3C,$4,$12,$7000,$A82A;
  355. FUNCTION VDGetHue(ti: VideoDigitizerThing;VAR hue: INTEGER): VideoDigitizerError;
  356.  INLINE $2F3C,$4,$13,$7000,$A82A;
  357. FUNCTION VDGetSharpness(ti: VideoDigitizerThing;VAR sharpness: INTEGER): VideoDigitizerError;
  358.  INLINE $2F3C,$4,$14,$7000,$A82A;
  359. FUNCTION VDGetSaturation(ti: VideoDigitizerThing;VAR saturation: INTEGER): VideoDigitizerError;
  360.  INLINE $2F3C,$4,$15,$7000,$A82A;
  361. FUNCTION VDGrabOneFrame(ti: VideoDigitizerThing): VideoDigitizerError;
  362.  INLINE $2F3C,$0,$16,$7000,$A82A;
  363. FUNCTION VDGetMaxAuxBuffer(ti: VideoDigitizerThing;VAR pm: PixMapHandle;
  364.  VAR r: Rect): VideoDigitizerError;
  365.  INLINE $2F3C,$8,$17,$7000,$A82A;
  366. FUNCTION VDGetDigitizerInfo(ti: VideoDigitizerThing;VAR info: DigitizerInfo): VideoDigitizerError;
  367.  INLINE $2F3C,$4,$19,$7000,$A82A;
  368. FUNCTION VDGetCurrentFlags(ti: VideoDigitizerThing;VAR inputCurrentFlag: LONGINT;
  369.  VAR outputCurrentFlag: LONGINT): VideoDigitizerError;
  370.  INLINE $2F3C,$8,$1A,$7000,$A82A;
  371. FUNCTION VDSetKeyColor(ti: VideoDigitizerThing;index: LONGINT): VideoDigitizerError;
  372.  INLINE $2F3C,$4,$1B,$7000,$A82A;
  373. FUNCTION VDGetKeyColor(ti: VideoDigitizerThing;VAR index: LONGINT): VideoDigitizerError;
  374.  INLINE $2F3C,$4,$1C,$7000,$A82A;
  375. FUNCTION VDAddKeyColor(ti: VideoDigitizerThing;VAR index: LONGINT): VideoDigitizerError;
  376.  INLINE $2F3C,$4,$1D,$7000,$A82A;
  377. FUNCTION VDGetNextKeyColor(ti: VideoDigitizerThing;index: LONGINT): VideoDigitizerError;
  378.  INLINE $2F3C,$4,$1E,$7000,$A82A;
  379. FUNCTION VDSetKeyColorRange(ti: VideoDigitizerThing;VAR minRGB: RGBColor;
  380.  VAR maxRGB: RGBColor): VideoDigitizerError;
  381.  INLINE $2F3C,$8,$1F,$7000,$A82A;
  382. FUNCTION VDGetKeyColorRange(ti: VideoDigitizerThing;VAR minRGB: RGBColor;
  383.  VAR maxRGB: RGBColor): VideoDigitizerError;
  384.  INLINE $2F3C,$8,$20,$7000,$A82A;
  385. FUNCTION VDSetDigitizerUserInterrupt(ti: VideoDigitizerThing;whichOne: INTEGER;
  386.  userInterruptProc: ProcPtr;params: Ptr): VideoDigitizerError;
  387.  INLINE $2F3C,$A,$21,$7000,$A82A;
  388. FUNCTION VDSetInputColorSpaceMode(ti: VideoDigitizerThing;colorSpaceMode: INTEGER): VideoDigitizerError;
  389.  INLINE $2F3C,$2,$22,$7000,$A82A;
  390. FUNCTION VDGetInputColorSpaceMode(ti: VideoDigitizerThing;VAR colorSpaceMode: INTEGER): VideoDigitizerError;
  391.  INLINE $2F3C,$4,$23,$7000,$A82A;
  392. FUNCTION VDSetClipState(ti: VideoDigitizerThing;clipEnable: INTEGER): VideoDigitizerError;
  393.  INLINE $2F3C,$2,$24,$7000,$A82A;
  394. FUNCTION VDGetClipState(ti: VideoDigitizerThing;VAR clipEnable: INTEGER): VideoDigitizerError;
  395.  INLINE $2F3C,$4,$25,$7000,$A82A;
  396. FUNCTION VDSetClipRgn(ti: VideoDigitizerThing;clipRegion: RgnHandle): VideoDigitizerError;
  397.  INLINE $2F3C,$4,$26,$7000,$A82A;
  398. FUNCTION VDClearClipRgn(ti: VideoDigitizerThing;clipRegion: RgnHandle): VideoDigitizerError;
  399.  INLINE $2F3C,$4,$27,$7000,$A82A;
  400. FUNCTION VDGetCLUTInUse(ti: VideoDigitizerThing;VAR colorTableHandle: CTabHandle): VideoDigitizerError;
  401.  INLINE $2F3C,$4,$28,$7000,$A82A;
  402. FUNCTION VDSetPLLFilterType(ti: VideoDigitizerThing;pllType: INTEGER): VideoDigitizerError;
  403.  INLINE $2F3C,$2,$29,$7000,$A82A;
  404. FUNCTION VDGetPLLFilterType(ti: VideoDigitizerThing;VAR pllType: INTEGER): VideoDigitizerError;
  405.  INLINE $2F3C,$4,$2A,$7000,$A82A;
  406. FUNCTION VDGetMaskandValue(ti: VideoDigitizerThing;blendLevel: INTEGER;
  407.  VAR mask: LONGINT;VAR value: LONGINT): VideoDigitizerError;
  408.  INLINE $2F3C,$A,$2B,$7000,$A82A;
  409. FUNCTION VDSetMasterBlendLevel(ti: VideoDigitizerThing;VAR blendLevel: INTEGER): VideoDigitizerError;
  410.  INLINE $2F3C,$4,$2C,$7000,$A82A;
  411. FUNCTION VDSetPlayThruDestination(ti: VideoDigitizerThing;dest: PixMapHandle;
  412.  VAR destRect: Rect;VAR m: MatrixRecord;mask: RgnHandle): VideoDigitizerError;
  413.  INLINE $2F3C,$10,$2D,$7000,$A82A;
  414. FUNCTION VDSetPlayThruOnOff(ti: VideoDigitizerThing;state: INTEGER): VideoDigitizerError;
  415.  INLINE $2F3C,$2,$2E,$7000,$A82A;
  416. FUNCTION VDGetAltDataTypes(ti: VideoDigitizerThing;list: VdigTypeListHandle): VideoDigitizerError;
  417.  INLINE $2F3C,$4,$2F,$7000,$A82A;
  418. FUNCTION VDSetAltDataDestination(ti: VideoDigitizerThing;dstType: LONGINT;
  419.  startAddr: Ptr;rowBytes: INTEGER;PixelSize: INTEGER;bufferSize: LONGINT;
  420.  VAR destRect: Rect;VAR m: MatrixRecord;frameDonePtr: ProcPtr): VideoDigitizerError;
  421.  INLINE $2F3C,$1C,$30,$7000,$A82A;
  422. FUNCTION VDSetAltDataOnOff(ti: VideoDigitizerThing;state: INTEGER): VideoDigitizerError;
  423.  INLINE $2F3C,$2,$31,$7000,$A82A;
  424. FUNCTION VDPreflightDestination(ti: VideoDigitizerThing;VAR digitizerRect: Rect;
  425.  dest: PixMapHandle;VAR destRect: Rect;VAR m: MatrixRecord): VideoDigitizerError;
  426.  INLINE $2F3C,$10,$32,$7000,$A82A;
  427. FUNCTION VDPreflightGlobalRect(ti: VideoDigitizerThing;theWindow: GrafPtr;
  428.  VAR globalRect: Rect): VideoDigitizerError;
  429.  INLINE $2F3C,$8,$33,$7000,$A82A;
  430. FUNCTION VDSetPlayThruGlobalRect(ti: VideoDigitizerThing;theWindow: GrafPtr;
  431.  VAR globalRect: Rect): VideoDigitizerError;
  432.  INLINE $2F3C,$8,$34,$7000,$A82A;
  433. FUNCTION VDSetInputGammaRecord(ti: VideoDigitizerThing;inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
  434.  INLINE $2F3C,$4,$35,$7000,$A82A;
  435. FUNCTION VDGetInputGammaRecord(ti: VideoDigitizerThing;VAR inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
  436.  INLINE $2F3C,$4,$36,$7000,$A82A;
  437. FUNCTION VDSetBlackLevelValue(ti: VideoDigitizerThing;VAR blackLevel: INTEGER): VideoDigitizerError;
  438.  INLINE $2F3C,$4,$37,$7000,$A82A;
  439. FUNCTION VDGetBlackLevelValue(ti: VideoDigitizerThing;VAR blackLevel: INTEGER): VideoDigitizerError;
  440.  INLINE $2F3C,$4,$38,$7000,$A82A;
  441. FUNCTION VDSetWhiteLevelValue(ti: VideoDigitizerThing;VAR whiteLevel: INTEGER): VideoDigitizerError;
  442.  INLINE $2F3C,$4,$39,$7000,$A82A;
  443. FUNCTION VDGetWhiteLevelValue(ti: VideoDigitizerThing;VAR whiteLevel: INTEGER): VideoDigitizerError;
  444.  INLINE $2F3C,$4,$3A,$7000,$A82A;
  445. FUNCTION VDGetVideoDefaults(ti: VideoDigitizerThing;VAR blackLevel: INTEGER;
  446.  VAR whiteLevel: INTEGER;VAR brightness: INTEGER;VAR hue: INTEGER;VAR saturation: INTEGER;
  447.  VAR contrast: INTEGER;VAR sharpness: INTEGER): VideoDigitizerError;
  448.  INLINE $2F3C,$1C,$3B,$7000,$A82A;
  449. FUNCTION VDGrabOneFrameAsync(ti: VideoDigitizerThing;bufferingOn: BOOLEAN;
  450.  nextDest: PixMapHandle;nextPt: Point): VideoDigitizerError;
  451.  INLINE $2F3C,$A,$18,$7000,$A82A;
  452. FUNCTION VDDone(ti: VideoDigitizerThing): LONGINT;
  453.  INLINE $2F3C,$0,$7,$7000,$A82A;
  454. FUNCTION VDGetNumberOfInputs(ti: VideoDigitizerThing;VAR inputs: INTEGER): VideoDigitizerError;
  455.  INLINE $2F3C,$4,$3C,$7000,$A82A;
  456. FUNCTION VDGetInputFormat(ti: VideoDigitizerThing;input: INTEGER;VAR format: INTEGER): VideoDigitizerError;
  457.  INLINE $2F3C,$6,$3D,$7000,$A82A;
  458. FUNCTION VDSetInput(ti: VideoDigitizerThing;input: INTEGER): VideoDigitizerError;
  459.  INLINE $2F3C,$2,$3E,$7000,$A82A;
  460. FUNCTION VDGetInput(ti: VideoDigitizerThing;VAR input: INTEGER): VideoDigitizerError;
  461.  INLINE $2F3C,$4,$3F,$7000,$A82A;
  462. FUNCTION VDSetInputStandard(ti: VideoDigitizerThing;inputStandard: INTEGER): VideoDigitizerError;
  463.  INLINE $2F3C,$2,$40,$7000,$A82A;
  464. FUNCTION     VDSetupBuffers(ti: VideoDigitizerThing; bufferList: VdigBufferRecListHandle ) : VideoDigitizerError;
  465.  INLINE $2F3C,$4,$41,$7000,$A82A;
  466. FUNCTION     VDGrabOneFrameAsync2(ti: VideoDigitizerThing; buffer : INTEGER) : VideoDigitizerError;
  467.  INLINE $2F3C,$2,$42,$7000,$A82A;
  468. FUNCTION     VDDone2(ti: VideoDigitizerThing; buffer : INTEGER) : LONGINT;
  469.  INLINE $2F3C,$2,$43,$7000,$A82A;
  470.  
  471. TYPE
  472. { Sequence Grab Component }
  473. SeqGrabComponent = ComponentInstance;
  474. SGChannel = ComponentInstance;
  475.  
  476. CONST
  477. SeqGrabComponentType = 'barg';
  478. SeqGrabChannelType = 'sgch';
  479. grabPictOffScreen = 1;
  480. sgFlagControlledGrab = 1;
  481.  
  482. channelPlayNormal = 0;
  483. channelPlayFast = 1;
  484. channelPlayHighQuality = 2;
  485. channelPlayAllData = 4;
  486.  
  487. seqGrabToDisk = 1;
  488. seqGrabToMemory = 2;
  489. seqGrabUseTempMemory = 4;
  490. seqGrabAppendToFile = 8;
  491. seqGrabDontAddMovieResource = 16;
  492. seqGrabRecord = 1;
  493. seqGrabPreview = 2;
  494. seqGrabPlayDuringRecord = 4;
  495. seqGrabHasBounds = 1;
  496. seqGrabHasVolume = 2;
  497. seqGrabHasDiscreteSamples = 4;
  498.  
  499. noDeviceForChannel = -9400;
  500. grabTimeComplete = -9401;
  501. cantDoThatInCurrentMode = -9402;
  502. notEnoughMemoryToGrab = -9403;
  503. notEnoughDiskSpaceToGrab = -9404;
  504. couldntGetRequiredComponent = -9405;
  505. badSGChannel = -9406;
  506. seqGrabInfoNotAvailable = -9407;
  507. deviceCantMeetRequest = -9408;
  508.  
  509. TYPE
  510. SeqGrabFrameInfo = RECORD
  511.  frameOffset: LONGINT;
  512.  frameTime: LONGINT;
  513.  frameSize: LONGINT;
  514.  frameChannel: SGChannel;
  515.  frameRefCon: LONGINT;
  516.  END;
  517.  
  518.  
  519.  
  520. FUNCTION SGInitialize(s: SeqGrabComponent): ComponentResult;
  521.  INLINE $2F3C,$0,$1,$7000,$A82A;
  522.  
  523. FUNCTION SGSetDataOutput(s: SeqGrabComponent;VAR movieFile: FSSpec;whereFlags: LONGINT): ComponentResult;
  524.  INLINE $2F3C,$8,$2,$7000,$A82A;
  525. FUNCTION SGGetDataOutput(s: SeqGrabComponent;VAR movieFile: FSSpec;VAR whereFlags: LONGINT): ComponentResult;
  526.  INLINE $2F3C,$8,$3,$7000,$A82A;
  527.  
  528. FUNCTION SGSetGWorld(s: SeqGrabComponent;gp: CGrafPtr;gd: GDHandle): ComponentResult;
  529.  INLINE $2F3C,$8,$4,$7000,$A82A;
  530. FUNCTION SGGetGWorld(s: SeqGrabComponent;VAR gp: CGrafPtr;VAR gd: GDHandle): ComponentResult;
  531.  INLINE $2F3C,$8,$5,$7000,$A82A;
  532.  
  533. FUNCTION SGNewChannel(s: SeqGrabComponent;channelType: OSType;VAR ref: SGChannel): ComponentResult;
  534.  INLINE $2F3C,$8,$6,$7000,$A82A;
  535. FUNCTION SGDisposeChannel(s: SeqGrabComponent;c: SGChannel): ComponentResult;
  536.  INLINE $2F3C,$4,$7,$7000,$A82A;
  537.  
  538. FUNCTION SGStartPreview(s: SeqGrabComponent): ComponentResult;
  539.  INLINE $2F3C,$0,$10,$7000,$A82A;
  540. FUNCTION SGStartRecord(s: SeqGrabComponent): ComponentResult;
  541.  INLINE $2F3C,$0,$11,$7000,$A82A;
  542. FUNCTION SGIdle(s: SeqGrabComponent): ComponentResult;
  543.  INLINE $2F3C,$0,$12,$7000,$A82A;
  544. FUNCTION SGStop(s: SeqGrabComponent): ComponentResult;
  545.  INLINE $2F3C,$0,$13,$7000,$A82A;
  546.  
  547. FUNCTION SGPause(s: SeqGrabComponent;pause: BOOLEAN): ComponentResult;
  548.  INLINE $2F3C,$2,$14,$7000,$A82A;
  549.  
  550. FUNCTION SGPrepare(s: SeqGrabComponent;prepareForPreview: BOOLEAN;prepareForRecord: BOOLEAN): ComponentResult;
  551.  INLINE $2F3C,$4,$15,$7000,$A82A;
  552. FUNCTION SGRelease(s: SeqGrabComponent): ComponentResult;
  553.  INLINE $2F3C,$0,$16,$7000,$A82A;
  554.  
  555. FUNCTION SGGetMovie(s: SeqGrabComponent): Movie;
  556.  INLINE $2F3C,$0,$17,$7000,$A82A;
  557.  
  558. FUNCTION SGSetMaximumRecordTime(s: SeqGrabComponent;ticks: LONGINT): ComponentResult;
  559.  INLINE $2F3C,$4,$18,$7000,$A82A;
  560. FUNCTION SGGetMaximumRecordTime(s: SeqGrabComponent;VAR ticks: LONGINT): ComponentResult;
  561.  INLINE $2F3C,$4,$19,$7000,$A82A;
  562.  
  563. FUNCTION SGGetStorageSpaceRemaining(s: SeqGrabComponent;VAR bytes: LONGINT): ComponentResult;
  564.  INLINE $2F3C,$4,$1A,$7000,$A82A;
  565. FUNCTION SGGetTimeRemaining(s: SeqGrabComponent;VAR ticksLeft: LONGINT): ComponentResult;
  566.  INLINE $2F3C,$4,$1B,$7000,$A82A;
  567.  
  568.  
  569. FUNCTION SGGrabPict(s: SeqGrabComponent; VAR p: PicHandle; bounds: Rect;
  570.  offscreenDepth: INTEGER; grabPictFlags: LONGINT): ComponentResult;
  571.  INLINE $2F3C,$E,$1C,$7000,$A82A;
  572.  
  573. FUNCTION SGGetLastMovieResID(s: SeqGrabComponent; VAR resID: INTEGER): ComponentResult;
  574.  INLINE $2F3C,$4,$1D,$7000,$A82A;
  575.  
  576. FUNCTION SGSetFlags(s: SeqGrabComponent; sgFlags: LONGINT): ComponentResult;
  577.  INLINE $2F3C,$4,$1E,$7000,$A82A;
  578.  
  579. FUNCTION SGGetFlags(s: SeqGrabComponent; VAR sgFlags: LONGINT): ComponentResult;
  580.  INLINE $2F3C,$4,$1F,$7000,$A82A;
  581.  
  582. {   General Channel Routines   }
  583. FUNCTION SGSetChannelUsage(c: SGChannel;usage: LONGINT): ComponentResult;
  584.  INLINE $2F3C,$4,$80,$7000,$A82A;
  585. FUNCTION SGGetChannelUsage(c: SGChannel;VAR usage: LONGINT): ComponentResult;
  586.  INLINE $2F3C,$4,$81,$7000,$A82A;
  587.  
  588. FUNCTION SGSetChannelBounds(c: SGChannel;bounds: Rect): ComponentResult;
  589.  INLINE $2F3C,$4,$82,$7000,$A82A;
  590. FUNCTION SGGetChannelBounds(c: SGChannel;VAR bounds: Rect): ComponentResult;
  591.  INLINE $2F3C,$4,$83,$7000,$A82A;
  592.  
  593. FUNCTION SGSetChannelVolume(c: SGChannel;volume: INTEGER): ComponentResult;
  594.  INLINE $2F3C,$2,$84,$7000,$A82A;
  595. FUNCTION SGGetChannelVolume(c: SGChannel;VAR volume: INTEGER): ComponentResult;
  596.  INLINE $2F3C,$4,$85,$7000,$A82A;
  597.  
  598. FUNCTION SGGetChannelInfo(c: SGChannel;VAR channelInfo: LONGINT): ComponentResult;
  599.  INLINE $2F3C,$4,$86,$7000,$A82A;
  600.  
  601. FUNCTION SGSetChannelPlayFlags(c: SGChannel;playFlags: LONGINT): ComponentResult;
  602.  INLINE $2F3C,$4,$87,$7000,$A82A;
  603. FUNCTION SGGetChannelPlayFlags(c: SGChannel;VAR playFlags: LONGINT): ComponentResult;
  604.  INLINE $2F3C,$4,$88,$7000,$A82A;
  605.  
  606. FUNCTION SGSetChannelMaxFrames(c: SGChannel;frameCount: LONGINT): ComponentResult;
  607.  INLINE $2F3C,$4,$89,$7000,$A82A;
  608. FUNCTION SGGetChannelMaxFrames(c: SGChannel;VAR frameCount: LONGINT): ComponentResult;
  609.  INLINE $2F3C,$4,$8A,$7000,$A82A;
  610.  
  611. FUNCTION SGSetChannelRefCon(c: SGChannel;refCon: LONGINT): ComponentResult;
  612.  INLINE $2F3C,$4,$8B,$7000,$A82A;
  613.  
  614.  
  615. TYPE
  616. { Video Routines }
  617.  
  618. GrabProc = ComponentResult;
  619. GrabCompleteProc = ComponentResult;
  620. DisplayProc = ComponentResult;
  621. CompressProc = ComponentResult;
  622. CompressCompleteProc = ComponentResult;
  623. AddFrameProc = ComponentResult;
  624. TransferFrameProc = ComponentResult;
  625.  
  626. VideoBottles = RECORD
  627.  procCount: INTEGER;
  628.  grabProc: GrabProc;
  629.  grabCompleteProc: GrabCompleteProc;
  630.  displayProc: DisplayProc;
  631.  compressProc: CompressProc;
  632.  addFrameProc: AddFrameProc;
  633.  transferFrameProc: TransferFrameProc;
  634.  END;
  635.  
  636. SGCompressInfo = RECORD
  637.   buffer: Ptr;
  638.   bufferSize: LONGINT;
  639.   similarity: CHAR;
  640.   reserved: CHAR;
  641.  END;
  642.  
  643.  
  644.  
  645. FUNCTION SGGetSrcVideoBounds(c: SGChannel;VAR r: Rect): ComponentResult;
  646.  INLINE $2F3C,$4,$100,$7000,$A82A;
  647. FUNCTION SGSetVideoRect(c: SGChannel;VAR r: Rect): ComponentResult;
  648.  INLINE $2F3C,$4,$101,$7000,$A82A;
  649. FUNCTION SGGetVideoRect(c: SGChannel;VAR r: Rect): ComponentResult;
  650.  INLINE $2F3C,$4,$102,$7000,$A82A;
  651.  
  652. FUNCTION SGGetVideoCompressorType(c: SGChannel;VAR compressorType: OSType): ComponentResult;
  653.  INLINE $2F3C,$4,$103,$7000,$A82A;
  654. FUNCTION SGSetVideoCompressorType(c: SGChannel;compressorType: OSType): ComponentResult;
  655.  INLINE $2F3C,$4,$104,$7000,$A82A;
  656.  
  657. FUNCTION SGSetVideoCompressor(c: SGChannel;depth: INTEGER;compressor: CompressorComponent;
  658.  spatialQuality: CodecQ;temporalQuality: CodecQ;keyFrameRate: LONGINT): ComponentResult;
  659.  INLINE $2F3C,$12,$105,$7000,$A82A;
  660. FUNCTION SGGetVideoCompressor(c: SGChannel;VAR depth: INTEGER;VAR compressor: CompressorComponent;
  661.  VAR spatialQuality: CodecQ;VAR temporalQuality: CodecQ;VAR keyFrameRate: LONGINT): ComponentResult;
  662.  INLINE $2F3C,$14,$106,$7000,$A82A;
  663.  
  664. FUNCTION SGGetVideoDigitizerComponent(c: SGChannel): ComponentInstance;
  665.  INLINE $2F3C,$0,$107,$7000,$A82A;
  666. FUNCTION SGSetVideoDigitizerComponent(c: SGChannel;vdig: ComponentInstance): ComponentResult;
  667.  INLINE $2F3C,$4,$108,$7000,$A82A;
  668. FUNCTION SGVideoDigitizerChanged(c: SGChannel): ComponentResult;
  669.  INLINE $2F3C,$0,$109,$7000,$A82A;
  670.  
  671. FUNCTION SGSetVideoBottlenecks(c: SGChannel;VAR vb: VideoBottles): ComponentResult;
  672.  INLINE $2F3C,$4,$10A,$7000,$A82A;
  673. FUNCTION SGGetVideoBottlenecks(c: SGChannel;VAR vb: VideoBottles): ComponentResult;
  674.  INLINE $2F3C,$4,$10B,$7000,$A82A;
  675.  
  676. FUNCTION SGGrabFrame(c: SGChannel;bufferNum: INTEGER): ComponentResult;
  677.  INLINE $2F3C,$2,$10C,$7000,$A82A;
  678. FUNCTION SGGrabFrameComplete(c: SGChannel;bufferNum:INTEGER;VAR done:Boolean): ComponentResult;
  679.  INLINE $2F3C,$6,$10D,$7000,$A82A;
  680.  
  681. FUNCTION SGDisplayFrame(c: SGChannel;bufferNum: INTEGER;VAR mp: MatrixRecord;
  682.  clipRgn: RgnHandle): ComponentResult;
  683.  INLINE $2F3C,$A,$10E,$7000,$A82A;
  684. FUNCTION SGCompressFrame(c: SGChannel;bufferNum:INTEGER): ComponentResult;
  685.  INLINE $2F3C,$2,$10F,$7000,$A82A;
  686. FUNCTION SGCompressFrameComplete(c: SGChannel;bufferNum:INTEGER;VAR done:Boolean;
  687.  VAR ci:SGCompressInfo): ComponentResult;
  688.  INLINE $2F3C,$A,$110,$7000,$A82A;
  689. FUNCTION SGAddFrame(c: SGChannel;bufferNum:INTEGER;atTime: TimeValue;scale: TimeScale;
  690.  ci: SGCompressInfo): ComponentResult;
  691.  INLINE $2F3C,$E,$111,$7000,$A82A;
  692.  
  693. FUNCTION SGTransferFrameForCompress(c: SGChannel;bufferNum:INTEGER;mp: MatrixRecord;
  694.  clipRgn: RgnHandle): ComponentResult;
  695.  INLINE $2F3C,$A,$112,$7000,$A82A;
  696.  
  697. FUNCTION SGSetCompressBuffer(c: SGChannel;depth: INTEGER;compressSize: Rect): ComponentResult;
  698.  INLINE $2F3C,$6,$113,$7000,$A82A;
  699.  
  700. FUNCTION SGGetCompressBuffer(c: SGChannel;VAR depth: INTEGER; VAR compressSize: Rect): ComponentResult;
  701.  INLINE $2F3C,$8,$114,$7000,$A82A;
  702.  
  703. FUNCTION SGGetBufferInfo(c: SGChannel;bufferNum: INTEGER; VAR bufferPM: PixMapHandle;
  704.  VAR bufferRect: Rect;VAR compressBuffer: GWorldPtr;
  705.  VAR compressBufferRect: Rect): ComponentResult;
  706.  INLINE $2F3C,$12,$115,$7000,$A82A;
  707.  
  708.  
  709. {   Sound Routines   }
  710. FUNCTION SGSetSoundInputDriver(c: SGChannel;driverName: Str255): ComponentResult;
  711.  INLINE $2F3C,$4,$100,$7000,$A82A;
  712. FUNCTION SGGetSoundInputDriver(c: SGChannel): LONGINT;
  713.  INLINE $2F3C,$0,$101,$7000,$A82A;
  714. FUNCTION SGSoundInputDriverChanged(c: SGChannel): ComponentResult;
  715.  INLINE $2F3C,$0,$102,$7000,$A82A;
  716.  
  717. FUNCTION SGSetSoundRecordChunkSize(c: SGChannel;seconds: LONGINT): ComponentResult;
  718.  INLINE $2F3C,$4,$103,$7000,$A82A;
  719. FUNCTION SGGetSoundRecordChunkSize(c: SGChannel): LONGINT;
  720.  INLINE $2F3C,$0,$104,$7000,$A82A;
  721.  
  722. FUNCTION SGSetSoundInputRate(c: SGChannel;rate: Fixed): ComponentResult;
  723.  INLINE $2F3C,$4,$105,$7000,$A82A;
  724. FUNCTION SGGetSoundInputRate(c: SGChannel): Fixed;
  725.  INLINE $2F3C,$0,$106,$7000,$A82A;
  726.  
  727.  
  728. {   calls from seqGrab to Channel   }
  729. FUNCTION SGInitChannel(c: SGChannel;owner: SeqGrabComponent): ComponentResult;
  730.  INLINE $2F3C,$4,$C8,$7000,$A82A;
  731. FUNCTION SGWriteSamples(c: SGChannel;m: Movie;theFile: AliasHandle): ComponentResult;
  732.  INLINE $2F3C,$8,$C9,$7000,$A82A;
  733. FUNCTION SGGetDataRate(c: SGChannel;VAR bytesPerSecond: LONGINT): ComponentResult;
  734.  INLINE $2F3C,$4,$CA,$7000,$A82A;
  735.  
  736.  
  737. {   calls from Channel to seqGrab   }
  738. FUNCTION SGWriteMovieData(s: SeqGrabComponent;c: SGChannel;p: Ptr;len: LONGINT;
  739.  VAR offset: LONGINT): ComponentResult;
  740.  INLINE $2F3C,$10,$80,$7000,$A82A;
  741. FUNCTION SGAddFrameReference(s: SeqGrabComponent;VAR frameInfo: SeqGrabFrameInfo): ComponentResult;
  742.  INLINE $2F3C,$4,$81,$7000,$A82A;
  743. FUNCTION SGGetNextFrameReference(s: SeqGrabComponent;VAR frameInfo: SeqGrabFrameInfo;
  744.  VAR frameDuration: TimeValue;VAR frameNumber: LONGINT): ComponentResult;
  745.  INLINE $2F3C,$C,$82,$7000,$A82A;
  746. FUNCTION SGGetTimeBase(s: SeqGrabComponent;VAR tb: TimeBase): ComponentResult;
  747.  INLINE $2F3C,$4,$83,$7000,$A82A;
  748.  
  749.  
  750. {****
  751.  
  752.  Clock Component
  753.  
  754. ****}
  755.  
  756. CONST
  757.  
  758. PreviewComponentType = 'prvt';
  759. { The subtypes of the preview components provided by Apple }
  760. FileInfoPrevCompSubType = 'finf';
  761. PICTPrevCompSubType = 'PICT';
  762. MoviePrevCompSubType = 'MooV';
  763.  
  764. prevComponentCreatePreviewRefNum = 2;
  765. prevComponentGetPreviewData = 3;
  766. prevComponentAddPreviewRefNum = 5;
  767. prevComponentStartPreviewing = 11;
  768. prevComponentDoDraw = 12;
  769. prevComponentTimeSlice = 13;
  770. prevComponentDoMouseDown = 14;
  771. prevComponentLastCall = 15;
  772.  
  773. prevComponentCantPreviewThisFile = -9999;
  774. prevComponentCouldGeneratePreviewForThisFile = -9998;
  775. prevComponentDontNeedTimeSlice = -9993;
  776.  
  777. TYPE
  778. Previewer = ComponentInstance;
  779. ResourceDesc = RECORD
  780.   resourceType: ResType;
  781.   resourceId: INTEGER;
  782.  END;
  783.  
  784. ThumbnailList = RECORD
  785.   date: LONGINT;
  786.   version: INTEGER;
  787.   prevComponentType: ResType;
  788.   fileTypeDesc: Str31;
  789.   fileTypeDescScript: INTEGER;
  790.   count: INTEGER;
  791.   resources: ARRAY [0..0] OF ResourceDesc;
  792.  END;
  793. ThumbnailListPtr = ^ThumbnailList;
  794. ThumbnailListHandle = ^ThumbnailListPtr;
  795.  
  796. Str31WithScript = RECORD
  797.   theString: Str31;
  798.   scriptCode: INTEGER;
  799.  END;
  800. Str31WithScriptPtr = ^Str31WithScript;
  801. Str31WithScriptHandle = ^Str31WithScriptPtr;
  802.  
  803. PreviewStatusRec = RECORD
  804.   fileInfo: StandardFileReply;
  805.   fileSize: LONGINT;
  806.   resRefNum: INTEGER;
  807.   PRVLHandle: ThumbnailListHandle;
  808.  END;
  809. PreviewStatusPtr = ^PreviewStatusRec;
  810. PreviewStatusHandle = ^PreviewStatusPtr;
  811.  
  812. FUNCTION PreviewCreatePreviewForResRefNum(p: Previewer; resRefNum: INTEGER;
  813.  theFile: FSSpecPtr; removieOldPreviews: Boolean; fileTypeDescription: Str31WithScriptPtr;
  814.  progressProc: ProgressProcRecordPtr): ComponentResult;
  815.  INLINE $2F3C,$10,$2,$7000,$A82A;
  816.  
  817. FUNCTION PreviewerGetPreviewData(p: Previewer; theFile: FSSpecPtr; 
  818.  previewData, auxData: Handle; progressProc: ProgressProcRecordPtr): ComponentResult;
  819.  INLINE $2F3C,$10,$3,$7000,$A82A;
  820.  
  821. FUNCTION PreviewerAddPreviewDataRefNum(p: Previewer; resRefNum: INTEGER;
  822.  theFile: FSSpecPtr; removieOldPreviews: Boolean; fileTypeDescription: Str31WithScriptPtr;
  823.  previewData, auxData: Handle): ComponentResult;
  824.  INLINE $2F3C,$14,$5,$7000,$A82A;
  825.  
  826. FUNCTION PreviewerStartPreviewing(p: Previewer; status: PreviewStatusPtr; window: WindowPtr;
  827.  VAR boundsRect: Rect; VAR NeedInitialUpdate: Boolean): ComponentResult;
  828.  INLINE $2F3C,$10,$B,$7000,$A82A;
  829.  
  830. FUNCTION PreviewerDoDraw(p: Previewer; status: PreviewStatusPtr): ComponentResult;
  831.  INLINE $2F3C,$4,$C,$7000,$A82A;
  832.  
  833. FUNCTION PreviewerTimeSlice(p: Previewer; status: PreviewStatusPtr): ComponentResult;
  834.  INLINE $2F3C,$4,$D,$7000,$A82A;
  835.  
  836. FUNCTION PreviewerLastCall(p: Previewer; status: PreviewStatusPtr): ComponentResult;
  837.  INLINE $2F3C,$4,$F,$7000,$A82A;
  838.  
  839.  
  840. {$ENDC} { UsingQuickTimeComponents }
  841.  
  842. {$IFC NOT UsingIncludes}
  843.  END.
  844. {$ENDC}
  845.  
  846.