mirror of
https://github.com/elliotnunn/sys7.1-doc-wip.git
synced 2024-05-31 13:41:30 +00:00
621 lines
26 KiB
C
621 lines
26 KiB
C
|
|
/************************************************************
|
|
|
|
Created: Tuesday, August 13, 1991 at 4:25 PM
|
|
ImageCompression.h
|
|
C Interface to the Macintosh Libraries
|
|
|
|
|
|
Copyright Apple Computer, Inc. 1991
|
|
All rights reserved
|
|
|
|
************************************************************/
|
|
|
|
|
|
#ifndef __IMAGECOMPRESSION__
|
|
#define __IMAGECOMPRESSION__
|
|
|
|
#ifndef __QUICKDRAW__
|
|
#include <QuickDraw.h>
|
|
#endif
|
|
|
|
#ifndef __QDOFFSCREEN__
|
|
#include <QDOffscreen.h>
|
|
#endif
|
|
|
|
#ifndef __TYPES__
|
|
#include <Types.h>
|
|
#endif
|
|
|
|
#ifndef __COMPONENTS__
|
|
#include <Components.h>
|
|
#endif
|
|
|
|
#ifndef __STANDARDFILE__
|
|
#include <StandardFile.h>
|
|
#endif
|
|
|
|
|
|
enum {
|
|
|
|
|
|
#define gestaltCompressionMgr 'icmp'
|
|
|
|
/* These are the bits that are set in the Component flags, and also in the codecInfo struct. */
|
|
|
|
#define codecInfoDoes1 (1L<<0) /* codec can work with 1-bit pixels */
|
|
#define codecInfoDoes2 (1L<<1) /* codec can work with 2-bit pixels */
|
|
#define codecInfoDoes4 (1L<<2) /* codec can work with 4-bit pixels */
|
|
#define codecInfoDoes8 (1L<<3) /* codec can work with 8-bit pixels */
|
|
#define codecInfoDoes16 (1L<<4) /* codec can work with 16-bit pixels */
|
|
#define codecInfoDoes32 (1L<<5) /* codec can work with 32-bit pixels */
|
|
#define codecInfoDoesDither (1L<<6) /* codec can do ditherMode */
|
|
#define codecInfoDoesStretch (1L<<7) /* codec can stretch to arbitrary sizes */
|
|
#define codecInfoDoesShrink (1L<<8) /* codec can shrink to arbitrary sizes */
|
|
#define codecInfoDoesMask (1L<<9) /* codec can mask to clipping regions */
|
|
|
|
#define codecInfoDoesTemporal (1L<<10) /* codec can handle temporal redundancy */
|
|
|
|
#define codecInfoDoesDouble (1L<<11) /* codec can stretch to double size exactly */
|
|
#define codecInfoDoesQuad (1L<<12) /* codec can stretch to quadruple size exactly */
|
|
#define codecInfoDoesHalf (1L<<13) /* codec can shrink to half size */
|
|
#define codecInfoDoesQuarter (1L<<14) /* codec can shrink to quarter size */
|
|
|
|
#define codecInfoDoesRotate (1L<<15) /* codec can rotate on decompress */
|
|
#define codecInfoDoesHorizFlip (1L<<16) /* codec can flip horizontally on decompress */
|
|
#define codecInfoDoesVertFlip (1L<<17) /* codec can flip vertically on decompress */
|
|
#define codecInfoDoesSkew (1L<<18) /* codec can skew on decompress */
|
|
#define codecInfoDoesBlend (1L<<19) /* codec can blend on decompress */
|
|
#define codecInfoDoesWarp (1L<<20) /* codec can warp arbitrarily on decompress */
|
|
#define codecInfoDoesRecompress (1L<<21) /* codec can recompress image without accumulating errors */
|
|
#define codecInfoDoesSpool (1L<<22) /* codec can spool image data */
|
|
|
|
#define codecInfoDepth1 (1L<<0) /* compressed data at 1 bpp depth available */
|
|
#define codecInfoDepth2 (1L<<1) /* compressed data at 2 bpp depth available */
|
|
#define codecInfoDepth4 (1L<<2) /* compressed data at 4 bpp depth available */
|
|
#define codecInfoDepth8 (1L<<3) /* compressed data at 8 bpp depth available */
|
|
#define codecInfoDepth16 (1L<<4) /* compressed data at 16 bpp depth available */
|
|
#define codecInfoDepth32 (1L<<5) /* compressed data at 32 bpp depth available */
|
|
#define codecInfoDepth24 (1L<<6) /* compressed data at 24 bpp depth available */
|
|
#define codecInfoDepth33 (1L<<7) /* compressed data at 1 bpp monochrome depth available */
|
|
#define codecInfoDepth34 (1L<<8) /* compressed data at 2 bpp grayscale depth available */
|
|
#define codecInfoDepth36 (1L<<9) /* compressed data at 4 bpp grayscale depth available */
|
|
#define codecInfoDepth40 (1L<<10) /* compressed data at 8 bpp grayscale depth available */
|
|
#define codecInfoStoresClut (1L<<11) /* compressed data can have custom cluts */
|
|
#define codecInfoDoesLossless (1L<<12) /* compressed data can be stored in lossless format */
|
|
|
|
#define codecFlagUseImageBuffer (1L<<0) /* (input) allocate buffer for whole image on decompress sequence */
|
|
#define codecFlagUseScreenBuffer (1L<<1) /* (input) allocate buffer for screen on decompress sequence for faster updates */
|
|
#define codecFlagUpdatePrevious (1L<<2) /* (input) udate previous buffer on compress sequence */
|
|
#define codecFlagNoScreenUpdate (1L<<3) /* (input) dont update screen, but do update image buffer if allocated */
|
|
#define codecFlagWasCompressed (1L<<4) /* (input) hint to compressor that image was previously compressed */
|
|
#define codecFlagDontOffscreen (1L<<5) /* return error instead of automatically going offscreen */
|
|
#define codecFlagUpdatePreviousComp (1L<<6) /* (input) udate previous buffer on compress sequence */
|
|
#define codecFlagForceKeyFrame (1L<<7) /* when sent to CompressSequenceFrame, forces that frame to be a key frame */
|
|
#define codecFlagOnlyScreenUpdate (1L<<8) /* (input) only update screen from */
|
|
#define codecFlagLiveGrab (1L<<9) /* (input) data being compressed is from live source (speed is critical) */
|
|
|
|
|
|
|
|
#define codecFlagUsedNewImageBuffer (1L<<14) /* (output) indicates that image buffer was first used on this decompress sequence */
|
|
#define codecFlagUsedImageBuffer (1L<<15) /* (output) indicates that image buffer was used on this decompress sequence */
|
|
|
|
#define codecErr -8960 /* the codec returned an error */
|
|
#define noCodecErr -8961 /* the specified codec could not be found */
|
|
#define codecUnimpErr -8962 /* this feature is not implemented by the specified codec */
|
|
#define codecSizeErr -8963
|
|
#define codecScreenBufErr -8964 /* the screen buffer could not be allocated */
|
|
#define codecImageBufErr -8965 /* the image buffer could not be allocated */
|
|
#define codecSpoolErr -8966 /* the compressed data must be in memory (spooling did not work) */
|
|
#define codecAbortErr -8967 /* the operation was aborted by the progress proc */
|
|
#define codecWouldOffscreenErr -8968 /* an offscreen access would have been used, but wasn't allowed because codecFlagDontOffscreen was set */
|
|
#define codecBadDataErr -8969 /* compressed data was found to have inconsistencies */
|
|
#define codecDataVersErr -8970 /* compressed data was of a format version that codec couldn't handle */
|
|
#define codecConditionErr -8972 /* codec can not do requested operation */
|
|
#define codecOpenErr -8973 /* the codec could not be opened */
|
|
|
|
|
|
codecMinimumDataSize = 32768 /* The minimum data size for spooling in or out data */
|
|
|
|
|
|
#define compressorComponentType 'imco' /* the type for "Components" which compress images */
|
|
#define decompressorComponentType 'imdc' /* the type for "Components" which decompress images */
|
|
};
|
|
|
|
typedef Component CompressorComponent; /* a Component which compresses images */
|
|
typedef Component DecompressorComponent; /* a Component which decompresses images */
|
|
typedef Component CodecComponent; /* a Component which decompresses or compresses images */
|
|
|
|
|
|
|
|
|
|
#define anyCodec ((CodecComponent)0) /* take first working codec of given type */
|
|
#define bestSpeedCodec ((CodecComponent)-1) /* take fastest codec of given type */
|
|
#define bestFidelityCodec ((CodecComponent)-2) /* take codec which is most accurate*/
|
|
#define bestCompressionCodec ((CodecComponent)-3) /* take codec of given type that is most accurate */
|
|
|
|
|
|
typedef short sBoolean; /* to make sure stack frames are right */
|
|
|
|
typedef long CodecType; /* type descriptor for codecs i.e: 'appl','jpeg','rle ' */
|
|
|
|
typedef unsigned short CodecFlags; /* flags for codec manager calls */
|
|
|
|
typedef unsigned long CodecQ;
|
|
|
|
|
|
|
|
|
|
#define codecLosslessQuality 0x400L
|
|
#define codecMaxQuality 0x3FFL
|
|
#define codecMinQuality 0x000L
|
|
#define codecLowQuality 0x100L
|
|
#define codecNormalQuality 0x200L
|
|
#define codecHighQuality 0x300L
|
|
|
|
typedef pascal OSErr (*DataProcPtr)(Ptr *dataP,long bytesNeeded,long refCon);
|
|
typedef pascal OSErr (*FlushProcPtr)(Ptr data,long bytesAdded,long refCon);
|
|
|
|
|
|
|
|
|
|
#define codecCompletionSource (1<<0) /* asynchronous codec is done with source data */
|
|
#define codecCompletionDest (1<<1) /* asynchronous codec is done with destination data */
|
|
|
|
typedef pascal void (*CompletionProcPtr)(OSErr result,short flags,long refCon);
|
|
|
|
enum {
|
|
|
|
codecProgressOpen = 0,
|
|
codecProgressUpdatePercent = 1,
|
|
codecProgressClose = 2
|
|
};
|
|
|
|
typedef pascal OSErr (*ProgressProcPtr)(short message,Fixed completeness,long refCon);
|
|
|
|
typedef long ImageSequence;
|
|
|
|
struct ProgressProcRecord {
|
|
ProgressProcPtr progressProc;
|
|
long progressRefCon;
|
|
};
|
|
|
|
typedef struct ProgressProcRecord ProgressProcRecord;
|
|
typedef ProgressProcRecord *ProgressProcRecordPtr;
|
|
|
|
struct CompletionProcRecord {
|
|
CompletionProcPtr completionProc;
|
|
long completionRefCon;
|
|
};
|
|
|
|
typedef struct CompletionProcRecord CompletionProcRecord;
|
|
typedef CompletionProcRecord *CompletionProcRecordPtr;
|
|
|
|
struct DataProcRecord {
|
|
DataProcPtr dataProc;
|
|
long dataRefCon;
|
|
};
|
|
|
|
typedef struct DataProcRecord DataProcRecord;
|
|
typedef DataProcRecord *DataProcRecordPtr;
|
|
|
|
struct FlushProcRecord {
|
|
FlushProcPtr flushProc;
|
|
long flushRefCon;
|
|
};
|
|
|
|
typedef struct FlushProcRecord FlushProcRecord;
|
|
typedef FlushProcRecord *FlushProcRecordPtr;
|
|
|
|
/*
|
|
The ImageDescription is private data which is produced when an image or sequence
|
|
is compressed. It fully describes the format of the compressed data.*/
|
|
|
|
struct ImageDescription {
|
|
long idSize; /* total size of ImageDescription including extra data ( CLUTs and other per sequence data */
|
|
CodecType cType; /* what kind of codec compressed this data */
|
|
long resvd1; /* reserved for apple use */
|
|
short resvd2; /* reserved for apple use */
|
|
short dataRefIndex; /* set to zero */
|
|
short version; /* which version is this data */
|
|
short revisionLevel; /* what version of that codec did this */
|
|
long vendor; /* whose codec compressed this data */
|
|
CodecQ temporalQuality; /* what was the temporal quality factor */
|
|
CodecQ spatialQuality; /* what was the spatial quality factor */
|
|
short width; /* how many pixels wide is this data */
|
|
short height; /* how many pixels high is this data */
|
|
Fixed hRes; /* horizontal resolution */
|
|
Fixed vRes; /* vertical resolution */
|
|
long dataSize; /* if known, the size of data for this image descriptor */
|
|
short frameCount; /* number of frames this description applies to */
|
|
char name[32]; /* name of codec ( in case not installed ) */
|
|
short depth; /* what depth is this data (1-32) or ( 33-40 grayscale ) */
|
|
short clutID; /* clut id or if 0 clut follows or -1 if no clut */
|
|
};
|
|
|
|
typedef struct ImageDescription ImageDescription;
|
|
typedef ImageDescription *ImageDescriptionPtr, **ImageDescriptionHandle;
|
|
|
|
/*
|
|
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.*/
|
|
|
|
struct CodecInfo {
|
|
char typeName[32]; /* name of the codec type i.e.: 'Apple Image Compression' */
|
|
short version; /* version of the codec data that this codec knows about */
|
|
short revisionLevel; /* revision level of this codec i.e: 0x00010001 (1.0.1) */
|
|
long vendor; /* Maker of this codec i.e: 'appl' */
|
|
long decompressFlags; /* codecInfo flags for decompression capabilities */
|
|
long compressFlags; /* codecInfo flags for compression capabilities */
|
|
long formatFlags; /* codecInfo flags for compression format details */
|
|
unsigned char compressionAccuracy; /* measure (1-255) of accuracy of this codec for compress (0 if unknown) */
|
|
unsigned char decompressionAccuracy; /* measure (1-255) of accuracy of this codec for decompress (0 if unknown) */
|
|
unsigned short compressionSpeed; /* ( millisecs for compressing 320x240 on base mac II) (0 if unknown) */
|
|
unsigned short decompressionSpeed; /* ( millisecs for decompressing 320x240 on mac II)(0 if unknown) */
|
|
unsigned char compressionLevel; /* measure (1-255) of compression level of this codec (0 if unknown) */
|
|
char resvd; /* pad */
|
|
short minimumHeight; /* minimum height of image (block size) */
|
|
short minimumWidth; /* minimum width of image (block size) */
|
|
short decompressPipelineLatency; /* in milliseconds ( for asynchronous codecs ) */
|
|
short compressPipelineLatency; /* in milliseconds ( for asynchronous codecs ) */
|
|
long privateData;
|
|
};
|
|
|
|
typedef struct CodecInfo CodecInfo;
|
|
|
|
/* Table used for fast dithering. */
|
|
struct DitherTable {
|
|
long tag;
|
|
long seed;
|
|
long reserved;
|
|
char data[1];
|
|
};
|
|
|
|
typedef struct DitherTable DitherTable;
|
|
typedef DitherTable *DTabPtr, **DTabHandle;
|
|
|
|
/* Name list returned by GetCodecNameList. */
|
|
struct CodecNameSpec {
|
|
CodecComponent codec;
|
|
CodecType cType;
|
|
char typeName[32];
|
|
Handle name;
|
|
};
|
|
|
|
typedef struct CodecNameSpec CodecNameSpec;
|
|
|
|
struct CodecNameSpecList {
|
|
short count;
|
|
CodecNameSpec list[1];
|
|
};
|
|
|
|
typedef struct CodecNameSpecList CodecNameSpecList;
|
|
typedef CodecNameSpecList *CodecNameSpecListPtr;
|
|
|
|
/* Matrix stuff */
|
|
struct MatrixRecord {
|
|
Fixed matrix[3][3];
|
|
};
|
|
|
|
typedef struct MatrixRecord MatrixRecord;
|
|
typedef MatrixRecord *MatrixRecordPtr;
|
|
|
|
#ifndef _FixedPoint_
|
|
#define _FixedPoint_
|
|
struct FixedPoint {
|
|
Fixed x;
|
|
Fixed y;
|
|
};
|
|
|
|
typedef struct FixedPoint FixedPoint;
|
|
#endif _FixedPoint_
|
|
|
|
#ifndef _FixedRect_
|
|
#define _FixedRect_
|
|
struct FixedRect {
|
|
Fixed left;
|
|
Fixed top;
|
|
Fixed right;
|
|
Fixed bottom;
|
|
};
|
|
|
|
typedef struct FixedRect FixedRect;
|
|
#endif _FixedRect_
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
pascal OSErr CodecManagerVersion(long *version)
|
|
= {0x7000,0xAAA3};
|
|
pascal OSErr GetCodecNameList(CodecNameSpecListPtr *list,sBoolean showAll)
|
|
= {0x7001,0xAAA3};
|
|
pascal OSErr DisposeCodecNameList(CodecNameSpecListPtr list)
|
|
= {0x700F,0xAAA3};
|
|
pascal OSErr GetCodecInfo(CodecInfo *info,CodecType cType,CodecComponent codec)
|
|
= {0x7003,0xAAA3};
|
|
pascal OSErr GetMaxCompressionSize(PixMapHandle src,const Rect *srcRect,short colorDepth,
|
|
CodecQ quality,CodecType cType,CompressorComponent codec,long *size)
|
|
= {0x7004,0xAAA3};
|
|
pascal OSErr GetCompressionTime(PixMapHandle src,const Rect *srcRect,short colorDepth,
|
|
CodecType cType,CompressorComponent codec,CodecQ *spatialQuality,CodecQ *temporalQuality,
|
|
unsigned long *compressTime)
|
|
= {0x7005,0xAAA3};
|
|
pascal OSErr CompressImage(PixMapHandle src,const Rect *srcRect,CodecQ quality,
|
|
CodecType cType,ImageDescriptionHandle desc,Ptr data)
|
|
= {0x7006,0xAAA3};
|
|
pascal OSErr FCompressImage(PixMapHandle src,const Rect *srcRect,short colorDepth,
|
|
CodecQ quality,CodecType cType,CompressorComponent codec,CTabHandle clut,
|
|
CodecFlags flags,long bufferSize,FlushProcRecordPtr flushProc,ProgressProcRecordPtr progressProc,
|
|
ImageDescriptionHandle desc,Ptr data)
|
|
= {0x7007,0xAAA3};
|
|
pascal OSErr DecompressImage(Ptr data,ImageDescriptionHandle desc,PixMapHandle dst,
|
|
const Rect *srcRect,const Rect *dstRect,short mode,RgnHandle mask)
|
|
= {0x7008,0xAAA3};
|
|
pascal OSErr FDecompressImage(Ptr data,ImageDescriptionHandle desc,PixMapHandle dst,
|
|
const Rect *srcRect,MatrixRecordPtr matrix,short mode,RgnHandle mask,PixMapHandle matte,
|
|
const Rect *matteRect,CodecQ accuracy,DecompressorComponent codec,long bufferSize,
|
|
DataProcRecordPtr dataProc,ProgressProcRecordPtr progressProc)
|
|
= {0x7009,0xAAA3};
|
|
pascal OSErr CompressSequenceBegin(ImageSequence *seqID,PixMapHandle src,
|
|
PixMapHandle prev,const Rect *srcRect,const Rect *prevRect,short colorDepth,CodecType cType,
|
|
CompressorComponent codec,CodecQ spatialQuality,CodecQ temporalQuality,
|
|
long keyFrameRate,CTabHandle clut,CodecFlags flags,ImageDescriptionHandle desc)
|
|
= {0x700A,0xAAA3};
|
|
pascal OSErr CompressSequenceFrame(ImageSequence seqID,PixMapHandle src,
|
|
const Rect *srcRect,CodecFlags flags,Ptr data,long *dataSize,unsigned char *similarity,
|
|
CompletionProcRecordPtr asyncCompletionProc)
|
|
= {0x700B,0xAAA3};
|
|
pascal OSErr DecompressSequenceBegin(ImageSequence *seqID,ImageDescriptionHandle desc,
|
|
CGrafPtr port,GDHandle gdh,const Rect *srcRect,MatrixRecordPtr matrix,short mode,
|
|
RgnHandle mask,CodecFlags flags,CodecQ accuracy,DecompressorComponent codec)
|
|
= {0x700D,0xAAA3};
|
|
pascal OSErr DecompressSequenceFrame(ImageSequence seqID,Ptr data,CodecFlags inFlags,
|
|
CodecFlags *outFlags,CompletionProcRecordPtr asyncCompletionProc)
|
|
= {0x700E,0xAAA3};
|
|
pascal OSErr SetDSequenceMatrix(ImageSequence seqID,MatrixRecordPtr matrix)
|
|
= {0x7010,0xAAA3};
|
|
pascal OSErr SetDSequenceMatte(ImageSequence seqID,PixMapHandle matte,const Rect *matteRect)
|
|
= {0x7011,0xAAA3};
|
|
pascal OSErr SetDSequenceMask(ImageSequence seqID,RgnHandle mask)
|
|
= {0x7012,0xAAA3};
|
|
pascal OSErr SetDSequenceTransferMode(ImageSequence seqID,short mode,const RGBColor *opColor)
|
|
= {0x7013,0xAAA3};
|
|
pascal OSErr SetDSequenceDataProc(ImageSequence seqID,DataProcRecordPtr dataProc,
|
|
long bufferSize)
|
|
= {0x7014,0xAAA3};
|
|
pascal OSErr SetDSequenceAccuracy(ImageSequence seqID,CodecQ accuracy)
|
|
= {0x7034,0xAAA3};
|
|
pascal OSErr SetDSequenceSrcRect(ImageSequence seqID,const Rect *srcRect)
|
|
= {0x7035,0xAAA3};
|
|
pascal OSErr GetDSequenceImageBuffer(ImageSequence seqID,GWorldPtr *gworld)
|
|
= {0x7015,0xAAA3};
|
|
pascal OSErr GetDSequenceScreenBuffer(ImageSequence seqID,GWorldPtr *gworld)
|
|
= {0x7016,0xAAA3};
|
|
pascal OSErr SetCSequenceQuality(ImageSequence seqID,CodecQ spatialQuality,
|
|
CodecQ temporalQuality)
|
|
= {0x7017,0xAAA3};
|
|
pascal OSErr SetCSequencePrev(ImageSequence seqID,PixMapHandle prev,const Rect *prevRect)
|
|
= {0x7018,0xAAA3};
|
|
pascal OSErr SetCSequenceFlushProc(ImageSequence seqID,FlushProcRecordPtr flushProc,
|
|
long bufferSize)
|
|
= {0x7033,0xAAA3};
|
|
pascal OSErr SetCSequenceKeyFrameRate(ImageSequence seqID,long keyframerate)
|
|
= {0x7036,0xAAA3};
|
|
pascal OSErr GetCSequencePrevBuffer(ImageSequence seqID,GWorldPtr *gworld)
|
|
= {0x7019,0xAAA3};
|
|
pascal OSErr CDSequenceBusy(ImageSequence seqID)
|
|
= {0x701A,0xAAA3};
|
|
pascal OSErr CDSequenceEnd(ImageSequence seqID)
|
|
= {0x701B,0xAAA3};
|
|
pascal OSErr GetCompressedImageSize(ImageDescriptionHandle desc,Ptr data,
|
|
long bufferSize,DataProcRecordPtr dataProc,long *dataSize)
|
|
= {0x701C,0xAAA3};
|
|
pascal OSErr GetSimilarity(PixMapHandle src,const Rect *srcRect,ImageDescriptionHandle desc,
|
|
Ptr data,Fixed *similarity)
|
|
= {0x701D,0xAAA3};
|
|
pascal OSErr GetImageDescriptionCTable(ImageDescriptionHandle desc,CTabHandle *ctable)
|
|
= {0x701E,0xAAA3};
|
|
pascal OSErr SetImageDescriptionCTable(ImageDescriptionHandle desc,CTabHandle ctable)
|
|
= {0x701F,0xAAA3};
|
|
pascal OSErr GetImageDescriptionExtension(ImageDescriptionHandle desc,Handle *extension,
|
|
long idType,long index)
|
|
= {0x7020,0xAAA3};
|
|
pascal OSErr SetImageDescriptionExtension(ImageDescriptionHandle desc,Handle extension,
|
|
long idType)
|
|
= {0x7021,0xAAA3};
|
|
pascal OSErr FindCodec(CodecType cType,CodecComponent specCodec,CompressorComponent *compressor,
|
|
DecompressorComponent *decompressor)
|
|
= {0x7023,0xAAA3};
|
|
pascal OSErr CompressPicture(PicHandle srcPicture,PicHandle dstPicture,
|
|
CodecQ quality,CodecType cType)
|
|
= {0x7024,0xAAA3};
|
|
pascal OSErr FCompressPicture(PicHandle srcPicture,PicHandle dstPicture,
|
|
short colorDepth,CTabHandle clut,CodecQ quality,sBoolean doDither,sBoolean compressAgain,
|
|
ProgressProcRecordPtr progressProc,CodecType cType,CompressorComponent codec)
|
|
= {0x7025,0xAAA3};
|
|
pascal OSErr CompressPictureFile(short srcRefNum,short dstRefNum,CodecQ quality,
|
|
CodecType cType)
|
|
= {0x7026,0xAAA3};
|
|
pascal OSErr FCompressPictureFile(short srcRefNum,short dstRefNum,short colorDepth,
|
|
CTabHandle clut,CodecQ quality,sBoolean doDither,sBoolean compressAgain,
|
|
ProgressProcRecordPtr progressProc,CodecType cType,CompressorComponent codec)
|
|
= {0x7027,0xAAA3};
|
|
pascal OSErr GetPictureFileHeader(short refNum,Rect *frame,OpenCPicParams *header)
|
|
= {0x7028,0xAAA3};
|
|
pascal OSErr DrawPictureFile(short refNum,const Rect *frame,ProgressProcRecordPtr progressProc)
|
|
= {0x7029,0xAAA3};
|
|
pascal OSErr DrawTrimmedPicture(PicHandle srcPicture,const Rect *frame,RgnHandle trimMask,
|
|
sBoolean doDither,ProgressProcRecordPtr progressProc)
|
|
= {0x702E,0xAAA3};
|
|
pascal OSErr DrawTrimmedPictureFile(short srcRefnum,const Rect *frame,RgnHandle trimMask,
|
|
sBoolean doDither,ProgressProcRecordPtr progressProc)
|
|
= {0x702F,0xAAA3};
|
|
pascal OSErr MakeThumbnailFromPicture(PicHandle picture,short colorDepth,
|
|
PicHandle thumbnail,ProgressProcRecordPtr progressProc)
|
|
= {0x702A,0xAAA3};
|
|
pascal OSErr MakeThumbnailFromPictureFile(short refNum,short colorDepth,
|
|
PicHandle thumbnail,ProgressProcRecordPtr progressProc)
|
|
= {0x702B,0xAAA3};
|
|
pascal OSErr MakeThumbnailFromPixMap(PixMapHandle src,const Rect *srcRect,short colorDepth,
|
|
PicHandle thumbnail,ProgressProcRecordPtr progressProc)
|
|
= {0x702C,0xAAA3};
|
|
pascal OSErr TrimImage(ImageDescriptionHandle desc,Ptr inData,long inBufferSize,
|
|
DataProcRecordPtr dataProc,Ptr outData,long outBufferSize,FlushProcRecordPtr flushProc,
|
|
Rect *trimRect,ProgressProcRecordPtr progressProc)
|
|
= {0x702D,0xAAA3};
|
|
pascal OSErr ConvertImage(ImageDescriptionHandle srcDD,Ptr srcData,short colorDepth,
|
|
CTabHandle clut,CodecQ accuracy,CodecQ quality,CodecType cType,CodecComponent codec,
|
|
ImageDescriptionHandle dstDD,Ptr dstData)
|
|
= {0x7030,0xAAA3};
|
|
pascal OSErr MakeDitherTable(GDHandle gdev,DTabHandle *ditherTable)
|
|
= {0x7031,0xAAA3};
|
|
pascal OSErr DisposeDitherTable(DTabHandle ditherTable)
|
|
= {0x7032,0xAAA3};
|
|
|
|
|
|
pascal void
|
|
StdPix(PixMapPtr src,const Rect *srcRect,MatrixRecordPtr matrix,short mode,
|
|
RgnHandle mask,PixMapPtr matte,const Rect *matteRect,short flags)
|
|
= {0x700C,0xAAA3};
|
|
|
|
pascal OSErr GetCompressedPixMapInfo(PixMapPtr pix,ImageDescriptionHandle *desc,
|
|
Ptr *data,long *bufferSize,DataProcRecord *dataProc,ProgressProcRecord *progressProc)
|
|
= {0x7037,0xAAA3};
|
|
pascal OSErr SetCompressedPixMapInfo(PixMapPtr pix,ImageDescriptionHandle desc,
|
|
Ptr data,long bufferSize,DataProcRecordPtr dataProc,ProgressProcRecordPtr progressProc)
|
|
= {0x7038,0xAAA3};
|
|
pascal OSErr TransformRgn(MatrixRecordPtr mp,RgnHandle r)
|
|
= {0x7039,0xAAA3};
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
enum {
|
|
identityMatrixType = 0x00, /* result if matrix is identity */
|
|
translateMatrixType = 0x01, /* result if matrix translates */
|
|
scaleMatrixType = 0x02, /* result if matrix scales */
|
|
scaleTranslateMatrixType = 0x03, /* result if matrix scales and translates */
|
|
linearMatrixType = 0x04, /* result if matrix is general 2 x 2 */
|
|
linearTranslateMatrixType = 0x05, /* result if matrix is general 2 x 2 and translates */
|
|
perspectiveMatrixType = 0x06 /* result if matrix is general 3 x 3 */
|
|
};
|
|
typedef unsigned char MatrixFlags;
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
pascal short GetMatrixType(MatrixRecordPtr m)
|
|
= {0x7014,0xABC2};
|
|
pascal void CopyMatrix(MatrixRecordPtr m1,MatrixRecord *m2)
|
|
= {0x7020,0xABC2};
|
|
pascal Boolean EqualMatrix(MatrixRecordPtr m1,MatrixRecordPtr m2)
|
|
= {0x7021,0xABC2};
|
|
pascal void SetIdentityMatrix(MatrixRecord *matrix)
|
|
= {0x7015,0xABC2};
|
|
pascal void TranslateMatrix(MatrixRecord *m,Fixed deltaH,Fixed deltaV)
|
|
= {0x7019,0xABC2};
|
|
pascal void RotateMatrix(MatrixRecord *m,Fixed degrees,Fixed aboutX,Fixed aboutY)
|
|
= {0x7016,0xABC2};
|
|
pascal void ScaleMatrix(MatrixRecord *m,Fixed scaleX,Fixed scaleY,Fixed aboutX,
|
|
Fixed aboutY)
|
|
= {0x7017,0xABC2};
|
|
pascal void SkewMatrix(MatrixRecord *m,Fixed skewX,Fixed skewY,Fixed aboutX,
|
|
Fixed aboutY)
|
|
= {0x7018,0xABC2};
|
|
pascal OSErr TransformFixedPoints(MatrixRecordPtr m,FixedPoint *fpt,long count)
|
|
= {0x7022,0xABC2};
|
|
pascal OSErr TransformPoints(MatrixRecordPtr mp,Point *pt1,long count)
|
|
= {0x7023,0xABC2};
|
|
pascal Boolean TransformFixedRect(MatrixRecordPtr m,FixedRect *fr,FixedPoint *fpp)
|
|
= {0x7024,0xABC2};
|
|
pascal Boolean TransformRect(MatrixRecordPtr m,Rect *r,FixedPoint *fpp)
|
|
= {0x7025,0xABC2};
|
|
pascal Boolean InverseMatrix(MatrixRecordPtr m,MatrixRecord *im)
|
|
= {0x701C,0xABC2};
|
|
pascal void ConcatMatrix(MatrixRecordPtr a,MatrixRecord *b)
|
|
= {0x701B,0xABC2};
|
|
pascal void RectMatrix(MatrixRecord *matrix,Rect *srcRect,Rect *dstRect)
|
|
= {0x701E,0xABC2};
|
|
pascal void MapMatrix(MatrixRecord *matrix,Rect *fromRect,Rect *toRect)
|
|
= {0x701D,0xABC2};
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* Standard Preview */
|
|
|
|
pascal void SFGetFilePreview(Point where,
|
|
ConstStr255Param prompt,
|
|
FileFilterProcPtr fileFilter,
|
|
short numTypes,
|
|
SFTypeList typeList,
|
|
DlgHookProcPtr dlgHook,
|
|
SFReply *reply)
|
|
= {0x303C,65,0xAAA3};
|
|
|
|
pascal void SFPGetFilePreview(Point where,
|
|
ConstStr255Param prompt,
|
|
FileFilterProcPtr fileFilter,
|
|
short numTypes,
|
|
SFTypeList typeList,
|
|
DlgHookProcPtr dlgHook,
|
|
SFReply *reply,
|
|
short dlgID,
|
|
ModalFilterProcPtr filterProc)
|
|
= {0x303C,66,0xAAA3};
|
|
|
|
pascal void StandardGetFilePreview(FileFilterProcPtr fileFilter,
|
|
short numTypes,
|
|
SFTypeList typeList,
|
|
StandardFileReply *reply)
|
|
= {0x303C,67,0xAAA3};
|
|
|
|
pascal void CustomGetFilePreview(FileFilterYDProcPtr fileFilter,
|
|
short numTypes,
|
|
SFTypeList typeList,
|
|
StandardFileReply *reply,
|
|
short dlgID,
|
|
Point where,
|
|
DlgHookYDProcPtr dlgHook,
|
|
ModalFilterYDProcPtr filterProc,
|
|
short *activeList,
|
|
ActivateYDProcPtr activateProc,
|
|
void *yourDataPtr)
|
|
= {0x303C,68,0xAAA3};
|
|
|
|
pascal OSErr MakeFilePreview(short resRefNum, ProgressProcRecordPtr progress)
|
|
= {0x303C,69,0xAAA3};
|
|
|
|
pascal OSErr AddFilePreview(short resRefNum, OSType previewType, Handle previewData)
|
|
= {0x303C,70,0xAAA3};
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
enum {
|
|
sfpItemPreviewAreaUser = 11,
|
|
sfpItemPreviewStaticText = 12,
|
|
sfpItemPreviewDividerUser = 13,
|
|
sfpItemCreatePreviewButton = 14,
|
|
sfpItemShowPreviewButton = 15
|
|
};
|
|
|
|
struct PreviewResourceRecord {
|
|
unsigned long modDate;
|
|
short version;
|
|
OSType resType;
|
|
short resID;
|
|
};
|
|
|
|
typedef struct PreviewResourceRecord PreviewResourceRecord;
|
|
typedef PreviewResourceRecord *PreviewResourcePtr, **PreviewResource;
|
|
|
|
#endif
|