Macintosh-SW/BuildCubeE
1
0
Fork 0
mirror of https://github.com/elliotnunn/BuildCubeE.git synced 2026-01-25 17:16:13 +00:00
Code Issues Projects Releases Wiki Activity
Files
mpw33
BuildCubeE/BootableMPW/PInterfaces/ImageCompression.p
Elliot Nunn 3218aa64d4 MPW 3.3, alas requires System 7
2018-11-06 13:05:08 +08:00

618 lines
27 KiB
OpenEdge ABL
Raw Permalink Blame History

{ All rights reserved
Created: Wednesday, January 27, 1992 at 5:31 PM
ImageCompression.p
Pascal Interface to the Macintosh Libraries
Copyright Apple Computer, Inc. 1991, 1992
All rights reserved
}
{$IFC UNDEFINED UsingIncludes}
{$SETC UsingIncludes := 0}
{$ENDC}
{$IFC NOT UsingIncludes}
UNIT ImageCompression;
INTERFACE
{$ENDC}
{$IFC UNDEFINED UsingImageCompression}
{$SETC UsingImageCompression := 1}
{$I+}
{$SETC ImageCompressionIncludes := UsingIncludes}
{$SETC UsingIncludes := 1}
{$IFC UNDEFINED UsingQuickDraw}
{$I $$Shell(PInterfaces)QuickDraw.p}
{$ENDC}
{$IFC UNDEFINED UsingQDOffscreen}
{$I $$Shell(PInterfaces)QDOffscreen.p}
{$ENDC}
{$IFC UNDEFINED UsingTypes}
{$I $$Shell(PInterfaces)Types.p}
{$ENDC}
{$IFC UNDEFINED UsingComponents}
{$I $$Shell(PInterfaces)Components.p}
{$ENDC}
{$IFC UNDEFINED UsingStandardFile}
{$I $$Shell(PInterfaces)StandardFile.p}
{$ENDC}
{$SETC UsingIncludes := ImageCompressionIncludes}
CONST
gestaltCompressionMgr = 'icmp';
TYPE
{ Matrix stuff }
MatrixRecord = RECORD
matrix: ARRAY [0..2,0..2] OF Fixed;
END;
MatrixRecordPtr = ^MatrixRecord;
FixedPoint = RECORD
x: Fixed;
y: Fixed;
END;
FixedRect = RECORD
left: Fixed;
top: Fixed;
right: Fixed;
bottom: Fixed;
END;
CONST
{ These are the bits that are set in the Component flags, and also in the codecInfo struct. }
codecInfoDoes1 = $1; { codec can work with 1-bit pixels }
codecInfoDoes2 = $2; { codec can work with 2-bit pixels }
codecInfoDoes4 = $4; { codec can work with 4-bit pixels }
codecInfoDoes8 = $8; { codec can work with 8-bit pixels }
codecInfoDoes16 = $10; { codec can work with 16-bit pixels }
codecInfoDoes32 = $20; { codec can work with 32-bit pixels }
codecInfoDoesDither = $40; { codec can do ditherMode }
codecInfoDoesStretch = $80; { codec can stretch to arbitrary sizes }
codecInfoDoesShrink = $100; { codec can shrink to arbitrary sizes }
codecInfoDoesMask = $200; { codec can mask to clipping regions }
codecInfoDoesTemporal = $400; { codec can handle temporal redundancy }
codecInfoDoesDouble = $800; { codec can stretch to double size exactly }
codecInfoDoesQuad = $1000; { codec can stretch to quadruple size exactly }
codecInfoDoesHalf = $2000; { codec can shrink to half size }
codecInfoDoesQuarter = $4000; { codec can shrink to quarter size }
codecInfoDoesRotate = $8000; { codec can rotate on decompress }
codecInfoDoesHorizFlip = $10000; { codec can flip horizontally on decompress }
codecInfoDoesVertFlip = $20000; { codec can flip vertically on decompress }
codecInfoDoesSkew = $40000; { codec can skew on decompress }
codecInfoDoesBlend = $80000; { codec can blend on decompress }
codecInfoDoesWarp = $100000; { codec can warp arbitrarily on decompress }
codecInfoDoesRecompress = $200000; { codec can recompress image without accumulating errors }
codecInfoDoesSpool = $400000; { codec can spool image data }
codecInfoDoesRateConstrain = $800000;
codecInfoDepth1 = $1; { compressed data at 1 bpp depth available }
codecInfoDepth2 = $2; { compressed data at 2 bpp depth available }
codecInfoDepth4 = $4; { compressed data at 4 bpp depth available }
codecInfoDepth8 = $8; { compressed data at 8 bpp depth available }
codecInfoDepth16 = $10; { compressed data at 16 bpp depth available }
codecInfoDepth32 = $20; { compressed data at 32 bpp depth available }
codecInfoDepth24 = $40; { compressed data at 24 bpp depth available }
codecInfoDepth33 = $80; { compressed data at 1 bpp monochrome depth available }
codecInfoDepth34 = $100; { compressed data at 2 bpp grayscale depth available }
codecInfoDepth36 = $200; { compressed data at 4 bpp grayscale depth available }
codecInfoDepth40 = $400; { compressed data at 8 bpp grayscale depth available }
codecInfoStoresClut = $800; { compressed data can have custom cluts }
codecInfoDoesLossless = $1000; { compressed data can be stored in lossless format }
codecInfoSequenceSensitive = $2000;
codecFlagUseImageBuffer = $1; { (input) allocate buffer for whole image on decompress sequence }
codecFlagUseScreenBuffer = $2; { (input) allocate buffer for screen on decompress sequence for faster updates }
codecFlagUpdatePrevious = $4; { (input) udate previous buffer on compress sequence }
codecFlagNoScreenUpdate = $8; { (input) dont update screen, but do update image buffer if allocated }
codecFlagWasCompressed = $10; { (input) hint to compressor that image was previously compressed }
codecFlagDontOffscreen = $20; { (input) return error instead of automatically going offscreen }
codecFlagUpdatePreviousComp = $40; { (input) udate previous buffer on compress sequence }
codecFlagForceKeyFrame = $80; { (input) when sent to CompressSequenceFrame, forces that frame to be a key frame }
codecFlagOnlyScreenUpdate = $100; { (input) only update screen from }
codecFlagLiveGrab = $200; { (input) data being compressed is from live source (speed is critical) }
codecFlagDontUseNewImageBuffer = $400; { (input) return error if image buffer is new or reallocated }
codecFlagInterlaceUpdate = $800; { (input) use interlaced update }
codecFlagUsedNewImageBuffer = $4000; { (output) indicates that image buffer was first used on this decompress sequence }
codecFlagUsedImageBuffer = $8000; { (output) indicates that image buffer was used on this decompress sequence }
codecErr = -8960; { the codec returned an error }
noCodecErr = -8961; { the specified codec could not be found }
codecUnimpErr = -8962; { this feature is not implemented by the specified codec }
codecSizeErr = -8963;
codecScreenBufErr = -8964; { the screen buffer could not be allocated }
codecImageBufErr = -8965; { the image buffer could not be allocated }
codecSpoolErr = -8966; { the compressed data must be in memory (spooling did not work) }
codecAbortErr = -8967; { the operation was aborted by the progress proc }
codecWouldOffscreenErr = -8968; { an offscreen access would have been used, but wasn't allowed because codecFlagDontOffscreen was set }
codecBadDataErr = -8969; { compressed data was found to have inconsistencies }
codecDataVersErr = -8970; { compressed data was of a format version that codec couldn't handle }
codecExtensionNotFoundErr = -8971;
codecConditionErr = -8972; { codec can not do requested operation }
codecOpenErr = -8973; { the codec could not be opened }
codecMinimumDataSize = 32768; { The minimum data size for spooling in or out data }
compressorComponentType = 'imco'; { the type for "Components" which compress images }
decompressorComponentType = 'imdc'; { the type for "Components" which decompress images }
TYPE
CompressorComponent = Component; { a Component which compresses images }
DecompressorComponent = Component; { a Component which decompresses images }
CodecComponent = Component; { a Component which decompresses or compresses images }
CONST
anyCodec = 0; { take first working codec of given type }
bestSpeedCodec = -1; { take fastest codec of given type }
bestFidelityCodec = -2; { take codec which is most accurate}
bestCompressionCodec = -3; { take codec of given type that is most accurate }
TYPE
CodecType = OsType; { type descriptor for codecs i.e: 'appl','jpeg','rle ' }
CodecFlags = INTEGER; { flags for codec manager calls }
CodecQ = LONGINT;
CONST
codecLosslessQuality = $400;
codecMaxQuality = $3FF;
codecMinQuality = $000;
codecLowQuality = $100;
codecNormalQuality = $200;
codecHighQuality = $300;
TYPE
DataProcPtr = ProcPtr;
FlushProcPtr = ProcPtr;
CompletionProcPtr = ProcPtr;
CONST
codecCompletionSource = 1; { asynchronous codec is done with source data }
codecCompletionDest = 2; { asynchronous codec is done with destination data }
TYPE
ProgressProcPtr = ProcPtr;
CONST
codecProgressOpen = 0;
codecProgressUpdatePercent = 1;
codecProgressClose = 2;
TYPE
StdPixProcPtr = ProcPtr;
ImageSequence = LONGINT;
ProgressProcRecordPtr = ^ProgressProcRecord;
ProgressProcRecord = RECORD
progressProc: ProgressProcPtr;
progressRefCon: LONGINT;
END;
CompletionProcRecordPtr = ^CompletionProcRecord;
CompletionProcRecord = RECORD
completionProc: CompletionProcPtr;
completionRefCon: LONGINT;
END;
DataProcRecordPtr = ^DataProcRecord;
DataProcRecord = RECORD
dataProc: DataProcPtr;
dataRefCon: LONGINT;
END;
FlushProcRecordPtr = ^FlushProcRecord;
FlushProcRecord = RECORD
flushProc: FlushProcPtr;
flushRefCon: LONGINT;
END;
AlignmentProcPtr = ProcPtr;
AlignmentProcRecordPtr = ^AlignmentProcRecord;
AlignmentProcRecord = RECORD
alignmentProc: AlignmentProcPtr;
alignmentRefCon: LONGINT;
END;
DataRateParamsPtr = ^DataRateParams;
DataRateParams = RECORD
dataRate: LONGINT;
dataOverrun: LONGINT;
frameDuration: LONGINT;
keyFrameRate: LONGINT;
minSpatialQuality: CodecQ;
minTemporalQuality: CodecQ;
END;
{
The ImageDescription is private data which is produced when an image or sequence
is compressed. It fully describes the format of the compressed data.}
ImageDescriptionPtr = ^ImageDescription;
ImageDescriptionHandle = ^ImageDescriptionPtr;
ImageDescription = PACKED RECORD
idSize: LONGINT; { total size of ImageDescription including extra data ( CLUTs and other per sequence data }
cType: CodecType; { what kind of codec compressed this data }
resvd1: LONGINT; { reserved for apple use }
resvd2: INTEGER; { reserved for apple use }
dataRefIndex: INTEGER; { set to zero }
version: INTEGER; { which version is this data }
revisionLevel: INTEGER; { what version of that codec did this }
vendor: LONGINT; { whose codec compressed this data }
temporalQuality: CodecQ; { what was the temporal quality factor }
spatialQuality: CodecQ; { what was the spatial quality factor }
width: INTEGER; { how many pixels wide is this data }
height: INTEGER; { how many pixels high is this data }
hRes: Fixed; { horizontal resolution }
vRes: Fixed; { vertical resolution }
dataSize: LONGINT; { if known, the size of data for this image descriptor }
frameCount: INTEGER; { number of frames this description applies to }
name: PACKED ARRAY [0..31] OF CHAR; { name of codec ( in case not installed ) }
depth: INTEGER; { what depth is this data (1-32) or ( 33-40 grayscale ) }
clutID: INTEGER; { clut id or if 0 clut follows or -1 if no clut }
END;
{
The CodecInfo is the information returned as the codecInfo struct by a codec Component
to the codec manager or to the caller. It is specific to the particular codec
implementation and not to the codec type.}
CodecInfo = PACKED RECORD
typeName: PACKED ARRAY [0..31] OF CHAR;{ name of the codec type i.e.: 'Apple Image Compression' }
version: INTEGER; { version of the codec data that this codec knows about }
revisionLevel: INTEGER; { revision level of this codec i.e: 0x00010001 (1.0.1) }
vendor: LONGINT; { Maker of this codec i.e: 'appl' }
decompressFlags: LONGINT; { codecInfo flags for decompression capabilities }
compressFlags: LONGINT; { codecInfo flags for compression capabilities }
formatFlags: LONGINT; { codecInfo flags for compression format details }
compressionAccuracy: CHAR; { measure (1-255) of accuracy of this codec for compress (0 if unknown) }
decompressionAccuracy: CHAR; { measure (1-255) of accuracy of this codec for decompress (0 if unknown) }
compressionSpeed: INTEGER; { ( millisecs for compressing 320x240 on base mac II) (0 if unknown) }
decompressionSpeed: INTEGER; { ( millisecs for decompressing 320x240 on mac II)(0 if unknown) }
compressionLevel: CHAR; { measure (1-255) of compression level of this codec (0 if unknown) }
resvd: CHAR; { pad }
minimumHeight: INTEGER; { minimum height of image (block size) }
minimumWidth: INTEGER; { minimum width of image (block size) }
decompressPipelineLatency: INTEGER; { in milliseconds ( for asynchronous codecs ) }
compressPipelineLatency: INTEGER; { in milliseconds ( for asynchronous codecs ) }
privateData: LONGINT;
END;
{ Name list returned by GetCodecNameList. }
CodecNameSpec = PACKED RECORD
codec: CodecComponent;
cType: CodecType;
typeName: PACKED ARRAY [0..31] OF CHAR;
name: Handle;
END;
CodecNameSpecListPtr = ^CodecNameSpecList;
CodecNameSpecList = RECORD
count: INTEGER;
list: ARRAY [0..0] OF CodecNameSpec;
END;
CONST
defaultDither = 0;
forceDither = 1;
suppressDither = 2;
FUNCTION CodecManagerVersion(VAR version: LONGINT): OSErr;
INLINE $7000,$AAA3;
FUNCTION GetCodecNameList(VAR list: CodecNameSpecListPtr;showAll: INTEGER): OSErr;
INLINE $7001,$AAA3;
FUNCTION DisposeCodecNameList(list: CodecNameSpecListPtr): OSErr;
INLINE $700F,$AAA3;
FUNCTION GetCodecInfo(VAR info: CodecInfo;cType: CodecType;codec: CodecComponent): OSErr;
INLINE $7003,$AAA3;
FUNCTION GetMaxCompressionSize(src: PixMapHandle;srcRect: Rect;colorDepth: INTEGER;
quality: CodecQ;cType: CodecType;codec: CompressorComponent;VAR size: LONGINT): OSErr;
INLINE $7004,$AAA3;
FUNCTION GetCompressionTime(src: PixMapHandle; srcRect: Rect;colorDepth: INTEGER;
cType: CodecType;codec: CompressorComponent;VAR spatialQuality: CodecQ;
VAR temporalQuality: CodecQ;VAR compressTime: LONGINT): OSErr;
INLINE $7005,$AAA3;
FUNCTION CompressImage(src: PixMapHandle; srcRect: Rect;quality: CodecQ;
cType: CodecType;desc: ImageDescriptionHandle;data: Ptr): OSErr;
INLINE $7006,$AAA3;
FUNCTION FCompressImage(src: PixMapHandle; srcRect: Rect;colorDepth: INTEGER;
quality: CodecQ;cType: CodecType;codec: CompressorComponent;clut: CTabHandle;
flags: CodecFlags;bufferSize: LONGINT;flushProc: FlushProcRecordPtr;progressProc: ProgressProcRecordPtr;
desc: ImageDescriptionHandle;data: Ptr): OSErr;
INLINE $7007,$AAA3;
FUNCTION DecompressImage(data: Ptr;desc: ImageDescriptionHandle;dst: PixMapHandle;
srcRect: Rect; dstRect: Rect;mode: INTEGER;mask: RgnHandle): OSErr;
INLINE $7008,$AAA3;
FUNCTION FDecompressImage(data: Ptr;desc: ImageDescriptionHandle;dst: PixMapHandle;
srcRect: Rect;matrix: MatrixRecordPtr;mode: INTEGER;mask: RgnHandle;
matte: PixMapHandle; matteRect: Rect;accuracy: CodecQ;codec: DecompressorComponent;
bufferSize: LONGINT;dataProc: DataProcRecordPtr;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $7009,$AAA3;
FUNCTION CompressSequenceBegin(VAR seqID: ImageSequence;src: PixMapHandle;
prev: PixMapHandle; srcRect: Rect; prevRect: Rect;colorDepth: INTEGER;
cType: CodecType;codec: CompressorComponent;spatialQuality: CodecQ;temporalQuality: CodecQ;
keyFrameRate: LONGINT;clut: CTabHandle;flags: CodecFlags;desc: ImageDescriptionHandle): OSErr;
INLINE $700A,$AAA3;
FUNCTION CompressSequenceFrame(seqID: ImageSequence;src: PixMapHandle; srcRect: Rect;
flags: CodecFlags;data: Ptr;VAR dataSize: LONGINT;VAR similarity: Byte;
asyncCompletionProc: CompletionProcRecordPtr): OSErr;
INLINE $206F,$0004,$4250,$52AF,$0004,$700B,$AAA3;
FUNCTION DecompressSequenceBegin(VAR seqID: ImageSequence;desc: ImageDescriptionHandle;
port: CGrafPtr;gdh: GDHandle; srcRect: Rect;matrix: MatrixRecordPtr;
mode: INTEGER;mask: RgnHandle;flags: CodecFlags;accuracy: CodecQ;codec: DecompressorComponent): OSErr;
INLINE $700D,$AAA3;
FUNCTION DecompressSequenceFrame(seqID: ImageSequence;data: Ptr;inFlags: CodecFlags;
VAR outFlags: CodecFlags;asyncCompletionProc: CompletionProcRecordPtr): OSErr;
INLINE $700E,$AAA3;
FUNCTION SetDSequenceMatrix(seqID: ImageSequence;matrix: MatrixRecordPtr): OSErr;
INLINE $7010,$AAA3;
FUNCTION SetDSequenceMatte(seqID: ImageSequence;matte: PixMapHandle; matteRect: Rect): OSErr;
INLINE $7011,$AAA3;
FUNCTION SetDSequenceMask(seqID: ImageSequence;mask: RgnHandle): OSErr;
INLINE $7012,$AAA3;
FUNCTION SetDSequenceTransferMode(seqID: ImageSequence;mode: INTEGER; opColor: RGBColor): OSErr;
INLINE $7013,$AAA3;
FUNCTION SetDSequenceDataProc(seqID: ImageSequence;dataProc: DataProcRecordPtr;
bufferSize: LONGINT): OSErr;
INLINE $7014,$AAA3;
FUNCTION SetDSequenceAccuracy(seqID: ImageSequence;accuracy: CodecQ): OSErr;
INLINE $7034,$AAA3;
FUNCTION SetDSequenceSrcRect(seqID: ImageSequence; srcRect: Rect): OSErr;
INLINE $7035,$AAA3;
FUNCTION GetDSequenceImageBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
INLINE $7015,$AAA3;
FUNCTION GetDSequenceScreenBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
INLINE $7016,$AAA3;
FUNCTION SetCSequenceQuality(seqID: ImageSequence;spatialQuality: CodecQ;
temporalQuality: CodecQ): OSErr;
INLINE $7017,$AAA3;
FUNCTION SetCSequencePrev(seqID: ImageSequence;prev: PixMapHandle; prevRect: Rect): OSErr;
INLINE $7018,$AAA3;
FUNCTION SetCSequenceFlushProc(seqID: ImageSequence;flushProc: FlushProcRecordPtr;
bufferSize: LONGINT): OSErr;
INLINE $7033,$AAA3;
FUNCTION SetCSequenceKeyFrameRate(seqID: ImageSequence;keyframerate: LONGINT): OSErr;
INLINE $7036,$AAA3;
FUNCTION GetCSequenceKeyFrameRate(seqID: ImageSequence; VAR keyframerate: LONGINT): OSErr;
INLINE $203C,12,75,$AAA3;
FUNCTION GetCSequencePrevBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
INLINE $7019,$AAA3;
FUNCTION CDSequenceBusy(seqID: ImageSequence): OSErr;
INLINE $701A,$AAA3;
FUNCTION CDSequenceEnd(seqID: ImageSequence): OSErr;
INLINE $701B,$AAA3;
FUNCTION GetCompressedImageSize(desc: ImageDescriptionHandle;data: Ptr;
bufferSize: LONGINT;dataProc: DataProcRecordPtr;VAR dataSize: LONGINT): OSErr;
INLINE $701C,$AAA3;
FUNCTION GetSimilarity(src: PixMapHandle; srcRect: Rect;desc: ImageDescriptionHandle;
data: Ptr;VAR similarity: Fixed): OSErr;
INLINE $701D,$AAA3;
FUNCTION GetImageDescriptionCTable(desc: ImageDescriptionHandle;VAR ctable: CTabHandle): OSErr;
INLINE $701E,$AAA3;
FUNCTION SetImageDescriptionCTable(desc: ImageDescriptionHandle;ctable: CTabHandle): OSErr;
INLINE $701F,$AAA3;
FUNCTION GetImageDescriptionExtension(desc: ImageDescriptionHandle;VAR extension: Handle;
idType: LONGINT;index: LONGINT): OSErr;
INLINE $7020,$AAA3;
FUNCTION SetImageDescriptionExtension(desc: ImageDescriptionHandle;extension: Handle;
idType: LONGINT): OSErr;
INLINE $7021,$AAA3;
FUNCTION RemoveImageDescriptionExtension(desc: ImageDescriptionHandle; idType: LONGINT; index: LONGINT): OSErr;
INLINE $203C,12,$003A,$AAA3;
FUNCTION CountImageDescriptionExtensionType(desc: ImageDescriptionHandle; idType: LONGINT; VAR count: LONGINT): OSErr;
INLINE $203C,12,$003B,$AAA3;
FUNCTION GetNextImageDescriptionExtensionType(desc: ImageDescriptionHandle; VAR idType: LONGINT): OSErr;
INLINE $203C,8,$003C,$AAA3;
FUNCTION FindCodec(cType: CodecType;specCodec: CodecComponent;VAR compressor: CompressorComponent;
VAR decompressor: DecompressorComponent): OSErr;
INLINE $7023,$AAA3;
FUNCTION CompressPicture(srcPicture: PicHandle;dstPicture: PicHandle;quality: CodecQ;
cType: CodecType): OSErr;
INLINE $7024,$AAA3;
FUNCTION FCompressPicture(srcPicture: PicHandle;dstPicture: PicHandle;colorDepth: INTEGER;
clut: CTabHandle;quality: CodecQ;doDither: INTEGER;compressAgain: INTEGER;
progressProc: ProgressProcRecordPtr;cType: CodecType;codec: CompressorComponent): OSErr;
INLINE $7025,$AAA3;
FUNCTION CompressPictureFile(srcRefNum: INTEGER;dstRefNum: INTEGER;quality: CodecQ;
cType: CodecType): OSErr;
INLINE $7026,$AAA3;
FUNCTION FCompressPictureFile(srcRefNum: INTEGER;dstRefNum: INTEGER;colorDepth: INTEGER;
clut: CTabHandle;quality: CodecQ;doDither: INTEGER;compressAgain: INTEGER;
progressProc: ProgressProcRecordPtr;cType: CodecType;codec: CompressorComponent): OSErr;
INLINE $7027,$AAA3;
FUNCTION GetPictureFileHeader(refNum: INTEGER;VAR frame: Rect;VAR header: OpenCPicParams): OSErr;
INLINE $7028,$AAA3;
FUNCTION DrawPictureFile(refNum: INTEGER; frame: Rect;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $7029,$AAA3;
FUNCTION DrawTrimmedPicture(srcPicture: PicHandle; frame: Rect;trimMask: RgnHandle;
doDither: INTEGER;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $702E,$AAA3;
FUNCTION DrawTrimmedPictureFile(srcRefnum: INTEGER; frame: Rect;trimMask: RgnHandle;
doDither: INTEGER;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $702F,$AAA3;
FUNCTION MakeThumbnailFromPicture(picture: PicHandle;colorDepth: INTEGER;
thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $702A,$AAA3;
FUNCTION MakeThumbnailFromPictureFile(refNum: INTEGER;colorDepth: INTEGER;
thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $702B,$AAA3;
FUNCTION MakeThumbnailFromPixMap(src: PixMapHandle; srcRect: Rect;colorDepth: INTEGER;
thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $702C,$AAA3;
FUNCTION TrimImage(desc: ImageDescriptionHandle;inData: Ptr;inBufferSize: LONGINT;
dataProc: DataProcRecordPtr;outData: Ptr;outBufferSize: LONGINT;flushProc: FlushProcRecordPtr;
VAR trimRect: Rect;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $702D,$AAA3;
FUNCTION ConvertImage(srcDD: ImageDescriptionHandle;srcData: Ptr;colorDepth: INTEGER;
clut: CTabHandle;accuracy: CodecQ;quality: CodecQ;cType: CodecType;codec: CodecComponent;
dstDD: ImageDescriptionHandle;dstData: Ptr): OSErr;
INLINE $7030,$AAA3;
FUNCTION GetCompressedPixMapInfo(pix: PixMapPtr;VAR desc: ImageDescriptionHandle;
VAR data: Ptr;VAR bufferSize: LONGINT; dataProc: DataProcRecordPtr; progressProc: ProgressProcRecordPtr): OSErr;
INLINE $7037,$AAA3;
FUNCTION SetCompressedPixMapInfo(pix: PixMapPtr;desc: ImageDescriptionHandle;
data: Ptr;bufferSize: LONGINT;dataProc: DataProcRecordPtr;progressProc: ProgressProcRecordPtr): OSErr;
INLINE $7038,$AAA3;
FUNCTION StdPix( src: PixMapPtr; srcRect :Rect; matrix : MatrixRecordPtr; mode : INTEGER;
mask: RgnHandle ; matte: PixMapPtr; matteRect: Rect; flags : INTEGER ) : OSErr;
INLINE $700C,$AAA3;
{ Standard Preview }
PROCEDURE SFGetFilePreview(where: Point;
prompt: Str255;
fileFilter: FileFilterProcPtr;
numTypes: INTEGER;
typeList: SFTypeList;
dlgHook: DlgHookProcPtr;
VAR reply: SFReply);
INLINE $303C,$41,$AAA3;
PROCEDURE SFPGetFilePreview(where: Point;
prompt: Str255;
fileFilter: FileFilterProcPtr;
numTypes: INTEGER;
typeList: SFTypeList;
dlgHook: DlgHookProcPtr;
VAR reply: SFReply;
dlgID: INTEGER;
filterProc: ModalFilterProcPtr);
INLINE $303C,$42,$AAA3;
PROCEDURE StandardGetFilePreview(fileFilter: FileFilterProcPtr;
numTypes: INTEGER;
typeList: SFTypeList;
VAR reply: StandardFileReply);
INLINE $303C,$43,$AAA3;
PROCEDURE CustomGetFilePreview(fileFilter: FileFilterYDProcPtr;
numTypes: INTEGER;
typeList: SFTypeList;
VAR reply: StandardFileReply;
dlgID: INTEGER;
where: Point;
dlgHook: DlgHookYDProcPtr;
filterProc: ModalFilterYDProcPtr;
activeList: Ptr;
activateProc: ActivateYDProcPtr;
yourDataPtr: UNIV Ptr);
INLINE $303C,$44,$AAA3;
FUNCTION MakeFilePreview(resRefNum: INTEGER; progress: ProgressProcRecordPtr): OSErr;
INLINE $303C,$45,$AAA3;
FUNCTION AddFilePreview(resRefNum: INTEGER; previewType: OSType; previewData: Handle): OSErr;
INLINE $303C,$46,$AAA3;
CONST
sfpItemPreviewAreaUser = 11;
sfpItemPreviewStaticText = 12;
sfpItemPreviewDividerUser = 13;
sfpItemCreatePreviewButton = 14;
sfpItemShowPreviewButton = 15;
TYPE
PreviewResourcePtr = ^PreviewResourceRecord;
PreviewResourceHandle = ^PreviewResourcePtr;
PreviewResourceRecord = RECORD
modDate : LONGINT;
version : INTEGER;
resType : OSType;
resID : INTEGER;
END;
PROCEDURE AlignScreenRect(VAR rp: Rect; alignmentProc:AlignmentProcRecordPtr);
INLINE $203C,$8,$4C,$AAA3;
PROCEDURE AlignWindow(wp: WindowPtr; front: Boolean; alignmentRect: RectPtr; alignmentProc:AlignmentProcRecordPtr );
INLINE $203C,$E,$4D,$AAA3;
PROCEDURE DragAlignedWindow(wp: WindowPtr; startPt: Point; VAR boundsRect: Rect; VAR alignmentRect: Rect; alignmentProc:AlignmentProcRecordPtr);
INLINE $203C,$14,$4E,$AAA3;
FUNCTION DragAlignedGrayRgn(theRgn: RgnHandle; startPt: Point; VAR boundsRect: Rect;
VAR slopRect: Rect; axis: INTEGER; actionProc: ProcPtr; VAR alignmentRect: Rect; alignmentProc:AlignmentProcRecordPtr): LONGINT;
INLINE $203C,$1E,$4F,$AAA3;
FUNCTION SetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
INLINE $203C,$8,$50,$AAA3;
FUNCTION SetCSequenceFrameNumber(seqID: ImageSequence; frameNumber: LONGINT): OSErr;
INLINE $203C,$8,$51,$AAA3;
FUNCTION NewImageGWorld(VAR gworld: GWorldPtr; idh: ImageDescriptionHandle; flags :GWorldFlags): OSErr;
INLINE $203C,$C,$52,$AAA3;
FUNCTION GetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
INLINE $203C,$8,$53,$AAA3;
FUNCTION GetCSequenceFrameNumber(seqID: ImageSequence; VAR frameNumber: LONGINT): OSErr;
INLINE $203C,$8,$54,$AAA3;
FUNCTION GetBestDeviceRect(VAR gdh: GDHandle; VAR rp: Rect): OSErr;
INLINE $203C,$8,$55,$AAA3;
CONST
identityMatrixType = $00; { result if matrix is identity }
translateMatrixType = $01; { result if matrix translates }
scaleMatrixType = $02; { result if matrix scales }
scaleTranslateMatrixType = $03; { result if matrix scales and translates }
linearMatrixType = $04; { result if matrix is general 2 x 2 }
linearTranslateMatrixType = $05; { result if matrix is general 2 x 2 and translates }
perspectiveMatrixType = $06; { result if matrix is general 3 x 3 }
FUNCTION GetMatrixType( m: MatrixRecord): INTEGER;
INLINE $7014,$ABC2;
PROCEDURE CopyMatrix(m1: MatrixRecord;VAR m2: MatrixRecord);
INLINE $7020,$ABC2;
FUNCTION EqualMatrix(m1: MatrixRecord; m2: MatrixRecord): BOOLEAN;
INLINE $7021,$ABC2;
PROCEDURE SetIdentityMatrix(VAR matrix: MatrixRecord);
INLINE $7015,$ABC2;
PROCEDURE TranslateMatrix(VAR m: MatrixRecord;deltaH: Fixed;deltaV: Fixed);
INLINE $7019,$ABC2;
PROCEDURE RotateMatrix(VAR m: MatrixRecord;degrees: Fixed;aboutX: Fixed;
aboutY: Fixed);
INLINE $7016,$ABC2;
PROCEDURE ScaleMatrix(VAR m: MatrixRecord;scaleX: Fixed;scaleY: Fixed;aboutX: Fixed;
aboutY: Fixed);
INLINE $7017,$ABC2;
PROCEDURE SkewMatrix(VAR m: MatrixRecord;skewX: Fixed;skewY: Fixed;aboutX: Fixed;
aboutY: Fixed);
INLINE $7018,$ABC2;
FUNCTION TransformFixedPoints( m: MatrixRecord;VAR fpt: FixedPoint;count: LONGINT): OSErr;
INLINE $7022,$ABC2;
FUNCTION TransformPoints( mp: MatrixRecord;VAR pt1: Point;count: LONGINT): OSErr;
INLINE $7023,$ABC2;
FUNCTION TransformFixedRect( m: MatrixRecord;VAR fr: FixedRect;VAR fpp: FixedPoint): BOOLEAN;
INLINE $7024,$ABC2;
FUNCTION TransformRect( m: MatrixRecord;VAR r: Rect;VAR fpp: FixedPoint): BOOLEAN;
INLINE $7025,$ABC2;
FUNCTION TransformRgn( mp: MatrixRecord;r: RgnHandle): OSErr;
INLINE $7039,$AAA3;
FUNCTION InverseMatrix(m: MatrixRecord; VAR im: MatrixRecord): BOOLEAN;
INLINE $701C,$ABC2;
PROCEDURE ConcatMatrix(a: MatrixRecord;VAR b: MatrixRecord);
INLINE $701B,$ABC2;
PROCEDURE RectMatrix(VAR matrix: MatrixRecord; srcRect: Rect; dstRect: Rect);
INLINE $701E,$ABC2;
PROCEDURE MapMatrix(VAR matrix: MatrixRecord; fromRect: Rect; toRect: Rect);
INLINE $701D,$ABC2;
{$ENDC} { UsingImageCompression }
{$IFC NOT UsingIncludes}
END.
{$ENDC}
Reference in New Issue View Git Blame Copy Permalink