diff options
Diffstat (limited to 'common/quicktime_win32/ImageCodec.h')
| -rw-r--r-- | common/quicktime_win32/ImageCodec.h | 3621 |
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__ */ + |