summaryrefslogtreecommitdiff
path: root/common/quicktime_win32/ImageCodec.h
diff options
context:
space:
mode:
authorFluorescentCIAAfricanAmerican <[email protected]>2020-04-22 12:56:21 -0400
committerFluorescentCIAAfricanAmerican <[email protected]>2020-04-22 12:56:21 -0400
commit3bf9df6b2785fa6d951086978a3e66f49427166a (patch)
tree2c0f1f0c63c4832882bc93814ebd2c2b1c6224e5 /common/quicktime_win32/ImageCodec.h
downloadarchived-source-engine-2018-hl2-src-master.tar.xz
archived-source-engine-2018-hl2-src-master.zip
1HEADmaster
Diffstat (limited to 'common/quicktime_win32/ImageCodec.h')
-rw-r--r--common/quicktime_win32/ImageCodec.h3621
1 files changed, 3621 insertions, 0 deletions
diff --git a/common/quicktime_win32/ImageCodec.h b/common/quicktime_win32/ImageCodec.h
new file mode 100644
index 0000000..a8ea620
--- /dev/null
+++ b/common/quicktime_win32/ImageCodec.h
@@ -0,0 +1,3621 @@
+/*
+ File: ImageCodec.h
+
+ Contains: QuickTime Interfaces.
+
+ Version: QuickTime 7.3
+
+ Copyright: (c) 2007 (c) 1990-2007 by Apple Inc., all rights reserved
+
+ Bugs?: For bug reports, consult the following page on
+ the World Wide Web:
+
+ http://developer.apple.com/bugreporter/
+
+*/
+#ifndef __IMAGECODEC__
+#define __IMAGECODEC__
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+#ifndef __QUICKDRAW__
+#include <Quickdraw.h>
+#endif
+
+#ifndef __COMPONENTS__
+#include <Components.h>
+#endif
+
+#ifndef __IMAGECOMPRESSION__
+#include <ImageCompression.h>
+#endif
+
+#ifndef __MOVIES__
+#include <Movies.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
+
+/* QuickTime is not available to 64-bit clients */
+
+#if !__LP64__
+
+/*
+ The following GX types were previously in GXTypes.h, but that header
+ is not available in any Mac OS X framework.
+*/
+struct gxPoint {
+ Fixed x;
+ Fixed y;
+};
+typedef struct gxPoint gxPoint;
+struct gxPath {
+ long vectors;
+ long controlBits[1];
+ gxPoint vector[1];
+};
+typedef struct gxPath gxPath;
+struct gxPaths {
+ long contours;
+ gxPath contour[1];
+};
+typedef struct gxPaths gxPaths;
+/* codec capabilities flags */
+enum {
+ codecCanScale = 1L << 0,
+ codecCanMask = 1L << 1,
+ codecCanMatte = 1L << 2,
+ codecCanTransform = 1L << 3,
+ codecCanTransferMode = 1L << 4,
+ codecCanCopyPrev = 1L << 5,
+ codecCanSpool = 1L << 6,
+ codecCanClipVertical = 1L << 7,
+ codecCanClipRectangular = 1L << 8,
+ codecCanRemapColor = 1L << 9,
+ codecCanFastDither = 1L << 10,
+ codecCanSrcExtract = 1L << 11,
+ codecCanCopyPrevComp = 1L << 12,
+ codecCanAsync = 1L << 13,
+ codecCanMakeMask = 1L << 14,
+ codecCanShift = 1L << 15,
+ codecCanAsyncWhen = 1L << 16,
+ codecCanShieldCursor = 1L << 17,
+ codecCanManagePrevBuffer = 1L << 18,
+ codecHasVolatileBuffer = 1L << 19, /* codec requires redraw after window movement */
+ codecWantsRegionMask = 1L << 20,
+ codecImageBufferIsOnScreen = 1L << 21, /* old def of codec using overlay surface, = ( codecIsDirectToScreenOnly | codecUsesOverlaySurface | codecImageBufferIsOverlaySurface | codecSrcMustBeImageBuffer ) */
+ codecWantsDestinationPixels = 1L << 22,
+ codecWantsSpecialScaling = 1L << 23,
+ codecHandlesInputs = 1L << 24,
+ codecCanDoIndirectSurface = 1L << 25, /* codec can handle indirect surface (GDI) */
+ codecIsSequenceSensitive = 1L << 26,
+ codecRequiresOffscreen = 1L << 27,
+ codecRequiresMaskBits = 1L << 28,
+ codecCanRemapResolution = 1L << 29,
+ codecIsDirectToScreenOnly = 1L << 30, /* codec can only decompress data to the screen */
+ codecCanLockSurface = 1L << 31 /* codec can lock destination surface, icm doesn't lock for you */
+};
+
+/* codec capabilities flags2 */
+enum {
+ codecUsesOverlaySurface = 1L << 0, /* codec uses overlay surface */
+ codecImageBufferIsOverlaySurface = 1L << 1, /* codec image buffer is overlay surface, the bits in the buffer are on the screen */
+ codecSrcMustBeImageBuffer = 1L << 2, /* codec can only source data from an image buffer */
+ codecImageBufferIsInAGPMemory = 1L << 4, /* codec image buffer is in AGP space, byte writes are OK */
+ codecImageBufferIsInPCIMemory = 1L << 5, /* codec image buffer is across a PCI bus; byte writes are bad */
+ codecImageBufferMemoryFlagsValid = 1L << 6, /* set by ImageCodecNewImageBufferMemory/NewImageGWorld to indicate that it set the AGP/PCI flags (supported in QuickTime 6.0 and later) */
+ codecDrawsHigherQualityScaled = 1L << 7, /* codec will draw higher-quality image if it performs scaling (eg, wipe effect with border) */
+ codecSupportsOutOfOrderDisplayTimes = 1L << 8, /* codec supports frames queued in one order for display in a different order, eg, IPB content */
+ codecSupportsScheduledBackwardsPlaybackWithDifferenceFrames = 1L << 9 /* codec can use additional buffers to minimise redecoding during backwards playback */
+};
+
+struct CodecCapabilities {
+ long flags;
+ short wantedPixelSize;
+ short extendWidth;
+ short extendHeight;
+ short bandMin;
+ short bandInc;
+ short pad;
+ unsigned long time;
+ long flags2; /* field new in QuickTime 4.0 */
+};
+typedef struct CodecCapabilities CodecCapabilities;
+/* codec condition flags */
+enum {
+ codecConditionFirstBand = 1L << 0,
+ codecConditionLastBand = 1L << 1,
+ codecConditionFirstFrame = 1L << 2,
+ codecConditionNewDepth = 1L << 3,
+ codecConditionNewTransform = 1L << 4,
+ codecConditionNewSrcRect = 1L << 5,
+ codecConditionNewMask = 1L << 6,
+ codecConditionNewMatte = 1L << 7,
+ codecConditionNewTransferMode = 1L << 8,
+ codecConditionNewClut = 1L << 9,
+ codecConditionNewAccuracy = 1L << 10,
+ codecConditionNewDestination = 1L << 11,
+ codecConditionFirstScreen = 1L << 12,
+ codecConditionDoCursor = 1L << 13,
+ codecConditionCatchUpDiff = 1L << 14,
+ codecConditionMaskMayBeChanged = 1L << 15,
+ codecConditionToBuffer = 1L << 16,
+ codecConditionCodecChangedMask = 1L << 31
+};
+
+
+enum {
+ codecInfoResourceType = FOUR_CHAR_CODE('cdci'), /* codec info resource type */
+ codecInterfaceVersion = 2 /* high word returned in component GetVersion */
+};
+
+struct CDSequenceDataSourceQueueEntry {
+ void * nextBusy;
+
+ long descSeed;
+ Handle dataDesc;
+ void * data;
+ long dataSize;
+
+ long useCount;
+
+ TimeValue frameTime;
+ TimeValue frameDuration;
+ TimeValue timeScale;
+};
+typedef struct CDSequenceDataSourceQueueEntry CDSequenceDataSourceQueueEntry;
+typedef CDSequenceDataSourceQueueEntry * CDSequenceDataSourceQueueEntryPtr;
+struct CDSequenceDataSource {
+ long recordSize;
+
+ void * next;
+
+ ImageSequence seqID;
+ ImageSequenceDataSource sourceID;
+ OSType sourceType;
+ long sourceInputNumber;
+ void * dataPtr;
+ Handle dataDescription;
+ long changeSeed;
+ ICMConvertDataFormatUPP transferProc;
+ void * transferRefcon;
+ long dataSize;
+
+ /* fields available in QT 3 and later */
+
+ QHdrPtr dataQueue; /* queue of CDSequenceDataSourceQueueEntry structures*/
+
+ void * originalDataPtr;
+ long originalDataSize;
+ Handle originalDataDescription;
+ long originalDataDescriptionSeed;
+};
+typedef struct CDSequenceDataSource CDSequenceDataSource;
+typedef CDSequenceDataSource * CDSequenceDataSourcePtr;
+struct ICMFrameTimeInfo {
+ wide startTime;
+ long scale;
+ long duration;
+};
+typedef struct ICMFrameTimeInfo ICMFrameTimeInfo;
+typedef ICMFrameTimeInfo * ICMFrameTimeInfoPtr;
+struct CodecCompressParams {
+ ImageSequence sequenceID; /* precompress,bandcompress */
+ ImageDescriptionHandle imageDescription; /* precompress,bandcompress */
+ Ptr data;
+ long bufferSize;
+ long frameNumber;
+ long startLine;
+ long stopLine;
+ long conditionFlags;
+ CodecFlags callerFlags;
+ CodecCapabilities * capabilities; /* precompress,bandcompress */
+ ICMProgressProcRecord progressProcRecord;
+ ICMCompletionProcRecord completionProcRecord;
+ ICMFlushProcRecord flushProcRecord;
+
+ PixMap srcPixMap; /* precompress,bandcompress */
+ PixMap prevPixMap;
+ CodecQ spatialQuality;
+ CodecQ temporalQuality;
+ Fixed similarity;
+ DataRateParamsPtr dataRateParams;
+ long reserved;
+
+ /* The following fields only exist for QuickTime 2.1 and greater */
+ UInt16 majorSourceChangeSeed;
+ UInt16 minorSourceChangeSeed;
+ CDSequenceDataSourcePtr sourceData;
+
+ /* The following fields only exist for QuickTime 2.5 and greater */
+ long preferredPacketSizeInBytes;
+
+ /* The following fields only exist for QuickTime 3.0 and greater */
+ long requestedBufferWidth; /* must set codecWantsSpecialScaling to indicate this field is valid*/
+ long requestedBufferHeight; /* must set codecWantsSpecialScaling to indicate this field is valid*/
+
+ /* The following fields only exist for QuickTime 4.0 and greater */
+ OSType wantedSourcePixelType;
+
+ /* The following fields only exist for QuickTime 5.0 and greater */
+ long compressedDataSize; /* if nonzero, this overrides (*imageDescription)->dataSize*/
+ UInt32 taskWeight; /* preferred weight for MP tasks implementing this operation*/
+ OSType taskName; /* preferred name (type) for MP tasks implementing this operation*/
+};
+typedef struct CodecCompressParams CodecCompressParams;
+struct CodecDecompressParams {
+ ImageSequence sequenceID; /* predecompress,banddecompress */
+ ImageDescriptionHandle imageDescription; /* predecompress,banddecompress */
+ Ptr data;
+ long bufferSize;
+ long frameNumber;
+ long startLine;
+ long stopLine;
+ long conditionFlags;
+ CodecFlags callerFlags;
+ CodecCapabilities * capabilities; /* predecompress,banddecompress */
+ ICMProgressProcRecord progressProcRecord;
+ ICMCompletionProcRecord completionProcRecord;
+ ICMDataProcRecord dataProcRecord;
+
+ CGrafPtr port; /* predecompress,banddecompress */
+ PixMap dstPixMap; /* predecompress,banddecompress */
+ BitMapPtr maskBits;
+ PixMapPtr mattePixMap;
+ Rect srcRect; /* predecompress,banddecompress */
+ MatrixRecord * matrix; /* predecompress,banddecompress */
+ CodecQ accuracy; /* predecompress,banddecompress */
+ short transferMode; /* predecompress,banddecompress */
+ ICMFrameTimePtr frameTime; /* banddecompress */
+ long reserved[1];
+
+ /* The following fields only exist for QuickTime 2.0 and greater */
+ SInt8 matrixFlags; /* high bit set if 2x resize */
+ SInt8 matrixType;
+ Rect dstRect; /* only valid for simple transforms */
+
+ /* The following fields only exist for QuickTime 2.1 and greater */
+ UInt16 majorSourceChangeSeed;
+ UInt16 minorSourceChangeSeed;
+ CDSequenceDataSourcePtr sourceData;
+
+ RgnHandle maskRegion;
+
+ /* The following fields only exist for QuickTime 2.5 and greater */
+ OSType ** wantedDestinationPixelTypes; /* Handle to 0-terminated list of OSTypes */
+
+ long screenFloodMethod;
+ long screenFloodValue;
+ short preferredOffscreenPixelSize;
+
+ /* The following fields only exist for QuickTime 3.0 and greater */
+ ICMFrameTimeInfoPtr syncFrameTime; /* banddecompress */
+ Boolean needUpdateOnTimeChange; /* banddecompress */
+ Boolean enableBlackLining;
+ Boolean needUpdateOnSourceChange; /* band decompress */
+ Boolean pad;
+
+ long unused;
+
+ CGrafPtr finalDestinationPort;
+
+ long requestedBufferWidth; /* must set codecWantsSpecialScaling to indicate this field is valid*/
+ long requestedBufferHeight; /* must set codecWantsSpecialScaling to indicate this field is valid*/
+
+ /* The following fields only exist for QuickTime 4.0 and greater */
+ Rect displayableAreaOfRequestedBuffer; /* set in predecompress*/
+ Boolean requestedSingleField;
+ Boolean needUpdateOnNextIdle;
+ Boolean pad2[2];
+ Fixed bufferGammaLevel;
+
+ /* The following fields only exist for QuickTime 5.0 and greater */
+ UInt32 taskWeight; /* preferred weight for MP tasks implementing this operation*/
+ OSType taskName; /* preferred name (type) for MP tasks implementing this operation*/
+
+ /* The following fields only exist for QuickTime 6.0 and greater */
+ Boolean pad3;
+ UInt8 destinationBufferMemoryPreference; /* a codec's PreDecompress/Preflight call can set this to express a preference about what kind of memory its destination buffer should go into. no guarantees.*/
+ UInt8 codecBufferMemoryPreference; /* may indicate preferred kind of memory that NewImageGWorld/NewImageBufferMemory should create its buffer in, if applicable.*/
+ Boolean onlyUseCodecIfItIsInUserPreferredCodecList; /* set to prevent this codec from being used unless it is in the userPreferredCodec list*/
+
+ QTMediaContextID mediaContextID;
+
+ /* The following fields only exist for QuickTime 6.5 and greater */
+ UInt8 deinterlaceRequest; /* set by the ICM before PreDecompress/Preflight */
+ UInt8 deinterlaceAnswer; /* codec should set this in PreDecompress/Preflight if it will satisfy the deinterlaceRequest */
+
+ /* The following fields only exist for QuickTime 7.0 and greater */
+ UInt8 pad4[2];
+ long reserved2;
+ UInt32 reserved3;
+ long reserved4;
+ void * reserved5;
+ void * reserved6;
+ void * reserved7;
+ void * reserved8;
+};
+typedef struct CodecDecompressParams CodecDecompressParams;
+enum {
+ matrixFlagScale2x = 1L << 7,
+ matrixFlagScale1x = 1L << 6,
+ matrixFlagScaleHalf = 1L << 5
+};
+
+enum {
+ kScreenFloodMethodNone = 0,
+ kScreenFloodMethodKeyColor = 1,
+ kScreenFloodMethodAlpha = 2
+};
+
+enum {
+ kFlushLastQueuedFrame = 0,
+ kFlushFirstQueuedFrame = 1
+};
+
+enum {
+ kNewImageGWorldErase = 1L << 0
+};
+
+/* values for destinationBufferMemoryPreference and codecBufferMemoryPreference */
+enum {
+ kICMImageBufferNoPreference = 0,
+ kICMImageBufferPreferMainMemory = 1,
+ kICMImageBufferPreferVideoMemory = 2
+};
+
+/* values for deinterlaceRequest and deinterlaceAnswer */
+enum {
+ kICMNoDeinterlacing = 0,
+ kICMDeinterlaceFields = 1
+};
+
+typedef CALLBACK_API( void , ImageCodecTimeTriggerProcPtr )(void * refcon);
+typedef CALLBACK_API( void , ImageCodecDrawBandCompleteProcPtr )(void *refcon, ComponentResult drawBandResult, UInt32 drawBandCompleteFlags);
+typedef STACK_UPP_TYPE(ImageCodecTimeTriggerProcPtr) ImageCodecTimeTriggerUPP;
+typedef STACK_UPP_TYPE(ImageCodecDrawBandCompleteProcPtr) ImageCodecDrawBandCompleteUPP;
+/*
+ * NewImageCodecTimeTriggerUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( ImageCodecTimeTriggerUPP )
+NewImageCodecTimeTriggerUPP(ImageCodecTimeTriggerProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+ enum { uppImageCodecTimeTriggerProcInfo = 0x000000C0 }; /* pascal no_return_value Func(4_bytes) */
+ #ifdef __cplusplus
+ inline DEFINE_API_C(ImageCodecTimeTriggerUPP) NewImageCodecTimeTriggerUPP(ImageCodecTimeTriggerProcPtr userRoutine) { return (ImageCodecTimeTriggerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppImageCodecTimeTriggerProcInfo, GetCurrentArchitecture()); }
+ #else
+ #define NewImageCodecTimeTriggerUPP(userRoutine) (ImageCodecTimeTriggerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppImageCodecTimeTriggerProcInfo, GetCurrentArchitecture())
+ #endif
+#endif
+
+/*
+ * NewImageCodecDrawBandCompleteUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.3 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( ImageCodecDrawBandCompleteUPP )
+NewImageCodecDrawBandCompleteUPP(ImageCodecDrawBandCompleteProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+ enum { uppImageCodecDrawBandCompleteProcInfo = 0x00000FC0 }; /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes) */
+ #ifdef __cplusplus
+ inline DEFINE_API_C(ImageCodecDrawBandCompleteUPP) NewImageCodecDrawBandCompleteUPP(ImageCodecDrawBandCompleteProcPtr userRoutine) { return (ImageCodecDrawBandCompleteUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppImageCodecDrawBandCompleteProcInfo, GetCurrentArchitecture()); }
+ #else
+ #define NewImageCodecDrawBandCompleteUPP(userRoutine) (ImageCodecDrawBandCompleteUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppImageCodecDrawBandCompleteProcInfo, GetCurrentArchitecture())
+ #endif
+#endif
+
+/*
+ * DisposeImageCodecTimeTriggerUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeImageCodecTimeTriggerUPP(ImageCodecTimeTriggerUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+ #ifdef __cplusplus
+ inline DEFINE_API_C(void) DisposeImageCodecTimeTriggerUPP(ImageCodecTimeTriggerUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+ #else
+ #define DisposeImageCodecTimeTriggerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+ #endif
+#endif
+
+/*
+ * DisposeImageCodecDrawBandCompleteUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.3 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeImageCodecDrawBandCompleteUPP(ImageCodecDrawBandCompleteUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+ #ifdef __cplusplus
+ inline DEFINE_API_C(void) DisposeImageCodecDrawBandCompleteUPP(ImageCodecDrawBandCompleteUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+ #else
+ #define DisposeImageCodecDrawBandCompleteUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+ #endif
+#endif
+
+/*
+ * InvokeImageCodecTimeTriggerUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( void )
+InvokeImageCodecTimeTriggerUPP(
+ void * refcon,
+ ImageCodecTimeTriggerUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+ #ifdef __cplusplus
+ inline DEFINE_API_C(void) InvokeImageCodecTimeTriggerUPP(void * refcon, ImageCodecTimeTriggerUPP userUPP) { CALL_ONE_PARAMETER_UPP(userUPP, uppImageCodecTimeTriggerProcInfo, refcon); }
+ #else
+ #define InvokeImageCodecTimeTriggerUPP(refcon, userUPP) CALL_ONE_PARAMETER_UPP((userUPP), uppImageCodecTimeTriggerProcInfo, (refcon))
+ #endif
+#endif
+
+/*
+ * InvokeImageCodecDrawBandCompleteUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.3 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( void )
+InvokeImageCodecDrawBandCompleteUPP(
+ void * refcon,
+ ComponentResult drawBandResult,
+ UInt32 drawBandCompleteFlags,
+ ImageCodecDrawBandCompleteUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+ #ifdef __cplusplus
+ inline DEFINE_API_C(void) InvokeImageCodecDrawBandCompleteUPP(void * refcon, ComponentResult drawBandResult, UInt32 drawBandCompleteFlags, ImageCodecDrawBandCompleteUPP userUPP) { CALL_THREE_PARAMETER_UPP(userUPP, uppImageCodecDrawBandCompleteProcInfo, refcon, drawBandResult, drawBandCompleteFlags); }
+ #else
+ #define InvokeImageCodecDrawBandCompleteUPP(refcon, drawBandResult, drawBandCompleteFlags, userUPP) CALL_THREE_PARAMETER_UPP((userUPP), uppImageCodecDrawBandCompleteProcInfo, (refcon), (drawBandResult), (drawBandCompleteFlags))
+ #endif
+#endif
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+ /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+ #define NewImageCodecTimeTriggerProc(userRoutine) NewImageCodecTimeTriggerUPP(userRoutine)
+ #define NewImageCodecDrawBandCompleteProc(userRoutine) NewImageCodecDrawBandCompleteUPP(userRoutine)
+ #define CallImageCodecTimeTriggerProc(userRoutine, refcon) InvokeImageCodecTimeTriggerUPP(refcon, userRoutine)
+ #define CallImageCodecDrawBandCompleteProc(userRoutine, refcon, drawBandResult, drawBandCompleteFlags) InvokeImageCodecDrawBandCompleteUPP(refcon, drawBandResult, drawBandCompleteFlags, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+struct ImageSubCodecDecompressCapabilities {
+ long recordSize; /* sizeof(ImageSubCodecDecompressCapabilities)*/
+ long decompressRecordSize; /* size of your codec's decompress record*/
+ Boolean canAsync; /* default true*/
+ UInt8 pad0;
+ /* The following field only exists for QuickTime 4.1 and greater */
+ UInt16 suggestedQueueSize;
+ /* The following field only exists for QuickTime 4.0 and greater */
+ Boolean canProvideTrigger;
+
+ /* The following fields only exist for QuickTime 5.0 and greater */
+ Boolean subCodecFlushesScreen; /* only used on Mac OS X*/
+ Boolean subCodecCallsDrawBandComplete;
+ UInt8 pad2[1];
+
+ /* The following fields only exist for QuickTime 5.0.1 and greater */
+ Boolean isChildCodec; /* set by base codec before calling Initialize*/
+ UInt8 reserved1;
+ UInt8 pad4[1];
+
+ /* The following fields only exist for QuickTime 7.0 and greater */
+ Boolean subCodecIsMultiBufferAware; /* set if subcodec always draws using ImageSubCodecDecompressRecord.baseAddr/rowBytes passed to ImageCodecDrawBand, and always writes every pixel in the buffer*/
+ Boolean subCodecSupportsOutOfOrderDisplayTimes;
+ Boolean subCodecSupportsScheduledBackwardsPlaybackWithDifferenceFrames;
+ Boolean subCodecNeedsHelpReportingNonDisplayableFrames;
+ Boolean baseCodecShouldCallDecodeBandForAllFrames;
+
+ UInt8 pad5[2];
+ Boolean subCodecSupportsDrawInDecodeOrder; /* indicates that it's okay for the subcodec to get a single DrawBand call for each frame in decode order even when frames need reordering. (This will only happen when other circumstances allow it.)*/
+ Boolean subCodecSupportsDecodeSmoothing; /* Frame-reordering subcodecs should set this to indicate that they can safely decode a non-droppable frame before drawing the previous non-droppable frame. This enables smoother playback in GWorlds.*/
+ UInt8 pad6[4];
+};
+typedef struct ImageSubCodecDecompressCapabilities ImageSubCodecDecompressCapabilities;
+enum {
+ kCodecFrameTypeUnknown = 0,
+ kCodecFrameTypeKey = 1,
+ kCodecFrameTypeDifference = 2,
+ kCodecFrameTypeDroppableDifference = 3
+};
+
+struct ImageSubCodecDecompressRecord {
+ Ptr baseAddr;
+ long rowBytes;
+ Ptr codecData;
+ ICMProgressProcRecord progressProcRecord;
+ ICMDataProcRecord dataProcRecord;
+ void * userDecompressRecord; /* pointer to codec-specific per-band data*/
+ UInt8 frameType;
+ Boolean inhibitMP; /* set this in BeginBand to tell the base decompressor not to call DrawBand from an MP task for this frame. (Only has any effect for MP-capable subcodecs. New in QuickTime 5.0.)*/
+ UInt8 pad[2];
+ long priv[2];
+
+ /* The following fields only exist for QuickTime 5.0 and greater */
+ ImageCodecDrawBandCompleteUPP drawBandCompleteUPP; /* only used if subcodec set subCodecCallsDrawBandComplete; if drawBandCompleteUPP is non-nil, codec must call it when a frame is finished, but may return from DrawBand before the frame is finished. */
+ void * drawBandCompleteRefCon; /* Note: do not call drawBandCompleteUPP directly from a hardware interrupt; instead, use DTInstall to run a function at deferred task time, and call drawBandCompleteUPP from that. */
+
+ /* The following fields only exist for QuickTime 7.0 and greater */
+ void * reserved1;
+ long reserved2;
+ long reserved3;
+};
+typedef struct ImageSubCodecDecompressRecord ImageSubCodecDecompressRecord;
+/*
+ These data structures are used by code that wants to pass planar pixmap
+ information around.
+ The structure below gives the basic idea of what is being done.
+ Normal instances of code will use a fixed number of planes (eg YUV420 uses
+ three planes, Y, U and V). Each such code instance will define its own
+ version of the PlanarPixMapInfo struct counting the number of planes it
+ needs along with defining constants that specify the meanings of each
+ plane.
+*/
+struct PlanarComponentInfo {
+ SInt32 offset;
+ UInt32 rowBytes;
+};
+typedef struct PlanarComponentInfo PlanarComponentInfo;
+struct PlanarPixMapInfo {
+ PlanarComponentInfo componentInfo[1];
+};
+typedef struct PlanarPixMapInfo PlanarPixMapInfo;
+struct PlanarPixmapInfoSorensonYUV9 {
+ PlanarComponentInfo componentInfoY;
+ PlanarComponentInfo componentInfoU;
+ PlanarComponentInfo componentInfoV;
+};
+typedef struct PlanarPixmapInfoSorensonYUV9 PlanarPixmapInfoSorensonYUV9;
+struct PlanarPixmapInfoYUV420 {
+ PlanarComponentInfo componentInfoY;
+ PlanarComponentInfo componentInfoCb;
+ PlanarComponentInfo componentInfoCr;
+};
+typedef struct PlanarPixmapInfoYUV420 PlanarPixmapInfoYUV420;
+enum {
+ codecSuggestedBufferSentinel = FOUR_CHAR_CODE('sent') /* codec public resource containing suggested data pattern to put past end of data buffer */
+};
+
+
+/* name of parameters or effect -- placed in root container, required */
+enum {
+ kParameterTitleName = FOUR_CHAR_CODE('name'),
+ kParameterTitleID = 1
+};
+
+/* codec sub-type of parameters or effect -- placed in root container, required */
+enum {
+ kParameterWhatName = FOUR_CHAR_CODE('what'),
+ kParameterWhatID = 1
+};
+
+/* effect version -- placed in root container, optional, but recommended */
+enum {
+ kParameterVersionName = FOUR_CHAR_CODE('vers'),
+ kParameterVersionID = 1
+};
+
+/* is effect repeatable -- placed in root container, optional, default is TRUE*/
+enum {
+ kParameterRepeatableName = FOUR_CHAR_CODE('pete'),
+ kParameterRepeatableID = 1
+};
+
+enum {
+ kParameterRepeatableTrue = 1,
+ kParameterRepeatableFalse = 0
+};
+
+/* substitution codec in case effect is missing -- placed in root container, recommended */
+enum {
+ kParameterAlternateCodecName = FOUR_CHAR_CODE('subs'),
+ kParameterAlternateCodecID = 1
+};
+
+/* maximum number of sources -- placed in root container, required */
+enum {
+ kParameterSourceCountName = FOUR_CHAR_CODE('srcs'),
+ kParameterSourceCountID = 1
+};
+
+/* EFFECT CLASSES*/
+
+/*
+ The effect major class defines the major grouping of the effect.
+ Major classes are defined only by Apple and are not extendable by third
+ parties. Major classes are used for filtering of the effect list by
+ applications, but do not define what UI sub-group may or may not be
+ presented to the user. For example, the major class may be a transition,
+ but the minor class may be a wipe.
+*/
+
+/*
+ Effects that fail to include a
+ kEffectMajorClassType will be classified as kMiscMajorClass.
+*/
+enum {
+ kEffectMajorClassType = FOUR_CHAR_CODE('clsa'),
+ kEffectMajorClassID = 1
+};
+
+enum {
+ kGeneratorMajorClass = FOUR_CHAR_CODE('genr'), /* zero source effects*/
+ kFilterMajorClass = FOUR_CHAR_CODE('filt'), /* one source effects*/
+ kTransitionMajorClass = FOUR_CHAR_CODE('tran'), /* multisource morph effects */
+ kCompositorMajorClass = FOUR_CHAR_CODE('comp'), /* multisource layer effects*/
+ kMiscMajorClass = FOUR_CHAR_CODE('misc') /* all other effects*/
+};
+
+/*
+ The effect minor class defines the grouping of effects for the purposes
+ of UI. Apple defines a set of minor classes and will extend it over
+ time. Apple also provides strings within the UI for minor classes
+ that it defines. Third party developers may either classify
+ their effects as a type defined by Apple, or may define their own
+ minor class. Effects which define a minor class of their own
+ must also then supply a kEffectMinorClassNameType atom.
+*/
+
+/*
+ If a kEffectMinorClassNameType atom is present, but
+ the minor type is one defined by Apple, the Apple supplied
+ string will be used in the UI.
+*/
+
+/*
+ Effects that fail to supply a kEffectMinorClassType will be
+ classified as kMiscMinorClass.
+*/
+enum {
+ kEffectMinorClassType = FOUR_CHAR_CODE('clsi'),
+ kEffectMinorClassID = 1,
+ kEffectMinorClassNameType = FOUR_CHAR_CODE('clsn'),
+ kEffectMinorClassNameID = 1
+};
+
+enum {
+ kGeneratorMinorClass = FOUR_CHAR_CODE('genr'), /* "Generators"*/
+ kRenderMinorClass = FOUR_CHAR_CODE('rend'), /* "Render"*/
+ kFilterMinorClass = FOUR_CHAR_CODE('filt'), /* "Filters"*/
+ kArtisticMinorClass = FOUR_CHAR_CODE('arts'), /* "Artistic*/
+ kBlurMinorClass = FOUR_CHAR_CODE('blur'), /* "Blur"*/
+ kSharpenMinorClass = FOUR_CHAR_CODE('shrp'), /* "Sharpen"*/
+ kDistortMinorClass = FOUR_CHAR_CODE('dist'), /* "Distort"*/
+ kNoiseMinorClass = FOUR_CHAR_CODE('nois'), /* "Noise"*/
+ kAdjustmentMinorClass = FOUR_CHAR_CODE('adst'), /* "Adjustments"*/
+ kTransitionMinorClass = FOUR_CHAR_CODE('tran'), /* "Transitions"*/
+ kWipeMinorClass = FOUR_CHAR_CODE('wipe'), /* "Wipes"*/
+ k3DMinorClass = FOUR_CHAR_CODE('pzre'), /* "3D Transitions"*/
+ kCompositorMinorClass = FOUR_CHAR_CODE('comp'), /* "Compositors"*/
+ kEffectsMinorClass = FOUR_CHAR_CODE('fxfx'), /* "Special Effects"*/
+ kMiscMinorClass = FOUR_CHAR_CODE('misc') /* "Miscellaneous"*/
+};
+
+/*
+ Effects can define a number of "preset" values which will be presented to the user
+ in a simplified UI. Each preset is an atom within the parameter description list
+ and must have an atom ID from 1 going up sequentially. Inside of this atom are three other
+ atoms containing:
+ 1) the name of the preset as a Pascal string
+ 2) a preview picture for the preset, 86 x 64 pixels in size
+ 3) the ENTIRE set of parameter values needed to create a sample of this preset.
+*/
+enum {
+ kEffectPresetType = FOUR_CHAR_CODE('peff'),
+ kPresetNameType = FOUR_CHAR_CODE('pnam'),
+ kPresetNameID = 1,
+ kPresetPreviewPictureType = FOUR_CHAR_CODE('ppct'),
+ kPresetPreviewPictureID = 1,
+ kPresetSettingsType = FOUR_CHAR_CODE('psst'),
+ kPresetSettingsID = 1
+};
+
+enum {
+ kParameterDependencyName = FOUR_CHAR_CODE('deep'),
+ kParameterDependencyID = 1
+};
+
+enum {
+ kParameterListDependsUponColorProfiles = FOUR_CHAR_CODE('prof'),
+ kParameterListDependsUponFonts = FOUR_CHAR_CODE('font')
+};
+
+struct ParameterDependancyRecord {
+ long dependCount;
+ OSType depends[1];
+};
+typedef struct ParameterDependancyRecord ParameterDependancyRecord;
+/*
+ enumeration list in container -- placed in root container, optional unless used by a
+ parameter in the list
+*/
+enum {
+ kParameterEnumList = FOUR_CHAR_CODE('enum')
+};
+
+struct EnumValuePair {
+ long value;
+ Str255 name;
+};
+typedef struct EnumValuePair EnumValuePair;
+struct EnumListRecord {
+ long enumCount; /* number of enumeration items to follow*/
+ EnumValuePair values[1]; /* values and names for them, packed */
+};
+typedef struct EnumListRecord EnumListRecord;
+/* atom type of parameter*/
+enum {
+ kParameterAtomTypeAndID = FOUR_CHAR_CODE('type')
+};
+
+enum {
+ kNoAtom = FOUR_CHAR_CODE('none'), /* atom type for no data got/set*/
+ kAtomNoFlags = 0x00000000,
+ kAtomNotInterpolated = 0x00000001, /* atom can never be interpolated*/
+ kAtomInterpolateIsOptional = 0x00000002, /* atom can be interpolated, but it is an advanced user operation*/
+ kAtomMayBeIndexed = 0x00000004 /* more than one value of atom can exist with accending IDs (ie, lists of colors)*/
+};
+
+struct ParameterAtomTypeAndID {
+ QTAtomType atomType; /* type of atom this data comes from/goes into*/
+ QTAtomID atomID; /* ID of atom this data comes from/goes into*/
+ long atomFlags; /* options for this atom*/
+ Str255 atomName; /* name of this value type*/
+};
+typedef struct ParameterAtomTypeAndID ParameterAtomTypeAndID;
+/* optional specification of mapping between parameters and properties*/
+enum {
+ kParameterProperty = FOUR_CHAR_CODE('prop')
+};
+
+struct ParameterProperty {
+ OSType propertyClass; /* class to set for this property (0 for default which is specified by caller)*/
+ OSType propertyID; /* id to set for this property (default is the atomType)*/
+};
+typedef struct ParameterProperty ParameterProperty;
+/* data type of a parameter*/
+enum {
+ kParameterDataType = FOUR_CHAR_CODE('data')
+};
+
+enum {
+ kParameterTypeDataLong = kTweenTypeLong, /* integer value*/
+ kParameterTypeDataFixed = kTweenTypeFixed, /* fixed point value*/
+ kParameterTypeDataRGBValue = kTweenTypeRGBColor, /* RGBColor data*/
+ kParameterTypeDataDouble = kTweenTypeQTFloatDouble, /* IEEE 64 bit floating point value*/
+ kParameterTypeDataText = FOUR_CHAR_CODE('text'), /* editable text item*/
+ kParameterTypeDataEnum = FOUR_CHAR_CODE('enum'), /* enumerated lookup value*/
+ kParameterTypeDataBitField = FOUR_CHAR_CODE('bool'), /* bit field value (something that holds boolean(s))*/
+ kParameterTypeDataImage = FOUR_CHAR_CODE('imag') /* reference to an image via Picture data*/
+};
+
+struct ParameterDataType {
+ OSType dataType; /* type of data this item is stored as*/
+};
+typedef struct ParameterDataType ParameterDataType;
+/*
+ alternate (optional) data type -- main data type always required.
+ Must be modified or deleted when modifying main data type.
+ Main data type must be modified when alternate is modified.
+*/
+enum {
+ kParameterAlternateDataType = FOUR_CHAR_CODE('alt1'),
+ kParameterTypeDataColorValue = FOUR_CHAR_CODE('cmlr'), /* CMColor data (supported on machines with ColorSync)*/
+ kParameterTypeDataCubic = FOUR_CHAR_CODE('cubi'), /* cubic bezier(s) (no built-in support)*/
+ kParameterTypeDataNURB = FOUR_CHAR_CODE('nurb') /* nurb(s) (no built-in support)*/
+};
+
+struct ParameterAlternateDataEntry {
+ OSType dataType; /* type of data this item is stored as*/
+ QTAtomType alternateAtom; /* where to store*/
+};
+typedef struct ParameterAlternateDataEntry ParameterAlternateDataEntry;
+struct ParameterAlternateDataType {
+ long numEntries;
+ ParameterAlternateDataEntry entries[1];
+};
+typedef struct ParameterAlternateDataType ParameterAlternateDataType;
+/* legal values for the parameter*/
+enum {
+ kParameterDataRange = FOUR_CHAR_CODE('rang')
+};
+
+enum {
+ kNoMinimumLongFixed = 0x7FFFFFFF, /* ignore minimum/maxiumum values*/
+ kNoMaximumLongFixed = (long)0x80000000,
+ kNoScaleLongFixed = 0, /* don't perform any scaling of value*/
+ kNoPrecision = (-1) /* allow as many digits as format*/
+};
+
+/* 'text'*/
+struct StringRangeRecord {
+ long maxChars; /* maximum length of string*/
+ long maxLines; /* number of editing lines to use (1 typical, 0 to default)*/
+};
+typedef struct StringRangeRecord StringRangeRecord;
+/* 'long'*/
+struct LongRangeRecord {
+ long minValue; /* no less than this*/
+ long maxValue; /* no more than this*/
+ long scaleValue; /* muliply content by this going in, divide going out*/
+ long precisionDigits; /* # digits of precision when editing via typing*/
+};
+typedef struct LongRangeRecord LongRangeRecord;
+/* 'enum'*/
+struct EnumRangeRecord {
+ long enumID; /* 'enum' list in root container to search within*/
+};
+typedef struct EnumRangeRecord EnumRangeRecord;
+/* 'fixd'*/
+struct FixedRangeRecord {
+ Fixed minValue; /* no less than this*/
+ Fixed maxValue; /* no more than this*/
+ Fixed scaleValue; /* muliply content by this going in, divide going out*/
+ long precisionDigits; /* # digits of precision when editing via typing*/
+};
+typedef struct FixedRangeRecord FixedRangeRecord;
+/* 'doub'*/
+
+ #define kNoMinimumDouble (NAN) /* ignore minimum/maxiumum values */
+ #define kNoMaximumDouble (NAN)
+ #define kNoScaleDouble (0) /* don't perform any scaling of value */
+ struct DoubleRangeRecord
+ {
+ QTFloatDouble minValue; /* no less than this */
+ QTFloatDouble maxValue; /* no more than this */
+ QTFloatDouble scaleValue; /* muliply content by this going in, divide going out */
+ long precisionDigits; /* # digits of precision when editing via typing */
+ };
+ typedef struct DoubleRangeRecord DoubleRangeRecord;
+
+/* 'bool' */
+struct BooleanRangeRecord {
+ long maskValue; /* value to mask on/off to set/clear the boolean*/
+};
+typedef struct BooleanRangeRecord BooleanRangeRecord;
+/* 'rgb '*/
+struct RGBRangeRecord {
+ RGBColor minColor;
+ RGBColor maxColor;
+};
+typedef struct RGBRangeRecord RGBRangeRecord;
+/* 'imag'*/
+enum {
+ kParameterImageNoFlags = 0,
+ kParameterImageIsPreset = 1
+};
+
+enum {
+ kStandardPresetGroup = FOUR_CHAR_CODE('pset')
+};
+
+struct ImageRangeRecord {
+ long imageFlags;
+ OSType fileType; /* file type to contain the preset group (normally kStandardPresetGroup)*/
+ long replacedAtoms; /* # atoms at this level replaced by this preset group*/
+};
+typedef struct ImageRangeRecord ImageRangeRecord;
+/* union of all of the above*/
+
+ struct ParameterRangeRecord
+ {
+ union
+ {
+ LongRangeRecord longRange;
+ EnumRangeRecord enumRange;
+ FixedRangeRecord fixedRange;
+ DoubleRangeRecord doubleRange;
+ StringRangeRecord stringRange;
+ BooleanRangeRecord booleanRange;
+ RGBRangeRecord rgbRange;
+ ImageRangeRecord imageRange;
+ } u;
+ };
+ typedef struct ParameterRangeRecord ParameterRangeRecord;
+
+/* UI behavior of a parameter*/
+enum {
+ kParameterDataBehavior = FOUR_CHAR_CODE('ditl')
+};
+
+enum {
+ /* items edited via typing*/
+ kParameterItemEditText = FOUR_CHAR_CODE('edit'), /* edit text box*/
+ kParameterItemEditLong = FOUR_CHAR_CODE('long'), /* long number editing box*/
+ kParameterItemEditFixed = FOUR_CHAR_CODE('fixd'), /* fixed point number editing box*/
+ kParameterItemEditDouble = FOUR_CHAR_CODE('doub'), /* double number editing box*/
+ /* items edited via control(s)*/
+ kParameterItemPopUp = FOUR_CHAR_CODE('popu'), /* pop up value for enum types*/
+ kParameterItemRadioCluster = FOUR_CHAR_CODE('radi'), /* radio cluster for enum types*/
+ kParameterItemCheckBox = FOUR_CHAR_CODE('chex'), /* check box for booleans*/
+ kParameterItemControl = FOUR_CHAR_CODE('cntl'), /* item controlled via a standard control of some type*/
+ /* special user items*/
+ kParameterItemLine = FOUR_CHAR_CODE('line'), /* line*/
+ kParameterItemColorPicker = FOUR_CHAR_CODE('pick'), /* color swatch & picker*/
+ kParameterItemGroupDivider = FOUR_CHAR_CODE('divi'), /* start of a new group of items*/
+ kParameterItemStaticText = FOUR_CHAR_CODE('stat'), /* display "parameter name" as static text*/
+ kParameterItemDragImage = FOUR_CHAR_CODE('imag'), /* allow image display, along with drag and drop*/
+ /* flags valid for lines and groups*/
+ kGraphicsNoFlags = 0x00000000, /* no options for graphics*/
+ kGraphicsFlagsGray = 0x00000001, /* draw lines with gray*/
+ /* flags valid for groups*/
+ kGroupNoFlags = 0x00000000, /* no options for group -- may be combined with graphics options */
+ kGroupAlignText = 0x00010000, /* edit text items in group have the same size*/
+ kGroupSurroundBox = 0x00020000, /* group should be surrounded with a box*/
+ kGroupMatrix = 0x00040000, /* side-by-side arrangement of group is okay*/
+ kGroupNoName = 0x00080000, /* name of group should not be displayed above box*/
+ /* flags valid for popup/radiocluster/checkbox/control*/
+ kDisableControl = 0x00000001,
+ kDisableWhenNotEqual = (0x00000000 + kDisableControl),
+ kDisableWhenEqual = (0x00000010 + kDisableControl),
+ kDisableWhenLessThan = (0x00000020 + kDisableControl),
+ kDisableWhenGreaterThan = (0x00000030 + kDisableControl), /* flags valid for controls*/
+ kCustomControl = 0x00100000, /* flags valid for popups*/
+ kPopupStoreAsString = 0x00010000
+};
+
+struct ControlBehaviors {
+ QTAtomID groupID; /* group under control of this item*/
+ long controlValue; /* control value for comparison purposes*/
+ QTAtomType customType; /* custom type identifier, for kCustomControl*/
+ QTAtomID customID; /* custom type ID, for kCustomControl*/
+};
+typedef struct ControlBehaviors ControlBehaviors;
+struct ParameterDataBehavior {
+ OSType behaviorType;
+ long behaviorFlags;
+ union {
+ ControlBehaviors controls;
+ } u;
+};
+typedef struct ParameterDataBehavior ParameterDataBehavior;
+/* higher level purpose of a parameter or set of parameters*/
+enum {
+ kParameterDataUsage = FOUR_CHAR_CODE('use ')
+};
+
+enum {
+ kParameterUsagePixels = FOUR_CHAR_CODE('pixl'),
+ kParameterUsageRectangle = FOUR_CHAR_CODE('rect'),
+ kParameterUsagePoint = FOUR_CHAR_CODE('xy '),
+ kParameterUsage3DPoint = FOUR_CHAR_CODE('xyz '),
+ kParameterUsageDegrees = FOUR_CHAR_CODE('degr'),
+ kParameterUsageRadians = FOUR_CHAR_CODE('rads'),
+ kParameterUsagePercent = FOUR_CHAR_CODE('pcnt'),
+ kParameterUsageSeconds = FOUR_CHAR_CODE('secs'),
+ kParameterUsageMilliseconds = FOUR_CHAR_CODE('msec'),
+ kParameterUsageMicroseconds = 0xB5736563,
+ kParameterUsage3by3Matrix = FOUR_CHAR_CODE('3by3'),
+ kParameterUsageCircularDegrees = FOUR_CHAR_CODE('degc'),
+ kParameterUsageCircularRadians = FOUR_CHAR_CODE('radc')
+};
+
+struct ParameterDataUsage {
+ OSType usageType; /* higher level purpose of the data or group*/
+};
+typedef struct ParameterDataUsage ParameterDataUsage;
+/* default value(s) for a parameter*/
+enum {
+ kParameterDataDefaultItem = FOUR_CHAR_CODE('dflt')
+};
+
+/* atoms that help to fill in data within the info window */
+enum {
+ kParameterInfoLongName = 0xA96E616D,
+ kParameterInfoCopyright = 0xA9637079,
+ kParameterInfoDescription = 0xA9696E66,
+ kParameterInfoWindowTitle = 0xA9776E74,
+ kParameterInfoPicture = 0xA9706978,
+ kParameterInfoManufacturer = 0xA96D616E,
+ kParameterInfoIDs = 1
+};
+
+/* flags for ImageCodecValidateParameters */
+enum {
+ kParameterValidationNoFlags = 0x00000000,
+ kParameterValidationFinalValidation = 0x00000001
+};
+
+
+typedef long QTParameterValidationOptions;
+/* QTAtomTypes for atoms in image compressor settings containers*/
+enum {
+ kImageCodecSettingsFieldCount = FOUR_CHAR_CODE('fiel'), /* Number of fields (UInt8) */
+ kImageCodecSettingsFieldOrdering = FOUR_CHAR_CODE('fdom'), /* Ordering of fields (UInt8)*/
+ kImageCodecSettingsFieldOrderingF1F2 = 1,
+ kImageCodecSettingsFieldOrderingF2F1 = 2
+};
+
+
+
+/*
+ * Summary:
+ * Additional Image Description Extensions
+ */
+enum {
+
+ /*
+ * Image description extension describing the color properties.
+ */
+ kColorInfoImageDescriptionExtension = FOUR_CHAR_CODE('colr'),
+
+ /*
+ * Image description extension describing the pixel aspect ratio.
+ */
+ kPixelAspectRatioImageDescriptionExtension = FOUR_CHAR_CODE('pasp'), /* big-endian PixelAspectRatioImageDescriptionExtension */
+
+ /*
+ * Image description extension describing the clean aperture.
+ */
+ kCleanApertureImageDescriptionExtension = FOUR_CHAR_CODE('clap'), /* big-endian CleanApertureImageDescriptionExtension */
+
+ /*
+ * Specifies the offset in bytes from the start of one pixel row to
+ * the next. Only valid for chunky pixel formats. If present, this
+ * image description extension overrides other conventions for
+ * calculating rowBytes.
+ */
+ kQTRowBytesImageDescriptionExtension = FOUR_CHAR_CODE('rowb') /* big-endian SInt32 */
+};
+
+/* Color Info Image Description Extension types*/
+enum {
+ kVideoColorInfoImageDescriptionExtensionType = FOUR_CHAR_CODE('nclc'), /* For video color descriptions (defined below) */
+ kICCProfileColorInfoImageDescriptionExtensionType = FOUR_CHAR_CODE('prof') /* For ICC Profile color descriptions (not defined here)*/
+};
+
+
+/* Video Color Info Image Description Extensions*/
+struct NCLCColorInfoImageDescriptionExtension {
+ OSType colorParamType; /* Type of color parameter 'nclc' */
+ UInt16 primaries; /* CIE 1931 xy chromaticity coordinates */
+ UInt16 transferFunction; /* Nonlinear transfer function from RGB to ErEgEb */
+ UInt16 matrix; /* Matrix from ErEgEb to EyEcbEcr */
+};
+typedef struct NCLCColorInfoImageDescriptionExtension NCLCColorInfoImageDescriptionExtension;
+/* Primaries*/
+enum {
+ kQTPrimaries_ITU_R709_2 = 1, /* ITU-R BT.709-2, SMPTE 274M-1995, and SMPTE 296M-1997 */
+ kQTPrimaries_Unknown = 2, /* Unknown */
+ kQTPrimaries_EBU_3213 = 5, /* EBU Tech. 3213 (1981) */
+ kQTPrimaries_SMPTE_C = 6 /* SMPTE C Primaries from SMPTE RP 145-1993 */
+};
+
+/* Transfer Function*/
+enum {
+ kQTTransferFunction_ITU_R709_2 = 1, /* Recommendation ITU-R BT.709-2, SMPTE 274M-1995, SMPTE 296M-1997, SMPTE 293M-1996 and SMPTE 170M-1994 */
+ kQTTransferFunction_Unknown = 2, /* Unknown */
+ kQTTransferFunction_SMPTE_240M_1995 = 7 /* SMPTE 240M-1995 and interim color implementation of SMPTE 274M-1995 */
+};
+
+/* Matrix*/
+enum {
+ kQTMatrix_ITU_R_709_2 = 1, /* Recommendation ITU-R BT.709-2 (1125/60/2:1 only), SMPTE 274M-1995 and SMPTE 296M-1997 */
+ kQTMatrix_Unknown = 2, /* Unknown */
+ kQTMatrix_ITU_R_601_4 = 6, /* Recommendation ITU-R BT.601-4, Recommendation ITU-R BT.470-4 System B and G, SMPTE 170M-1994 and SMPTE 293M-1996 */
+ kQTMatrix_SMPTE_240M_1995 = 7 /* SMPTE 240M-1995 and interim color implementation of SMPTE 274M-1995 */
+};
+
+
+/* Field/Frame Info Image Description (this remaps to FieldInfoImageDescriptionExtension)*/
+struct FieldInfoImageDescriptionExtension2 {
+ UInt8 fields;
+ UInt8 detail;
+};
+typedef struct FieldInfoImageDescriptionExtension2 FieldInfoImageDescriptionExtension2;
+enum {
+ kQTFieldsProgressiveScan = 1,
+ kQTFieldsInterlaced = 2
+};
+
+enum {
+ kQTFieldDetailUnknown = 0,
+ kQTFieldDetailTemporalTopFirst = 1,
+ kQTFieldDetailTemporalBottomFirst = 6,
+ kQTFieldDetailSpatialFirstLineEarly = 9,
+ kQTFieldDetailSpatialFirstLineLate = 14
+};
+
+
+/* Pixel Aspect Ratio Image Description Extensions*/
+struct PixelAspectRatioImageDescriptionExtension {
+ UInt32 hSpacing; /* Horizontal Spacing */
+ UInt32 vSpacing; /* Vertical Spacing */
+};
+typedef struct PixelAspectRatioImageDescriptionExtension PixelAspectRatioImageDescriptionExtension;
+/* Clean Aperture Image Description Extensions*/
+struct CleanApertureImageDescriptionExtension {
+ UInt32 cleanApertureWidthN; /* width of clean aperture, numerator, denominator */
+ UInt32 cleanApertureWidthD;
+ UInt32 cleanApertureHeightN; /* height of clean aperture, numerator, denominator*/
+ UInt32 cleanApertureHeightD;
+ SInt32 horizOffN; /* horizontal offset of clean aperture center minus (width-1)/2, numerator, denominator */
+ UInt32 horizOffD;
+ SInt32 vertOffN; /* vertical offset of clean aperture center minus (height-1)/2, numerator, denominator */
+ UInt32 vertOffD;
+};
+typedef struct CleanApertureImageDescriptionExtension CleanApertureImageDescriptionExtension;
+typedef CALLBACK_API( ComponentResult , ImageCodecMPDrawBandProcPtr )(void *refcon, ImageSubCodecDecompressRecord *drp);
+typedef STACK_UPP_TYPE(ImageCodecMPDrawBandProcPtr) ImageCodecMPDrawBandUPP;
+/*
+ * NewImageCodecMPDrawBandUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( ImageCodecMPDrawBandUPP )
+NewImageCodecMPDrawBandUPP(ImageCodecMPDrawBandProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+ enum { uppImageCodecMPDrawBandProcInfo = 0x000003F0 }; /* pascal 4_bytes Func(4_bytes, 4_bytes) */
+ #ifdef __cplusplus
+ inline DEFINE_API_C(ImageCodecMPDrawBandUPP) NewImageCodecMPDrawBandUPP(ImageCodecMPDrawBandProcPtr userRoutine) { return (ImageCodecMPDrawBandUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppImageCodecMPDrawBandProcInfo, GetCurrentArchitecture()); }
+ #else
+ #define NewImageCodecMPDrawBandUPP(userRoutine) (ImageCodecMPDrawBandUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppImageCodecMPDrawBandProcInfo, GetCurrentArchitecture())
+ #endif
+#endif
+
+/*
+ * DisposeImageCodecMPDrawBandUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeImageCodecMPDrawBandUPP(ImageCodecMPDrawBandUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+ #ifdef __cplusplus
+ inline DEFINE_API_C(void) DisposeImageCodecMPDrawBandUPP(ImageCodecMPDrawBandUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+ #else
+ #define DisposeImageCodecMPDrawBandUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+ #endif
+#endif
+
+/*
+ * InvokeImageCodecMPDrawBandUPP()
+ *
+ * Availability:
+ * Non-Carbon CFM: available as macro/inline
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ */
+EXTERN_API_C( ComponentResult )
+InvokeImageCodecMPDrawBandUPP(
+ void * refcon,
+ ImageSubCodecDecompressRecord * drp,
+ ImageCodecMPDrawBandUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+ #ifdef __cplusplus
+ inline DEFINE_API_C(ComponentResult) InvokeImageCodecMPDrawBandUPP(void * refcon, ImageSubCodecDecompressRecord * drp, ImageCodecMPDrawBandUPP userUPP) { return (ComponentResult)CALL_TWO_PARAMETER_UPP(userUPP, uppImageCodecMPDrawBandProcInfo, refcon, drp); }
+ #else
+ #define InvokeImageCodecMPDrawBandUPP(refcon, drp, userUPP) (ComponentResult)CALL_TWO_PARAMETER_UPP((userUPP), uppImageCodecMPDrawBandProcInfo, (refcon), (drp))
+ #endif
+#endif
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+ /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+ #define NewImageCodecMPDrawBandProc(userRoutine) NewImageCodecMPDrawBandUPP(userRoutine)
+ #define CallImageCodecMPDrawBandProc(userRoutine, refcon, drp) InvokeImageCodecMPDrawBandUPP(refcon, drp, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+/* codec selectors 0-127 are reserved by Apple */
+/* codec selectors 128-191 are subtype specific */
+/* codec selectors 192-255 are vendor specific */
+/* codec selectors 256-511 are available for general use */
+/* codec selectors 512-1023 are reserved by Apple */
+/* codec selectors 1024-32767 are available for general use */
+/* negative selectors are reserved by the Component Manager */
+/*
+ * ImageCodecGetCodecInfo()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetCodecInfo(
+ ComponentInstance ci,
+ CodecInfo * info) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0000, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetCompressionTime()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetCompressionTime(
+ ComponentInstance ci,
+ PixMapHandle src,
+ const Rect * srcRect,
+ short depth,
+ CodecQ * spatialQuality,
+ CodecQ * temporalQuality,
+ unsigned long * time) FIVEWORDINLINE(0x2F3C, 0x0016, 0x0001, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetMaxCompressionSize()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetMaxCompressionSize(
+ ComponentInstance ci,
+ PixMapHandle src,
+ const Rect * srcRect,
+ short depth,
+ CodecQ quality,
+ long * size) FIVEWORDINLINE(0x2F3C, 0x0012, 0x0002, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecPreCompress()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecPreCompress(
+ ComponentInstance ci,
+ CodecCompressParams * params) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecBandCompress()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecBandCompress(
+ ComponentInstance ci,
+ CodecCompressParams * params) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecPreDecompress()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecPreDecompress(
+ ComponentInstance ci,
+ CodecDecompressParams * params) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecBandDecompress()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecBandDecompress(
+ ComponentInstance ci,
+ CodecDecompressParams * params) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0006, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecBusy()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecBusy(
+ ComponentInstance ci,
+ ImageSequence seq) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetCompressedImageSize()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetCompressedImageSize(
+ ComponentInstance ci,
+ ImageDescriptionHandle desc,
+ Ptr data,
+ long bufferSize,
+ ICMDataProcRecordPtr dataProc,
+ long * dataSize) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0008, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetSimilarity()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetSimilarity(
+ ComponentInstance ci,
+ PixMapHandle src,
+ const Rect * srcRect,
+ ImageDescriptionHandle desc,
+ Ptr data,
+ Fixed * similarity) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0009, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecTrimImage()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecTrimImage(
+ ComponentInstance ci,
+ ImageDescriptionHandle Desc,
+ Ptr inData,
+ long inBufferSize,
+ ICMDataProcRecordPtr dataProc,
+ Ptr outData,
+ long outBufferSize,
+ ICMFlushProcRecordPtr flushProc,
+ Rect * trimRect,
+ ICMProgressProcRecordPtr progressProc) FIVEWORDINLINE(0x2F3C, 0x0024, 0x000A, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecRequestSettings()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecRequestSettings(
+ ComponentInstance ci,
+ Handle settings,
+ Rect * rp,
+ ModalFilterUPP filterProc) FIVEWORDINLINE(0x2F3C, 0x000C, 0x000B, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetSettings()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetSettings(
+ ComponentInstance ci,
+ Handle settings) FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecSetSettings()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecSetSettings(
+ ComponentInstance ci,
+ Handle settings) FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecFlush()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecFlush(ComponentInstance ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x000E, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecSetTimeCode()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecSetTimeCode(
+ ComponentInstance ci,
+ void * timeCodeFormat,
+ void * timeCodeTime) FIVEWORDINLINE(0x2F3C, 0x0008, 0x000F, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecIsImageDescriptionEquivalent()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecIsImageDescriptionEquivalent(
+ ComponentInstance ci,
+ ImageDescriptionHandle newDesc,
+ Boolean * equivalent) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0010, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecNewMemory()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecNewMemory(
+ ComponentInstance ci,
+ Ptr * data,
+ Size dataSize,
+ long dataUse,
+ ICMMemoryDisposedUPP memoryGoneProc,
+ void * refCon) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0011, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDisposeMemory()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDisposeMemory(
+ ComponentInstance ci,
+ Ptr data) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecHitTestData()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecHitTestData(
+ ComponentInstance ci,
+ ImageDescriptionHandle desc,
+ void * data,
+ Size dataSize,
+ Point where,
+ Boolean * hit) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0013, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecNewImageBufferMemory()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecNewImageBufferMemory(
+ ComponentInstance ci,
+ CodecDecompressParams * params,
+ long flags,
+ ICMMemoryDisposedUPP memoryGoneProc,
+ void * refCon) FIVEWORDINLINE(0x2F3C, 0x0010, 0x0014, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecExtractAndCombineFields()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecExtractAndCombineFields(
+ ComponentInstance ci,
+ long fieldFlags,
+ void * data1,
+ long dataSize1,
+ ImageDescriptionHandle desc1,
+ void * data2,
+ long dataSize2,
+ ImageDescriptionHandle desc2,
+ void * outputData,
+ long * outDataSize,
+ ImageDescriptionHandle descOut) FIVEWORDINLINE(0x2F3C, 0x0028, 0x0015, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetMaxCompressionSizeWithSources()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetMaxCompressionSizeWithSources(
+ ComponentInstance ci,
+ PixMapHandle src,
+ const Rect * srcRect,
+ short depth,
+ CodecQ quality,
+ CDSequenceDataSourcePtr sourceData,
+ long * size) FIVEWORDINLINE(0x2F3C, 0x0016, 0x0016, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecSetTimeBase()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecSetTimeBase(
+ ComponentInstance ci,
+ void * base) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0017, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecSourceChanged()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecSourceChanged(
+ ComponentInstance ci,
+ UInt32 majorSourceChangeSeed,
+ UInt32 minorSourceChangeSeed,
+ CDSequenceDataSourcePtr sourceData,
+ long * flagsOut) FIVEWORDINLINE(0x2F3C, 0x0010, 0x0018, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecFlushFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecFlushFrame(
+ ComponentInstance ci,
+ UInt32 flags) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0019, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetSettingsAsText()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.1 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetSettingsAsText(
+ ComponentInstance ci,
+ Handle * text) FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetParameterListHandle()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetParameterListHandle(
+ ComponentInstance ci,
+ Handle * parameterDescriptionHandle) FIVEWORDINLINE(0x2F3C, 0x0004, 0x001B, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetParameterList()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetParameterList(
+ ComponentInstance ci,
+ QTAtomContainer * parameterDescription) FIVEWORDINLINE(0x2F3C, 0x0004, 0x001C, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecCreateStandardParameterDialog()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecCreateStandardParameterDialog(
+ ComponentInstance ci,
+ QTAtomContainer parameterDescription,
+ QTAtomContainer parameters,
+ QTParameterDialogOptions dialogOptions,
+ DialogPtr existingDialog,
+ short existingUserItem,
+ QTParameterDialog * createdDialog) FIVEWORDINLINE(0x2F3C, 0x0016, 0x001D, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecIsStandardParameterDialogEvent()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecIsStandardParameterDialogEvent(
+ ComponentInstance ci,
+ EventRecord * pEvent,
+ QTParameterDialog createdDialog) FIVEWORDINLINE(0x2F3C, 0x0008, 0x001E, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDismissStandardParameterDialog()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDismissStandardParameterDialog(
+ ComponentInstance ci,
+ QTParameterDialog createdDialog) FIVEWORDINLINE(0x2F3C, 0x0004, 0x001F, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecStandardParameterDialogDoAction()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecStandardParameterDialogDoAction(
+ ComponentInstance ci,
+ QTParameterDialog createdDialog,
+ long action,
+ void * params) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0020, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecNewImageGWorld()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecNewImageGWorld(
+ ComponentInstance ci,
+ CodecDecompressParams * params,
+ GWorldPtr * newGW,
+ long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0021, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDisposeImageGWorld()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDisposeImageGWorld(
+ ComponentInstance ci,
+ GWorldPtr theGW) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0022, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecHitTestDataWithFlags()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.1 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecHitTestDataWithFlags(
+ ComponentInstance ci,
+ ImageDescriptionHandle desc,
+ void * data,
+ Size dataSize,
+ Point where,
+ long * hit,
+ long hitFlags) FIVEWORDINLINE(0x2F3C, 0x0018, 0x0023, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecValidateParameters()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecValidateParameters(
+ ComponentInstance ci,
+ QTAtomContainer parameters,
+ QTParameterValidationOptions validationFlags,
+ StringPtr errorString) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0024, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetBaseMPWorkFunction()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetBaseMPWorkFunction(
+ ComponentInstance ci,
+ ComponentMPWorkFunctionUPP * workFunction,
+ void ** refCon,
+ ImageCodecMPDrawBandUPP drawProc,
+ void * drawProcRefCon) FIVEWORDINLINE(0x2F3C, 0x0010, 0x0025, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecLockBits()
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.3 (or QuickTime 6.4) and later
+ * Windows: in qtmlClient.lib 6.5 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecLockBits(
+ ComponentInstance ci,
+ CGrafPtr port) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0026, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecUnlockBits()
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.3 (or QuickTime 6.4) and later
+ * Windows: in qtmlClient.lib 6.5 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecUnlockBits(
+ ComponentInstance ci,
+ CGrafPtr port) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0027, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecRequestGammaLevel()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 5.0 and later
+ * CarbonLib: in CarbonLib 1.3 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 5.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecRequestGammaLevel(
+ ComponentInstance ci,
+ Fixed srcGammaLevel,
+ Fixed dstGammaLevel,
+ long * codecCanMatch) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0028, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetSourceDataGammaLevel()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 5.0 and later
+ * CarbonLib: in CarbonLib 1.3 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 5.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetSourceDataGammaLevel(
+ ComponentInstance ci,
+ Fixed * sourceDataGammaLevel) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0029, 0x7000, 0xA82A);
+
+
+/* (Selector 42 skipped) */
+/*
+ * ImageCodecGetDecompressLatency()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 5.0 and later
+ * CarbonLib: in CarbonLib 1.3 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 5.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetDecompressLatency(
+ ComponentInstance ci,
+ TimeRecord * latency) FIVEWORDINLINE(0x2F3C, 0x0004, 0x002B, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecMergeFloatingImageOntoWindow()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecMergeFloatingImageOntoWindow(
+ ComponentInstance ci,
+ UInt32 flags) FIVEWORDINLINE(0x2F3C, 0x0004, 0x002C, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecRemoveFloatingImage()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecRemoveFloatingImage(
+ ComponentInstance ci,
+ UInt32 flags) FIVEWORDINLINE(0x2F3C, 0x0004, 0x002D, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecGetDITLForSize()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetDITLForSize(
+ ComponentInstance ci,
+ Handle * ditl,
+ Point * requestedSize) FIVEWORDINLINE(0x2F3C, 0x0008, 0x002E, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDITLInstall()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDITLInstall(
+ ComponentInstance ci,
+ DialogRef d,
+ short itemOffset) FIVEWORDINLINE(0x2F3C, 0x0006, 0x002F, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDITLEvent()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDITLEvent(
+ ComponentInstance ci,
+ DialogRef d,
+ short itemOffset,
+ const EventRecord * theEvent,
+ short * itemHit,
+ Boolean * handled) FIVEWORDINLINE(0x2F3C, 0x0012, 0x0030, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDITLItem()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDITLItem(
+ ComponentInstance ci,
+ DialogRef d,
+ short itemOffset,
+ short itemNum) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0031, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDITLRemove()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDITLRemove(
+ ComponentInstance ci,
+ DialogRef d,
+ short itemOffset) FIVEWORDINLINE(0x2F3C, 0x0006, 0x0032, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDITLValidateInput()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 6.0 and later
+ * CarbonLib: in CarbonLib 1.6 and later
+ * Mac OS X: in version 10.2 and later
+ * Windows: in qtmlClient.lib 6.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDITLValidateInput(
+ ComponentInstance ci,
+ Boolean * ok) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0033, 0x7000, 0xA82A);
+
+
+/* (Selector 52 skipped) */
+/* (Selector 53 skipped) */
+/*
+ * ImageCodecGetPreferredChunkSizeAndAlignment()
+ *
+ * Summary:
+ * Returns the preferences of an image decompressor for the chunking
+ * of image data within a container, e.g. a movie file.
+ *
+ * Discussion:
+ * If you are writing image data to a container, you can optimize
+ * the subsequent loading of the image data for playback and other
+ * operations by chunking multiple samples of image data together.
+ * This function can be called to determine whether an image
+ * decompressor has special chunking preferences.
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * desc:
+ * The image description for the image data to be chunked.
+ *
+ * frameRate:
+ * Mean frame rate in frames per second as in SCTemporalSettings;
+ * 0 if not known or not applicable.
+ *
+ * dataRate:
+ * Mean data rate in bytes per second as in SCDataRateSettings; 0
+ * if not known.
+ *
+ * bytesPerChunk:
+ * Points to a variable to receive the preferred maximum size in
+ * bytes of each chunk of image data. It is not safe to pass NULL
+ * for this parameter. The codec may indicate that it has no
+ * preference regarding chunk sizing by setting the variable to 0.
+ *
+ * alignment:
+ * Points to a variable to receive the preferred boundary for
+ * chunk alignment in bytes, e.g. 512. It is not safe to pass NULL
+ * for this parameter. The codec may indicate that it has no
+ * preference regarding chunk alignment by setting the variable to
+ * 0.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecGetPreferredChunkSizeAndAlignment(
+ ComponentInstance ci,
+ ImageDescriptionHandle desc,
+ Fixed frameRate,
+ UInt32 dataRate,
+ long * bytesPerChunk,
+ long * alignment) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0036, 0x7000, 0xA82A);
+
+
+
+/* B-Frame Capable Image Compressor Component API */
+/*
+ * ImageCodecPrepareToCompressFrames()
+ *
+ * Summary:
+ * Prepares the compressor to receive frames.
+ *
+ * Discussion:
+ * The compressor should record session and retain
+ * compressionSessionOptions for use in later calls.
+ * The compressor may modify imageDescription at this point.
+ * The compressor should create and return pixel buffer attributes,
+ * which the ICM will release.
+ * (Note: this replaces ImageCodecPreCompress.)
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * session:
+ * The compressor session reference. The compressor should store
+ * this in its globals; it will need it when calling the ICM back
+ * (eg, to call ICMEncodedFrameCreateMutable and
+ * ICMCompressorSessionEmitEncodedFrame).
+ * This is not a CF type. Do not call CFRetain or CFRelease on it.
+ *
+ * compressionSessionOptions:
+ * The session options from the client. The compressor should
+ * retain this and use the settings to guide compression.
+ *
+ * imageDescription:
+ * The image description. The compressor may add image description
+ * extensions.
+ *
+ * reserved:
+ * Reserved for future use. Ignore this parameter.
+ *
+ * compressorPixelBufferAttributesOut:
+ * The compressor should create a pixel buffer attributes
+ * dictionary and set compressorPixelBufferAttributesOut to it.
+ * The ICM will release it.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecPrepareToCompressFrames(
+ ComponentInstance ci,
+ ICMCompressorSessionRef session,
+ ICMCompressionSessionOptionsRef compressionSessionOptions,
+ ImageDescriptionHandle imageDescription,
+ void * reserved,
+ CFDictionaryRef * compressorPixelBufferAttributesOut) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0037, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEncodeFrame()
+ *
+ * Summary:
+ * Presents the compressor with a frame to encode.
+ *
+ * Discussion:
+ * The compressor may encode the frame immediately or queue it for
+ * later encoding. If the compressor queues the frame for later
+ * decode, it must retain it (by calling
+ * ICMCompressorSourceFrameRetain) and release it when it is done
+ * with it (by calling ICMCompressorSourceFrameRelease).
+ * Pixel buffers are guaranteed to conform to the pixel buffer
+ * attributes returned by ImageCodecPrepareToCompressFrames.
+ * During multipass encoding, if the compressor requested the
+ * kICMCompressionPassMode_NoSourceFrames flag, the source frame
+ * pixel buffers may be NULL.
+ * (Note: this replaces ImageCodecBandCompress.)
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * sourceFrame:
+ * The source frame to encode.
+ *
+ * flags:
+ * Reserved; ignore.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEncodeFrame(
+ ComponentInstance ci,
+ ICMCompressorSourceFrameRef sourceFrame,
+ UInt32 flags) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0038, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecCompleteFrame()
+ *
+ * Summary:
+ * Directs the compressor to finish with a queued source frame,
+ * either emitting or dropping it.
+ *
+ * Discussion:
+ * This frame does not necessarily need to be the first or only
+ * source frame emitted or dropped during this call, but the
+ * compressor must call either ICMCompressorSessionDropFrame or
+ * ICMCompressorSessionEmitEncodedFrame with this frame before
+ * returning.
+ * The ICM will call this function to force frames to be encoded for
+ * the following reasons: (a) the maximum frame delay count or
+ * maximum frame delay time in the compressionSessionOptions does
+ * not permit frames to be queued; (b) the client has called
+ * ICMCompressionSessionCompleteFrames.
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * sourceFrame:
+ * The source frame that must be completed.
+ *
+ * flags:
+ * Reserved; ignore.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecCompleteFrame(
+ ComponentInstance ci,
+ ICMCompressorSourceFrameRef sourceFrame,
+ UInt32 flags) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0039, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecBeginPass()
+ *
+ * Summary:
+ * Notifies the compressor that it should operate in multipass mode
+ * and use the given multipass storage.
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * passModeFlags:
+ * Indicates how the compressor should operate in this pass.
+ * If the kICMCompressionPassMode_WriteToMultiPassStorage flag is
+ * set, the compressor may gather information of interest and
+ * store it in multiPassStorage.
+ * If the kICMCompressionPassMode_ReadFromMultiPassStorage flag is
+ * set, the compressor may retrieve information from
+ * multiPassStorage.
+ * If the kICMCompressionPassMode_OutputEncodedFrames flag is set,
+ * the compressor must encode or drop every frame by calling
+ * ICMCompressorSessionDropFrame or
+ * ICMCompressorSessionEmitEncodedFrame. If that flag is not set,
+ * the compressor should not call these routines.
+ *
+ * flags:
+ * Reserved. Ignore this parameter.
+ *
+ * multiPassStorage:
+ * The multipass storage object that the compressor should use to
+ * store and retrieve information between passes.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecBeginPass(
+ ComponentInstance ci,
+ ICMCompressionPassModeFlags passModeFlags,
+ UInt32 flags,
+ ICMMultiPassStorageRef multiPassStorage) FIVEWORDINLINE(0x2F3C, 0x000C, 0x003A, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEndPass()
+ *
+ * Summary:
+ * Notifies the compressor that a pass is over.
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEndPass(ComponentInstance ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x003B, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecProcessBetweenPasses()
+ *
+ * Summary:
+ * Gives the compressor an opportunity to perform processing between
+ * passes.
+ *
+ * Discussion:
+ * This function will be called repeatedly until it returns true in
+ * *interpassProcessingDoneOut.
+ * The compressor may read and write to multiPassStorage.
+ * The compressor should indicate which type of pass it would prefer
+ * to perform next by setting *requestedNextPassTypeOut.
+ *
+ * Parameters:
+ *
+ * ci:
+ * Component instance / instance globals.
+ *
+ * multiPassStorage:
+ * The multipass storage object that the compressor should use to
+ * store and retrieve information between passes.
+ *
+ * interpassProcessingDoneOut:
+ * Points to a Boolean. Set this to false if you want your
+ * ImageCodecProcessBetweenPasses function to be called again to
+ * perform more processing, true if not.
+ *
+ * requestedNextPassModeFlagsOut:
+ * Set *requestedNextPassModeFlagsOut to indicate the type of pass
+ * that should be performed next:
+ * To recommend a repeated analysis pass, set it to
+ * kICMCompressionPassMode_ReadFromMultiPassStorage |
+ * kICMCompressionPassMode_WriteToMultiPassStorage.
+ * To recommend a final encoding pass, set it to
+ * kICMCompressionPassMode_ReadFromMultiPassStorage |
+ * kICMCompressionPassMode_OutputEncodedFrames.
+ * If source frame buffers are not necessary for the recommended
+ * pass (eg, because all the required data has been copied into
+ * multipass storage), set kICMCompressionPassMode_NoSourceFrames.
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecProcessBetweenPasses(
+ ComponentInstance ci,
+ ICMMultiPassStorageRef multiPassStorage,
+ Boolean * interpassProcessingDoneOut,
+ ICMCompressionPassModeFlags * requestedNextPassModeFlagsOut) FIVEWORDINLINE(0x2F3C, 0x000C, 0x003C, 0x7000, 0xA82A);
+
+
+
+/* (Selector 61 skipped) */
+/* (Selector 62 skipped) */
+/* (Selector 63 skipped) */
+/* (Selector 64 skipped) */
+/* (Selector 65 skipped) */
+/* (Selector 66 skipped) */
+/*
+ * ImageCodecPreflight()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecPreflight(
+ ComponentInstance ci,
+ CodecDecompressParams * params) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0200, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecInitialize()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecInitialize(
+ ComponentInstance ci,
+ ImageSubCodecDecompressCapabilities * cap) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0201, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecBeginBand()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecBeginBand(
+ ComponentInstance ci,
+ CodecDecompressParams * params,
+ ImageSubCodecDecompressRecord * drp,
+ long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0202, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDrawBand()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDrawBand(
+ ComponentInstance ci,
+ ImageSubCodecDecompressRecord * drp) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0203, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEndBand()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEndBand(
+ ComponentInstance ci,
+ ImageSubCodecDecompressRecord * drp,
+ OSErr result,
+ long flags) FIVEWORDINLINE(0x2F3C, 0x000A, 0x0204, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecQueueStarting()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecQueueStarting(ComponentInstance ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0205, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecQueueStopping()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecQueueStopping(ComponentInstance ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0206, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDroppingFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDroppingFrame(
+ ComponentInstance ci,
+ const ImageSubCodecDecompressRecord * drp) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0207, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecScheduleFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 4.0 and later
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 4.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecScheduleFrame(
+ ComponentInstance ci,
+ const ImageSubCodecDecompressRecord * drp,
+ ImageCodecTimeTriggerUPP triggerProc,
+ void * triggerProcRefCon) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0208, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecCancelTrigger()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 4.0 and later
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 4.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecCancelTrigger(ComponentInstance ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0209, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecDecodeBand()
+ *
+ * Availability:
+ * Non-Carbon CFM: not available
+ * CarbonLib: not available
+ * Mac OS X: in version 10.4 (or QuickTime 7.0) and later
+ * Windows: in qtmlClient.lib version 10.4 (or QuickTime 7.0) and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecDecodeBand(
+ ComponentInstance ci,
+ ImageSubCodecDecompressRecord * drp,
+ unsigned long flags) FIVEWORDINLINE(0x2F3C, 0x0008, 0x020F, 0x7000, 0xA82A);
+
+
+
+
+
+/* selectors for component calls */
+enum {
+ kImageCodecGetCodecInfoSelect = 0x0000,
+ kImageCodecGetCompressionTimeSelect = 0x0001,
+ kImageCodecGetMaxCompressionSizeSelect = 0x0002,
+ kImageCodecPreCompressSelect = 0x0003,
+ kImageCodecBandCompressSelect = 0x0004,
+ kImageCodecPreDecompressSelect = 0x0005,
+ kImageCodecBandDecompressSelect = 0x0006,
+ kImageCodecBusySelect = 0x0007,
+ kImageCodecGetCompressedImageSizeSelect = 0x0008,
+ kImageCodecGetSimilaritySelect = 0x0009,
+ kImageCodecTrimImageSelect = 0x000A,
+ kImageCodecRequestSettingsSelect = 0x000B,
+ kImageCodecGetSettingsSelect = 0x000C,
+ kImageCodecSetSettingsSelect = 0x000D,
+ kImageCodecFlushSelect = 0x000E,
+ kImageCodecSetTimeCodeSelect = 0x000F,
+ kImageCodecIsImageDescriptionEquivalentSelect = 0x0010,
+ kImageCodecNewMemorySelect = 0x0011,
+ kImageCodecDisposeMemorySelect = 0x0012,
+ kImageCodecHitTestDataSelect = 0x0013,
+ kImageCodecNewImageBufferMemorySelect = 0x0014,
+ kImageCodecExtractAndCombineFieldsSelect = 0x0015,
+ kImageCodecGetMaxCompressionSizeWithSourcesSelect = 0x0016,
+ kImageCodecSetTimeBaseSelect = 0x0017,
+ kImageCodecSourceChangedSelect = 0x0018,
+ kImageCodecFlushFrameSelect = 0x0019,
+ kImageCodecGetSettingsAsTextSelect = 0x001A,
+ kImageCodecGetParameterListHandleSelect = 0x001B,
+ kImageCodecGetParameterListSelect = 0x001C,
+ kImageCodecCreateStandardParameterDialogSelect = 0x001D,
+ kImageCodecIsStandardParameterDialogEventSelect = 0x001E,
+ kImageCodecDismissStandardParameterDialogSelect = 0x001F,
+ kImageCodecStandardParameterDialogDoActionSelect = 0x0020,
+ kImageCodecNewImageGWorldSelect = 0x0021,
+ kImageCodecDisposeImageGWorldSelect = 0x0022,
+ kImageCodecHitTestDataWithFlagsSelect = 0x0023,
+ kImageCodecValidateParametersSelect = 0x0024,
+ kImageCodecGetBaseMPWorkFunctionSelect = 0x0025,
+ kImageCodecLockBitsSelect = 0x0026,
+ kImageCodecUnlockBitsSelect = 0x0027,
+ kImageCodecRequestGammaLevelSelect = 0x0028,
+ kImageCodecGetSourceDataGammaLevelSelect = 0x0029,
+ kImageCodecGetDecompressLatencySelect = 0x002B,
+ kImageCodecMergeFloatingImageOntoWindowSelect = 0x002C,
+ kImageCodecRemoveFloatingImageSelect = 0x002D,
+ kImageCodecGetDITLForSizeSelect = 0x002E,
+ kImageCodecDITLInstallSelect = 0x002F,
+ kImageCodecDITLEventSelect = 0x0030,
+ kImageCodecDITLItemSelect = 0x0031,
+ kImageCodecDITLRemoveSelect = 0x0032,
+ kImageCodecDITLValidateInputSelect = 0x0033,
+ kImageCodecGetPreferredChunkSizeAndAlignmentSelect = 0x0036,
+ kImageCodecPrepareToCompressFramesSelect = 0x0037,
+ kImageCodecEncodeFrameSelect = 0x0038,
+ kImageCodecCompleteFrameSelect = 0x0039,
+ kImageCodecBeginPassSelect = 0x003A,
+ kImageCodecEndPassSelect = 0x003B,
+ kImageCodecProcessBetweenPassesSelect = 0x003C,
+ kImageCodecPreflightSelect = 0x0200,
+ kImageCodecInitializeSelect = 0x0201,
+ kImageCodecBeginBandSelect = 0x0202,
+ kImageCodecDrawBandSelect = 0x0203,
+ kImageCodecEndBandSelect = 0x0204,
+ kImageCodecQueueStartingSelect = 0x0205,
+ kImageCodecQueueStoppingSelect = 0x0206,
+ kImageCodecDroppingFrameSelect = 0x0207,
+ kImageCodecScheduleFrameSelect = 0x0208,
+ kImageCodecCancelTriggerSelect = 0x0209,
+ kImageCodecDecodeBandSelect = 0x020F
+};
+
+
+
+
+
+
+
+
+enum {
+ kMotionJPEGTag = FOUR_CHAR_CODE('mjpg'),
+ kJPEGQuantizationTablesImageDescriptionExtension = FOUR_CHAR_CODE('mjqt'),
+ kJPEGHuffmanTablesImageDescriptionExtension = FOUR_CHAR_CODE('mjht'),
+ kFieldInfoImageDescriptionExtension = FOUR_CHAR_CODE('fiel') /* image description extension describing the field count and field orderings*/
+};
+
+enum {
+ kFieldOrderUnknown = 0,
+ kFieldsStoredF1F2DisplayedF1F2 = 1,
+ kFieldsStoredF1F2DisplayedF2F1 = 2,
+ kFieldsStoredF2F1DisplayedF1F2 = 5,
+ kFieldsStoredF2F1DisplayedF2F1 = 6
+};
+
+struct MotionJPEGApp1Marker {
+ long unused;
+ long tag;
+ long fieldSize;
+ long paddedFieldSize;
+ long offsetToNextField;
+ long qTableOffset;
+ long huffmanTableOffset;
+ long sofOffset;
+ long sosOffset;
+ long soiOffset;
+};
+typedef struct MotionJPEGApp1Marker MotionJPEGApp1Marker;
+struct FieldInfoImageDescriptionExtension {
+ UInt8 fieldCount;
+ UInt8 fieldOrderings;
+};
+typedef struct FieldInfoImageDescriptionExtension FieldInfoImageDescriptionExtension;
+
+/*
+ * QTPhotoSetSampling()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+QTPhotoSetSampling(
+ ComponentInstance codec,
+ short yH,
+ short yV,
+ short cbH,
+ short cbV,
+ short crH,
+ short crV) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0100, 0x7000, 0xA82A);
+
+
+/*
+ * QTPhotoSetRestartInterval()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+QTPhotoSetRestartInterval(
+ ComponentInstance codec,
+ unsigned short restartInterval) FIVEWORDINLINE(0x2F3C, 0x0002, 0x0101, 0x7000, 0xA82A);
+
+
+/*
+ * QTPhotoDefineHuffmanTable()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+QTPhotoDefineHuffmanTable(
+ ComponentInstance codec,
+ short componentNumber,
+ Boolean isDC,
+ unsigned char * lengthCounts,
+ unsigned char * values) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0102, 0x7000, 0xA82A);
+
+
+/*
+ * QTPhotoDefineQuantizationTable()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 2.5 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+QTPhotoDefineQuantizationTable(
+ ComponentInstance codec,
+ short componentNumber,
+ unsigned char * table) FIVEWORDINLINE(0x2F3C, 0x0006, 0x0103, 0x7000, 0xA82A);
+
+
+
+/* selectors for component calls */
+enum {
+ kQTPhotoSetSamplingSelect = 0x0100,
+ kQTPhotoSetRestartIntervalSelect = 0x0101,
+ kQTPhotoDefineHuffmanTableSelect = 0x0102,
+ kQTPhotoDefineQuantizationTableSelect = 0x0103
+};
+
+/*
+ * Summary:
+ * Properties for image compressor components
+ */
+enum {
+
+ /*
+ * Property class for image compressor components.
+ */
+ kQTPropertyClass_ImageCompressor = FOUR_CHAR_CODE('imco')
+};
+
+
+/*
+ * Summary:
+ * Enforced properties for image compressor components
+ *
+ * Discussion:
+ * Image compressors that sometimes or always restrict image
+ * dimensions, clean aperture and/or pixel aspect ratio should
+ * support these properties.
+ * If these properties can change dynamically for a compressor (eg,
+ * in response to user interaction) then the properties should be
+ * listenable, and the compressor should call the listeners whenever
+ * the properties change. (In this case, the component's
+ * GetComponentPropertyInfo function should set the
+ * kComponentPropertyFlagWillNotifyListeners flag.)
+ * If a compressor has a mode in which these properties are
+ * flexible, then when the component is in that mode, (a) the
+ * component's GetComponentProperty function should return
+ * kQTPropertyAskLaterErr for these properties, and (b) the
+ * component's GetComponentPropertyInfo function should set the
+ * kComponentPropertyFlagCanGetLater flag for these properties.
+ */
+enum {
+
+ /*
+ * The encoded width enforced for compressed frames.
+ */
+ kICMImageCompressorPropertyID_EnforcedEncodedWidth = FOUR_CHAR_CODE('enwi'), /* SInt32, Read/Sometimes Listen */
+
+ /*
+ * The encoded height enforced for compressed frames.
+ */
+ kICMImageCompressorPropertyID_EnforcedEncodedHeight = FOUR_CHAR_CODE('enhe'), /* SInt32, Read/Sometimes Listen */
+
+ /*
+ * The clean aperture enforced for compressed frames.
+ */
+ kICMImageCompressorPropertyID_EnforcedCleanAperture = FOUR_CHAR_CODE('encl'), /* CleanApertureImageDescriptionExtension, Read/Sometimes Listen */
+
+ /*
+ * The pixel aspect ratio enforced for compressed frames.
+ */
+ kICMImageCompressorPropertyID_EnforcedPixelAspectRatio = FOUR_CHAR_CODE('enpa'), /* PixelAspectRatioImageDescriptionExtension, Read/Sometimes Listen */
+
+ /*
+ * The number and order of fields enforced for compressed frames.
+ */
+ kICMImageCompressorPropertyID_EnforcedFieldInfo = FOUR_CHAR_CODE('enfi') /* FieldInfoImageDescriptionExtension2, Read/Sometimes Listen */
+};
+
+
+
+/*
+ * Summary:
+ * DV Compressor Component Properties.
+ */
+enum {
+
+ /*
+ * Property class for DV compressors. (Applicable to DV25, DV50,
+ * NTSC, PAL, PROPAL.)
+ */
+ kQTPropertyClass_DVCompressor = FOUR_CHAR_CODE('dvco'),
+
+ /*
+ * If set, indicates that the compressed frames should be marked as
+ * progressive-scan. By default, this flag is clear, meaning that
+ * frames should be marked as interlaced.
+ */
+ kDVCompressorPropertyID_ProgressiveScan = FOUR_CHAR_CODE('prog'), /* Boolean, Read/Write */
+
+ /*
+ * If set, indicates that the compressor should use a 16:9 picture
+ * aspect ratio. If clear, the compressor will use the default 4:3
+ * picture aspect ratio.
+ */
+ kDVCompressorPropertyID_AspectRatio16x9 = FOUR_CHAR_CODE('16x9') /* Boolean, Read/Write */
+};
+
+
+
+/* source identifier -- placed in root container of description, one or more required */
+enum {
+ kEffectSourceName = FOUR_CHAR_CODE('src ')
+};
+
+
+/* source type -- placed in the input map to identify the source kind */
+enum {
+ kEffectDataSourceType = FOUR_CHAR_CODE('dtst')
+};
+
+/* default effect types */
+enum {
+ kEffectRawSource = 0, /* the source is raw image data*/
+ kEffectGenericType = FOUR_CHAR_CODE('geff') /* generic effect for combining others*/
+};
+
+typedef struct EffectSource EffectSource;
+
+typedef EffectSource * EffectSourcePtr;
+union SourceData {
+ CDSequenceDataSourcePtr image;
+ EffectSourcePtr effect;
+};
+typedef union SourceData SourceData;
+struct EffectSource {
+ long effectType; /* type of effect or kEffectRawSource if raw ICM data*/
+ Ptr data; /* track data for this effect*/
+ SourceData source; /* source/effect pointers*/
+ EffectSourcePtr next; /* the next source for the parent effect*/
+
+ /* fields added for QuickTime 4.0*/
+ TimeValue lastTranslatedFrameTime; /* start frame time of last converted frame, may be -1*/
+ TimeValue lastFrameDuration; /* duration of the last converted frame, may be zero*/
+ TimeValue lastFrameTimeScale; /* time scale of this source frame, only has meaning if above fields are valid*/
+};
+
+struct ICMFrameTimeRecord_QT3 {
+ wide value; /* frame display 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_QT3 ICMFrameTimeRecord_QT3;
+struct EffectsFrameParams {
+ ICMFrameTimeRecord_QT3 frameTime; /* timing data (uses non-extended ICMFrameTimeRecord)*/
+ long effectDuration; /* the duration of a single effect frame*/
+ Boolean doAsync; /* set to true if the effect can go async*/
+ unsigned char pad[3];
+ EffectSourcePtr source; /* ptr to the source input tree*/
+ void * refCon; /* storage for the effect*/
+};
+typedef struct EffectsFrameParams EffectsFrameParams;
+typedef EffectsFrameParams * EffectsFrameParamsPtr;
+
+/*
+ * ImageCodecEffectSetup()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectSetup(
+ ComponentInstance effect,
+ CodecDecompressParams * p) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0300, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectBegin()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectBegin(
+ ComponentInstance effect,
+ CodecDecompressParams * p,
+ EffectsFrameParamsPtr ePtr) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0301, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectRenderFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectRenderFrame(
+ ComponentInstance effect,
+ EffectsFrameParamsPtr p) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0302, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectConvertEffectSourceToFormat()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectConvertEffectSourceToFormat(
+ ComponentInstance effect,
+ EffectSourcePtr sourceToConvert,
+ ImageDescriptionHandle requestedDesc) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0303, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectCancel()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectCancel(
+ ComponentInstance effect,
+ EffectsFrameParamsPtr p) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0304, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectGetSpeed()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectGetSpeed(
+ ComponentInstance effect,
+ QTAtomContainer parameters,
+ Fixed * pFPS) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0305, 0x7000, 0xA82A);
+
+
+
+enum {
+ kSMPTENoFlag = 0,
+ kSMPTESmoothEdgeFlag = 0x01, /* smooth edges of the stroke*/
+ kSMPTEStrokeEdgeFlag = 0x02 /* stroke edge with color*/
+};
+
+typedef long SMPTEFlags;
+typedef long SMPTEFrameReference;
+enum {
+ kSlideHorizontalWipe = 1,
+ kSlideVerticalWipe = 2,
+ kTopLeftWipe = 3,
+ kTopRightWipe = 4,
+ kBottomRightWipe = 5,
+ kBottomLeftWipe = 6,
+ kFourCornerWipe = 7,
+ kFourBoxWipe = 8,
+ kBarnVerticalWipe = 21,
+ kBarnHorizontalWipe = 22,
+ kTopCenterWipe = 23,
+ kRightCenterWipe = 24,
+ kBottomCenterWipe = 25,
+ kLeftCenterWipe = 26,
+ kDiagonalLeftDownWipe = 41,
+ kDiagonalRightDownWipe = 42,
+ kTopBottomBowTieWipe = 43,
+ kLeftRightBowTieWipe = 44,
+ kDiagonalLeftOutWipe = 45,
+ kDiagonalRightOutWipe = 46,
+ kDiagonalCrossWipe = 47,
+ kDiagonalBoxWipe = 48,
+ kFilledVWipe = 61,
+ kFilledVRightWipe = 62,
+ kFilledVBottomWipe = 63,
+ kFilledVLeftWipe = 64,
+ kHollowVWipe = 65,
+ kHollowVRightWipe = 66,
+ kHollowVBottomWipe = 67,
+ kHollowVLeftWipe = 68,
+ kVerticalZigZagWipe = 71,
+ kHorizontalZigZagWipe = 72,
+ kVerticalBarnZigZagWipe = 73,
+ kHorizontalBarnZigZagWipe = 74
+};
+
+enum {
+ kRectangleWipe = 101,
+ kDiamondWipe = 102,
+ kTriangleWipe = 103,
+ kTriangleRightWipe = 104,
+ kTriangleUpsideDownWipe = 105,
+ kTriangleLeftWipe = 106,
+ kSpaceShipWipe = 107,
+ kSpaceShipRightWipe = 108,
+ kSpaceShipUpsideDownWipe = 109,
+ kSpaceShipLeftWipe = 110,
+ kPentagonWipe = 111,
+ kPentagonUpsideDownWipe = 112,
+ kHexagonWipe = 113,
+ kHexagonSideWipe = 114,
+ kCircleWipe = 119,
+ kOvalWipe = 120,
+ kOvalSideWipe = 121,
+ kCatEyeWipe = 122,
+ kCatEyeSideWipe = 123,
+ kRoundRectWipe = 124,
+ kRoundRectSideWipe = 125,
+ kFourPointStarWipe = 127,
+ kFivePointStarWipe = 128,
+ kStarOfDavidWipe = 129,
+ kHeartWipe = 130,
+ kKeyholeWipe = 131
+};
+
+enum {
+ kRotatingTopWipe = 201,
+ kRotatingRightWipe = 202,
+ kRotatingBottomWipe = 203,
+ kRotatingLeftWipe = 204,
+ kRotatingTopBottomWipe = 205,
+ kRotatingLeftRightWipe = 206,
+ kRotatingQuadrantWipe = 207,
+ kTopToBottom180Wipe = 211,
+ kRightToLeft180Wipe = 212,
+ kTopToBottom90Wipe = 213,
+ kRightToLeft90Wipe = 214,
+ kTop180Wipe = 221,
+ kRight180Wipe = 222,
+ kBottom180Wipe = 223,
+ kLeft180Wipe = 224,
+ kCounterRotatingTopBottomWipe = 225,
+ kCounterRotatingLeftRightWipe = 226,
+ kDoubleRotatingTopBottomWipe = 227,
+ kDoubleRotatingLeftRightWipe = 228,
+ kVOpenTopWipe = 231,
+ kVOpenRightWipe = 232,
+ kVOpenBottomWipe = 233,
+ kVOpenLeftWipe = 234,
+ kVOpenTopBottomWipe = 235,
+ kVOpenLeftRightWipe = 236,
+ kRotatingTopLeftWipe = 241,
+ kRotatingBottomLeftWipe = 242,
+ kRotatingBottomRightWipe = 243,
+ kRotatingTopRightWipe = 244,
+ kRotatingTopLeftBottomRightWipe = 245,
+ kRotatingBottomLeftTopRightWipe = 246,
+ kRotatingTopLeftRightWipe = 251,
+ kRotatingLeftTopBottomWipe = 252,
+ kRotatingBottomLeftRightWipe = 253,
+ kRotatingRightTopBottomWipe = 254,
+ kRotatingDoubleCenterRightWipe = 261,
+ kRotatingDoubleCenterTopWipe = 262,
+ kRotatingDoubleCenterTopBottomWipe = 263,
+ kRotatingDoubleCenterLeftRightWipe = 264
+};
+
+enum {
+ kHorizontalMatrixWipe = 301,
+ kVerticalMatrixWipe = 302,
+ kTopLeftDiagonalMatrixWipe = 303,
+ kTopRightDiagonalMatrixWipe = 304,
+ kBottomRightDiagonalMatrixWipe = 305,
+ kBottomLeftDiagonalMatrixWipe = 306,
+ kClockwiseTopLeftMatrixWipe = 310,
+ kClockwiseTopRightMatrixWipe = 311,
+ kClockwiseBottomRightMatrixWipe = 312,
+ kClockwiseBottomLeftMatrixWipe = 313,
+ kCounterClockwiseTopLeftMatrixWipe = 314,
+ kCounterClockwiseTopRightMatrixWipe = 315,
+ kCounterClockwiseBottomRightMatrixWipe = 316,
+ kCounterClockwiseBottomLeftMatrixWipe = 317,
+ kVerticalStartTopMatrixWipe = 320,
+ kVerticalStartBottomMatrixWipe = 321,
+ kVerticalStartTopOppositeMatrixWipe = 322,
+ kVerticalStartBottomOppositeMatrixWipe = 323,
+ kHorizontalStartLeftMatrixWipe = 324,
+ kHorizontalStartRightMatrixWipe = 325,
+ kHorizontalStartLeftOppositeMatrixWipe = 326,
+ kHorizontalStartRightOppositeMatrixWipe = 327,
+ kDoubleDiagonalTopRightMatrixWipe = 328,
+ kDoubleDiagonalBottomRightMatrixWipe = 329,
+ kDoubleSpiralTopMatixWipe = 340,
+ kDoubleSpiralBottomMatixWipe = 341,
+ kDoubleSpiralLeftMatixWipe = 342,
+ kDoubleSpiralRightMatixWipe = 343,
+ kQuadSpiralVerticalMatixWipe = 344,
+ kQuadSpiralHorizontalMatixWipe = 345,
+ kVerticalWaterfallLeftMatrixWipe = 350,
+ kVerticalWaterfallRightMatrixWipe = 351,
+ kHorizontalWaterfallLeftMatrixWipe = 352,
+ kHorizontalWaterfallRightMatrixWipe = 353,
+ kRandomWipe = 409, /* non-SMPTE standard numbers*/
+ kRandomWipeGroupWipe = 501,
+ kRandomIrisGroupWipe = 502,
+ kRandomRadialGroupWipe = 503,
+ kRandomMatrixGroupWipe = 504
+};
+
+typedef unsigned long SMPTEWipeType;
+/*
+ * ImageCodecEffectPrepareSMPTEFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 4.0 and later
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 4.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectPrepareSMPTEFrame(
+ ComponentInstance effect,
+ PixMapPtr destPixMap,
+ SMPTEFrameReference * returnValue) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0100, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectDisposeSMPTEFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 4.0 and later
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 4.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectDisposeSMPTEFrame(
+ ComponentInstance effect,
+ SMPTEFrameReference frameRef) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);
+
+
+/*
+ * ImageCodecEffectRenderSMPTEFrame()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 4.0 and later
+ * CarbonLib: in CarbonLib 1.0.2 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 4.0 and later
+ */
+EXTERN_API( ComponentResult )
+ImageCodecEffectRenderSMPTEFrame(
+ ComponentInstance effect,
+ PixMapPtr destPixMap,
+ SMPTEFrameReference frameRef,
+ Fixed effectPercentageEven,
+ Fixed effectPercentageOdd,
+ Rect * pSourceRect,
+ MatrixRecord * matrixP,
+ SMPTEWipeType effectNumber,
+ long xRepeat,
+ long yRepeat,
+ SMPTEFlags flags,
+ Fixed penWidth,
+ long strokeValue) FIVEWORDINLINE(0x2F3C, 0x0030, 0x0102, 0x7000, 0xA82A);
+
+
+
+/* selectors for component calls */
+enum {
+ kImageCodecEffectSetupSelect = 0x0300,
+ kImageCodecEffectBeginSelect = 0x0301,
+ kImageCodecEffectRenderFrameSelect = 0x0302,
+ kImageCodecEffectConvertEffectSourceToFormatSelect = 0x0303,
+ kImageCodecEffectCancelSelect = 0x0304,
+ kImageCodecEffectGetSpeedSelect = 0x0305,
+ kImageCodecEffectPrepareSMPTEFrameSelect = 0x0100,
+ kImageCodecEffectDisposeSMPTEFrameSelect = 0x0101,
+ kImageCodecEffectRenderSMPTEFrameSelect = 0x0102
+};
+
+
+/* curve atom types and data structures */
+enum {
+ kCurvePathAtom = FOUR_CHAR_CODE('path'),
+ kCurveEndAtom = FOUR_CHAR_CODE('zero'),
+ kCurveAntialiasControlAtom = FOUR_CHAR_CODE('anti'),
+ kCurveAntialiasOff = 0,
+ kCurveAntialiasOn = (long)0xFFFFFFFF,
+ kCurveFillTypeAtom = FOUR_CHAR_CODE('fill'),
+ kCurvePenThicknessAtom = FOUR_CHAR_CODE('pent'),
+ kCurveMiterLimitAtom = FOUR_CHAR_CODE('mitr'),
+ kCurveJoinAttributesAtom = FOUR_CHAR_CODE('join'),
+ kCurveMinimumDepthAtom = FOUR_CHAR_CODE('mind'),
+ kCurveDepthAlwaysOffscreenMask = (long)0x80000000,
+ kCurveTransferModeAtom = FOUR_CHAR_CODE('xfer'),
+ kCurveGradientAngleAtom = FOUR_CHAR_CODE('angl'),
+ kCurveGradientRadiusAtom = FOUR_CHAR_CODE('radi'),
+ kCurveGradientOffsetAtom = FOUR_CHAR_CODE('cent')
+};
+
+enum {
+ kCurveARGBColorAtom = FOUR_CHAR_CODE('argb')
+};
+
+struct ARGBColor {
+ unsigned short alpha;
+ unsigned short red;
+ unsigned short green;
+ unsigned short blue;
+};
+typedef struct ARGBColor ARGBColor;
+enum {
+ kCurveGradientRecordAtom = FOUR_CHAR_CODE('grad')
+};
+
+struct GradientColorRecord {
+ ARGBColor thisColor;
+ Fixed endingPercentage;
+};
+typedef struct GradientColorRecord GradientColorRecord;
+typedef GradientColorRecord * GradientColorPtr;
+enum {
+ kCurveGradientTypeAtom = FOUR_CHAR_CODE('grdt')
+};
+
+/* currently supported gradient types */
+enum {
+ kLinearGradient = 0,
+ kCircularGradient = 1
+};
+
+typedef long GradientType;
+/*
+ * CurveGetLength()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveGetLength(
+ ComponentInstance effect,
+ gxPaths * target,
+ long index,
+ wide * wideLength) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0100, 0x7000, 0xA82A);
+
+
+/*
+ * CurveLengthToPoint()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveLengthToPoint(
+ ComponentInstance effect,
+ gxPaths * target,
+ long index,
+ Fixed length,
+ FixedPoint * location,
+ FixedPoint * tangent) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0101, 0x7000, 0xA82A);
+
+
+/*
+ * CurveNewPath()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveNewPath(
+ ComponentInstance effect,
+ Handle * pPath) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0102, 0x7000, 0xA82A);
+
+
+/*
+ * CurveCountPointsInPath()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveCountPointsInPath(
+ ComponentInstance effect,
+ gxPaths * aPath,
+ unsigned long contourIndex,
+ unsigned long * pCount) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0103, 0x7000, 0xA82A);
+
+
+/*
+ * CurveGetPathPoint()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveGetPathPoint(
+ ComponentInstance effect,
+ gxPaths * aPath,
+ unsigned long contourIndex,
+ unsigned long pointIndex,
+ gxPoint * thePoint,
+ Boolean * ptIsOnPath) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0104, 0x7000, 0xA82A);
+
+
+/*
+ * CurveInsertPointIntoPath()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveInsertPointIntoPath(
+ ComponentInstance effect,
+ gxPoint * aPoint,
+ Handle thePath,
+ unsigned long contourIndex,
+ unsigned long pointIndex,
+ Boolean ptIsOnPath) FIVEWORDINLINE(0x2F3C, 0x0012, 0x0105, 0x7000, 0xA82A);
+
+
+/*
+ * CurveSetPathPoint()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveSetPathPoint(
+ ComponentInstance effect,
+ gxPaths * aPath,
+ unsigned long contourIndex,
+ unsigned long pointIndex,
+ gxPoint * thePoint,
+ Boolean ptIsOnPath) FIVEWORDINLINE(0x2F3C, 0x0012, 0x0106, 0x7000, 0xA82A);
+
+
+/*
+ * CurveGetNearestPathPoint()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveGetNearestPathPoint(
+ ComponentInstance effect,
+ gxPaths * aPath,
+ FixedPoint * thePoint,
+ unsigned long * contourIndex,
+ unsigned long * pointIndex,
+ Fixed * theDelta) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0107, 0x7000, 0xA82A);
+
+
+/*
+ * CurvePathPointToLength()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurvePathPointToLength(
+ ComponentInstance ci,
+ gxPaths * aPath,
+ Fixed startDist,
+ Fixed endDist,
+ FixedPoint * thePoint,
+ Fixed * pLength) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0108, 0x7000, 0xA82A);
+
+
+/*
+ * CurveCreateVectorStream()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveCreateVectorStream(
+ ComponentInstance effect,
+ Handle * pStream) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0109, 0x7000, 0xA82A);
+
+
+/*
+ * CurveAddAtomToVectorStream()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveAddAtomToVectorStream(
+ ComponentInstance effect,
+ OSType atomType,
+ Size atomSize,
+ void * pAtomData,
+ Handle vectorStream) FIVEWORDINLINE(0x2F3C, 0x0010, 0x010A, 0x7000, 0xA82A);
+
+
+/*
+ * CurveAddPathAtomToVectorStream()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveAddPathAtomToVectorStream(
+ ComponentInstance effect,
+ Handle pathData,
+ Handle vectorStream) FIVEWORDINLINE(0x2F3C, 0x0008, 0x010B, 0x7000, 0xA82A);
+
+
+/*
+ * CurveAddZeroAtomToVectorStream()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveAddZeroAtomToVectorStream(
+ ComponentInstance effect,
+ Handle vectorStream) FIVEWORDINLINE(0x2F3C, 0x0004, 0x010C, 0x7000, 0xA82A);
+
+
+/*
+ * CurveGetAtomDataFromVectorStream()
+ *
+ * Availability:
+ * Non-Carbon CFM: in QuickTimeLib 3.0 and later
+ * CarbonLib: in CarbonLib 1.0 and later
+ * Mac OS X: in version 10.0 and later
+ * Windows: in qtmlClient.lib 3.0 and later
+ */
+EXTERN_API( ComponentResult )
+CurveGetAtomDataFromVectorStream(
+ ComponentInstance effect,
+ Handle vectorStream,
+ long atomType,
+ long * dataSize,
+ Ptr * dataPtr) FIVEWORDINLINE(0x2F3C, 0x0010, 0x010D, 0x7000, 0xA82A);
+
+
+
+
+/* selectors for component calls */
+enum {
+ kCurveGetLengthSelect = 0x0100,
+ kCurveLengthToPointSelect = 0x0101,
+ kCurveNewPathSelect = 0x0102,
+ kCurveCountPointsInPathSelect = 0x0103,
+ kCurveGetPathPointSelect = 0x0104,
+ kCurveInsertPointIntoPathSelect = 0x0105,
+ kCurveSetPathPointSelect = 0x0106,
+ kCurveGetNearestPathPointSelect = 0x0107,
+ kCurvePathPointToLengthSelect = 0x0108,
+ kCurveCreateVectorStreamSelect = 0x0109,
+ kCurveAddAtomToVectorStreamSelect = 0x010A,
+ kCurveAddPathAtomToVectorStreamSelect = 0x010B,
+ kCurveAddZeroAtomToVectorStreamSelect = 0x010C,
+ kCurveGetAtomDataFromVectorStreamSelect = 0x010D
+};
+/* UPP call backs */
+
+#endif // !__LP64__
+
+
+
+#if PRAGMA_STRUCT_ALIGN
+ #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+ #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+ #pragma pack()
+#endif
+
+#ifdef PRAGMA_IMPORT_OFF
+#pragma import off
+#elif PRAGMA_IMPORT
+#pragma import reset
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __IMAGECODEC__ */
+
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-07 00:43:19 +0000