summaryrefslogtreecommitdiff
path: root/src/libw32dll/qtx
diff options
context:
space:
mode:
authorGuenter Bartsch <guenter@users.sourceforge.net>2002-12-18 04:00:45 +0000
committerGuenter Bartsch <guenter@users.sourceforge.net>2002-12-18 04:00:45 +0000
commit85632e5177760e08d3d40dcfe9456bef54fcdc2d (patch)
tree23fe16c5ebbc032f620ac5d97706a539982426a2 /src/libw32dll/qtx
parent54e7d3ecdb73fbbe09025c7f8b3bdbbe8ea87690 (diff)
downloadxine-lib-85632e5177760e08d3d40dcfe9456bef54fcdc2d.tar.gz
xine-lib-85632e5177760e08d3d40dcfe9456bef54fcdc2d.tar.bz2
first draft of quicktime binary-only codec support
CVS patchset: 3580 CVS date: 2002/12/18 04:00:45
Diffstat (limited to 'src/libw32dll/qtx')
-rw-r--r--src/libw32dll/qtx/Makefile.am13
-rw-r--r--src/libw32dll/qtx/qtxsdk/Makefile.am18
-rw-r--r--src/libw32dll/qtx/qtxsdk/components.h720
-rw-r--r--src/libw32dll/qtx/qtxsdk/select.h68
4 files changed, 819 insertions, 0 deletions
diff --git a/src/libw32dll/qtx/Makefile.am b/src/libw32dll/qtx/Makefile.am
new file mode 100644
index 000000000..96dc8d4e4
--- /dev/null
+++ b/src/libw32dll/qtx/Makefile.am
@@ -0,0 +1,13 @@
+SUBDIRS = qtxsdk
+
+debug:
+ @$(MAKE) CFLAGS="$(DEBUG_CFLAGS)"
+
+mostlyclean-generic:
+ -rm -f *~ \#* .*~ .\#*
+
+maintainer-clean-generic:
+ -@echo "This command is intended for maintainers to use;"
+ -@echo "it deletes files that may require special tools to rebuild."
+ -rm -f Makefile.in
+
diff --git a/src/libw32dll/qtx/qtxsdk/Makefile.am b/src/libw32dll/qtx/qtxsdk/Makefile.am
new file mode 100644
index 000000000..87991c24f
--- /dev/null
+++ b/src/libw32dll/qtx/qtxsdk/Makefile.am
@@ -0,0 +1,18 @@
+noinst_HEADERS = components.h select.h
+
+debug:
+ @list='$(SUBDIRS)'; for subdir in $$list; do \
+ (cd $$subdir && $(MAKE) $@) || exit;\
+ done;
+ @$(MAKE) CFLAGS="$(DEBUG_CFLAGS)"
+
+install-debug: debug
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+mostlyclean-generic:
+ -rm -f *~ \#* .*~ .\#*
+
+maintainer-clean-generic:
+ -@echo "This command is intended for maintainers to use;"
+ -@echo "it deletes files that may require special tools to rebuild."
+ -rm -f Makefile.in
diff --git a/src/libw32dll/qtx/qtxsdk/components.h b/src/libw32dll/qtx/qtxsdk/components.h
new file mode 100644
index 000000000..9d1b167be
--- /dev/null
+++ b/src/libw32dll/qtx/qtxsdk/components.h
@@ -0,0 +1,720 @@
+// Basic types:
+
+typedef char * Ptr;
+typedef Ptr * Handle;
+typedef long Size;
+typedef unsigned char Boolean;
+typedef unsigned char Str31[32];
+typedef long Fixed;
+
+typedef long OSErr;
+typedef int OSType;
+
+typedef long ComponentResult;
+typedef unsigned char UInt8;
+typedef signed char SInt8;
+typedef unsigned short UInt16;
+typedef signed short SInt16;
+typedef unsigned long UInt32;
+typedef signed long SInt32;
+
+#define FOUR_CHAR_CODE(x) ((unsigned long)(x)) /* otherwise compiler will complain about values with high bit set */
+
+// codec private shit:
+typedef void *GlobalsPtr;
+typedef void **Globals;
+
+//==================== COMPONENTS ===========================
+
+struct __attribute__((__packed__)) ComponentParameters {
+ UInt8 flags; /* call modifiers: sync/async, deferred, immed, etc */
+ UInt8 paramSize; /* size in bytes of actual parameters passed to this call */
+ short what; /* routine selector, negative for Component management calls */
+ long params[1]; /* actual parameters for the indicated routine */
+};
+typedef struct ComponentParameters ComponentParameters;
+
+
+struct __attribute__((__packed__)) ComponentDescription {
+ OSType componentType; /* A unique 4-byte code indentifying the command set */
+ OSType componentSubType; /* Particular flavor of this instance */
+ OSType componentManufacturer; /* Vendor indentification */
+ unsigned long componentFlags; /* 8 each for Component,Type,SubType,Manuf/revision */
+ unsigned long componentFlagsMask; /* Mask for specifying which flags to consider in search, zero during registration */
+};
+typedef struct ComponentDescription ComponentDescription;
+
+
+struct __attribute__((__packed__)) ResourceSpec {
+ OSType resType; /* 4-byte code */
+ short resID; /* */
+};
+typedef struct ResourceSpec ResourceSpec;
+
+
+struct __attribute__((__packed__)) ComponentResource {
+ ComponentDescription cd; /* Registration parameters */
+ ResourceSpec component; /* resource where Component code is found */
+ ResourceSpec componentName; /* name string resource */
+ ResourceSpec componentInfo; /* info string resource */
+ ResourceSpec componentIcon; /* icon resource */
+};
+typedef struct ComponentResource ComponentResource;
+typedef ComponentResource * ComponentResourcePtr;
+typedef ComponentResourcePtr * ComponentResourceHandle;
+
+
+struct __attribute__((__packed__)) ComponentRecord {
+ long data[1];
+};
+typedef struct ComponentRecord ComponentRecord;
+typedef ComponentRecord * Component;
+
+
+struct __attribute__((__packed__)) ComponentInstanceRecord {
+ long data[1];
+};
+typedef struct ComponentInstanceRecord ComponentInstanceRecord;
+ typedef ComponentInstanceRecord * ComponentInstance;
+
+// ========================= QUICKDRAW =========================
+
+struct __attribute__((__packed__)) Rect {
+ short top;
+ short left;
+ short bottom;
+ short right;
+};
+typedef struct Rect Rect;
+typedef Rect * RectPtr;
+
+struct __attribute__((__packed__)) RGBColor {
+ unsigned short red; /*magnitude of red component*/
+ unsigned short green; /*magnitude of green component*/
+ unsigned short blue; /*magnitude of blue component*/
+};
+typedef struct RGBColor RGBColor;
+typedef RGBColor * RGBColorPtr;
+typedef RGBColorPtr * RGBColorHdl;
+
+struct __attribute__((__packed__)) ColorSpec {
+ short value; /*index or other value*/
+ RGBColor rgb; /*true color*/
+};
+typedef struct ColorSpec ColorSpec;
+typedef ColorSpec * ColorSpecPtr;
+typedef ColorSpec CSpecArray[1];
+
+struct __attribute__((__packed__)) ColorTable {
+ long ctSeed; /*unique identifier for table*/
+ short ctFlags; /*high bit: 0 = PixMap; 1 = device*/
+ short ctSize; /*number of entries in CTTable*/
+ CSpecArray ctTable; /*array [0..0] of ColorSpec*/
+};
+typedef struct ColorTable ColorTable;
+typedef ColorTable * CTabPtr;
+typedef CTabPtr * CTabHandle;
+
+struct __attribute__((__packed__)) MatrixRecord {
+ Fixed matrix[3][3];
+};
+typedef struct MatrixRecord MatrixRecord;
+typedef MatrixRecord * MatrixRecordPtr;
+
+typedef long ImageSequence;
+typedef OSType CodecType;
+typedef unsigned short CodecFlags;
+typedef unsigned long CodecQ;
+
+struct __attribute__((__packed__)) ImageDescription {
+ long idSize; /* total size of ImageDescription including extra data ( CLUTs and other per sequence data ) */
+ CodecType cType; /* what kind of codec compressed this data */
+ long resvd1; /* reserved for Apple use */
+ short resvd2; /* reserved for Apple use */
+ short dataRefIndex; /* set to zero */
+ short version; /* which version is this data */
+ short revisionLevel; /* what version of that codec did this */
+ long vendor; /* whose codec compressed this data */
+ CodecQ temporalQuality; /* what was the temporal quality factor */
+ CodecQ spatialQuality; /* what was the spatial quality factor */
+ short width; /* how many pixels wide is this data */
+ short height; /* how many pixels high is this data */
+ Fixed hRes; /* horizontal resolution */
+ Fixed vRes; /* vertical resolution */
+ long dataSize; /* if known, the size of data for this image descriptor */
+ short frameCount; /* number of frames this description applies to */
+ Str31 name; /* name of codec ( in case not installed ) */
+ short depth; /* what depth is this data (1-32) or ( 33-40 grayscale ) */
+ short clutID; /* clut id or if 0 clut follows or -1 if no clut */
+};
+typedef struct ImageDescription ImageDescription;
+typedef ImageDescription * ImageDescriptionPtr;
+typedef ImageDescriptionPtr * ImageDescriptionHandle;
+
+/* values for PixMap.pixelFormat*/
+enum {
+ k16LE555PixelFormat = FOUR_CHAR_CODE('L555'), /* 16 bit LE rgb 555 (PC)*/
+ k16LE5551PixelFormat = FOUR_CHAR_CODE('5551'), /* 16 bit LE rgb 5551*/
+ k16BE565PixelFormat = FOUR_CHAR_CODE('B565'), /* 16 bit BE rgb 565*/
+ k16LE565PixelFormat = FOUR_CHAR_CODE('L565'), /* 16 bit LE rgb 565*/
+ k24BGRPixelFormat = FOUR_CHAR_CODE('24BG'), /* 24 bit bgr */
+ k32BGRAPixelFormat = FOUR_CHAR_CODE('BGRA'), /* 32 bit bgra (Matrox)*/
+ k32ABGRPixelFormat = FOUR_CHAR_CODE('ABGR'), /* 32 bit abgr */
+ k32RGBAPixelFormat = FOUR_CHAR_CODE('RGBA'), /* 32 bit rgba */
+ kYUVSPixelFormat = FOUR_CHAR_CODE('yuvs'), /* YUV 4:2:2 byte ordering 16-unsigned = 'YUY2'*/
+ kYUVUPixelFormat = FOUR_CHAR_CODE('yuvu'), /* YUV 4:2:2 byte ordering 16-signed*/
+ kYVU9PixelFormat = FOUR_CHAR_CODE('YVU9'), /* YVU9 Planar 9*/
+ kYUV411PixelFormat = FOUR_CHAR_CODE('Y411'), /* YUV 4:1:1 Interleaved 16*/
+ kYVYU422PixelFormat = FOUR_CHAR_CODE('YVYU'), /* YVYU 4:2:2 byte ordering 16*/
+ kUYVY422PixelFormat = FOUR_CHAR_CODE('UYVY'), /* UYVY 4:2:2 byte ordering 16*/
+ kYUV211PixelFormat = FOUR_CHAR_CODE('Y211'), /* YUV 2:1:1 Packed 8*/
+ k2vuyPixelFormat = FOUR_CHAR_CODE('2vuy') /* UYVY 4:2:2 byte ordering 16*/
+};
+
+struct __attribute__((__packed__)) PixMapExtension {
+ long extSize; /*size of struct, duh!*/
+ unsigned long pmBits; /*pixmap attributes bitfield*/
+ void * pmGD; /*this is a GDHandle*/
+ long pmSeed;
+ Fixed gammaLevel; /*pixmap gammalevel*/
+ Fixed requestedGammaLevel;
+ unsigned long reserved2;
+ long longRowBytes; /*used when rowBytes > 16382*/
+ unsigned long signature;
+ Handle baseAddrHandle;
+};
+typedef struct PixMapExtension PixMapExtension;
+
+typedef PixMapExtension * PixMapExtPtr;
+typedef PixMapExtPtr * PixMapExtHandle;
+
+
+struct __attribute__((__packed__)) PixMap {
+ Ptr baseAddr; /*pointer to pixels*/
+ short rowBytes; /*offset to next line*/
+ Rect bounds; /*encloses bitmap*/
+ short pmVersion; /*pixMap version number*/
+ short packType; /*defines packing format*/
+ long packSize; /*length of pixel data*/
+ Fixed hRes; /*horiz. resolution (ppi)*/
+ Fixed vRes; /*vert. resolution (ppi)*/
+ short pixelType; /*defines pixel type*/
+ short pixelSize; /*# bits in pixel*/
+ short cmpCount; /*# components in pixel*/
+ short cmpSize; /*# bits per component*/
+ OSType pixelFormat; /*fourCharCode representation*/
+ CTabHandle pmTable; /*color map for this pixMap*/
+ PixMapExtHandle pmExt; /*Handle to pixMap extension*/
+};
+typedef struct PixMap PixMap;
+typedef PixMap * PixMapPtr;
+typedef PixMapPtr * PixMapHandle;
+
+
+struct __attribute__((__packed__)) BitMap {
+ Ptr baseAddr;
+ short rowBytes;
+ Rect bounds;
+};
+typedef struct BitMap BitMap;
+typedef BitMap * BitMapPtr;
+typedef BitMapPtr * BitMapHandle;
+typedef struct OpaqueRgnHandle* RgnHandle;
+
+struct Pattern {
+ UInt8 pat[8];
+};
+typedef struct Pattern Pattern;
+typedef unsigned char Style;
+typedef Style StyleField;
+struct __attribute__((__packed__)) Point {
+ short v;
+ short h;
+};
+typedef struct Point Point;
+struct __attribute__((__packed__)) GrafPort {
+ short device;
+ BitMap portBits;
+ Rect portRect;
+ RgnHandle visRgn;
+ RgnHandle clipRgn;
+ Pattern bkPat;
+ Pattern fillPat;
+ Point pnLoc;
+ Point pnSize;
+ short pnMode;
+ Pattern pnPat;
+ short pnVis;
+ short txFont;
+ StyleField txFace; /*StyleField occupies 16-bits, but only first 8-bits are used*/
+ UInt8 txFlags; /* QuickTime uses second 8 bits of StyleField for txFlags */
+ short txMode;
+ short txSize;
+ Fixed spExtra;
+ long fgColor;
+ long bkColor;
+ short colrBit;
+ short patStretch;
+ Handle picSave;
+ Handle rgnSave;
+ Handle polySave;
+ /*QDProcsPtr*/void* grafProcs;
+};
+typedef struct GrafPort GrafPort;
+typedef GrafPort *GWorldPtr;
+typedef GWorldPtr *GWorldHandle;
+#define anyCodec ((CodecComponent)0)
+enum {
+ /* transfer modes */
+ srcCopy = 0, /*the 16 transfer modes*/
+ srcOr = 1,
+ srcXor = 2,
+ srcBic = 3,
+ notSrcCopy = 4,
+ notSrcOr = 5,
+ notSrcXor = 6,
+ notSrcBic = 7,
+ patCopy = 8,
+ patOr = 9,
+ patXor = 10,
+ patBic = 11,
+ notPatCopy = 12,
+ notPatOr = 13,
+ notPatXor = 14,
+ notPatBic = 15, /* Special Text Transfer Mode */
+ grayishTextOr = 49,
+ hilitetransfermode = 50,
+ hilite = 50, /* Arithmetic transfer modes */
+ blend = 32,
+ addPin = 33,
+ addOver = 34,
+ subPin = 35,
+ addMax = 37,
+ adMax = 37,
+ subOver = 38,
+ adMin = 39,
+ ditherCopy = 64, /* Transparent mode constant */
+ transparent = 36
+};
+
+typedef unsigned long GWorldFlags;
+
+
+
+// ============================== CODECS ===========================
+
+typedef Component CompressorComponent;
+typedef Component DecompressorComponent;
+typedef Component CodecComponent;
+
+enum {
+ codecLosslessQuality = 0x00000400,
+ codecMaxQuality = 0x000003FF,
+ codecMinQuality = 0x00000000,
+ codecLowQuality = 0x00000100,
+ codecNormalQuality = 0x00000200,
+ codecHighQuality = 0x00000300
+};
+
+
+
+// callbacks:
+typedef void* ImageCodecDrawBandCompleteUPP;
+typedef long long ICMProgressProcRecord;
+typedef long long ICMCompletionProcRecord;
+typedef long long ICMDataProcRecord;
+typedef void* ICMFrameTimePtr;
+typedef void* CDSequenceDataSourcePtr;
+typedef void* ICMFrameTimeInfoPtr;
+
+// graphics port
+typedef struct OpaqueGrafPtr* GrafPtr;
+typedef GrafPtr CGrafPtr;
+
+
+/* codec capabilities flags */
+enum {
+ codecCanScale = 1L << 0, // 1
+ codecCanMask = 1L << 1, // 2
+ codecCanMatte = 1L << 2, // 4
+ codecCanTransform = 1L << 3, // 8
+ codecCanTransferMode = 1L << 4, // 10
+ codecCanCopyPrev = 1L << 5, // 20
+ codecCanSpool = 1L << 6, // 40
+ codecCanClipVertical = 1L << 7, // 80
+ codecCanClipRectangular = 1L << 8, // 100
+ codecCanRemapColor = 1L << 9, // 200
+ codecCanFastDither = 1L << 10, // 400
+ codecCanSrcExtract = 1L << 11, // 800
+ codecCanCopyPrevComp = 1L << 12, // 1000
+ codecCanAsync = 1L << 13, // 2000
+ codecCanMakeMask = 1L << 14, // 4000
+ codecCanShift = 1L << 15, // 8000
+ codecCanAsyncWhen = 1L << 16, // 10000
+ codecCanShieldCursor = 1L << 17, // 20000
+ codecCanManagePrevBuffer = 1L << 18, // 40000
+ codecHasVolatileBuffer = 1L << 19, // 80000 /* codec requires redraw after window movement */
+ codecWantsRegionMask = 1L << 20, // 100000
+ codecImageBufferIsOnScreen = 1L << 21, // 200000 /* old def of codec using overlay surface, = ( codecIsDirectToScreenOnly | codecUsesOverlaySurface | codecImageBufferIsOverlaySurface | codecSrcMustBeImageBuffer ) */
+ codecWantsDestinationPixels = 1L << 22, // 400000
+ codecWantsSpecialScaling = 1L << 23, // 800000
+ codecHandlesInputs = 1L << 24, // 1000000
+ 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 */
+};
+
+/* codec condition flags */
+// FFD = 13 = 8+4+1
+enum {
+ codecConditionFirstBand = 1L << 0, // 1
+ codecConditionLastBand = 1L << 1, // 2
+ codecConditionFirstFrame = 1L << 2, // 4
+ codecConditionNewDepth = 1L << 3, // 8
+ codecConditionNewTransform = 1L << 4, // 10
+ codecConditionNewSrcRect = 1L << 5, // 20
+ codecConditionNewMask = 1L << 6, // 40
+ codecConditionNewMatte = 1L << 7, // 80
+ codecConditionNewTransferMode = 1L << 8, // 100
+ codecConditionNewClut = 1L << 9, // 200
+ codecConditionNewAccuracy = 1L << 10, // 400
+ codecConditionNewDestination = 1L << 11, // 800
+ codecConditionFirstScreen = 1L << 12, // 1000
+ codecConditionDoCursor = 1L << 13, // 2000
+ codecConditionCatchUpDiff = 1L << 14, // 4000
+ codecConditionMaskMayBeChanged = 1L << 15, // 8000
+ codecConditionToBuffer = 1L << 16, // 10000
+ codecConditionCodecChangedMask = 1L << 31 // 20000
+};
+
+
+
+struct __attribute__((__packed__)) 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;
+
+struct __attribute__((__packed__)) CodecDecompressParams {
+ ImageSequence sequenceID; /* predecompress,banddecompress */
+ ImageDescriptionHandle imageDescription; /* predecompress,banddecompress */
+ Ptr data;
+ long bufferSize;
+
+ long frameNumber;
+ long startLine;
+ long stopLine;
+ long conditionFlags;
+
+ CodecFlags callerFlags; // short
+ 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*/
+};
+typedef struct CodecDecompressParams CodecDecompressParams;
+
+
+
+struct __attribute__((__packed__)) ImageSubCodecDecompressCapabilities {
+ long recordSize; /* sizeof(ImageSubCodecDecompressCapabilities)*/
+ long decompressRecordSize; /* size of your codec's decompress record*/
+ Boolean canAsync; /* default true*/
+ UInt8 pad0;
+
+ /* The following fields only exist for QuickTime 4.0 and greater */
+ UInt16 suggestedQueueSize;
+ 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.1 and greater */
+ Boolean isChildCodec; /* set by base codec before calling Initialize*/
+ UInt8 pad3[3];
+};
+typedef struct ImageSubCodecDecompressCapabilities ImageSubCodecDecompressCapabilities;
+
+
+struct __attribute__((__packed__)) 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. */
+};
+typedef struct ImageSubCodecDecompressRecord ImageSubCodecDecompressRecord;
+
+
+/* These are the bits that are set in the Component flags, and also in the codecInfo struct. */
+enum {
+ codecInfoDoes1 = (1L << 0), /* codec can work with 1-bit pixels */
+ codecInfoDoes2 = (1L << 1), /* codec can work with 2-bit pixels */
+ codecInfoDoes4 = (1L << 2), /* codec can work with 4-bit pixels */
+ codecInfoDoes8 = (1L << 3), /* codec can work with 8-bit pixels */
+ codecInfoDoes16 = (1L << 4), /* codec can work with 16-bit pixels */
+ codecInfoDoes32 = (1L << 5), /* codec can work with 32-bit pixels */
+ codecInfoDoesDither = (1L << 6), /* codec can do ditherMode */
+ codecInfoDoesStretch = (1L << 7), /* codec can stretch to arbitrary sizes */
+ codecInfoDoesShrink = (1L << 8), /* codec can shrink to arbitrary sizes */
+ codecInfoDoesMask = (1L << 9), /* codec can mask to clipping regions */
+ codecInfoDoesTemporal = (1L << 10), /* codec can handle temporal redundancy */
+ codecInfoDoesDouble = (1L << 11), /* codec can stretch to double size exactly */
+ codecInfoDoesQuad = (1L << 12), /* codec can stretch to quadruple size exactly */
+ codecInfoDoesHalf = (1L << 13), /* codec can shrink to half size */
+ codecInfoDoesQuarter = (1L << 14), /* codec can shrink to quarter size */
+ codecInfoDoesRotate = (1L << 15), /* codec can rotate on decompress */
+ codecInfoDoesHorizFlip = (1L << 16), /* codec can flip horizontally on decompress */
+ codecInfoDoesVertFlip = (1L << 17), /* codec can flip vertically on decompress */
+ codecInfoHasEffectParameterList = (1L << 18), /* codec implements get effects parameter list call, once was codecInfoDoesSkew */
+ codecInfoDoesBlend = (1L << 19), /* codec can blend on decompress */
+ codecInfoDoesWarp = (1L << 20), /* codec can warp arbitrarily on decompress */
+ codecInfoDoesRecompress = (1L << 21), /* codec can recompress image without accumulating errors */
+ codecInfoDoesSpool = (1L << 22), /* codec can spool image data */
+ codecInfoDoesRateConstrain = (1L << 23) /* codec can data rate constrain */
+};
+
+
+enum {
+ codecInfoDepth1 = (1L << 0), /* compressed data at 1 bpp depth available */
+ codecInfoDepth2 = (1L << 1), /* compressed data at 2 bpp depth available */
+ codecInfoDepth4 = (1L << 2), /* compressed data at 4 bpp depth available */
+ codecInfoDepth8 = (1L << 3), /* compressed data at 8 bpp depth available */
+ codecInfoDepth16 = (1L << 4), /* compressed data at 16 bpp depth available */
+ codecInfoDepth32 = (1L << 5), /* compressed data at 32 bpp depth available */
+ codecInfoDepth24 = (1L << 6), /* compressed data at 24 bpp depth available */
+ codecInfoDepth33 = (1L << 7), /* compressed data at 1 bpp monochrome depth available */
+ codecInfoDepth34 = (1L << 8), /* compressed data at 2 bpp grayscale depth available */
+ codecInfoDepth36 = (1L << 9), /* compressed data at 4 bpp grayscale depth available */
+ codecInfoDepth40 = (1L << 10), /* compressed data at 8 bpp grayscale depth available */
+ codecInfoStoresClut = (1L << 11), /* compressed data can have custom cluts */
+ codecInfoDoesLossless = (1L << 12), /* compressed data can be stored in lossless format */
+ codecInfoSequenceSensitive = (1L << 13) /* compressed data is sensitive to out of sequence decoding */
+};
+
+struct __attribute__((__packed__)) CodecInfo {
+ Str31 typeName; /* name of the codec type i.e.: 'Apple Image Compression' */
+ short version; /* version of the codec data that this codec knows about */
+ short revisionLevel; /* revision level of this codec i.e: 0x00010001 (1.0.1) */
+ long vendor; /* Maker of this codec i.e: 'appl' */
+ long decompressFlags; /* codecInfo flags for decompression capabilities */
+ long compressFlags; /* codecInfo flags for compression capabilities */
+ long formatFlags; /* codecInfo flags for compression format details */
+ UInt8 compressionAccuracy; /* measure (1-255) of accuracy of this codec for compress (0 if unknown) */
+ UInt8 decompressionAccuracy; /* measure (1-255) of accuracy of this codec for decompress (0 if unknown) */
+ unsigned short compressionSpeed; /* ( millisecs for compressing 320x240 on base mac II) (0 if unknown) */
+ unsigned short decompressionSpeed; /* ( millisecs for decompressing 320x240 on mac II)(0 if unknown) */
+ UInt8 compressionLevel; /* measure (1-255) of compression level of this codec (0 if unknown) */
+ UInt8 resvd; /* pad */
+ short minimumHeight; /* minimum height of image (block size) */
+ short minimumWidth; /* minimum width of image (block size) */
+ short decompressPipelineLatency; /* in milliseconds ( for asynchronous codecs ) */
+ short compressPipelineLatency; /* in milliseconds ( for asynchronous codecs ) */
+ long privateData;
+};
+typedef struct CodecInfo CodecInfo;
+
+static inline void dump_ImageDescription(void* xxx){
+ ImageDescription* id=(ImageDescription*)xxx;
+ unsigned char* x;
+ int i;
+
+ for(i=0;i<id->idSize;i++){
+ printf(" %02X",((unsigned char*)id)[i]);
+ if((i%16)==15) printf("\n");
+ }
+ printf("\n");
+
+
+ printf("=============== ImageDescription at %p ==================\n",xxx);
+ printf("idSize=0x%X fourcc=0x%08X\n",id->idSize,id->cType);
+ printf("ver=%d rev=%d vendor=0x%08X\n",id->version,id->revisionLevel,id->vendor);
+ printf("tempQ=%d spatQ=%d dim: %d x %d dpi: %d x %d depth: %d\n",
+ id->temporalQuality,id->spatialQuality,
+ id->width, id->height,
+ id->hRes, id->vRes,
+ id->depth);
+ printf("dataSize=%d frameCount=%d clutID=%d\n",id->dataSize, id->frameCount, id->clutID);
+ printf("name='%.*s'\n",((char*)(&id->name))[0],((char*)(&id->name))+1);
+ x=((char*)(&id->clutID))+2;
+ if(id->idSize>sizeof(ImageDescription)){
+ printf("%02X %02X %02X %02X | %02X %02X %02X %02X | %02X %02X %02X %02X | %02X %02X %02X %02X\n",
+ x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],x[8],x[9],x[10],x[11],x[12],x[13],x[14],x[15]);
+ }
+ printf("=========================================================\n");
+}
+
+static inline void dump_Rect(char* title,Rect *r){
+ printf("%s: %d;%d - %d;%d\n",title,
+ (int)r->top,(int)r->left,(int)r->bottom,(int)r->right);
+}
+
+static inline void dump_MatrixRecord(char* title, MatrixRecord *m){
+ printf("%s: [%d %d %d][%d %d %d][%d %d %d]\n",title,
+ m->matrix[0][0],m->matrix[0][1],m->matrix[0][2],
+ m->matrix[1][0],m->matrix[1][1],m->matrix[1][2],
+ m->matrix[2][0],m->matrix[2][1],m->matrix[2][2]);
+}
+
+static inline void dump_PixMap(void* xxx){
+ PixMap *p=xxx;
+ printf("=============== PixMap at %p ==================\n",xxx);
+ printf("base=%p stride=%d\n",p->baseAddr, p->rowBytes);
+ dump_Rect("bounds",&p->bounds);
+ printf("pmVersion=0x%X packType=0x%X\n packSize=0x%X\n",
+ p->pmVersion,p->packType, p->packSize);
+ printf("hRes=0x%X vRes=0x%X pixelType=0x%X pixelSize=0x%X\n",
+ p->hRes,p->vRes,p->pixelType,p->pixelSize);
+ printf("cmpCount=0x%X cmpSize=0x%X pixelFormat=0x%X\n",
+ p->cmpCount,p->cmpSize,p->pixelFormat);
+ printf("pmTable=%p pmExt=%p\n",p->pmTable,p->pmExt);
+ printf("=========================================================\n");
+}
+
+static inline void dump_CodecCapabilities(void* xxx){
+ CodecCapabilities* cc=xxx;
+ if(!xxx) return;
+ printf("=============== CodecCapabilities at %p =================\n",xxx);
+ printf("flags=0x%X flags2=0x%X\n",cc->flags,cc->flags2);
+ printf("wantedPixelSize=%d extendWidth=%d extendHeight=%d band=%d+%d\n",
+ cc->wantedPixelSize,cc->extendWidth,cc->extendHeight,
+ cc->bandMin,cc->bandInc);
+ printf("pad=0x%X time=0x%X\n",cc->pad,cc->time);
+ printf("=========================================================\n");
+}
+
+static inline void dump_CodecDecompressParams(void* xxx){
+ CodecDecompressParams* cd=xxx;
+ ImageDescription **idh;
+ int i;
+ if(!xxx) return;
+ printf("=============== CodecDecompressParams at %p ==================\n",xxx);
+ printf("sequenceID=%d\n",cd->sequenceID);
+ idh=cd->imageDescription;
+ if(idh && idh[0]) dump_ImageDescription(idh[0]);
+
+ for(i=0;i<sizeof(CodecDecompressParams);i++){
+ printf(" %02X",((unsigned char*)cd)[i]);
+ if((i%16)==15) printf("\n");
+ }
+ printf("\n");
+
+ printf("data=%p size=%d\n",cd->data,cd->bufferSize);
+ printf("frameno=%d lines: %d .. %d condflags=0x%X callerflags=0x%X\n",
+ cd->frameNumber, cd->startLine, cd->stopLine, cd->conditionFlags,cd->callerFlags);
+// printf("maskBits=%p mattePixMap=%p\n",
+// cd->maskBits,cd->mattePixMap);
+ dump_PixMap(&cd->dstPixMap);
+// if(cd->mattePixMap) dump_PixMap(cd->mattePixMap);
+ if(cd->matrix) dump_MatrixRecord("matrix",cd->matrix);
+ if(cd->capabilities) dump_CodecCapabilities(cd->capabilities);
+ printf("accuracy=%d transferMode=%d matrixFlags=0x%X matrixType=%d\n",
+ (int)cd->accuracy, (int)cd->transferMode, (int)cd->matrixFlags, (int)cd->matrixType);
+ printf("srcrect: %d;%d - %d;%d\n",cd->srcRect.top,cd->srcRect.left,cd->srcRect.bottom,cd->srcRect.right);
+ printf("dstrect: %d;%d - %d;%d\n",cd->dstRect.top,cd->dstRect.left,cd->dstRect.bottom,cd->dstRect.right);
+ printf("wantedDestinationPixelTypes=%p\n",cd->wantedDestinationPixelTypes);
+ if(cd->wantedDestinationPixelTypes){
+ unsigned int* p=cd->wantedDestinationPixelTypes;
+ while(p[0]){
+ printf(" 0x%08X %.4s\n",p[0],&p[0]);
+ ++p;
+ }
+ }
+ printf("screenFloodMethod=%d value=%d preferredOffscreenPixelSize=%d\n",
+ cd->screenFloodMethod, cd->screenFloodValue, cd->preferredOffscreenPixelSize);
+ printf("callbacks: progress=%p compl=%p data=%p ftime=%p srcdata=%p sync=%p\n",
+ cd->progressProcRecord, cd->completionProcRecord,
+ cd->dataProcRecord, cd->frameTime, cd->sourceData, cd->syncFrameTime);
+// printf("\n");
+
+ printf("=========================================================\n");
+
+
+}
+
diff --git a/src/libw32dll/qtx/qtxsdk/select.h b/src/libw32dll/qtx/qtxsdk/select.h
new file mode 100644
index 000000000..313cc5768
--- /dev/null
+++ b/src/libw32dll/qtx/qtxsdk/select.h
@@ -0,0 +1,68 @@
+
+enum {
+ kComponentOpenSelect = -1, /* ComponentInstance for this open */
+ kComponentCloseSelect = -2, /* ComponentInstance for this close */
+ kComponentCanDoSelect = -3, /* selector # being queried */
+ kComponentVersionSelect = -4, /* no params */
+ kComponentRegisterSelect = -5, /* no params */
+ kComponentTargetSelect = -6, /* ComponentInstance for top of call chain */
+ kComponentUnregisterSelect = -7, /* no params */
+ kComponentGetMPWorkFunctionSelect = -8, /* some params */
+ kComponentExecuteWiredActionSelect = -9, /* QTAtomContainer actionContainer, QTAtom actionAtom, QTCustomActionTargetPtr target, QTEventRecordPtr event */
+ kComponentGetPublicResourceSelect = -10 /* OSType resourceType, short resourceId, Handle *resource */
+};
+
+/* 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,
+ kImageCodecRequestGammaLevelSelect = 0x0028,
+ kImageCodecGetSourceDataGammaLevelSelect = 0x0029,
+ kImageCodecGetDecompressLatencySelect = 0x002B,
+ kImageCodecPreflightSelect = 0x0200,
+ kImageCodecInitializeSelect = 0x0201,
+ kImageCodecBeginBandSelect = 0x0202,
+ kImageCodecDrawBandSelect = 0x0203,
+ kImageCodecEndBandSelect = 0x0204,
+ kImageCodecQueueStartingSelect = 0x0205,
+ kImageCodecQueueStoppingSelect = 0x0206,
+ kImageCodecDroppingFrameSelect = 0x0207,
+ kImageCodecScheduleFrameSelect = 0x0208,
+ kImageCodecCancelTriggerSelect = 0x0209
+};
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-26 05:35:02 +0000