home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / QuickTime / Programming Stuff / QuickTime 2.1 for Developers / Interfaces / PInterfaces / ImageCompression.p < prev    next >
Encoding:
Text File  |  1995-08-07  |  36.4 KB  |  941 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        ImageCompression.p
  3.  
  4.      Contains:    QuickTime interfaces
  5.  
  6.      Version:    
  7.  
  8.      DRI:        Jim Batson
  9.  
  10.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Warning:    *** APPLE INTERNAL USE ONLY ***
  14.                  This file may contain unreleased API's
  15.  
  16.      BuildInfo:    Built by:            QuickTime
  17.                  With Interfacer:    1.1d11  
  18.                  From:                ImageCompression.i
  19.                      Revision:        0
  20.                      Dated:            08/07/95
  21.                      Last change by:    JB
  22.                      Last comment:    This is a fake header used so interfacer is happy.
  23.  
  24.      Bugs:        Report bugs to Radar component “System Interfaces”, “Latest”
  25.                  List the version information (from above) in the Problem Description.
  26.  
  27. }
  28.  
  29. {$IFC UNDEFINED UsingIncludes}
  30. {$SETC UsingIncludes := 0}
  31. {$ENDC}
  32.  
  33. {$IFC NOT UsingIncludes}
  34.  UNIT ImageCompression;
  35.  INTERFACE
  36. {$ENDC}
  37.  
  38. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  39. {$SETC __IMAGECOMPRESSION__ := 1}
  40.  
  41. {$I+}
  42. {$SETC ImageCompressionIncludes := UsingIncludes}
  43. {$SETC UsingIncludes := 1}
  44.  
  45.  
  46. {$IFC UNDEFINED __TYPES__}
  47. {$I Types.p}
  48. {$ENDC}
  49. {    ConditionalMacros.p                                            }
  50.  
  51. {$IFC UNDEFINED __QUICKDRAW__}
  52. {$I Quickdraw.p}
  53. {$ENDC}
  54. {    MixedMode.p                                                    }
  55. {    QuickdrawText.p                                                }
  56.  
  57. {$IFC UNDEFINED __QDOFFSCREEN__}
  58. {$I QDOffscreen.p}
  59. {$ENDC}
  60. {    Errors.p                                                    }
  61.  
  62. {$IFC UNDEFINED __COMPONENTS__}
  63. {$I Components.p}
  64. {$ENDC}
  65.  
  66. {$IFC UNDEFINED __WINDOWS__}
  67. {$I Windows.p}
  68. {$ENDC}
  69. {    Memory.p                                                    }
  70. {    Events.p                                                    }
  71. {        OSUtils.p                                                }
  72. {    Controls.p                                                    }
  73. {        Menus.p                                                    }
  74.  
  75. {$IFC UNDEFINED __STANDARDFILE__}
  76. {$I StandardFile.p}
  77. {$ENDC}
  78. {    Dialogs.p                                                    }
  79. {        TextEdit.p                                                }
  80. {    Files.p                                                        }
  81.  
  82. {$PUSH}
  83. {$ALIGN MAC68K}
  84. {$LibExport+}
  85.  
  86. TYPE
  87.     MatrixRecord = RECORD
  88.         matrix:                    ARRAY [0..2,0..2] OF Fixed;
  89.     END;
  90.  
  91.     MatrixRecordPtr = ^MatrixRecord;
  92.  
  93.     FixedPoint = RECORD
  94.         x:                        Fixed;
  95.         y:                        Fixed;
  96.     END;
  97.  
  98.     FixedRect = RECORD
  99.         left:                    Fixed;
  100.         top:                    Fixed;
  101.         right:                    Fixed;
  102.         bottom:                    Fixed;
  103.     END;
  104.  
  105. { These are the bits that are set in the Component flags, and also in the codecInfo struct. }
  106.  
  107. CONST
  108.     codecInfoDoes1                = 0+(1 * (2**(0)));
  109.     codecInfoDoes2                = 0+(1 * (2**(1)));
  110.     codecInfoDoes4                = 0+(1 * (2**(2)));
  111.     codecInfoDoes8                = 0+(1 * (2**(3)));
  112.     codecInfoDoes16                = 0+(1 * (2**(4)));
  113.     codecInfoDoes32                = 0+(1 * (2**(5)));
  114.     codecInfoDoesDither            = 0+(1 * (2**(6)));
  115.     codecInfoDoesStretch        = 0+(1 * (2**(7)));
  116.     codecInfoDoesShrink            = 0+(1 * (2**(8)));
  117.     codecInfoDoesMask            = 0+(1 * (2**(9)));
  118.     codecInfoDoesTemporal        = 0+(1 * (2**(10)));
  119.     codecInfoDoesDouble            = 0+(1 * (2**(11)));
  120.     codecInfoDoesQuad            = 0+(1 * (2**(12)));
  121.     codecInfoDoesHalf            = 0+(1 * (2**(13)));
  122.     codecInfoDoesQuarter        = 0+(1 * (2**(14)));
  123.     codecInfoDoesRotate            = 0+(1 * (2**(15)));
  124.     codecInfoDoesHorizFlip        = 0+(1 * (2**(16)));
  125.     codecInfoDoesVertFlip        = 0+(1 * (2**(17)));
  126.     codecInfoDoesSkew            = 0+(1 * (2**(18)));
  127.     codecInfoDoesBlend            = 0+(1 * (2**(19)));
  128.     codecInfoDoesWarp            = 0+(1 * (2**(20)));
  129.     codecInfoDoesRecompress        = 0+(1 * (2**(21)));
  130.     codecInfoDoesSpool            = 0+(1 * (2**(22)));
  131.     codecInfoDoesRateConstrain    = 0+(1 * (2**(23)));
  132.  
  133.     codecInfoDepth1                = 0+(1 * (2**(0)));
  134.     codecInfoDepth2                = 0+(1 * (2**(1)));
  135.     codecInfoDepth4                = 0+(1 * (2**(2)));
  136.     codecInfoDepth8                = 0+(1 * (2**(3)));
  137.     codecInfoDepth16            = 0+(1 * (2**(4)));
  138.     codecInfoDepth32            = 0+(1 * (2**(5)));
  139.     codecInfoDepth24            = 0+(1 * (2**(6)));
  140.     codecInfoDepth33            = 0+(1 * (2**(7)));
  141.     codecInfoDepth34            = 0+(1 * (2**(8)));
  142.     codecInfoDepth36            = 0+(1 * (2**(9)));
  143.     codecInfoDepth40            = 0+(1 * (2**(10)));
  144.     codecInfoStoresClut            = 0+(1 * (2**(11)));
  145.     codecInfoDoesLossless        = 0+(1 * (2**(12)));
  146.     codecInfoSequenceSensitive    = 0+(1 * (2**(13)));
  147.  
  148.     codecFlagUseImageBuffer        = 0+(1 * (2**(0)));
  149.     codecFlagUseScreenBuffer    = 0+(1 * (2**(1)));
  150.     codecFlagUpdatePrevious        = 0+(1 * (2**(2)));
  151.     codecFlagNoScreenUpdate        = 0+(1 * (2**(3)));
  152.     codecFlagWasCompressed        = 0+(1 * (2**(4)));
  153.     codecFlagDontOffscreen        = 0+(1 * (2**(5)));
  154.     codecFlagUpdatePreviousComp    = 0+(1 * (2**(6)));
  155.     codecFlagForceKeyFrame        = 0+(1 * (2**(7)));
  156.     codecFlagOnlyScreenUpdate    = 0+(1 * (2**(8)));
  157.     codecFlagLiveGrab            = 0+(1 * (2**(9)));
  158.     codecFlagDontUseNewImageBuffer = 0+(1 * (2**(10)));
  159.     codecFlagInterlaceUpdate    = 0+(1 * (2**(11)));
  160.     codecFlagCatchUpDiff        = 0+(1 * (2**(12)));
  161.     codecFlagUsedNewImageBuffer    = 0+(1 * (2**(14)));
  162.     codecFlagUsedImageBuffer    = 0+(1 * (2**(15)));
  163.  
  164. { The minimum data size for spooling in or out data }
  165.     codecMinimumDataSize        = 32768;
  166.  
  167.     compressorComponentType        = 'imco';                        { the type for "Components" which compress images }
  168.     decompressorComponentType    = 'imdc';
  169.  
  170.     
  171. TYPE
  172.     CompressorComponent = Component;
  173.  
  174.     DecompressorComponent = Component;
  175.  
  176.     CodecComponent = Component;
  177.  
  178.  
  179. CONST
  180.     anyCodec                    = 0;                            { take first working codec of given type }
  181.     bestSpeedCodec                = -1;                            { take fastest codec of given type }
  182.     bestFidelityCodec            = -2;                            { take codec which is most accurate }
  183.     bestCompressionCodec        = -3;                            { take codec of given type that is most accurate }
  184.  
  185.     
  186. TYPE
  187.     CodecType = LONGINT;
  188.  
  189.     CodecFlags = INTEGER;
  190.  
  191.     CodecQ = LONGINT;
  192.  
  193.  
  194. CONST
  195.     codecLosslessQuality        = $400;
  196.     codecMaxQuality                = $3ff;
  197.     codecMinQuality                = $000;
  198.     codecLowQuality                = $100;
  199.     codecNormalQuality            = $200;
  200.     codecHighQuality            = $300;
  201.  
  202.     codecCompletionSource        = 0+(1 * (2**(0)));                { asynchronous codec is done with source data }
  203.     codecCompletionDest            = 0+(1 * (2**(1)));                { asynchronous codec is done with destination data }
  204.     codecCompletionDontUnshield    = 0+(1 * (2**(2)));                { on dest complete don't unshield cursor }
  205.  
  206.     codecProgressOpen            = 0;
  207.     codecProgressUpdatePercent    = 1;
  208.     codecProgressClose            = 2;
  209.  
  210.     
  211. TYPE
  212.     ICMCursorNotify = Ptr;
  213.  
  214.     ICMDataProcPtr = ProcPtr;  { FUNCTION ICMData(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT): OSErr; }
  215.     ICMFlushProcPtr = ProcPtr;  { FUNCTION ICMFlush(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT): OSErr; }
  216.     ICMCompletionProcPtr = ProcPtr;  { PROCEDURE ICMCompletion(result: OSErr; flags: INTEGER; refcon: LONGINT); }
  217.     ICMProgressProcPtr = ProcPtr;  { FUNCTION ICMProgress(message: INTEGER; completeness: Fixed; refcon: LONGINT): OSErr; }
  218.     StdPixProcPtr = ProcPtr;  { PROCEDURE StdPix(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER); }
  219.     ICMAlignmentProcPtr = ProcPtr;  { PROCEDURE ICMAlignment(VAR rp: Rect; refcon: LONGINT); }
  220.     ICMCursorShieldedProcPtr = ProcPtr;  { PROCEDURE ICMCursorShielded((CONST)VAR r: Rect; refcon: UNIV Ptr; flags: LONGINT); }
  221.     ICMMemoryDisposedProcPtr = ProcPtr;  { PROCEDURE ICMMemoryDisposed(memoryBlock: Ptr; refcon: UNIV Ptr); }
  222.     ICMDataUPP = UniversalProcPtr;
  223.     ICMFlushUPP = UniversalProcPtr;
  224.     ICMCompletionUPP = UniversalProcPtr;
  225.     ICMProgressUPP = UniversalProcPtr;
  226.     StdPixUPP = UniversalProcPtr;
  227.     ICMAlignmentUPP = UniversalProcPtr;
  228.     ICMCursorShieldedUPP = UniversalProcPtr;
  229.     ICMMemoryDisposedUPP = UniversalProcPtr;
  230.  
  231.     ImageSequence = LONGINT;
  232.  
  233.     ImageSequenceDataSource = LONGINT;
  234.  
  235.     ICMProgressProcRecord = RECORD
  236.         progressProc:            ICMProgressUPP;
  237.         progressRefCon:            LONGINT;
  238.     END;
  239.  
  240.     ICMProgressProcRecordPtr = ^ICMProgressProcRecord;
  241.  
  242.     ICMCompletionProcRecord = RECORD
  243.         completionProc:            ICMCompletionUPP;
  244.         completionRefCon:        LONGINT;
  245.     END;
  246.  
  247.     ICMCompletionProcRecordPtr = ^ICMCompletionProcRecord;
  248.  
  249.     ICMDataProcRecord = RECORD
  250.         dataProc:                ICMDataUPP;
  251.         dataRefCon:                LONGINT;
  252.     END;
  253.  
  254.     ICMDataProcRecordPtr = ^ICMDataProcRecord;
  255.  
  256.     ICMFlushProcRecord = RECORD
  257.         flushProc:                ICMFlushUPP;
  258.         flushRefCon:            LONGINT;
  259.     END;
  260.  
  261.     ICMFlushProcRecordPtr = ^ICMFlushProcRecord;
  262.  
  263.     ICMAlignmentProcRecord = RECORD
  264.         alignmentProc:            ICMAlignmentUPP;
  265.         alignmentRefCon:        LONGINT;
  266.     END;
  267.  
  268.     ICMAlignmentProcRecordPtr = ^ICMAlignmentProcRecord;
  269.  
  270.     DataRateParams = RECORD
  271.         dataRate:                LONGINT;
  272.         dataOverrun:            LONGINT;
  273.         frameDuration:            LONGINT;
  274.         keyFrameRate:            LONGINT;
  275.         minSpatialQuality:        CodecQ;
  276.         minTemporalQuality:        CodecQ;
  277.     END;
  278.  
  279.     DataRateParamsPtr = ^DataRateParams;
  280.  
  281.     ImageDescription = PACKED RECORD
  282.         idSize:                    LONGINT;                                { total size of ImageDescription including extra data ( CLUTs and other per sequence data }
  283.         cType:                    CodecType;                                { what kind of codec compressed this data }
  284.         resvd1:                    LONGINT;                                { reserved for Apple use }
  285.         resvd2:                    INTEGER;                                { reserved for Apple use }
  286.         dataRefIndex:            INTEGER;                                { set to zero  }
  287.         version:                INTEGER;                                { which version is this data }
  288.         revisionLevel:            INTEGER;                                { what version of that codec did this }
  289.         vendor:                    LONGINT;                                { whose  codec compressed this data }
  290.         temporalQuality:        CodecQ;                                    { what was the temporal quality factor  }
  291.         spatialQuality:            CodecQ;                                    { what was the spatial quality factor }
  292.         width:                    INTEGER;                                { how many pixels wide is this data }
  293.         height:                    INTEGER;                                { how many pixels high is this data }
  294.         hRes:                    Fixed;                                    { horizontal resolution }
  295.         vRes:                    Fixed;                                    { vertical resolution }
  296.         dataSize:                LONGINT;                                { if known, the size of data for this image descriptor }
  297.         frameCount:                INTEGER;                                { number of frames this description applies to }
  298.         name:                    Str31;                                    { name of codec ( in case not installed )  }
  299.         depth:                    INTEGER;                                { what depth is this data (1-32) or ( 33-40 grayscale ) }
  300.         clutID:                    INTEGER;                                { clut id or if 0 clut follows  or -1 if no clut }
  301.     END;
  302.  
  303.     ImageDescriptionPtr = ^ImageDescription;
  304.     ImageDescriptionHandle = ^ImageDescriptionPtr;
  305.  
  306.     CodecInfo = PACKED RECORD
  307.         typeName:                Str31;                                    { name of the codec type i.e.: 'Apple Image Compression' }
  308.         version:                INTEGER;                                { version of the codec data that this codec knows about }
  309.         revisionLevel:            INTEGER;                                { revision level of this codec i.e: 0x00010001 (1.0.1) }
  310.         vendor:                    LONGINT;                                { Maker of this codec i.e: 'appl' }
  311.         decompressFlags:        LONGINT;                                { codecInfo flags for decompression capabilities }
  312.         compressFlags:            LONGINT;                                { codecInfo flags for compression capabilities }
  313.         formatFlags:            LONGINT;                                { codecInfo flags for compression format details }
  314.         compressionAccuracy:    UInt8;                                    { measure (1-255) of accuracy of this codec for compress (0 if unknown) }
  315.         decompressionAccuracy:    UInt8;                                    { measure (1-255) of accuracy of this codec for decompress (0 if unknown) }
  316.         compressionSpeed:        INTEGER;                                { ( millisecs for compressing 320x240 on base mac II) (0 if unknown)  }
  317.         decompressionSpeed:        INTEGER;                                { ( millisecs for decompressing 320x240 on mac II)(0 if unknown)  }
  318.         compressionLevel:        UInt8;                                    { measure (1-255) of compression level of this codec (0 if unknown)  }
  319.         resvd:                    UInt8;                                    { pad }
  320.         minimumHeight:            INTEGER;                                { minimum height of image (block size) }
  321.         minimumWidth:            INTEGER;                                { minimum width of image (block size) }
  322.         decompressPipelineLatency: INTEGER;                                { in milliseconds ( for asynchronous codecs ) }
  323.         compressPipelineLatency: INTEGER;                                { in milliseconds ( for asynchronous codecs ) }
  324.         privateData:            LONGINT;
  325.     END;
  326.  
  327.     CodecNameSpec = RECORD
  328.         codec:                    CodecComponent;
  329.         cType:                    CodecType;
  330.         typeName:                Str31;
  331.         name:                    Handle;
  332.     END;
  333.  
  334.     CodecNameSpecList = RECORD
  335.         count:                    INTEGER;
  336.         list:                    ARRAY [0..0] OF CodecNameSpec;
  337.     END;
  338.  
  339.     CodecNameSpecListPtr = ^CodecNameSpecList;
  340.  
  341.  
  342. CONST
  343.     defaultDither                = 0;
  344.     forceDither                    = 1;
  345.     suppressDither                = 2;
  346.     useColorMatching            = 4;
  347.  
  348.  
  349. TYPE
  350.     ICMFrameTimeRecord = RECORD
  351.         value:                    wide;                                    { frame time}
  352.         scale:                    LONGINT;                                { timescale of value/duration fields}
  353.         base:                    Ptr;                                    { timebase}
  354.         duration:                LONGINT;                                { duration frame is to be displayed (0 if unknown)}
  355.         rate:                    Fixed;                                    { rate of timebase relative to wall-time}
  356.     END;
  357.  
  358.     ICMFrameTimePtr = ^ICMFrameTimeRecord;
  359.  
  360.  
  361. CONST
  362.     uppICMDataProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  363.     uppICMFlushProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  364.     uppICMCompletionProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  365.     uppICMProgressProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  366.     uppStdPixProcInfo = $002FEFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param); }
  367.     uppICMAlignmentProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  368.     uppICMCursorShieldedProcInfo = $00000FC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param); }
  369.     uppICMMemoryDisposedProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  370.  
  371. FUNCTION NewICMDataProc(userRoutine: ICMDataProcPtr): ICMDataUPP;
  372.     {$IFC NOT GENERATINGCFM }
  373.     INLINE $2E9F;
  374.     {$ENDC}
  375.  
  376. FUNCTION NewICMFlushProc(userRoutine: ICMFlushProcPtr): ICMFlushUPP;
  377.     {$IFC NOT GENERATINGCFM }
  378.     INLINE $2E9F;
  379.     {$ENDC}
  380.  
  381. FUNCTION NewICMCompletionProc(userRoutine: ICMCompletionProcPtr): ICMCompletionUPP;
  382.     {$IFC NOT GENERATINGCFM }
  383.     INLINE $2E9F;
  384.     {$ENDC}
  385.  
  386. FUNCTION NewICMProgressProc(userRoutine: ICMProgressProcPtr): ICMProgressUPP;
  387.     {$IFC NOT GENERATINGCFM }
  388.     INLINE $2E9F;
  389.     {$ENDC}
  390.  
  391. FUNCTION NewStdPixProc(userRoutine: StdPixProcPtr): StdPixUPP;
  392.     {$IFC NOT GENERATINGCFM }
  393.     INLINE $2E9F;
  394.     {$ENDC}
  395.  
  396. FUNCTION NewICMAlignmentProc(userRoutine: ICMAlignmentProcPtr): ICMAlignmentUPP;
  397.     {$IFC NOT GENERATINGCFM }
  398.     INLINE $2E9F;
  399.     {$ENDC}
  400.  
  401. FUNCTION NewICMCursorShieldedProc(userRoutine: ICMCursorShieldedProcPtr): ICMCursorShieldedUPP;
  402.     {$IFC NOT GENERATINGCFM }
  403.     INLINE $2E9F;
  404.     {$ENDC}
  405.  
  406. FUNCTION NewICMMemoryDisposedProc(userRoutine: ICMMemoryDisposedProcPtr): ICMMemoryDisposedUPP;
  407.     {$IFC NOT GENERATINGCFM }
  408.     INLINE $2E9F;
  409.     {$ENDC}
  410.  
  411. FUNCTION CallICMDataProc(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT; userRoutine: ICMDataUPP): OSErr;
  412.     {$IFC NOT GENERATINGCFM}
  413.     INLINE $205F, $4E90;
  414.     {$ENDC}
  415.  
  416. FUNCTION CallICMFlushProc(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT; userRoutine: ICMFlushUPP): OSErr;
  417.     {$IFC NOT GENERATINGCFM}
  418.     INLINE $205F, $4E90;
  419.     {$ENDC}
  420.  
  421. PROCEDURE CallICMCompletionProc(result: OSErr; flags: INTEGER; refcon: LONGINT; userRoutine: ICMCompletionUPP);
  422.     {$IFC NOT GENERATINGCFM}
  423.     INLINE $205F, $4E90;
  424.     {$ENDC}
  425.  
  426. FUNCTION CallICMProgressProc(message: INTEGER; completeness: Fixed; refcon: LONGINT; userRoutine: ICMProgressUPP): OSErr;
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $205F, $4E90;
  429.     {$ENDC}
  430.  
  431. PROCEDURE CallStdPixProc(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER; userRoutine: StdPixUPP);
  432.     {$IFC NOT GENERATINGCFM}
  433.     INLINE $205F, $4E90;
  434.     {$ENDC}
  435.  
  436. PROCEDURE CallICMAlignmentProc(VAR rp: Rect; refcon: LONGINT; userRoutine: ICMAlignmentUPP);
  437.     {$IFC NOT GENERATINGCFM}
  438.     INLINE $205F, $4E90;
  439.     {$ENDC}
  440.  
  441. PROCEDURE CallICMCursorShieldedProc({CONST}VAR r: Rect; refcon: UNIV Ptr; flags: LONGINT; userRoutine: ICMCursorShieldedUPP);
  442.     {$IFC NOT GENERATINGCFM}
  443.     INLINE $205F, $4E90;
  444.     {$ENDC}
  445.  
  446. PROCEDURE CallICMMemoryDisposedProc(memoryBlock: Ptr; refcon: UNIV Ptr; userRoutine: ICMMemoryDisposedUPP);
  447.     {$IFC NOT GENERATINGCFM}
  448.     INLINE $205F, $4E90;
  449.     {$ENDC}
  450.  
  451. FUNCTION CodecManagerVersion(VAR version: LONGINT): OSErr;
  452.     {$IFC NOT GENERATINGCFM}
  453.     INLINE $7000, $AAA3;
  454.     {$ENDC}
  455. FUNCTION GetCodecNameList(VAR list: CodecNameSpecListPtr; showAll: INTEGER): OSErr;
  456.     {$IFC NOT GENERATINGCFM}
  457.     INLINE $7001, $AAA3;
  458.     {$ENDC}
  459. FUNCTION DisposeCodecNameList(list: CodecNameSpecListPtr): OSErr;
  460.     {$IFC NOT GENERATINGCFM}
  461.     INLINE $700F, $AAA3;
  462.     {$ENDC}
  463. FUNCTION GetCodecInfo(VAR info: CodecInfo; cType: CodecType; codec: CodecComponent): OSErr;
  464.     {$IFC NOT GENERATINGCFM}
  465.     INLINE $7003, $AAA3;
  466.     {$ENDC}
  467. FUNCTION GetMaxCompressionSize(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; VAR size: LONGINT): OSErr;
  468.     {$IFC NOT GENERATINGCFM}
  469.     INLINE $7004, $AAA3;
  470.     {$ENDC}
  471. FUNCTION GetCompressionTime(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; VAR spatialQuality: CodecQ; VAR temporalQuality: CodecQ; VAR compressTime: LONGINT): OSErr;
  472.     {$IFC NOT GENERATINGCFM}
  473.     INLINE $7005, $AAA3;
  474.     {$ENDC}
  475. FUNCTION CompressImage(src: PixMapHandle; {CONST}VAR srcRect: Rect; quality: CodecQ; cType: CodecType; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  476.     {$IFC NOT GENERATINGCFM}
  477.     INLINE $7006, $AAA3;
  478.     {$ENDC}
  479. FUNCTION FCompressImage(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; clut: CTabHandle; flags: CodecFlags; bufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; progressProc: ICMProgressProcRecordPtr; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  480.     {$IFC NOT GENERATINGCFM}
  481.     INLINE $7007, $AAA3;
  482.     {$ENDC}
  483. FUNCTION DecompressImage(data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; mask: RgnHandle): OSErr;
  484.     {$IFC NOT GENERATINGCFM}
  485.     INLINE $7008, $AAA3;
  486.     {$ENDC}
  487. FUNCTION FDecompressImage(data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapHandle; {CONST}VAR matteRect: Rect; accuracy: CodecQ; codec: DecompressorComponent; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  488.     {$IFC NOT GENERATINGCFM}
  489.     INLINE $7009, $AAA3;
  490.     {$ENDC}
  491. FUNCTION CompressSequenceBegin(VAR seqID: ImageSequence; src: PixMapHandle; prev: PixMapHandle; {CONST}VAR srcRect: Rect; {CONST}VAR prevRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; spatialQuality: CodecQ; temporalQuality: CodecQ; keyFrameRate: LONGINT; clut: CTabHandle; flags: CodecFlags; desc: ImageDescriptionHandle): OSErr;
  492.     {$IFC NOT GENERATINGCFM}
  493.     INLINE $700A, $AAA3;
  494.     {$ENDC}
  495. FUNCTION CompressSequenceFrame(seqID: ImageSequence; src: PixMapHandle; {CONST}VAR srcRect: Rect; flags: CodecFlags; data: Ptr; VAR dataSize: LONGINT; VAR similarity: UInt8; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  496.     {$IFC NOT GENERATINGCFM}
  497.     INLINE $700B, $AAA3;
  498.     {$ENDC}
  499. FUNCTION DecompressSequenceBegin(VAR seqID: ImageSequence; desc: ImageDescriptionHandle; port: CGrafPtr; gdh: GDHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  500.     {$IFC NOT GENERATINGCFM}
  501.     INLINE $700D, $AAA3;
  502.     {$ENDC}
  503. FUNCTION DecompressSequenceBeginS(VAR seqID: ImageSequence; desc: ImageDescriptionHandle; data: Ptr; dataSize: LONGINT; port: CGrafPtr; gdh: GDHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  504.     {$IFC NOT GENERATINGCFM}
  505.     INLINE $203C, $30, $5D, $AAA3;
  506.     {$ENDC}
  507. FUNCTION DecompressSequenceFrame(seqID: ImageSequence; data: Ptr; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  508.     {$IFC NOT GENERATINGCFM}
  509.     INLINE $700E, $AAA3;
  510.     {$ENDC}
  511. FUNCTION DecompressSequenceFrameS(seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  512.     {$IFC NOT GENERATINGCFM}
  513.     INLINE $203C, $16, $47, $AAA3;
  514.     {$ENDC}
  515. FUNCTION DecompressSequenceFrameWhen(seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr; {CONST}VAR frameTime: ICMFrameTimeRecord): OSErr;
  516.     {$IFC NOT GENERATINGCFM}
  517.     INLINE $203C, $1A, $5E, $AAA3;
  518.     {$ENDC}
  519. FUNCTION CDSequenceFlush(seqID: ImageSequence): OSErr;
  520.     {$IFC NOT GENERATINGCFM}
  521.     INLINE $203C, $4, $5F, $AAA3;
  522.     {$ENDC}
  523. FUNCTION SetDSequenceMatrix(seqID: ImageSequence; matrix: MatrixRecordPtr): OSErr;
  524.     {$IFC NOT GENERATINGCFM}
  525.     INLINE $7010, $AAA3;
  526.     {$ENDC}
  527. FUNCTION SetDSequenceMatte(seqID: ImageSequence; matte: PixMapHandle; {CONST}VAR matteRect: Rect): OSErr;
  528.     {$IFC NOT GENERATINGCFM}
  529.     INLINE $7011, $AAA3;
  530.     {$ENDC}
  531. FUNCTION SetDSequenceMask(seqID: ImageSequence; mask: RgnHandle): OSErr;
  532.     {$IFC NOT GENERATINGCFM}
  533.     INLINE $7012, $AAA3;
  534.     {$ENDC}
  535. FUNCTION SetDSequenceTransferMode(seqID: ImageSequence; mode: INTEGER; {CONST}VAR opColor: RGBColor): OSErr;
  536.     {$IFC NOT GENERATINGCFM}
  537.     INLINE $7013, $AAA3;
  538.     {$ENDC}
  539. FUNCTION SetDSequenceDataProc(seqID: ImageSequence; dataProc: ICMDataProcRecordPtr; bufferSize: LONGINT): OSErr;
  540.     {$IFC NOT GENERATINGCFM}
  541.     INLINE $7014, $AAA3;
  542.     {$ENDC}
  543. FUNCTION SetDSequenceAccuracy(seqID: ImageSequence; accuracy: CodecQ): OSErr;
  544.     {$IFC NOT GENERATINGCFM}
  545.     INLINE $7034, $AAA3;
  546.     {$ENDC}
  547. FUNCTION SetDSequenceSrcRect(seqID: ImageSequence; {CONST}VAR srcRect: Rect): OSErr;
  548.     {$IFC NOT GENERATINGCFM}
  549.     INLINE $7035, $AAA3;
  550.     {$ENDC}
  551. FUNCTION GetDSequenceImageBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  552.     {$IFC NOT GENERATINGCFM}
  553.     INLINE $7015, $AAA3;
  554.     {$ENDC}
  555. FUNCTION GetDSequenceScreenBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  556.     {$IFC NOT GENERATINGCFM}
  557.     INLINE $7016, $AAA3;
  558.     {$ENDC}
  559. FUNCTION SetCSequenceQuality(seqID: ImageSequence; spatialQuality: CodecQ; temporalQuality: CodecQ): OSErr;
  560.     {$IFC NOT GENERATINGCFM}
  561.     INLINE $7017, $AAA3;
  562.     {$ENDC}
  563. FUNCTION SetCSequencePrev(seqID: ImageSequence; prev: PixMapHandle; {CONST}VAR prevRect: Rect): OSErr;
  564.     {$IFC NOT GENERATINGCFM}
  565.     INLINE $7018, $AAA3;
  566.     {$ENDC}
  567. FUNCTION SetCSequenceFlushProc(seqID: ImageSequence; flushProc: ICMFlushProcRecordPtr; bufferSize: LONGINT): OSErr;
  568.     {$IFC NOT GENERATINGCFM}
  569.     INLINE $7033, $AAA3;
  570.     {$ENDC}
  571. FUNCTION SetCSequenceKeyFrameRate(seqID: ImageSequence; keyframerate: LONGINT): OSErr;
  572.     {$IFC NOT GENERATINGCFM}
  573.     INLINE $7036, $AAA3;
  574.     {$ENDC}
  575. FUNCTION GetCSequenceKeyFrameRate(seqID: ImageSequence; VAR keyframerate: LONGINT): OSErr;
  576.     {$IFC NOT GENERATINGCFM}
  577.     INLINE $203C, $8, $4B, $AAA3;
  578.     {$ENDC}
  579. FUNCTION GetCSequencePrevBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  580.     {$IFC NOT GENERATINGCFM}
  581.     INLINE $7019, $AAA3;
  582.     {$ENDC}
  583. FUNCTION CDSequenceBusy(seqID: ImageSequence): OSErr;
  584.     {$IFC NOT GENERATINGCFM}
  585.     INLINE $701A, $AAA3;
  586.     {$ENDC}
  587. FUNCTION CDSequenceEnd(seqID: ImageSequence): OSErr;
  588.     {$IFC NOT GENERATINGCFM}
  589.     INLINE $701B, $AAA3;
  590.     {$ENDC}
  591. FUNCTION CDSequenceEquivalentImageDescription(seqID: ImageSequence; newDesc: ImageDescriptionHandle; VAR equivalent: BOOLEAN): OSErr;
  592.     {$IFC NOT GENERATINGCFM}
  593.     INLINE $203C, $C, $65, $AAA3;
  594.     {$ENDC}
  595. FUNCTION GetCompressedImageSize(desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; VAR dataSize: LONGINT): OSErr;
  596.     {$IFC NOT GENERATINGCFM}
  597.     INLINE $701C, $AAA3;
  598.     {$ENDC}
  599. FUNCTION GetSimilarity(src: PixMapHandle; {CONST}VAR srcRect: Rect; desc: ImageDescriptionHandle; data: Ptr; VAR similarity: Fixed): OSErr;
  600.     {$IFC NOT GENERATINGCFM}
  601.     INLINE $701D, $AAA3;
  602.     {$ENDC}
  603. FUNCTION GetImageDescriptionCTable(desc: ImageDescriptionHandle; VAR ctable: CTabHandle): OSErr;
  604.     {$IFC NOT GENERATINGCFM}
  605.     INLINE $701E, $AAA3;
  606.     {$ENDC}
  607. FUNCTION SetImageDescriptionCTable(desc: ImageDescriptionHandle; ctable: CTabHandle): OSErr;
  608.     {$IFC NOT GENERATINGCFM}
  609.     INLINE $701F, $AAA3;
  610.     {$ENDC}
  611. FUNCTION GetImageDescriptionExtension(desc: ImageDescriptionHandle; VAR extension: Handle; idType: LONGINT; index: LONGINT): OSErr;
  612.     {$IFC NOT GENERATINGCFM}
  613.     INLINE $7020, $AAA3;
  614.     {$ENDC}
  615. FUNCTION AddImageDescriptionExtension(desc: ImageDescriptionHandle; extension: Handle; idType: LONGINT): OSErr;
  616.     {$IFC NOT GENERATINGCFM}
  617.     INLINE $7021, $AAA3;
  618.     {$ENDC}
  619. FUNCTION SetImageDescriptionExtension(desc: ImageDescriptionHandle; extension: Handle; idType: LONGINT): OSErr;
  620.     {$IFC NOT GENERATINGCFM}
  621.     INLINE $7021, $AAA3;
  622.     {$ENDC}
  623. FUNCTION RemoveImageDescriptionExtension(VAR desc: ImageDescription; idType: LONGINT; index: LONGINT): OSErr;
  624.     {$IFC NOT GENERATINGCFM}
  625.     INLINE $203C, $C, $3A, $AAA3;
  626.     {$ENDC}
  627. FUNCTION CountImageDescriptionExtensionType(VAR desc: ImageDescription; idType: LONGINT; VAR count: LONGINT): OSErr;
  628.     {$IFC NOT GENERATINGCFM}
  629.     INLINE $203C, $C, $3B, $AAA3;
  630.     {$ENDC}
  631. FUNCTION GetNextImageDescriptionExtensionType(VAR desc: ImageDescription; VAR idType: LONGINT): OSErr;
  632.     {$IFC NOT GENERATINGCFM}
  633.     INLINE $203C, $8, $3C, $AAA3;
  634.     {$ENDC}
  635. FUNCTION FindCodec(cType: CodecType; specCodec: CodecComponent; VAR compressor: CompressorComponent; VAR decompressor: DecompressorComponent): OSErr;
  636.     {$IFC NOT GENERATINGCFM}
  637.     INLINE $7023, $AAA3;
  638.     {$ENDC}
  639. FUNCTION CompressPicture(srcPicture: PicHandle; dstPicture: PicHandle; quality: CodecQ; cType: CodecType): OSErr;
  640.     {$IFC NOT GENERATINGCFM}
  641.     INLINE $7024, $AAA3;
  642.     {$ENDC}
  643. FUNCTION FCompressPicture(srcPicture: PicHandle; dstPicture: PicHandle; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  644.     {$IFC NOT GENERATINGCFM}
  645.     INLINE $7025, $AAA3;
  646.     {$ENDC}
  647. FUNCTION CompressPictureFile(srcRefNum: INTEGER; dstRefNum: INTEGER; quality: CodecQ; cType: CodecType): OSErr;
  648.     {$IFC NOT GENERATINGCFM}
  649.     INLINE $7026, $AAA3;
  650.     {$ENDC}
  651. FUNCTION FCompressPictureFile(srcRefNum: INTEGER; dstRefNum: INTEGER; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  652.     {$IFC NOT GENERATINGCFM}
  653.     INLINE $7027, $AAA3;
  654.     {$ENDC}
  655. FUNCTION GetPictureFileHeader(refNum: INTEGER; VAR frame: Rect; VAR header: OpenCPicParams): OSErr;
  656.     {$IFC NOT GENERATINGCFM}
  657.     INLINE $7028, $AAA3;
  658.     {$ENDC}
  659. FUNCTION DrawPictureFile(refNum: INTEGER; {CONST}VAR frame: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  660.     {$IFC NOT GENERATINGCFM}
  661.     INLINE $7029, $AAA3;
  662.     {$ENDC}
  663. FUNCTION DrawTrimmedPicture(srcPicture: PicHandle; {CONST}VAR frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  664.     {$IFC NOT GENERATINGCFM}
  665.     INLINE $702E, $AAA3;
  666.     {$ENDC}
  667. FUNCTION DrawTrimmedPictureFile(srcRefnum: INTEGER; {CONST}VAR frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  668.     {$IFC NOT GENERATINGCFM}
  669.     INLINE $702F, $AAA3;
  670.     {$ENDC}
  671. FUNCTION MakeThumbnailFromPicture(picture: PicHandle; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  672.     {$IFC NOT GENERATINGCFM}
  673.     INLINE $702A, $AAA3;
  674.     {$ENDC}
  675. FUNCTION MakeThumbnailFromPictureFile(refNum: INTEGER; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  676.     {$IFC NOT GENERATINGCFM}
  677.     INLINE $702B, $AAA3;
  678.     {$ENDC}
  679. FUNCTION MakeThumbnailFromPixMap(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  680.     {$IFC NOT GENERATINGCFM}
  681.     INLINE $702C, $AAA3;
  682.     {$ENDC}
  683. FUNCTION TrimImage(desc: ImageDescriptionHandle; inData: Ptr; inBufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; outData: Ptr; outBufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; VAR trimRect: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  684.     {$IFC NOT GENERATINGCFM}
  685.     INLINE $702D, $AAA3;
  686.     {$ENDC}
  687. FUNCTION ConvertImage(srcDD: ImageDescriptionHandle; srcData: Ptr; colorDepth: INTEGER; clut: CTabHandle; accuracy: CodecQ; quality: CodecQ; cType: CodecType; codec: CodecComponent; dstDD: ImageDescriptionHandle; dstData: Ptr): OSErr;
  688.     {$IFC NOT GENERATINGCFM}
  689.     INLINE $7030, $AAA3;
  690.     {$ENDC}
  691. FUNCTION GetCompressedPixMapInfo(pix: PixMapPtr; VAR desc: ImageDescriptionHandle; VAR data: Ptr; VAR bufferSize: LONGINT; VAR dataProc: ICMDataProcRecord; VAR progressProc: ICMProgressProcRecord): OSErr;
  692.     {$IFC NOT GENERATINGCFM}
  693.     INLINE $7037, $AAA3;
  694.     {$ENDC}
  695. FUNCTION SetCompressedPixMapInfo(pix: PixMapPtr; desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  696.     {$IFC NOT GENERATINGCFM}
  697.     INLINE $7038, $AAA3;
  698.     {$ENDC}
  699. PROCEDURE StdPix(src: PixMapPtr; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapPtr; {CONST}VAR matteRect: Rect; flags: INTEGER);
  700.     {$IFC NOT GENERATINGCFM}
  701.     INLINE $700C, $AAA3;
  702.     {$ENDC}
  703. FUNCTION TransformRgn(matrix: MatrixRecordPtr; rgn: RgnHandle): OSErr;
  704.     {$IFC NOT GENERATINGCFM}
  705.     INLINE $7039, $AAA3;
  706.     {$ENDC}
  707. {**********
  708.     preview stuff
  709. **********}
  710. PROCEDURE SFGetFilePreview(where: Point; prompt: ConstStr255Param; fileFilter: FileFilterUPP; numTypes: INTEGER; VAR typeList: SFTypeList; dlgHook: DlgHookUPP; VAR reply: SFReply);
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $7041, $AAA3;
  713.     {$ENDC}
  714. PROCEDURE SFPGetFilePreview(where: Point; prompt: ConstStr255Param; fileFilter: FileFilterUPP; numTypes: INTEGER; VAR typeList: SFTypeList; dlgHook: DlgHookUPP; VAR reply: SFReply; dlgID: INTEGER; filterProc: ModalFilterUPP);
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $7042, $AAA3;
  717.     {$ENDC}
  718. PROCEDURE StandardGetFilePreview(fileFilter: FileFilterUPP; numTypes: INTEGER; VAR typeList: SFTypeList; VAR reply: StandardFileReply);
  719.     {$IFC NOT GENERATINGCFM}
  720.     INLINE $7043, $AAA3;
  721.     {$ENDC}
  722. PROCEDURE CustomGetFilePreview(fileFilter: FileFilterYDUPP; numTypes: INTEGER; VAR typeList: SFTypeList; VAR reply: StandardFileReply; dlgID: INTEGER; where: Point; dlgHook: DlgHookYDUPP; filterProc: ModalFilterYDUPP; {CONST}VAR activeList: INTEGER; activateProc: ActivateYDUPP; yourDataPtr: UNIV Ptr);
  723.     {$IFC NOT GENERATINGCFM}
  724.     INLINE $7044, $AAA3;
  725.     {$ENDC}
  726. FUNCTION MakeFilePreview(resRefNum: INTEGER; progress: ICMProgressProcRecordPtr): OSErr;
  727.     {$IFC NOT GENERATINGCFM}
  728.     INLINE $7045, $AAA3;
  729.     {$ENDC}
  730. FUNCTION AddFilePreview(resRefNum: INTEGER; previewType: OSType; previewData: Handle): OSErr;
  731.     {$IFC NOT GENERATINGCFM}
  732.     INLINE $7046, $AAA3;
  733.     {$ENDC}
  734.  
  735. CONST
  736.     sfpItemPreviewAreaUser        = 11;
  737.     sfpItemPreviewStaticText    = 12;
  738.     sfpItemPreviewDividerUser    = 13;
  739.     sfpItemCreatePreviewButton    = 14;
  740.     sfpItemShowPreviewButton    = 15;
  741.  
  742.  
  743. TYPE
  744.     PreviewResourceRecord = RECORD
  745.         modDate:                LONGINT;
  746.         version:                INTEGER;
  747.         resType:                OSType;
  748.         resID:                    INTEGER;
  749.     END;
  750.  
  751.     PreviewResourcePtr = ^PreviewResourceRecord;
  752.     PreviewResource = ^PreviewResourcePtr;
  753.  
  754.  
  755. PROCEDURE AlignScreenRect(VAR rp: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  756.     {$IFC NOT GENERATINGCFM}
  757.     INLINE $203C, $8, $4C, $AAA3;
  758.     {$ENDC}
  759. PROCEDURE AlignWindow(wp: WindowPtr; front: BOOLEAN; {CONST}VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  760.     {$IFC NOT GENERATINGCFM}
  761.     INLINE $203C, $E, $4D, $AAA3;
  762.     {$ENDC}
  763. PROCEDURE DragAlignedWindow(wp: WindowPtr; startPt: Point; VAR boundsRect: Rect; VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  764.     {$IFC NOT GENERATINGCFM}
  765.     INLINE $203C, $14, $4E, $AAA3;
  766.     {$ENDC}
  767. FUNCTION DragAlignedGrayRgn(theRgn: RgnHandle; startPt: Point; VAR boundsRect: Rect; VAR slopRect: Rect; axis: INTEGER; actionProc: UniversalProcPtr; VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr): LONGINT;
  768.     {$IFC NOT GENERATINGCFM}
  769.     INLINE $203C, $1E, $4F, $AAA3;
  770.     {$ENDC}
  771. FUNCTION SetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  772.     {$IFC NOT GENERATINGCFM}
  773.     INLINE $203C, $8, $50, $AAA3;
  774.     {$ENDC}
  775. FUNCTION SetCSequenceFrameNumber(seqID: ImageSequence; frameNumber: LONGINT): OSErr;
  776.     {$IFC NOT GENERATINGCFM}
  777.     INLINE $203C, $8, $51, $AAA3;
  778.     {$ENDC}
  779. FUNCTION NewImageGWorld(VAR gworld: GWorldPtr; idh: ImageDescriptionHandle; flags: GWorldFlags): QDErr;
  780.     {$IFC NOT GENERATINGCFM}
  781.     INLINE $203C, $C, $52, $AAA3;
  782.     {$ENDC}
  783. FUNCTION GetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  784.     {$IFC NOT GENERATINGCFM}
  785.     INLINE $203C, $8, $53, $AAA3;
  786.     {$ENDC}
  787. FUNCTION GetCSequenceFrameNumber(seqID: ImageSequence; VAR frameNumber: LONGINT): OSErr;
  788.     {$IFC NOT GENERATINGCFM}
  789.     INLINE $203C, $8, $54, $AAA3;
  790.     {$ENDC}
  791. FUNCTION GetBestDeviceRect(VAR gdh: GDHandle; VAR rp: Rect): OSErr;
  792.     {$IFC NOT GENERATINGCFM}
  793.     INLINE $203C, $8, $55, $AAA3;
  794.     {$ENDC}
  795. FUNCTION SetSequenceProgressProc(seqID: ImageSequence; VAR progressProc: ICMProgressProcRecord): OSErr;
  796.     {$IFC NOT GENERATINGCFM}
  797.     INLINE $203C, $8, $56, $AAA3;
  798.     {$ENDC}
  799. FUNCTION GDHasScale(gdh: GDHandle; depth: INTEGER; VAR scale: Fixed): OSErr;
  800.     {$IFC NOT GENERATINGCFM}
  801.     INLINE $203C, $A, $5A, $AAA3;
  802.     {$ENDC}
  803. FUNCTION GDGetScale(gdh: GDHandle; VAR scale: Fixed; VAR flags: INTEGER): OSErr;
  804.     {$IFC NOT GENERATINGCFM}
  805.     INLINE $203C, $C, $5B, $AAA3;
  806.     {$ENDC}
  807. FUNCTION GDSetScale(gdh: GDHandle; scale: Fixed; flags: INTEGER): OSErr;
  808.     {$IFC NOT GENERATINGCFM}
  809.     INLINE $203C, $A, $5C, $AAA3;
  810.     {$ENDC}
  811. FUNCTION ICMShieldSequenceCursor(seqID: ImageSequence): OSErr;
  812.     {$IFC NOT GENERATINGCFM}
  813.     INLINE $203C, $4, $62, $AAA3;
  814.     {$ENDC}
  815. PROCEDURE ICMDecompressComplete(seqID: ImageSequence; err: OSErr; flag: INTEGER; completionRtn: ICMCompletionProcRecordPtr);
  816.     {$IFC NOT GENERATINGCFM}
  817.     INLINE $203C, $C, $63, $AAA3;
  818.     {$ENDC}
  819. FUNCTION SetDSequenceTimeCode(seqID: ImageSequence; timeCodeFormat: UNIV Ptr; timeCodeTime: UNIV Ptr): OSErr;
  820.     {$IFC NOT GENERATINGCFM}
  821.     INLINE $203C, $C, $64, $AAA3;
  822.     {$ENDC}
  823. FUNCTION CDSequenceNewMemory(seqID: ImageSequence; VAR data: Ptr; dataSize: Size; dataUse: LONGINT; memoryGoneProc: ICMMemoryDisposedUPP; refCon: UNIV Ptr): OSErr;
  824.     {$IFC NOT GENERATINGCFM}
  825.     INLINE $203C, $18, $66, $AAA3;
  826.     {$ENDC}
  827. FUNCTION CDSequenceDisposeMemory(seqID: ImageSequence; data: Ptr): OSErr;
  828.     {$IFC NOT GENERATINGCFM}
  829.     INLINE $203C, $8, $67, $AAA3;
  830.     {$ENDC}
  831. FUNCTION CDSequenceNewDataSource(seqID: ImageSequence; VAR sourceID: ImageSequenceDataSource; sourceType: OSType; sourceInputNumber: LONGINT; dataDescription: Handle; transferProc: UNIV Ptr; refCon: UNIV Ptr): OSErr;
  832.     {$IFC NOT GENERATINGCFM}
  833.     INLINE $203C, $1C, $68, $AAA3;
  834.     {$ENDC}
  835. FUNCTION CDSequenceDisposeDataSource(sourceID: ImageSequenceDataSource): OSErr;
  836.     {$IFC NOT GENERATINGCFM}
  837.     INLINE $203C, $4, $69, $AAA3;
  838.     {$ENDC}
  839. FUNCTION CDSequenceSetSourceData(sourceID: ImageSequenceDataSource; data: UNIV Ptr): OSErr;
  840.     {$IFC NOT GENERATINGCFM}
  841.     INLINE $203C, $8, $6A, $AAA3;
  842.     {$ENDC}
  843. FUNCTION CDSequenceChangedSourceData(sourceID: ImageSequenceDataSource): OSErr;
  844.     {$IFC NOT GENERATINGCFM}
  845.     INLINE $203C, $4, $6B, $AAA3;
  846.     {$ENDC}
  847. FUNCTION PtInDSequenceData(seqID: ImageSequence; data: UNIV Ptr; dataSize: Size; where: Point; VAR hit: BOOLEAN): OSErr;
  848.     {$IFC NOT GENERATINGCFM}
  849.     INLINE $203C, $14, $6C, $AAA3;
  850.     {$ENDC}
  851.  
  852. CONST
  853.     identityMatrixType            = $00;                            { result if matrix is identity }
  854.     translateMatrixType            = $01;                            { result if matrix translates }
  855.     scaleMatrixType                = $02;                            { result if matrix scales }
  856.     scaleTranslateMatrixType    = $03;                            { result if matrix scales and translates }
  857.     linearMatrixType            = $04;                            { result if matrix is general 2 x 2 }
  858.     linearTranslateMatrixType    = $05;                            { result if matrix is general 2 x 2 and translates }
  859.     perspectiveMatrixType        = $06;                            { result if matrix is general 3 x 3 }
  860.  
  861.     
  862. TYPE
  863.     MatrixFlags = INTEGER;
  864.  
  865.  
  866. FUNCTION GetMatrixType({CONST}VAR m: MatrixRecord): INTEGER;
  867.     {$IFC NOT GENERATINGCFM}
  868.     INLINE $7014, $ABC2;
  869.     {$ENDC}
  870. PROCEDURE CopyMatrix({CONST}VAR m1: MatrixRecord; VAR m2: MatrixRecord);
  871.     {$IFC NOT GENERATINGCFM}
  872.     INLINE $7020, $ABC2;
  873.     {$ENDC}
  874. FUNCTION EqualMatrix({CONST}VAR m1: MatrixRecord; {CONST}VAR m2: MatrixRecord): BOOLEAN;
  875.     {$IFC NOT GENERATINGCFM}
  876.     INLINE $7021, $ABC2;
  877.     {$ENDC}
  878. PROCEDURE SetIdentityMatrix(VAR matrix: MatrixRecord);
  879.     {$IFC NOT GENERATINGCFM}
  880.     INLINE $7015, $ABC2;
  881.     {$ENDC}
  882. PROCEDURE TranslateMatrix(VAR m: MatrixRecord; deltaH: Fixed; deltaV: Fixed);
  883.     {$IFC NOT GENERATINGCFM}
  884.     INLINE $7019, $ABC2;
  885.     {$ENDC}
  886. PROCEDURE RotateMatrix(VAR m: MatrixRecord; degrees: Fixed; aboutX: Fixed; aboutY: Fixed);
  887.     {$IFC NOT GENERATINGCFM}
  888.     INLINE $7016, $ABC2;
  889.     {$ENDC}
  890. PROCEDURE ScaleMatrix(VAR m: MatrixRecord; scaleX: Fixed; scaleY: Fixed; aboutX: Fixed; aboutY: Fixed);
  891.     {$IFC NOT GENERATINGCFM}
  892.     INLINE $7017, $ABC2;
  893.     {$ENDC}
  894. PROCEDURE SkewMatrix(VAR m: MatrixRecord; skewX: Fixed; skewY: Fixed; aboutX: Fixed; aboutY: Fixed);
  895.     {$IFC NOT GENERATINGCFM}
  896.     INLINE $7018, $ABC2;
  897.     {$ENDC}
  898. FUNCTION TransformFixedPoints({CONST}VAR m: MatrixRecord; VAR fpt: FixedPoint; count: LONGINT): OSErr;
  899.     {$IFC NOT GENERATINGCFM}
  900.     INLINE $7022, $ABC2;
  901.     {$ENDC}
  902. FUNCTION TransformPoints({CONST}VAR mp: MatrixRecord; VAR pt1: Point; count: LONGINT): OSErr;
  903.     {$IFC NOT GENERATINGCFM}
  904.     INLINE $7023, $ABC2;
  905.     {$ENDC}
  906. FUNCTION TransformFixedRect({CONST}VAR m: MatrixRecord; VAR fr: FixedRect; VAR fpp: FixedPoint): BOOLEAN;
  907.     {$IFC NOT GENERATINGCFM}
  908.     INLINE $7024, $ABC2;
  909.     {$ENDC}
  910. FUNCTION TransformRect({CONST}VAR m: MatrixRecord; VAR r: Rect; VAR fpp: FixedPoint): BOOLEAN;
  911.     {$IFC NOT GENERATINGCFM}
  912.     INLINE $7025, $ABC2;
  913.     {$ENDC}
  914. FUNCTION InverseMatrix({CONST}VAR m: MatrixRecord; VAR im: MatrixRecord): BOOLEAN;
  915.     {$IFC NOT GENERATINGCFM}
  916.     INLINE $701C, $ABC2;
  917.     {$ENDC}
  918. PROCEDURE ConcatMatrix({CONST}VAR a: MatrixRecord; VAR b: MatrixRecord);
  919.     {$IFC NOT GENERATINGCFM}
  920.     INLINE $701B, $ABC2;
  921.     {$ENDC}
  922. PROCEDURE RectMatrix(VAR matrix: MatrixRecord; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  923.     {$IFC NOT GENERATINGCFM}
  924.     INLINE $701E, $ABC2;
  925.     {$ENDC}
  926. PROCEDURE MapMatrix(VAR matrix: MatrixRecord; {CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect);
  927.     {$IFC NOT GENERATINGCFM}
  928.     INLINE $701D, $ABC2;
  929.     {$ENDC}
  930.  
  931. {$ALIGN RESET}
  932. {$POP}
  933.  
  934. {$SETC UsingIncludes := ImageCompressionIncludes}
  935.  
  936. {$ENDC} {__IMAGECOMPRESSION__}
  937.  
  938. {$IFC NOT UsingIncludes}
  939.  END.
  940. {$ENDC}
  941.