多媒体编程

开发平台：

Visual C++

ImageCompression.h：源码内容

/*
File: ImageCompression.h
Contains: QuickTime Interfaces.
Version: Technology: QuickTime 6.0
Release: QuickTime 6.0.2
Bugs?: For bug reports, consult the following page on
the World Wide Web:
http://developer.apple.com/bugreporter/
*/
#ifndef __IMAGECOMPRESSION__
#define __IMAGECOMPRESSION__
#ifndef __MACTYPES__
#include "MacTypes.h"
#endif
#ifndef __QUICKDRAW__
#include "Quickdraw.h"
#endif
#ifndef __QDOFFSCREEN__
#include "QDOffscreen.h"
#endif
#ifndef __COMPONENTS__
#include "Components.h"
#endif
#ifndef __STANDARDFILE__
#include "StandardFile.h"
#endif
#if PRAGMA_ONCE
#pragma once
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if PRAGMA_IMPORT
#pragma import on
#endif
#if PRAGMA_STRUCT_ALIGN
#pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
struct MatrixRecord {
Fixed matrix[3][3];
};
typedef struct MatrixRecord MatrixRecord;
typedef MatrixRecord * MatrixRecordPtr;
enum {
kRawCodecType = FOUR_CHAR_CODE('raw '),
kCinepakCodecType = FOUR_CHAR_CODE('cvid'),
kGraphicsCodecType = FOUR_CHAR_CODE('smc '),
kAnimationCodecType = FOUR_CHAR_CODE('rle '),
kVideoCodecType = FOUR_CHAR_CODE('rpza'),
kComponentVideoCodecType = FOUR_CHAR_CODE('yuv2'),
kJPEGCodecType = FOUR_CHAR_CODE('jpeg'),
kMotionJPEGACodecType = FOUR_CHAR_CODE('mjpa'),
kMotionJPEGBCodecType = FOUR_CHAR_CODE('mjpb'),
kSGICodecType = FOUR_CHAR_CODE('.SGI'),
kPlanarRGBCodecType = FOUR_CHAR_CODE('8BPS'),
kMacPaintCodecType = FOUR_CHAR_CODE('PNTG'),
kGIFCodecType = FOUR_CHAR_CODE('gif '),
kPhotoCDCodecType = FOUR_CHAR_CODE('kpcd'),
kQuickDrawGXCodecType = FOUR_CHAR_CODE('qdgx'),
kAVRJPEGCodecType = FOUR_CHAR_CODE('avr '),
kOpenDMLJPEGCodecType = FOUR_CHAR_CODE('dmb1'),
kBMPCodecType = FOUR_CHAR_CODE('WRLE'),
kWindowsRawCodecType = FOUR_CHAR_CODE('WRAW'),
kVectorCodecType = FOUR_CHAR_CODE('path'),
kQuickDrawCodecType = FOUR_CHAR_CODE('qdrw'),
kWaterRippleCodecType = FOUR_CHAR_CODE('ripl'),
kFireCodecType = FOUR_CHAR_CODE('fire'),
kCloudCodecType = FOUR_CHAR_CODE('clou'),
kH261CodecType = FOUR_CHAR_CODE('h261'),
kH263CodecType = FOUR_CHAR_CODE('h263'),
kDVCNTSCCodecType = FOUR_CHAR_CODE('dvc '), /* DV - NTSC and DVCPRO NTSC (available in QuickTime 6.0 or later)*/
/* NOTE: kDVCProNTSCCodecType is deprecated. */
/* Use kDVCNTSCCodecType instead -- as far as the codecs are concerned, */
/* the two data formats are identical.*/
kDVCPALCodecType = FOUR_CHAR_CODE('dvcp'),
kDVCProPALCodecType = FOUR_CHAR_CODE('dvpp'), /* available in QuickTime 6.0 or later*/
kBaseCodecType = FOUR_CHAR_CODE('base'),
kFLCCodecType = FOUR_CHAR_CODE('flic'),
kTargaCodecType = FOUR_CHAR_CODE('tga '),
kPNGCodecType = FOUR_CHAR_CODE('png '),
kTIFFCodecType = FOUR_CHAR_CODE('tiff'), /* NOTE: despite what might seem obvious from the two constants*/
/* below and their names, they really are correct. 'yuvu' really */
/* does mean signed, and 'yuvs' really does mean unsigned. Really. */
kComponentVideoSigned = FOUR_CHAR_CODE('yuvu'),
kComponentVideoUnsigned = FOUR_CHAR_CODE('yuvs'),
kCMYKCodecType = FOUR_CHAR_CODE('cmyk'),
kMicrosoftVideo1CodecType = FOUR_CHAR_CODE('msvc'),
kSorensonCodecType = FOUR_CHAR_CODE('SVQ1'),
kSorenson3CodecType = FOUR_CHAR_CODE('SVQ3'), /* available in QuickTime 5 and later*/
kIndeo4CodecType = FOUR_CHAR_CODE('IV41'),
kMPEG4VisualCodecType = FOUR_CHAR_CODE('mp4v'),
k64ARGBCodecType = FOUR_CHAR_CODE('b64a'),
k48RGBCodecType = FOUR_CHAR_CODE('b48r'),
k32AlphaGrayCodecType = FOUR_CHAR_CODE('b32a'),
k16GrayCodecType = FOUR_CHAR_CODE('b16g'),
kMpegYUV420CodecType = FOUR_CHAR_CODE('myuv'),
kYUV420CodecType = FOUR_CHAR_CODE('y420'),
kSorensonYUV9CodecType = FOUR_CHAR_CODE('syv9'),
k422YpCbCr8CodecType = FOUR_CHAR_CODE('2vuy'), /* Component Y'CbCr 8-bit 4:2:2 */
k444YpCbCr8CodecType = FOUR_CHAR_CODE('v308'), /* Component Y'CbCr 8-bit 4:4:4 */
k4444YpCbCrA8CodecType = FOUR_CHAR_CODE('v408'), /* Component Y'CbCrA 8-bit 4:4:4:4 */
k422YpCbCr16CodecType = FOUR_CHAR_CODE('v216'), /* Component Y'CbCr 10,12,14,16-bit 4:2:2*/
k422YpCbCr10CodecType = FOUR_CHAR_CODE('v210'), /* Component Y'CbCr 10-bit 4:2:2 */
k444YpCbCr10CodecType = FOUR_CHAR_CODE('v410'), /* Component Y'CbCr 10-bit 4:4:4 */
k4444YpCbCrA8RCodecType = FOUR_CHAR_CODE('r408') /* Component Y'CbCrA 8-bit 4:4:4:4, rendering format. full range alpha, zero biased yuv*/
};
/* one source effects */
enum {
kBlurImageFilterType = FOUR_CHAR_CODE('blur'),
kSharpenImageFilterType = FOUR_CHAR_CODE('shrp'),
kEdgeDetectImageFilterType = FOUR_CHAR_CODE('edge'),
kEmbossImageFilterType = FOUR_CHAR_CODE('embs'),
kConvolveImageFilterType = FOUR_CHAR_CODE('genk'),
kAlphaGainImageFilterType = FOUR_CHAR_CODE('gain'),
kRGBColorBalanceImageFilterType = FOUR_CHAR_CODE('rgbb'),
kHSLColorBalanceImageFilterType = FOUR_CHAR_CODE('hslb'),
kColorSyncImageFilterType = FOUR_CHAR_CODE('sync'),
kFilmNoiseImageFilterType = FOUR_CHAR_CODE('fmns'),
kSolarizeImageFilterType = FOUR_CHAR_CODE('solr'),
kColorTintImageFilterType = FOUR_CHAR_CODE('tint'),
kLensFlareImageFilterType = FOUR_CHAR_CODE('lens'),
kBrightnessContrastImageFilterType = FOUR_CHAR_CODE('brco')
};
/* two source effects */
enum {
kAlphaCompositorTransitionType = FOUR_CHAR_CODE('blnd'),
kCrossFadeTransitionType = FOUR_CHAR_CODE('dslv'),
kChannelCompositeEffectType = FOUR_CHAR_CODE('chan'),
kChromaKeyTransitionType = FOUR_CHAR_CODE('ckey'),
kImplodeTransitionType = FOUR_CHAR_CODE('mplo'),
kExplodeTransitionType = FOUR_CHAR_CODE('xplo'),
kGradientTransitionType = FOUR_CHAR_CODE('matt'),
kPushTransitionType = FOUR_CHAR_CODE('push'),
kSlideTransitionType = FOUR_CHAR_CODE('slid'),
kWipeTransitionType = FOUR_CHAR_CODE('smpt'),
kIrisTransitionType = FOUR_CHAR_CODE('smp2'),
kRadialTransitionType = FOUR_CHAR_CODE('smp3'),
kMatrixTransitionType = FOUR_CHAR_CODE('smp4'),
kZoomTransitionType = FOUR_CHAR_CODE('zoom')
};
/* three source effects */
enum {
kTravellingMatteEffectType = FOUR_CHAR_CODE('trav')
};
/* Supported by QTNewGWorld in QuickTime 4.0 and later */
enum {
kCMYKPixelFormat = FOUR_CHAR_CODE('cmyk'), /* CMYK, 8-bit */
k64ARGBPixelFormat = FOUR_CHAR_CODE('b64a'), /* ARGB, 16-bit big-endian samples */
k48RGBPixelFormat = FOUR_CHAR_CODE('b48r'), /* RGB, 16-bit big-endian samples */
k32AlphaGrayPixelFormat = FOUR_CHAR_CODE('b32a'), /* AlphaGray, 16-bit big-endian samples */
k16GrayPixelFormat = FOUR_CHAR_CODE('b16g'), /* Grayscale, 16-bit big-endian samples */
k422YpCbCr8PixelFormat = FOUR_CHAR_CODE('2vuy') /* Component Y'CbCr 8-bit 4:2:2, ordered Cb Y'0 Cr Y'1 */
};
/* Supported by QTNewGWorld in QuickTime 4.1.2 and later */
enum {
k4444YpCbCrA8PixelFormat = FOUR_CHAR_CODE('v408'), /* Component Y'CbCrA 8-bit 4:4:4:4, ordered Cb Y' Cr A */
k4444YpCbCrA8RPixelFormat = FOUR_CHAR_CODE('r408') /* Component Y'CbCrA 8-bit 4:4:4:4, rendering format. full range alpha, zero biased yuv, ordered A Y' Cb Cr */
};
/* Supported by QTNewGWorld in QuickTime 6.0 and later */
enum {
kYUV420PixelFormat = FOUR_CHAR_CODE('y420') /* Planar Component Y'CbCr 8-bit 4:2:0. PixMap baseAddr points to a big-endian PlanarPixmapInfoYUV420 struct; see ImageCodec.i. */
};
/* These are the bits that are set in the Component flags, and also in the codecInfo struct. */
enum {
codecInfoDoes1 = (1L << 0), /* codec can work with 1-bit pixels */
codecInfoDoes2 = (1L << 1), /* codec can work with 2-bit pixels */
codecInfoDoes4 = (1L << 2), /* codec can work with 4-bit pixels */
codecInfoDoes8 = (1L << 3), /* codec can work with 8-bit pixels */
codecInfoDoes16 = (1L << 4), /* codec can work with 16-bit pixels */
codecInfoDoes32 = (1L << 5), /* codec can work with 32-bit pixels */
codecInfoDoesDither = (1L << 6), /* codec can do ditherMode */
codecInfoDoesStretch = (1L << 7), /* codec can stretch to arbitrary sizes */
codecInfoDoesShrink = (1L << 8), /* codec can shrink to arbitrary sizes */
codecInfoDoesMask = (1L << 9), /* codec can mask to clipping regions */
codecInfoDoesTemporal = (1L << 10), /* codec can handle temporal redundancy */
codecInfoDoesDouble = (1L << 11), /* codec can stretch to double size exactly */
codecInfoDoesQuad = (1L << 12), /* codec can stretch to quadruple size exactly */
codecInfoDoesHalf = (1L << 13), /* codec can shrink to half size */
codecInfoDoesQuarter = (1L << 14), /* codec can shrink to quarter size */
codecInfoDoesRotate = (1L << 15), /* codec can rotate on decompress */
codecInfoDoesHorizFlip = (1L << 16), /* codec can flip horizontally on decompress */
codecInfoDoesVertFlip = (1L << 17), /* codec can flip vertically on decompress */
codecInfoHasEffectParameterList = (1L << 18), /* codec implements get effects parameter list call, once was codecInfoDoesSkew */
codecInfoDoesBlend = (1L << 19), /* codec can blend on decompress */
codecInfoDoesWarp = (1L << 20), /* codec can warp arbitrarily on decompress */
codecInfoDoesRecompress = (1L << 21), /* codec can recompress image without accumulating errors */
codecInfoDoesSpool = (1L << 22), /* codec can spool image data */
codecInfoDoesRateConstrain = (1L << 23) /* codec can data rate constrain */
};
enum {
codecInfoDepth1 = (1L << 0), /* compressed data at 1 bpp depth available */
codecInfoDepth2 = (1L << 1), /* compressed data at 2 bpp depth available */
codecInfoDepth4 = (1L << 2), /* compressed data at 4 bpp depth available */
codecInfoDepth8 = (1L << 3), /* compressed data at 8 bpp depth available */
codecInfoDepth16 = (1L << 4), /* compressed data at 16 bpp depth available */
codecInfoDepth32 = (1L << 5), /* compressed data at 32 bpp depth available */
codecInfoDepth24 = (1L << 6), /* compressed data at 24 bpp depth available */
codecInfoDepth33 = (1L << 7), /* compressed data at 1 bpp monochrome depth available */
codecInfoDepth34 = (1L << 8), /* compressed data at 2 bpp grayscale depth available */
codecInfoDepth36 = (1L << 9), /* compressed data at 4 bpp grayscale depth available */
codecInfoDepth40 = (1L << 10), /* compressed data at 8 bpp grayscale depth available */
codecInfoStoresClut = (1L << 11), /* compressed data can have custom cluts */
codecInfoDoesLossless = (1L << 12), /* compressed data can be stored in lossless format */
codecInfoSequenceSensitive = (1L << 13) /* compressed data is sensitive to out of sequence decoding */
};
/* input sequence flags*/
enum {
codecFlagUseImageBuffer = (1L << 0), /* decompress*/
codecFlagUseScreenBuffer = (1L << 1), /* decompress*/
codecFlagUpdatePrevious = (1L << 2), /* compress*/
codecFlagNoScreenUpdate = (1L << 3), /* decompress*/
codecFlagWasCompressed = (1L << 4), /* compress*/
codecFlagDontOffscreen = (1L << 5), /* decompress*/
codecFlagUpdatePreviousComp = (1L << 6), /* compress*/
codecFlagForceKeyFrame = (1L << 7), /* compress*/
codecFlagOnlyScreenUpdate = (1L << 8), /* decompress*/
codecFlagLiveGrab = (1L << 9), /* compress*/
codecFlagDiffFrame = (1L << 9), /* decompress*/
codecFlagDontUseNewImageBuffer = (1L << 10), /* decompress*/
codecFlagInterlaceUpdate = (1L << 11), /* decompress*/
codecFlagCatchUpDiff = (1L << 12), /* decompress*/
codecFlagSupportDisable = (1L << 13), /* decompress*/
codecFlagReenable = (1L << 14) /* decompress*/
};
/* output sequence flags*/
enum {
codecFlagOutUpdateOnNextIdle = (1L << 9),
codecFlagOutUpdateOnDataSourceChange = (1L << 10),
codecFlagSequenceSensitive = (1L << 11),
codecFlagOutUpdateOnTimeChange = (1L << 12),
codecFlagImageBufferNotSourceImage = (1L << 13),
codecFlagUsedNewImageBuffer = (1L << 14),
codecFlagUsedImageBuffer = (1L << 15)
};
enum {
/* The minimum data size for spooling in or out data */
codecMinimumDataSize = 32768L
};
enum {
compressorComponentType = FOUR_CHAR_CODE('imco'), /* the type for "Components" which compress images */
decompressorComponentType = FOUR_CHAR_CODE('imdc') /* the type for "Components" which decompress images */
};
typedef Component CompressorComponent;
typedef Component DecompressorComponent;
typedef Component CodecComponent;
#define anyCodec ((CodecComponent)0)
#define bestSpeedCodec ((CodecComponent)-1)
#define bestFidelityCodec ((CodecComponent)-2)
#define bestCompressionCodec ((CodecComponent)-3)
typedef OSType CodecType;
typedef unsigned short CodecFlags;
typedef unsigned long CodecQ;
enum {
codecLosslessQuality = 0x00000400,
codecMaxQuality = 0x000003FF,
codecMinQuality = 0x00000000,
codecLowQuality = 0x00000100,
codecNormalQuality = 0x00000200,
codecHighQuality = 0x00000300
};
enum {
codecLockBitsShieldCursor = (1 << 0) /* shield cursor */
};
enum {
codecCompletionSource = (1 << 0), /* asynchronous codec is done with source data */
codecCompletionDest = (1 << 1), /* asynchronous codec is done with destination data */
codecCompletionDontUnshield = (1 << 2), /* on dest complete don't unshield cursor */
codecCompletionWentOffscreen = (1 << 3), /* codec used offscreen buffer */
codecCompletionUnlockBits = (1 << 4), /* on dest complete, call ICMSequenceUnlockBits */
codecCompletionForceChainFlush = (1 << 5), /* ICM needs to flush the whole chain */
codecCompletionDropped = (1 << 6) /* codec decided to drop this frame */
};
enum {
codecProgressOpen = 0,
codecProgressUpdatePercent = 1,
codecProgressClose = 2
};
typedef CALLBACK_API( OSErr , ICMDataProcPtr )(Ptr *dataP, long bytesNeeded, long refcon);
typedef CALLBACK_API( OSErr , ICMFlushProcPtr )(Ptr data, long bytesAdded, long refcon);
typedef CALLBACK_API( void , ICMCompletionProcPtr )(OSErr result, short flags, long refcon);
typedef CALLBACK_API( OSErr , ICMProgressProcPtr )(short message, Fixed completeness, long refcon);
typedef CALLBACK_API( void , StdPixProcPtr )(PixMap *src, Rect *srcRect, MatrixRecord *matrix, short mode, RgnHandle mask, PixMap *matte, Rect *matteRect, short flags);
typedef CALLBACK_API( void , QDPixProcPtr )(PixMap *src, Rect *srcRect, MatrixRecord *matrix, short mode, RgnHandle mask, PixMap *matte, Rect *matteRect, short flags);
typedef CALLBACK_API( void , ICMAlignmentProcPtr )(Rect *rp, long refcon);
typedef CALLBACK_API( void , ICMCursorShieldedProcPtr )(const Rect *r, void *refcon, long flags);
typedef CALLBACK_API( void , ICMMemoryDisposedProcPtr )(Ptr memoryBlock, void *refcon);
typedef void * ICMCursorNotify;
typedef CALLBACK_API( OSErr , ICMConvertDataFormatProcPtr )(void *refCon, long flags, Handle desiredFormat, Handle sourceDataFormat, void *srcData, long srcDataSize, void **dstData, long *dstDataSize);
typedef STACK_UPP_TYPE(ICMDataProcPtr) ICMDataUPP;
typedef STACK_UPP_TYPE(ICMFlushProcPtr) ICMFlushUPP;
typedef STACK_UPP_TYPE(ICMCompletionProcPtr) ICMCompletionUPP;
typedef STACK_UPP_TYPE(ICMProgressProcPtr) ICMProgressUPP;
typedef STACK_UPP_TYPE(StdPixProcPtr) StdPixUPP;
typedef STACK_UPP_TYPE(QDPixProcPtr) QDPixUPP;
typedef STACK_UPP_TYPE(ICMAlignmentProcPtr) ICMAlignmentUPP;
typedef STACK_UPP_TYPE(ICMCursorShieldedProcPtr) ICMCursorShieldedUPP;
typedef STACK_UPP_TYPE(ICMMemoryDisposedProcPtr) ICMMemoryDisposedUPP;
typedef STACK_UPP_TYPE(ICMConvertDataFormatProcPtr) ICMConvertDataFormatUPP;
typedef long ImageSequence;
typedef long ImageSequenceDataSource;
typedef long ImageTranscodeSequence;
typedef long ImageFieldSequence;
struct ICMProgressProcRecord {
ICMProgressUPP progressProc;
long progressRefCon;
};
typedef struct ICMProgressProcRecord ICMProgressProcRecord;
typedef ICMProgressProcRecord * ICMProgressProcRecordPtr;
struct ICMCompletionProcRecord {
ICMCompletionUPP completionProc;
long completionRefCon;
};
typedef struct ICMCompletionProcRecord ICMCompletionProcRecord;
typedef ICMCompletionProcRecord * ICMCompletionProcRecordPtr;
struct ICMDataProcRecord {
ICMDataUPP dataProc;
long dataRefCon;
};
typedef struct ICMDataProcRecord ICMDataProcRecord;
typedef ICMDataProcRecord * ICMDataProcRecordPtr;
struct ICMFlushProcRecord {
ICMFlushUPP flushProc;
long flushRefCon;
};
typedef struct ICMFlushProcRecord ICMFlushProcRecord;
typedef ICMFlushProcRecord * ICMFlushProcRecordPtr;
struct ICMAlignmentProcRecord {
ICMAlignmentUPP alignmentProc;
long alignmentRefCon;
};
typedef struct ICMAlignmentProcRecord ICMAlignmentProcRecord;
typedef ICMAlignmentProcRecord * ICMAlignmentProcRecordPtr;
struct DataRateParams {
long dataRate;
long dataOverrun;
long frameDuration;
long keyFrameRate;
CodecQ minSpatialQuality;
CodecQ minTemporalQuality;
};
typedef struct DataRateParams DataRateParams;
typedef DataRateParams * DataRateParamsPtr;
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 */
Str31 name; /* 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;
typedef ImageDescriptionPtr * ImageDescriptionHandle;
struct CodecInfo {
Str31 typeName; /* 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 */
UInt8 compressionAccuracy; /* measure (1-255) of accuracy of this codec for compress (0 if unknown) */
UInt8 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) */
UInt8 compressionLevel; /* measure (1-255) of compression level of this codec (0 if unknown) */
UInt8 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;
struct CodecNameSpec {
CodecComponent codec;
CodecType cType;
Str31 typeName;
Handle name;
};
typedef struct CodecNameSpec CodecNameSpec;
struct CodecNameSpecList {
short count;
CodecNameSpec list[1];
};
typedef struct CodecNameSpecList CodecNameSpecList;
typedef CodecNameSpecList * CodecNameSpecListPtr;
enum {
defaultDither = 0,
forceDither = 1,
suppressDither = 2,
useColorMatching = 4
};
enum {
callStdBits = 1,
callOldBits = 2,
noDefaultOpcodes = 4
};
enum {
graphicsModeStraightAlpha = 256,
graphicsModePreWhiteAlpha = 257,
graphicsModePreBlackAlpha = 258,
graphicsModeComposition = 259,
graphicsModeStraightAlphaBlend = 260,
graphicsModePreMulColorAlpha = 261
};
enum {
evenField1ToEvenFieldOut = 1 << 0,
evenField1ToOddFieldOut = 1 << 1,
oddField1ToEvenFieldOut = 1 << 2,
oddField1ToOddFieldOut = 1 << 3,
evenField2ToEvenFieldOut = 1 << 4,
evenField2ToOddFieldOut = 1 << 5,
oddField2ToEvenFieldOut = 1 << 6,
oddField2ToOddFieldOut = 1 << 7
};
enum {
icmFrameTimeHasVirtualStartTimeAndDuration = 1 << 0
};
struct ICMFrameTimeRecord {
wide value; /* frame time*/
long scale; /* timescale of value/duration fields*/
void * base; /* timebase*/
long duration; /* duration frame is to be displayed (0 if unknown)*/
Fixed rate; /* rate of timebase relative to wall-time*/
long recordSize; /* total number of bytes in ICMFrameTimeRecord*/
long frameNumber; /* number of frame, zero if not known*/
long flags;
wide virtualStartTime; /* conceptual start time*/
long virtualDuration; /* conceptual duration*/
};
typedef struct ICMFrameTimeRecord ICMFrameTimeRecord;
typedef ICMFrameTimeRecord * ICMFrameTimePtr;
#ifndef __QTUUID__
#define __QTUUID__ 1
/* QuickTime flavor of universally unique identifier (uuid)*/
struct QTUUID {
UInt32 data1;
UInt16 data2;
UInt16 data3;
UInt8 data4[8];
};
typedef struct QTUUID QTUUID;
typedef QTUUID QTMediaContextID;
#endif /* !defined(__QTUUID__) */
#if OPAQUE_UPP_TYPES
EXTERN_API(ICMDataUPP)
NewICMDataUPP (ICMDataProcPtr userRoutine);
EXTERN_API(ICMFlushUPP)
NewICMFlushUPP (ICMFlushProcPtr userRoutine);
EXTERN_API(ICMCompletionUPP)
NewICMCompletionUPP (ICMCompletionProcPtr userRoutine);
EXTERN_API(ICMProgressUPP)
NewICMProgressUPP (ICMProgressProcPtr userRoutine);
EXTERN_API(StdPixUPP)
NewStdPixUPP (StdPixProcPtr userRoutine);
EXTERN_API(QDPixUPP)
NewQDPixUPP (QDPixProcPtr userRoutine);
EXTERN_API(ICMAlignmentUPP)
NewICMAlignmentUPP (ICMAlignmentProcPtr userRoutine);
EXTERN_API(ICMCursorShieldedUPP)
NewICMCursorShieldedUPP (ICMCursorShieldedProcPtr userRoutine);
EXTERN_API(ICMMemoryDisposedUPP)
NewICMMemoryDisposedUPP (ICMMemoryDisposedProcPtr userRoutine);
EXTERN_API(ICMConvertDataFormatUPP)
NewICMConvertDataFormatUPP (ICMConvertDataFormatProcPtr userRoutine);
EXTERN_API(void)
DisposeICMDataUPP (ICMDataUPP userUPP);
EXTERN_API(void)
DisposeICMFlushUPP (ICMFlushUPP userUPP);
EXTERN_API(void)
DisposeICMCompletionUPP (ICMCompletionUPP userUPP);
EXTERN_API(void)
DisposeICMProgressUPP (ICMProgressUPP userUPP);
EXTERN_API(void)
DisposeStdPixUPP (StdPixUPP userUPP);
EXTERN_API(void)
DisposeQDPixUPP (QDPixUPP userUPP);
EXTERN_API(void)
DisposeICMAlignmentUPP (ICMAlignmentUPP userUPP);
EXTERN_API(void)
DisposeICMCursorShieldedUPP (ICMCursorShieldedUPP userUPP);
EXTERN_API(void)
DisposeICMMemoryDisposedUPP (ICMMemoryDisposedUPP userUPP);
EXTERN_API(void)
DisposeICMConvertDataFormatUPP (ICMConvertDataFormatUPP userUPP);
EXTERN_API(OSErr)
InvokeICMDataUPP (Ptr * dataP,
long bytesNeeded,
long refcon,
ICMDataUPP userUPP);
EXTERN_API(OSErr)
InvokeICMFlushUPP (Ptr data,
long bytesAdded,
long refcon,
ICMFlushUPP userUPP);
EXTERN_API(void)
InvokeICMCompletionUPP (OSErr result,
short flags,
long refcon,
ICMCompletionUPP userUPP);
EXTERN_API(OSErr)
InvokeICMProgressUPP (short message,
Fixed completeness,
long refcon,
ICMProgressUPP userUPP);
EXTERN_API(void)
InvokeStdPixUPP (PixMap * src,
Rect * srcRect,
MatrixRecord * matrix,
short mode,
RgnHandle mask,
PixMap * matte,
Rect * matteRect,
short flags,
StdPixUPP userUPP);
EXTERN_API(void)
InvokeQDPixUPP (PixMap * src,
Rect * srcRect,
MatrixRecord * matrix,
short mode,
RgnHandle mask,
PixMap * matte,
Rect * matteRect,
short flags,
QDPixUPP userUPP);
EXTERN_API(void)
InvokeICMAlignmentUPP (Rect * rp,
long refcon,
ICMAlignmentUPP userUPP);
EXTERN_API(void)
InvokeICMCursorShieldedUPP (const Rect * r,
void * refcon,
long flags,
ICMCursorShieldedUPP userUPP);
EXTERN_API(void)
InvokeICMMemoryDisposedUPP (Ptr memoryBlock,
void * refcon,
ICMMemoryDisposedUPP userUPP);
EXTERN_API(OSErr)
InvokeICMConvertDataFormatUPP (void * refCon,
long flags,
Handle desiredFormat,
Handle sourceDataFormat,
void * srcData,
long srcDataSize,
void ** dstData,
long * dstDataSize,
ICMConvertDataFormatUPP userUPP);
#else
enum { uppICMDataProcInfo = 0x00000FE0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes) */
enum { uppICMFlushProcInfo = 0x00000FE0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes) */
enum { uppICMCompletionProcInfo = 0x00000E80 }; /* pascal no_return_value Func(2_bytes, 2_bytes, 4_bytes) */
enum { uppICMProgressProcInfo = 0x00000FA0 }; /* pascal 2_bytes Func(2_bytes, 4_bytes, 4_bytes) */
enum { uppStdPixProcInfo = 0x002FEFC0 }; /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes, 2_bytes) */
enum { uppQDPixProcInfo = 0x002FEFC0 }; /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes, 2_bytes) */
enum { uppICMAlignmentProcInfo = 0x000003C0 }; /* pascal no_return_value Func(4_bytes, 4_bytes) */
enum { uppICMCursorShieldedProcInfo = 0x00000FC0 }; /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes) */
enum { uppICMMemoryDisposedProcInfo = 0x000003C0 }; /* pascal no_return_value Func(4_bytes, 4_bytes) */
enum { uppICMConvertDataFormatProcInfo = 0x003FFFE0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#define NewICMDataUPP(userRoutine) (ICMDataUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMDataProcInfo, GetCurrentArchitecture())
#define NewICMFlushUPP(userRoutine) (ICMFlushUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMFlushProcInfo, GetCurrentArchitecture())
#define NewICMCompletionUPP(userRoutine) (ICMCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMCompletionProcInfo, GetCurrentArchitecture())
#define NewICMProgressUPP(userRoutine) (ICMProgressUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMProgressProcInfo, GetCurrentArchitecture())
#define NewStdPixUPP(userRoutine) (StdPixUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppStdPixProcInfo, GetCurrentArchitecture())
#define NewQDPixUPP(userRoutine) (QDPixUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDPixProcInfo, GetCurrentArchitecture())
#define NewICMAlignmentUPP(userRoutine) (ICMAlignmentUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMAlignmentProcInfo, GetCurrentArchitecture())
#define NewICMCursorShieldedUPP(userRoutine) (ICMCursorShieldedUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMCursorShieldedProcInfo, GetCurrentArchitecture())
#define NewICMMemoryDisposedUPP(userRoutine) (ICMMemoryDisposedUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMMemoryDisposedProcInfo, GetCurrentArchitecture())
#define NewICMConvertDataFormatUPP(userRoutine) (ICMConvertDataFormatUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMConvertDataFormatProcInfo, GetCurrentArchitecture())
#define DisposeICMDataUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMFlushUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMProgressUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeStdPixUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeQDPixUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMAlignmentUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMCursorShieldedUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMMemoryDisposedUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeICMConvertDataFormatUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define InvokeICMDataUPP(dataP, bytesNeeded, refcon, userUPP) (OSErr)CALL_THREE_PARAMETER_UPP((userUPP), uppICMDataProcInfo, (dataP), (bytesNeeded), (refcon))
#define InvokeICMFlushUPP(data, bytesAdded, refcon, userUPP) (OSErr)CALL_THREE_PARAMETER_UPP((userUPP), uppICMFlushProcInfo, (data), (bytesAdded), (refcon))
#define InvokeICMCompletionUPP(result, flags, refcon, userUPP) CALL_THREE_PARAMETER_UPP((userUPP), uppICMCompletionProcInfo, (result), (flags), (refcon))
#define InvokeICMProgressUPP(message, completeness, refcon, userUPP) (OSErr)CALL_THREE_PARAMETER_UPP((userUPP), uppICMProgressProcInfo, (message), (completeness), (refcon))
#define InvokeStdPixUPP(src, srcRect, matrix, mode, mask, matte, matteRect, flags, userUPP) CALL_EIGHT_PARAMETER_UPP((userUPP), uppStdPixProcInfo, (src), (srcRect), (matrix), (mode), (mask), (matte), (matteRect), (flags))
#define InvokeQDPixUPP(src, srcRect, matrix, mode, mask, matte, matteRect, flags, userUPP) CALL_EIGHT_PARAMETER_UPP((userUPP), uppQDPixProcInfo, (src), (srcRect), (matrix), (mode), (mask), (matte), (matteRect), (flags))
#define InvokeICMAlignmentUPP(rp, refcon, userUPP) CALL_TWO_PARAMETER_UPP((userUPP), uppICMAlignmentProcInfo, (rp), (refcon))
#define InvokeICMCursorShieldedUPP(r, refcon, flags, userUPP) CALL_THREE_PARAMETER_UPP((userUPP), uppICMCursorShieldedProcInfo, (r), (refcon), (flags))
#define InvokeICMMemoryDisposedUPP(memoryBlock, refcon, userUPP) CALL_TWO_PARAMETER_UPP((userUPP), uppICMMemoryDisposedProcInfo, (memoryBlock), (refcon))
#define InvokeICMConvertDataFormatUPP(refCon, flags, desiredFormat, sourceDataFormat, srcData, srcDataSize, dstData, dstDataSize, userUPP) (OSErr)CALL_EIGHT_PARAMETER_UPP((userUPP), uppICMConvertDataFormatProcInfo, (refCon), (flags), (desiredFormat), (sourceDataFormat), (srcData), (srcDataSize), (dstData), (dstDataSize))
#endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
#define NewICMDataProc(userRoutine) NewICMDataUPP(userRoutine)
#define NewICMFlushProc(userRoutine) NewICMFlushUPP(userRoutine)
#define NewICMCompletionProc(userRoutine) NewICMCompletionUPP(userRoutine)
#define NewICMProgressProc(userRoutine) NewICMProgressUPP(userRoutine)
#define NewStdPixProc(userRoutine) NewStdPixUPP(userRoutine)
#define NewQDPixProc(userRoutine) NewQDPixUPP(userRoutine)
#define NewICMAlignmentProc(userRoutine) NewICMAlignmentUPP(userRoutine)
#define NewICMCursorShieldedProc(userRoutine) NewICMCursorShieldedUPP(userRoutine)
#define NewICMMemoryDisposedProc(userRoutine) NewICMMemoryDisposedUPP(userRoutine)
#define NewICMConvertDataFormatProc(userRoutine) NewICMConvertDataFormatUPP(userRoutine)
#define CallICMDataProc(userRoutine, dataP, bytesNeeded, refcon) InvokeICMDataUPP(dataP, bytesNeeded, refcon, userRoutine)
#define CallICMFlushProc(userRoutine, data, bytesAdded, refcon) InvokeICMFlushUPP(data, bytesAdded, refcon, userRoutine)
#define CallICMCompletionProc(userRoutine, result, flags, refcon) InvokeICMCompletionUPP(result, flags, refcon, userRoutine)
#define CallICMProgressProc(userRoutine, message, completeness, refcon) InvokeICMProgressUPP(message, completeness, refcon, userRoutine)
#define CallStdPixProc(userRoutine, src, srcRect, matrix, mode, mask, matte, matteRect, flags) InvokeStdPixUPP(src, srcRect, matrix, mode, mask, matte, matteRect, flags, userRoutine)
#define CallQDPixProc(userRoutine, src, srcRect, matrix, mode, mask, matte, matteRect, flags) InvokeQDPixUPP(src, srcRect, matrix, mode, mask, matte, matteRect, flags, userRoutine)
#define CallICMAlignmentProc(userRoutine, rp, refcon) InvokeICMAlignmentUPP(rp, refcon, userRoutine)
#define CallICMCursorShieldedProc(userRoutine, r, refcon, flags) InvokeICMCursorShieldedUPP(r, refcon, flags, userRoutine)
#define CallICMMemoryDisposedProc(userRoutine, memoryBlock, refcon) InvokeICMMemoryDisposedUPP(memoryBlock, refcon, userRoutine)
#define CallICMConvertDataFormatProc(userRoutine, refCon, flags, desiredFormat, sourceDataFormat, srcData, srcDataSize, dstData, dstDataSize) InvokeICMConvertDataFormatUPP(refCon, flags, desiredFormat, sourceDataFormat, srcData, srcDataSize, dstData, dstDataSize, userRoutine)
EXTERN_API( OSErr )
CodecManagerVersion (long * version) TWOWORDINLINE(0x7000, 0xAAA3);
EXTERN_API( OSErr )
GetCodecNameList (CodecNameSpecListPtr * list,
short showAll) TWOWORDINLINE(0x7001, 0xAAA3);
EXTERN_API( OSErr )
DisposeCodecNameList (CodecNameSpecListPtr list) TWOWORDINLINE(0x700F, 0xAAA3);
EXTERN_API( OSErr )
GetCodecInfo (CodecInfo * info,
CodecType cType,
CodecComponent codec) TWOWORDINLINE(0x7003, 0xAAA3);
EXTERN_API( OSErr )
GetMaxCompressionSize (PixMapHandle src,
const Rect * srcRect,
short colorDepth,
CodecQ quality,
CodecType cType,
CompressorComponent codec,
long * size) TWOWORDINLINE(0x7004, 0xAAA3);
EXTERN_API( OSErr )
GetCSequenceMaxCompressionSize (ImageSequence seqID,
PixMapHandle src,
long * size) FOURWORDINLINE(0x203C, 0x000C, 0x0074, 0xAAA3);
EXTERN_API( OSErr )
GetCompressionTime (PixMapHandle src,
const Rect * srcRect,
short colorDepth,
CodecType cType,
CompressorComponent codec,
CodecQ * spatialQuality,
CodecQ * temporalQuality,
unsigned long * compressTime) TWOWORDINLINE(0x7005, 0xAAA3);
EXTERN_API( OSErr )
CompressImage (PixMapHandle src,
const Rect * srcRect,
CodecQ quality,
CodecType cType,
ImageDescriptionHandle desc,
Ptr data) TWOWORDINLINE(0x7006, 0xAAA3);
EXTERN_API( OSErr )
FCompressImage (PixMapHandle src,
const Rect * srcRect,
short colorDepth,
CodecQ quality,
CodecType cType,
CompressorComponent codec,
CTabHandle ctable,
CodecFlags flags,
long bufferSize,
ICMFlushProcRecordPtr flushProc,
ICMProgressProcRecordPtr progressProc,
ImageDescriptionHandle desc,
Ptr data) TWOWORDINLINE(0x7007, 0xAAA3);
EXTERN_API( OSErr )
DecompressImage (Ptr data,
ImageDescriptionHandle desc,
PixMapHandle dst,
const Rect * srcRect,
const Rect * dstRect,
short mode,
RgnHandle mask) TWOWORDINLINE(0x7008, 0xAAA3);
EXTERN_API( 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,
ICMDataProcRecordPtr dataProc,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x7009, 0xAAA3);
EXTERN_API( 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 ctable,
CodecFlags flags,
ImageDescriptionHandle desc) TWOWORDINLINE(0x700A, 0xAAA3);
EXTERN_API( OSErr )
CompressSequenceFrame (ImageSequence seqID,
PixMapHandle src,
const Rect * srcRect,
CodecFlags flags,
Ptr data,
long * dataSize,
UInt8 * similarity,
ICMCompletionProcRecordPtr asyncCompletionProc) TWOWORDINLINE(0x700B, 0xAAA3);
EXTERN_API( 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) TWOWORDINLINE(0x700D, 0xAAA3);
EXTERN_API( OSErr )
DecompressSequenceBeginS (ImageSequence * seqID,
ImageDescriptionHandle desc,
Ptr data,
long dataSize,
CGrafPtr port,
GDHandle gdh,
const Rect * srcRect,
MatrixRecordPtr matrix,
short mode,
RgnHandle mask,
CodecFlags flags,
CodecQ accuracy,
DecompressorComponent codec) FOURWORDINLINE(0x203C, 0x0030, 0x005D, 0xAAA3);
EXTERN_API( OSErr )
DecompressSequenceFrame (ImageSequence seqID,
Ptr data,
CodecFlags inFlags,
CodecFlags * outFlags,
ICMCompletionProcRecordPtr asyncCompletionProc) TWOWORDINLINE(0x700E, 0xAAA3);
EXTERN_API( OSErr )
DecompressSequenceFrameS (ImageSequence seqID,
Ptr data,
long dataSize,
CodecFlags inFlags,
CodecFlags * outFlags,
ICMCompletionProcRecordPtr asyncCompletionProc) FOURWORDINLINE(0x203C, 0x0016, 0x0047, 0xAAA3);
EXTERN_API( OSErr )
DecompressSequenceFrameWhen (ImageSequence seqID,
Ptr data,
long dataSize,
CodecFlags inFlags,
CodecFlags * outFlags,
ICMCompletionProcRecordPtr asyncCompletionProc,
const ICMFrameTimeRecord * frameTime) FOURWORDINLINE(0x203C, 0x001A, 0x005E, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceFlush (ImageSequence seqID) FOURWORDINLINE(0x203C, 0x0004, 0x005F, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceMatrix (ImageSequence seqID,
MatrixRecordPtr matrix) TWOWORDINLINE(0x7010, 0xAAA3);
EXTERN_API( OSErr )
GetDSequenceMatrix (ImageSequence seqID,
MatrixRecordPtr matrix) FOURWORDINLINE(0x203C, 0x0008, 0x0091, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceMatte (ImageSequence seqID,
PixMapHandle matte,
const Rect * matteRect) TWOWORDINLINE(0x7011, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceMask (ImageSequence seqID,
RgnHandle mask) TWOWORDINLINE(0x7012, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceTransferMode (ImageSequence seqID,
short mode,
const RGBColor * opColor) TWOWORDINLINE(0x7013, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceDataProc (ImageSequence seqID,
ICMDataProcRecordPtr dataProc,
long bufferSize) TWOWORDINLINE(0x7014, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceAccuracy (ImageSequence seqID,
CodecQ accuracy) TWOWORDINLINE(0x7034, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceSrcRect (ImageSequence seqID,
const Rect * srcRect) TWOWORDINLINE(0x7035, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceFlags (ImageSequence seqID,
long flags,
long flagsMask) FOURWORDINLINE(0x203C, 0x000C, 0x0057, 0xAAA3);
enum {
codecDSequenceDisableOverlaySurface = (1L << 5),
codecDSequenceSingleField = (1L << 6),
codecDSequenceBidirectionalPrediction = (1L << 7),
codecDSequenceFlushInsteadOfDirtying = (1L << 8),
codecDSequenceEnableSubPixelPositioning = (1L << 9)
};
typedef CodecComponent * CodecComponentPtr;
typedef CodecComponentPtr * CodecComponentHandle;
/* selectors for ICMSequenceGet/SetInfo*/
enum {
kICMSequenceTaskWeight = FOUR_CHAR_CODE('twei'), /* data is pointer to UInt32*/
kICMSequenceTaskName = FOUR_CHAR_CODE('tnam'), /* data is pointer to OSType*/
kICMSequenceUserPreferredCodecs = FOUR_CHAR_CODE('punt') /* data is pointer to CodecComponentHandle*/
};
EXTERN_API( OSErr )
ICMSequenceGetInfo (ImageSequence seqID,
OSType which,
void * data) FOURWORDINLINE(0x203C, 0x000C, 0x0089, 0xAAA3);
EXTERN_API( OSErr )
ICMSequenceSetInfo (ImageSequence seqID,
OSType which,
void * data,
Size dataSize) FOURWORDINLINE(0x203C, 0x0010, 0x009D, 0xAAA3);
EXTERN_API( OSErr )
GetDSequenceImageBuffer (ImageSequence seqID,
GWorldPtr * gworld) TWOWORDINLINE(0x7015, 0xAAA3);
EXTERN_API( OSErr )
GetDSequenceScreenBuffer (ImageSequence seqID,
GWorldPtr * gworld) TWOWORDINLINE(0x7016, 0xAAA3);
EXTERN_API( OSErr )
SetCSequenceQuality (ImageSequence seqID,
CodecQ spatialQuality,
CodecQ temporalQuality) TWOWORDINLINE(0x7017, 0xAAA3);
EXTERN_API( OSErr )
SetCSequencePrev (ImageSequence seqID,
PixMapHandle prev,
const Rect * prevRect) TWOWORDINLINE(0x7018, 0xAAA3);
EXTERN_API( OSErr )
SetCSequenceFlushProc (ImageSequence seqID,
ICMFlushProcRecordPtr flushProc,
long bufferSize) TWOWORDINLINE(0x7033, 0xAAA3);
EXTERN_API( OSErr )
SetCSequenceKeyFrameRate (ImageSequence seqID,
long keyFrameRate) TWOWORDINLINE(0x7036, 0xAAA3);
EXTERN_API( OSErr )
GetCSequenceKeyFrameRate (ImageSequence seqID,
long * keyFrameRate) FOURWORDINLINE(0x203C, 0x0008, 0x004B, 0xAAA3);
EXTERN_API( OSErr )
GetCSequencePrevBuffer (ImageSequence seqID,
GWorldPtr * gworld) TWOWORDINLINE(0x7019, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceBusy (ImageSequence seqID) TWOWORDINLINE(0x701A, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceEnd (ImageSequence seqID) TWOWORDINLINE(0x701B, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceEquivalentImageDescription (ImageSequence seqID,
ImageDescriptionHandle newDesc,
Boolean * equivalent) FOURWORDINLINE(0x203C, 0x000C, 0x0065, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceEquivalentImageDescriptionS (ImageSequence seqID,
ImageDescriptionHandle newDesc,
Boolean * equivalent,
Boolean * canSwitch) FOURWORDINLINE(0x203C, 0x0010, 0x009F, 0xAAA3);
EXTERN_API( OSErr )
ReplaceDSequenceImageDescription (ImageSequence seqID,
ImageDescriptionHandle newDesc) FOURWORDINLINE(0x203C, 0x0008, 0x00A0, 0xAAA3);
EXTERN_API( OSErr )
GetCompressedImageSize (ImageDescriptionHandle desc,
Ptr data,
long bufferSize,
ICMDataProcRecordPtr dataProc,
long * dataSize) TWOWORDINLINE(0x701C, 0xAAA3);
EXTERN_API( OSErr )
GetSimilarity (PixMapHandle src,
const Rect * srcRect,
ImageDescriptionHandle desc,
Ptr data,
Fixed * similarity) TWOWORDINLINE(0x701D, 0xAAA3);
enum {
kImageDescriptionSampleFormat = FOUR_CHAR_CODE('idfm'), /* image description extension describing sample format*/
kImageDescriptionClassicAtomFormat = FOUR_CHAR_CODE('atom'), /* sample contains classic atom structure (ie, GX codec and Curve codec)*/
kImageDescriptionQTAtomFormat = FOUR_CHAR_CODE('qtat'), /* sample contains QT atom structure*/
kImageDescriptionEffectDataFormat = FOUR_CHAR_CODE('fxat'), /* sample describes an effect (as QTAtoms)*/
kImageDescriptionPrivateDataFormat = FOUR_CHAR_CODE('priv'), /* sample is in a private codec specific format*/
kImageDescriptionAlternateCodec = FOUR_CHAR_CODE('subs'), /* image description extension containing the OSType of a substitute codec should the main codec not be available*/
kImageDescriptionColorSpace = FOUR_CHAR_CODE('cspc') /* image description extension containing an OSType naming the native pixel format of an image (only used for pixel formats not supported by classic Color QuickDraw)*/
};
EXTERN_API( OSErr )
GetImageDescriptionCTable (ImageDescriptionHandle desc,
CTabHandle * ctable) TWOWORDINLINE(0x701E, 0xAAA3);
EXTERN_API( OSErr )
SetImageDescriptionCTable (ImageDescriptionHandle desc,
CTabHandle ctable) TWOWORDINLINE(0x701F, 0xAAA3);
EXTERN_API( OSErr )
GetImageDescriptionExtension (ImageDescriptionHandle desc,
Handle * extension,
long idType,
long index) TWOWORDINLINE(0x7020, 0xAAA3);
EXTERN_API( OSErr )
AddImageDescriptionExtension (ImageDescriptionHandle desc,
Handle extension,
long idType) TWOWORDINLINE(0x7021, 0xAAA3);
EXTERN_API( OSErr )
RemoveImageDescriptionExtension (ImageDescriptionHandle desc,
long idType,
long index) FOURWORDINLINE(0x203C, 0x000C, 0x003A, 0xAAA3);
EXTERN_API( OSErr )
CountImageDescriptionExtensionType (ImageDescriptionHandle desc,
long idType,
long * count) FOURWORDINLINE(0x203C, 0x000C, 0x003B, 0xAAA3);
EXTERN_API( OSErr )
GetNextImageDescriptionExtensionType (ImageDescriptionHandle desc,
long * idType) FOURWORDINLINE(0x203C, 0x0008, 0x003C, 0xAAA3);
EXTERN_API( OSErr )
FindCodec (CodecType cType,
CodecComponent specCodec,
CompressorComponent * compressor,
DecompressorComponent * decompressor) TWOWORDINLINE(0x7023, 0xAAA3);
EXTERN_API( OSErr )
CompressPicture (PicHandle srcPicture,
PicHandle dstPicture,
CodecQ quality,
CodecType cType) TWOWORDINLINE(0x7024, 0xAAA3);
EXTERN_API( OSErr )
FCompressPicture (PicHandle srcPicture,
PicHandle dstPicture,
short colorDepth,
CTabHandle ctable,
CodecQ quality,
short doDither,
short compressAgain,
ICMProgressProcRecordPtr progressProc,
CodecType cType,
CompressorComponent codec) TWOWORDINLINE(0x7025, 0xAAA3);
EXTERN_API( OSErr )
CompressPictureFile (short srcRefNum,
short dstRefNum,
CodecQ quality,
CodecType cType) TWOWORDINLINE(0x7026, 0xAAA3);
EXTERN_API( OSErr )
FCompressPictureFile (short srcRefNum,
short dstRefNum,
short colorDepth,
CTabHandle ctable,
CodecQ quality,
short doDither,
short compressAgain,
ICMProgressProcRecordPtr progressProc,
CodecType cType,
CompressorComponent codec) TWOWORDINLINE(0x7027, 0xAAA3);
EXTERN_API( OSErr )
GetPictureFileHeader (short refNum,
Rect * frame,
OpenCPicParams * header) TWOWORDINLINE(0x7028, 0xAAA3);
EXTERN_API( OSErr )
DrawPictureFile (short refNum,
const Rect * frame,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x7029, 0xAAA3);
EXTERN_API( OSErr )
DrawTrimmedPicture (PicHandle srcPicture,
const Rect * frame,
RgnHandle trimMask,
short doDither,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x702E, 0xAAA3);
EXTERN_API( OSErr )
DrawTrimmedPictureFile (short srcRefnum,
const Rect * frame,
RgnHandle trimMask,
short doDither,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x702F, 0xAAA3);
EXTERN_API( OSErr )
MakeThumbnailFromPicture (PicHandle picture,
short colorDepth,
PicHandle thumbnail,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x702A, 0xAAA3);
EXTERN_API( OSErr )
MakeThumbnailFromPictureFile (short refNum,
short colorDepth,
PicHandle thumbnail,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x702B, 0xAAA3);
EXTERN_API( OSErr )
MakeThumbnailFromPixMap (PixMapHandle src,
const Rect * srcRect,
short colorDepth,
PicHandle thumbnail,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x702C, 0xAAA3);
EXTERN_API( OSErr )
TrimImage (ImageDescriptionHandle desc,
Ptr inData,
long inBufferSize,
ICMDataProcRecordPtr dataProc,
Ptr outData,
long outBufferSize,
ICMFlushProcRecordPtr flushProc,
Rect * trimRect,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x702D, 0xAAA3);
EXTERN_API( OSErr )
ConvertImage (ImageDescriptionHandle srcDD,
Ptr srcData,
short colorDepth,
CTabHandle ctable,
CodecQ accuracy,
CodecQ quality,
CodecType cType,
CodecComponent codec,
ImageDescriptionHandle dstDD,
Ptr dstData) TWOWORDINLINE(0x7030, 0xAAA3);
EXTERN_API( OSErr )
GetCompressedPixMapInfo (PixMapPtr pix,
ImageDescriptionHandle * desc,
Ptr * data,
long * bufferSize,
ICMDataProcRecord * dataProc,
ICMProgressProcRecord * progressProc) TWOWORDINLINE(0x7037, 0xAAA3);
EXTERN_API( OSErr )
SetCompressedPixMapInfo (PixMapPtr pix,
ImageDescriptionHandle desc,
Ptr data,
long bufferSize,
ICMDataProcRecordPtr dataProc,
ICMProgressProcRecordPtr progressProc) TWOWORDINLINE(0x7038, 0xAAA3);
EXTERN_API( void )
StdPix (PixMapPtr src,
const Rect * srcRect,
MatrixRecordPtr matrix,
short mode,
RgnHandle mask,
PixMapPtr matte,
const Rect * matteRect,
short flags) TWOWORDINLINE(0x700C, 0xAAA3);
EXTERN_API( OSErr )
TransformRgn (MatrixRecordPtr matrix,
RgnHandle rgn) TWOWORDINLINE(0x7039, 0xAAA3);
/***********
preview stuff
***********/
EXTERN_API( void )
SFGetFilePreview (Point where,
ConstStr255Param prompt,
FileFilterUPP fileFilter,
short numTypes,
ConstSFTypeListPtr typeList,
DlgHookUPP dlgHook,
SFReply * reply) TWOWORDINLINE(0x7041, 0xAAA3);
EXTERN_API( void )
SFPGetFilePreview (Point where,
ConstStr255Param prompt,
FileFilterUPP fileFilter,
short numTypes,
ConstSFTypeListPtr typeList,
DlgHookUPP dlgHook,
SFReply * reply,
short dlgID,
ModalFilterUPP filterProc) TWOWORDINLINE(0x7042, 0xAAA3);
EXTERN_API( void )
StandardGetFilePreview (FileFilterUPP fileFilter,
short numTypes,
ConstSFTypeListPtr typeList,
StandardFileReply * reply) TWOWORDINLINE(0x7043, 0xAAA3);
EXTERN_API( void )
CustomGetFilePreview (FileFilterYDUPP fileFilter,
short numTypes,
ConstSFTypeListPtr typeList,
StandardFileReply * reply,
short dlgID,
Point where,
DlgHookYDUPP dlgHook,
ModalFilterYDUPP filterProc,
ActivationOrderListPtr activeList,
ActivateYDUPP activateProc,
void * yourDataPtr) TWOWORDINLINE(0x7044, 0xAAA3);
EXTERN_API( OSErr )
MakeFilePreview (short resRefNum,
ICMProgressProcRecordPtr progress) TWOWORDINLINE(0x7045, 0xAAA3);
EXTERN_API( OSErr )
AddFilePreview (short resRefNum,
OSType previewType,
Handle previewData) TWOWORDINLINE(0x7046, 0xAAA3);
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;
typedef PreviewResourcePtr * PreviewResource;
EXTERN_API( void )
AlignScreenRect (Rect * rp,
ICMAlignmentProcRecordPtr alignmentProc) FOURWORDINLINE(0x203C, 0x0008, 0x004C, 0xAAA3);
EXTERN_API( void )
AlignWindow (WindowRef wp,
Boolean front,
const Rect * alignmentRect,
ICMAlignmentProcRecordPtr alignmentProc) FOURWORDINLINE(0x203C, 0x000E, 0x004D, 0xAAA3);
EXTERN_API( void )
DragAlignedWindow (WindowRef wp,
Point startPt,
Rect * boundsRect,
Rect * alignmentRect,
ICMAlignmentProcRecordPtr alignmentProc) FOURWORDINLINE(0x203C, 0x0014, 0x004E, 0xAAA3);
EXTERN_API( long )
DragAlignedGrayRgn (RgnHandle theRgn,
Point startPt,
Rect * boundsRect,
Rect * slopRect,
short axis,
UniversalProcPtr actionProc,
Rect * alignmentRect,
ICMAlignmentProcRecordPtr alignmentProc) FOURWORDINLINE(0x203C, 0x001E, 0x004F, 0xAAA3);
EXTERN_API( OSErr )
SetCSequenceDataRateParams (ImageSequence seqID,
DataRateParamsPtr params) FOURWORDINLINE(0x203C, 0x0008, 0x0050, 0xAAA3);
EXTERN_API( OSErr )
SetCSequenceFrameNumber (ImageSequence seqID,
long frameNumber) FOURWORDINLINE(0x203C, 0x0008, 0x0051, 0xAAA3);
EXTERN_API( OSErr )
SetCSequencePreferredPacketSize (ImageSequence seqID,
long preferredPacketSizeInBytes) FOURWORDINLINE(0x203C, 0x0008, 0x0078, 0xAAA3);
EXTERN_API( OSErr )
NewImageGWorld (GWorldPtr * gworld,
ImageDescriptionHandle idh,
GWorldFlags flags) FOURWORDINLINE(0x203C, 0x000C, 0x0052, 0xAAA3);
EXTERN_API( OSErr )
GetCSequenceDataRateParams (ImageSequence seqID,
DataRateParamsPtr params) FOURWORDINLINE(0x203C, 0x0008, 0x0053, 0xAAA3);
EXTERN_API( OSErr )
GetCSequenceFrameNumber (ImageSequence seqID,
long * frameNumber) FOURWORDINLINE(0x203C, 0x0008, 0x0054, 0xAAA3);
EXTERN_API( OSErr )
GetBestDeviceRect (GDHandle * gdh,
Rect * rp) FOURWORDINLINE(0x203C, 0x0008, 0x0055, 0xAAA3);
EXTERN_API( OSErr )
SetSequenceProgressProc (ImageSequence seqID,
ICMProgressProcRecord * progressProc) FOURWORDINLINE(0x203C, 0x0008, 0x0056, 0xAAA3);
EXTERN_API( OSErr )
GDHasScale (GDHandle gdh,
short depth,
Fixed * scale) FOURWORDINLINE(0x203C, 0x000A, 0x005A, 0xAAA3);
EXTERN_API( OSErr )
GDGetScale (GDHandle gdh,
Fixed * scale,
short * flags) FOURWORDINLINE(0x203C, 0x000C, 0x005B, 0xAAA3);
EXTERN_API( OSErr )
GDSetScale (GDHandle gdh,
Fixed scale,
short flags) FOURWORDINLINE(0x203C, 0x000A, 0x005C, 0xAAA3);
EXTERN_API( OSErr )
ICMShieldSequenceCursor (ImageSequence seqID) FOURWORDINLINE(0x203C, 0x0004, 0x0062, 0xAAA3);
EXTERN_API( void )
ICMDecompressComplete (ImageSequence seqID,
OSErr err,
short flag,
ICMCompletionProcRecordPtr completionRtn) FOURWORDINLINE(0x203C, 0x000C, 0x0063, 0xAAA3);
EXTERN_API( OSErr )
ICMDecompressCompleteS (ImageSequence seqID,
OSErr err,
short flag,
ICMCompletionProcRecordPtr completionRtn) FOURWORDINLINE(0x203C, 0x000C, 0x0082, 0xAAA3);
EXTERN_API( OSErr )
ICMSequenceLockBits (ImageSequence seqID,
PixMapPtr dst,
long flags) FOURWORDINLINE(0x203C, 0x000C, 0x007C, 0xAAA3);
EXTERN_API( OSErr )
ICMSequenceUnlockBits (ImageSequence seqID,
long flags) FOURWORDINLINE(0x203C, 0x0008, 0x007D, 0xAAA3);
enum {
kICMPixelFormatIsPlanarMask = 0x0F, /* these bits in formatFlags indicate how many planes there are; they're 0 if chunky*/
kICMPixelFormatIsIndexed = (1L << 4),
kICMPixelFormatIsSupportedByQD = (1L << 5),
kICMPixelFormatIsMonochrome = (1L << 6),
kICMPixelFormatHasAlphaChannel = (1L << 7)
};
struct ICMPixelFormatInfo {
long size; /* caller MUST fill this in with sizeof(ICMPixelFormatInfo) before calling ICMGet/SetPixelFormatInfo*/
unsigned long formatFlags;
short bitsPerPixel[14]; /* list each plane's bits per pixel separately if planar*/
/* new field for QuickTime 4.1*/
Fixed defaultGammaLevel;
/* new fields for QuickTime 6.0*/
short horizontalSubsampling[14]; /* per plane; use 1 if plane is not subsampled*/
short verticalSubsampling[14]; /* per plane; use 1 if plane is not subsampled*/
};
typedef struct ICMPixelFormatInfo ICMPixelFormatInfo;
typedef ICMPixelFormatInfo * ICMPixelFormatInfoPtr;
/* IMPORTANT: Fill in theInfo->size with sizeof(ICMPixelFormatInfo) before calling ICMGetPixelFormatInfo */
EXTERN_API( OSErr )
ICMGetPixelFormatInfo (OSType PixelFormat,
ICMPixelFormatInfoPtr theInfo) FOURWORDINLINE(0x203C, 0x0008, 0x0083, 0xAAA3);
/* IMPORTANT: Fill in theInfo->size with sizeof(ICMPixelFormatInfo) before calling ICMSetPixelFormatInfo */
EXTERN_API( OSErr )
ICMSetPixelFormatInfo (OSType PixelFormat,
ICMPixelFormatInfoPtr theInfo) FOURWORDINLINE(0x203C, 0x0008, 0x008A, 0xAAA3);
enum {
kICMGetChainUltimateParent = 0,
kICMGetChainParent = 1,
kICMGetChainChild = 2,
kICMGetChainUltimateChild = 3
};
EXTERN_API( OSErr )
ICMSequenceGetChainMember (ImageSequence seqID,
ImageSequence * retSeqID,
long flags) FOURWORDINLINE(0x203C, 0x000C, 0x007E, 0xAAA3);
EXTERN_API( OSErr )
SetDSequenceTimeCode (ImageSequence seqID,
void * timeCodeFormat,
void * timeCodeTime) FOURWORDINLINE(0x203C, 0x000C, 0x0064, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceNewMemory (ImageSequence seqID,
Ptr * data,
Size dataSize,
long dataUse,
ICMMemoryDisposedUPP memoryGoneProc,
void * refCon) FOURWORDINLINE(0x203C, 0x0018, 0x0066, 0xAAA3);
EXTERN_API( OSErr )
CDSequenceDisposeMemory (ImageSequence seqID,
Ptr data) FOURWORDINLINE(0x203C, 0x0008, 0x0067, 0xAAA3);