mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 14:16:50 +00:00
3622 lines
132 KiB
C
3622 lines
132 KiB
C
/*
|
|
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__ */
|
|
|