/***************************************************************************** * DXTrans.idl * *-------------* * * Description: * This is the IDL file for DirectX installable transform coclass, * interface, and type definitions. * * History: * 09/02/1999 a-matcal Added IDXTFilterBehavior, IDXTFilter interfaces. * Added CDXTFilterFactory, CDXTFilterBehavior, * CDXTFilter coclasses. * *----------------------------------------------------------------------------- * Creation: EWC 07/07/97 * Copyright Microsoft Corporation 1997-1999 * All rights reserved. * *****************************************************************************/ cpp_quote("#include ") cpp_quote("#include ") cpp_quote("#include ") cpp_quote("#include ") cpp_quote("#include ") //--- Import base idl import "oaidl.idl"; import "ocidl.idl"; import "servprov.idl"; import "comcat.idl"; // // Since direct draw does not have an IDL, we'll define DDSURFACEDESC to // be a void, but include ddraw.h in the header file. This makes MIDL happy. // #ifndef DDSURFACEDESC cpp_quote("#if 0") cpp_quote("// Bogus definition used to make MIDL compiler happy") typedef void DDSURFACEDESC; typedef void D3DRMBOX; typedef void D3DVECTOR; typedef void D3DRMMATRIX4D; typedef void* LPSECURITY_ATTRIBUTES; cpp_quote("#endif") #endif //--- Additional includes //--- Export cpp_quote( "#ifdef _DXTRANSIMPL") cpp_quote( " #define _DXTRANS_IMPL_EXT _declspec(dllexport)") cpp_quote( "#else") cpp_quote( " #define _DXTRANS_IMPL_EXT _declspec(dllimport)") cpp_quote( "#endif") //=== Forward References ==================================================== interface IDXTransformFactory; interface IDXTransform; interface IDXTaskManager; interface IDXSurfaceFactory; interface IDXSurface; interface IDXARGBSurfaceInit; interface IDXRawSurface; interface IDXARGBReadPtr; interface IDXARGBReadWritePtr; interface IDXDCLock; interface IDXTScale; interface IDXLookupTable; interface IDXTBindHost; interface IBindHost; interface IDXTScaleOutput; interface IDXGradient; //=== Constants ============================================================= cpp_quote("//") cpp_quote("// All GUIDs for DXTransform are declared in DXTGUID.C in the SDK include directory") cpp_quote("//") cpp_quote("EXTERN_C const GUID DDPF_RGB1;") cpp_quote("EXTERN_C const GUID DDPF_RGB2;") cpp_quote("EXTERN_C const GUID DDPF_RGB4;") cpp_quote("EXTERN_C const GUID DDPF_RGB8;") cpp_quote("EXTERN_C const GUID DDPF_RGB332;") cpp_quote("EXTERN_C const GUID DDPF_ARGB4444;") cpp_quote("EXTERN_C const GUID DDPF_RGB565;") cpp_quote("EXTERN_C const GUID DDPF_BGR565;") cpp_quote("EXTERN_C const GUID DDPF_RGB555;") cpp_quote("EXTERN_C const GUID DDPF_ARGB1555;") cpp_quote("EXTERN_C const GUID DDPF_RGB24;") cpp_quote("EXTERN_C const GUID DDPF_BGR24;") cpp_quote("EXTERN_C const GUID DDPF_RGB32;") cpp_quote("EXTERN_C const GUID DDPF_BGR32;") cpp_quote("EXTERN_C const GUID DDPF_ABGR32;") cpp_quote("EXTERN_C const GUID DDPF_ARGB32;") cpp_quote("EXTERN_C const GUID DDPF_PMARGB32;") cpp_quote("EXTERN_C const GUID DDPF_A1;") cpp_quote("EXTERN_C const GUID DDPF_A2;") cpp_quote("EXTERN_C const GUID DDPF_A4;") cpp_quote("EXTERN_C const GUID DDPF_A8;") cpp_quote("EXTERN_C const GUID DDPF_Z8;") cpp_quote("EXTERN_C const GUID DDPF_Z16;") cpp_quote("EXTERN_C const GUID DDPF_Z24;") cpp_quote("EXTERN_C const GUID DDPF_Z32;") cpp_quote("//") cpp_quote("// Component categories") cpp_quote("//") cpp_quote("EXTERN_C const GUID CATID_DXImageTransform;") cpp_quote("EXTERN_C const GUID CATID_DX3DTransform;") cpp_quote("EXTERN_C const GUID CATID_DXAuthoringTransform;") cpp_quote("EXTERN_C const GUID CATID_DXSurface;") cpp_quote("//") cpp_quote("// Service IDs") cpp_quote("//") cpp_quote("EXTERN_C const GUID SID_SDirectDraw;") cpp_quote("EXTERN_C const GUID SID_SDirect3DRM;") cpp_quote("#define SID_SDXTaskManager CLSID_DXTaskManager") cpp_quote("#define SID_SDXSurfaceFactory IID_IDXSurfaceFactory") //=== Struct & Enum definitions ============================================= //=== Interface definitions ================================================= [ uuid(17B59B2B-9CC8-11d1-9053-00C04FD9189D), helpstring("IDXBaseObject Interface"), pointer_default(unique) ] interface IDXBaseObject : IUnknown { HRESULT GetGenerationId( [out]ULONG *pID); HRESULT IncrementGenerationId([in] BOOL bRefresh); HRESULT GetObjectSize( [out] ULONG *pcbSize); } //--- Dimension identifiers typedef enum DXBNDID { DXB_X = 0, DXB_Y = 1, DXB_Z = 2, DXB_T = 3 } DXBNDID; //--- Bound types typedef enum DXBNDTYPE { DXBT_DISCRETE, DXBT_DISCRETE64, DXBT_CONTINUOUS, DXBT_CONTINUOUS64 } DXBNDTYPE; //--- Discrete bounds (image & sound) typedef struct DXDBND { long Min; long Max; } DXDBND; typedef DXDBND DXDBNDS[4]; typedef struct DXDBND64 { LONGLONG Min; LONGLONG Max; } DXDBND64; typedef DXDBND64 DXDBNDS64[4]; //--- Continuous bounds (geometry) typedef struct DXCBND { float Min; float Max; } DXCBND; typedef DXCBND DXCBNDS[4]; typedef struct DXCBND64 { double Min; double Max; } DXCBND64; typedef DXCBND64 DXCBNDS64[4]; //--- Combined space typedef union DXBNDS switch( DXBNDTYPE eType ) u { case DXBT_DISCRETE: DXDBND D[4]; case DXBT_DISCRETE64: DXDBND64 LD[4]; case DXBT_CONTINUOUS: DXCBND C[4]; case DXBT_CONTINUOUS64: DXCBND64 LC[4]; } DXBNDS; //--- Discrete 4D vector typedef long DXDVEC[4]; typedef LONGLONG DXDVEC64[4]; //--- Continous 4D vector typedef float DXCVEC[4]; typedef double DXCVEC64[4]; //--- Combined space vector typedef union DXVEC switch( DXBNDTYPE eType ) u { case DXBT_DISCRETE: long D[4]; case DXBT_DISCRETE64: LONGLONG LD[4]; case DXBT_CONTINUOUS: float C[4]; case DXBT_CONTINUOUS64: double LC[4]; } DXVEC; //--- IDXTransformFactory --------------------------------------------------- [ uuid(6A950B2B-A971-11d1-81C8-0000F87557DB), helpstring("IDXTransformFactory Interface"), pointer_default(unique) ] interface IDXTransformFactory : IServiceProvider { HRESULT SetService( [in]REFGUID guidService, [in]IUnknown *pUnkService, [in]BOOL bWeakReference); HRESULT CreateTransform( [in, size_is(ulNumInputs)]IUnknown** punkInputs, [in]ULONG ulNumInputs, [in, size_is(ulNumOutputs)]IUnknown** punkOutputs, [in]ULONG ulNumOutputs, [in]IPropertyBag* pInitProps, [in]IErrorLog* pErrLog, [in]REFCLSID TransCLSID, [in]REFIID TransIID, [out, iid_is(TransIID)]void** ppTransform ); HRESULT InitializeTransform( [in]IDXTransform* pTransform, [in, size_is(ulNumInputs)]IUnknown** punkInputs, [in]ULONG ulNumInputs, [in, size_is(ulNumOutputs)]IUnknown** punkOutputs, [in]ULONG ulNumOutputs, [in]IPropertyBag* pInitProps, [in]IErrorLog* pErrLog ); }; //--- IDXTransform ------------------------------------------------- typedef enum DXTMISCFLAGS { DXTMF_BLEND_WITH_OUTPUT = ( 1L << 0 ), DXTMF_DITHER_OUTPUT = ( 1L << 1 ), DXTMF_OPTION_MASK = (0x0000FFFF), // Low word is settable options DXTMF_VALID_OPTIONS = (DXTMF_BLEND_WITH_OUTPUT | DXTMF_DITHER_OUTPUT), // // Status flags can not be changed by call to SetMiscFlags // DXTMF_BLEND_SUPPORTED = ( 1L << 16 ), DXTMF_DITHER_SUPPORTED = ( 1L << 17 ), DXTMF_INPLACE_OPERATION = ( 1L << 24 ), DXTMF_BOUNDS_SUPPORTED = ( 1L << 25 ), DXTMF_PLACEMENT_SUPPORTED = ( 1L << 26 ), DXTMF_QUALITY_SUPPORTED = ( 1L << 27 ), DXTMF_OPAQUE_RESULT = ( 1L << 28 ) } DXTMISCFLAGS; typedef enum DXINOUTINFOFLAGS { DXINOUTF_OPTIONAL = ( 1L << 0) } DXINOUTINFOFLAGS; [ uuid(30A5FB78-E11F-11d1-9064-00C04FD9189D), helpstring("IDXTransform Interface"), pointer_default(unique) ] interface IDXTransform : IDXBaseObject { HRESULT Setup( [in, size_is(ulNumInputs)] IUnknown * const * punkInputs, [in]ULONG ulNumInputs, [in, size_is(ulNumOutputs)] IUnknown * const * punkOutputs, [in]ULONG ulNumOutputs, [in]DWORD dwFlags ); HRESULT Execute( [in]const GUID* pRequestID, [in]const DXBNDS *pClipBnds, [in]const DXVEC *pPlacement ); HRESULT MapBoundsIn2Out( [in] const DXBNDS *pInBounds, [in]ULONG ulNumInBnds, [in]ULONG ulOutIndex, [out]DXBNDS *pOutBounds ); HRESULT MapBoundsOut2In( [in] ULONG ulOutIndex, [in] const DXBNDS *pOutBounds, [in] ULONG ulInIndex, [out]DXBNDS *pInBounds ); HRESULT SetMiscFlags( [in] DWORD dwMiscFlags); HRESULT GetMiscFlags( [out]DWORD * pdwMiscFlags ); HRESULT GetInOutInfo( [in]BOOL bIsOutput, [in]ULONG ulIndex, [out]DWORD *pdwFlags, [out, size_is(*pcIDs)] GUID *pIDs, [in, out] ULONG *pcIDs, [out] IUnknown **ppUnkCurrentObject); HRESULT SetQuality( [in] float fQuality ); HRESULT GetQuality( [out] float * fQuality ); }; [ uuid(30A5FB79-E11F-11d1-9064-00C04FD9189D), helpstring("IDXSurfacePick Interface"), pointer_default(unique) ] interface IDXSurfacePick : IUnknown { HRESULT PointPick([in]const DXVEC *pPoint, [out]ULONG * pulInputSurfaceIndex, [out]DXVEC *pInputPoint); } //--- IDXTBindHost --------------------------------------------------- // This interface is used to set a site-specific bind host for a transform. // Only transforms that need access to a bind host need to implement this interface. // // For some reason, MIDL does not like IBindHost, so we've declared this interface local // [ uuid(D26BCE55-E9DC-11d1-9066-00C04FD9189D), helpstring("IDXTBindHost Interface"), pointer_default(unique), local ] interface IDXTBindHost : IUnknown { HRESULT SetBindHost([in] IBindHost * pBindHost); } //--- IDXTaskManager --------------------------------------------------- // This interface is used to implement a task managment service provider // to optimize thread usage. // Function type prototypes typedef void (__stdcall DXTASKPROC)(void *pTaskData, BOOL* pbContinueProcessing ); typedef DXTASKPROC *PFNDXTASKPROC; typedef void (__stdcall DXAPCPROC)(DWORD dwData); typedef DXAPCPROC *PFNDXAPCPROC; cpp_quote("#ifdef __cplusplus") cpp_quote("typedef struct DXTMTASKINFO" ) cpp_quote("{") cpp_quote(" PFNDXTASKPROC pfnTaskProc; // Pointer to function to execute") cpp_quote(" PVOID pTaskData; // Pointer to argument data") cpp_quote(" PFNDXAPCPROC pfnCompletionAPC; // Pointer to completion APC proc") cpp_quote(" DWORD dwCompletionData; // Pointer to APC proc data") cpp_quote(" const GUID* pRequestID; // Used to identify groups of tasks") cpp_quote("} DXTMTASKINFO;") cpp_quote("#else") typedef struct DXTMTASKINFO { PVOID pfnTaskProc; // Pointer to function to execute PVOID pTaskData; // Pointer to argument data PVOID pfnCompletionAPC; // Pointer to completion APC proc DWORD dwCompletionData; // Pointer to APC proc data const GUID* pRequestID; // Used to identify groups of tasks } DXTMTASKINFO; cpp_quote("#endif") [ local, uuid(254DBBC1-F922-11d0-883A-3C8B00C10000), helpstring("IDXTaskManager Interface"), pointer_default(unique) ] interface IDXTaskManager : IUnknown { HRESULT QueryNumProcessors( [out]ULONG* pulNumProc ); HRESULT SetThreadPoolSize( [in]ULONG ulNumThreads ); HRESULT GetThreadPoolSize( [out]ULONG* pulNumThreads ); HRESULT SetConcurrencyLimit( [in]ULONG ulNumThreads ); HRESULT GetConcurrencyLimit( [out]ULONG* pulNumThreads ); HRESULT ScheduleTasks( [in]DXTMTASKINFO TaskInfo[], [in]HANDLE Events[], [out]DWORD TaskIDs[], [in]ULONG ulNumTasks, [in]ULONG ulWaitPeriod ); HRESULT TerminateTasks( [in]DWORD TaskIDs[], [in]ULONG ulCount, [in]ULONG ulTimeOut ); HRESULT TerminateRequest( [in]REFIID RequestID, [in]ULONG ulTimeOut ); }; //--- IDXSurfaceFactory --------------------------------------------------- // // We want an operator so that we can cast from a DXSAMPLE to a DWORD, so for C++ we will // define the structure a special way. // cpp_quote("#ifdef __cplusplus") cpp_quote("/////////////////////////////////////////////////////") cpp_quote("") cpp_quote("class DXBASESAMPLE;") cpp_quote("class DXSAMPLE;") cpp_quote("class DXPMSAMPLE;") cpp_quote("") cpp_quote("/////////////////////////////////////////////////////") cpp_quote("") cpp_quote("class DXBASESAMPLE") cpp_quote("{") cpp_quote("public:") cpp_quote(" BYTE Blue;") cpp_quote(" BYTE Green;") cpp_quote(" BYTE Red;") cpp_quote(" BYTE Alpha;") cpp_quote(" DXBASESAMPLE() {}") cpp_quote(" DXBASESAMPLE(const BYTE alpha, const BYTE red, const BYTE green, const BYTE blue) :") cpp_quote(" Alpha(alpha),") cpp_quote(" Red(red),") cpp_quote(" Green(green),") cpp_quote(" Blue(blue) {}") cpp_quote(" DXBASESAMPLE(const DWORD val) { *this = (*(DXBASESAMPLE *)&val); }") cpp_quote(" operator DWORD () const {return *((DWORD *)this); }") cpp_quote(" DWORD operator=(const DWORD val) { return *this = *((DXBASESAMPLE *)&val); }") cpp_quote("}; // DXBASESAMPLE") cpp_quote("") cpp_quote("/////////////////////////////////////////////////////") cpp_quote("") cpp_quote("class DXSAMPLE : public DXBASESAMPLE") cpp_quote("{") cpp_quote("public:") cpp_quote(" DXSAMPLE() {}") cpp_quote(" DXSAMPLE(const BYTE alpha, const BYTE red, const BYTE green, const BYTE blue) :") cpp_quote(" DXBASESAMPLE(alpha, red, green, blue) {}") cpp_quote(" DXSAMPLE(const DWORD val) { *this = (*(DXSAMPLE *)&val); }") cpp_quote(" operator DWORD () const {return *((DWORD *)this); }") cpp_quote(" DWORD operator=(const DWORD val) { return *this = *((DXSAMPLE *)&val); }") cpp_quote(" operator DXPMSAMPLE() const;") cpp_quote("}; // DXSAMPLE") cpp_quote("") cpp_quote("/////////////////////////////////////////////////////") cpp_quote("") cpp_quote("class DXPMSAMPLE : public DXBASESAMPLE") cpp_quote("{") cpp_quote("public:") cpp_quote(" DXPMSAMPLE() {}") cpp_quote(" DXPMSAMPLE(const BYTE alpha, const BYTE red, const BYTE green, const BYTE blue) :") cpp_quote(" DXBASESAMPLE(alpha, red, green, blue) {}") cpp_quote(" DXPMSAMPLE(const DWORD val) { *this = (*(DXPMSAMPLE *)&val); }") cpp_quote(" operator DWORD () const {return *((DWORD *)this); }") cpp_quote(" DWORD operator=(const DWORD val) { return *this = *((DXPMSAMPLE *)&val); }") cpp_quote(" operator DXSAMPLE() const;") cpp_quote("}; // DXPMSAMPLE") cpp_quote("") cpp_quote("//") cpp_quote("// The following cast operators are to prevent a direct assignment of a DXSAMPLE to a DXPMSAMPLE") cpp_quote("//") cpp_quote("inline DXSAMPLE::operator DXPMSAMPLE() const { return *((DXPMSAMPLE *)this); }") cpp_quote("inline DXPMSAMPLE::operator DXSAMPLE() const { return *((DXSAMPLE *)this); }") cpp_quote("#else // !__cplusplus") typedef struct DXBASESAMPLE { BYTE Blue; BYTE Green; BYTE Red; BYTE Alpha; } DXBASESAMPLE; typedef struct DXSAMPLE { BYTE Blue; BYTE Green; BYTE Red; BYTE Alpha; } DXSAMPLE; typedef struct DXPMSAMPLE { BYTE Blue; BYTE Green; BYTE Red; BYTE Alpha; } DXPMSAMPLE; cpp_quote("#endif // !__cplusplus") typedef enum DXRUNTYPE { DXRUNTYPE_CLEAR = 0, // The run is zero Alpha DXRUNTYPE_OPAQUE = 1, // The run is full Alpha (i.e. 255) DXRUNTYPE_TRANS = 2, // The run is non-zero Alpha DXRUNTYPE_UNKNOWN= 3 // The run type is unknown. Caller must inspect. } DXRUNTYPE; const ULONG DX_MAX_RUN_INFO_COUNT = 128; // Defines the maximum number of RUNINFOs in a single row cpp_quote("// Ignore the definition used by MIDL for TLB generation") cpp_quote("#if 0") typedef struct DXRUNINFO { ULONG Bitfields; } DXRUNINFO; cpp_quote("#endif // 0") // Emit the C definition to the H file directly, as bit fields are not // supported by MIDL. cpp_quote("typedef struct DXRUNINFO") cpp_quote("{") cpp_quote(" ULONG Type : 2; // Type") cpp_quote(" ULONG Count : 30; // Number of samples in run") cpp_quote("} DXRUNINFO;") typedef enum DXSFCREATE { DXSF_FORMAT_IS_CLSID = ( 1L << 0 ), DXSF_NO_LAZY_DDRAW_LOCK = ( 1L << 1 ) } DXSFCREATE; typedef enum DXBLTOPTIONS { DXBOF_DO_OVER = (1L << 0), DXBOF_DITHER = (1L << 1) } DXBLTOPTIONS; [ uuid(144946F5-C4D4-11d1-81D1-0000F87557DB), helpstring("IDXSurfaceFactory Interface"), pointer_default(unique) ] interface IDXSurfaceFactory : IUnknown { [local] HRESULT CreateSurface([in] IUnknown *pDirectDraw, [in] const DDSURFACEDESC * pDDSurfaceDesc, [in] const GUID * pFormatID, [in] const DXBNDS *pBounds, [in] DWORD dwFlags, [in] IUnknown *punkOuter, [in] REFIID riid, [out, iid_is( riid )] void ** ppDXSurface); HRESULT CreateFromDDSurface([in] IUnknown *pDDrawSurface, [in] const GUID *pFormatID, [in] DWORD dwFlags, [in] IUnknown *punkOuter, [in] REFIID riid, [out, iid_is( riid )] void ** ppDXSurface); [local] HRESULT LoadImage( [in] const LPWSTR pszFileName, [in] IUnknown *pDirectDraw, [in] const DDSURFACEDESC * pDDSurfaceDesc, [in] const GUID *pFormatID, [in] REFIID riid, [out, iid_is( riid )] void ** ppDXSurface); [local] HRESULT LoadImageFromStream([in] IStream *pStream, [in] IUnknown *pDirectDraw, [in] const DDSURFACEDESC * pDDSurfaceDesc, [in] const GUID *pFormatID, [in] REFIID riid, [out, iid_is( riid )] void ** ppDXSurface); [local] HRESULT CopySurfaceToNewFormat( [in]IDXSurface* pSrc, [in] IUnknown *pDirectDraw, [in] const DDSURFACEDESC * pDDSurfaceDesc, [in] const GUID *pDestFormatID, [out] IDXSurface** ppNewSurface ); [local] HRESULT CreateD3DRMTexture([in] IDXSurface *pSrc, [in] IUnknown *pDirectDraw, [in] IUnknown *pD3DRM3, [in] REFIID riid, [out, iid_is(riid)] void **ppTexture3); HRESULT BitBlt([in] IDXSurface *pDest, [in] const DXVEC *pPlacement, [in] IDXSurface *pSrc, [in] const DXBNDS *pClipBounds, [in] DWORD dwFlags); } typedef enum DXSURFMODCOMPOP { DXSURFMOD_COMP_OVER = 0, DXSURFMOD_COMP_ALPHA_MASK = 1, DXSURFMOD_COMP_MAX_VALID = 1 } DXSURFMODCOMPOP; [ uuid(9EA3B637-C37D-11d1-905E-00C04FD9189D), helpstring("IDXSurfaceModifier Interface"), pointer_default(unique) ] interface IDXSurfaceModifier : IUnknown { HRESULT SetFillColor([in] DXSAMPLE Color); HRESULT GetFillColor([out] DXSAMPLE *pColor); HRESULT SetBounds([in] const DXBNDS *pBounds ); // Get supported though IDXSurface interface HRESULT SetBackground([in] IDXSurface *pSurface); HRESULT GetBackground([out] IDXSurface **ppSurface); HRESULT SetCompositeOperation([in] DXSURFMODCOMPOP CompOp); HRESULT GetCompositeOperation([out] DXSURFMODCOMPOP *pCompOp); // // The following methods only apply to the FOREGROUND surface // HRESULT SetForeground([in] IDXSurface *pSurface, [in] BOOL bTile, [in] const POINT * pOrigin); HRESULT GetForeground([out] IDXSurface **ppSurface, [out] BOOL *pbTile, [out] POINT * pOrigin); HRESULT SetOpacity([in] float Opacity); HRESULT GetOpacity([out] float *pOpacity); HRESULT SetLookup( [in]IDXLookupTable * pLookupTable ); HRESULT GetLookup( [out]IDXLookupTable ** ppLookupTable ); } //--- IDXSurface --------------------------------------------------- typedef enum DXSAMPLEFORMATENUM { DXPF_FLAGSMASK = (0xFFFF0000), // Top word is flags, low word is enum DXPF_NONPREMULT = (0x00010000), // Flags to be OR'd with pixel formats DXPF_TRANSPARENCY = (0x00020000), // Color key or one-bit alpha (alpha only 0 or 0xFF) DXPF_TRANSLUCENCY = (0x00040000), // Alpha can be any value from 0->0xFF // // This 3-bit field is used to determine what type of dithering to be used // DXPF_2BITERROR = (0x00200000), // 2 bits of error term DXPF_3BITERROR = (0x00300000), // 3 bits of error term for color (16-bit color) DXPF_4BITERROR = (0x00400000), // 4 bits of error term (ARGB 4444) DXPF_5BITERROR = (0x00500000), // 5 bits of error term for color (8-bit color) DXPF_ERRORMASK = (0x00700000), // Mask of bits used for dithering DXPF_NONSTANDARD = (0), // To be used for any surface that is not one of the following formats // This can be combined with DXPFNONPREMULT if the surface can work // better in non-premultiplied space. DXPF_PMARGB32 = (1 | DXPF_TRANSPARENCY | DXPF_TRANSLUCENCY), DXPF_ARGB32 = (2 | DXPF_NONPREMULT | DXPF_TRANSPARENCY | DXPF_TRANSLUCENCY), DXPF_ARGB4444 = (3 | DXPF_NONPREMULT | DXPF_TRANSPARENCY | DXPF_TRANSLUCENCY | DXPF_4BITERROR), DXPF_A8 = (4 | DXPF_TRANSPARENCY | DXPF_TRANSLUCENCY), DXPF_RGB32 = (5), DXPF_RGB24 = (6), DXPF_RGB565 = (7 | DXPF_3BITERROR), DXPF_RGB555 = (8 | DXPF_3BITERROR), DXPF_RGB8 = (9 | DXPF_5BITERROR), DXPF_ARGB1555 = (10 | DXPF_TRANSPARENCY | DXPF_3BITERROR), DXPF_RGB32_CK = (DXPF_RGB32 | DXPF_TRANSPARENCY), DXPF_RGB24_CK = (DXPF_RGB24 | DXPF_TRANSPARENCY), DXPF_RGB555_CK = (DXPF_RGB555 | DXPF_TRANSPARENCY), DXPF_RGB565_CK = (DXPF_RGB565 | DXPF_TRANSPARENCY), DXPF_RGB8_CK = (DXPF_RGB8 | DXPF_TRANSPARENCY) } DXSAMPLEFORMATENUM; typedef enum DXLOCKSURF { DXLOCKF_READ = 0, DXLOCKF_READWRITE = (1 << 0), DXLOCKF_EXISTINGINFOONLY = (1 << 1), // If used in conjunction with WANTRUNINFO will prevent creation of a runmap if one does not exist DXLOCKF_WANTRUNINFO = (1 << 2), // // The flags in the high word should be specific to the type of pointer that // is requested. These flags define ARGB flags. These flags are advisory and // are not required to be set for ARGB locks. // DXLOCKF_NONPREMULT = (1 << 16), // Caller will request non-premultiplied data DXLOCKF_VALIDFLAGS = (DXLOCKF_READWRITE | DXLOCKF_EXISTINGINFOONLY | DXLOCKF_WANTRUNINFO | DXLOCKF_NONPREMULT) } DXLOCKSURF; typedef enum DXSURFSTATUS { DXSURF_TRANSIENT = (1 << 0), // Data in this surface changes often. DXSURF_READONLY = (1 << 1), // Surface is read-only DXSURF_VALIDFLAGS = (DXSURF_TRANSIENT | DXSURF_READONLY) } DXSURFSTATUS; [ uuid(B39FD73F-E139-11d1-9065-00C04FD9189D), helpstring("IDXSurface Interface"), pointer_default(unique) ] interface IDXSurface : IDXBaseObject { HRESULT GetPixelFormat([out] GUID * pFormatID, [out] DXSAMPLEFORMATENUM *pSampleFormatEnum); HRESULT GetBounds( [out]DXBNDS *pBounds ); HRESULT GetStatusFlags([out] DWORD * pdwStatusFlags); HRESULT SetStatusFlags([in] DWORD dwStatusFlags); HRESULT LockSurface( [in]const DXBNDS *pBounds, [in]ULONG ulTimeOut, [in]DWORD dwFlags, [in]REFIID riid, [out, iid_is(riid)] void **ppPointer, [out]ULONG* pulGenerationId ); HRESULT GetDirectDrawSurface( [in] REFIID riid, [out, iid_is(riid)] void ** ppSurface); HRESULT GetColorKey(DXSAMPLE * pColorKey); // Can return E_NOTIMPL HRESULT SetColorKey(DXSAMPLE ColorKey); // Set color of 0 to get rid of color key, can return E_NOTIMPL HRESULT LockSurfaceDC( [in] const DXBNDS *pBounds, [in]ULONG ulTimeOut, [in] DWORD dwFlags, [out] IDXDCLock **ppDCLock); HRESULT SetAppData(DWORD dwAppData); HRESULT GetAppData(DWORD *pdwAppData); } //--- IDXSurfaceInit --------------------------------------------------- [ uuid(9EA3B639-C37D-11d1-905E-00C04FD9189D), helpstring("IDXSurfaceInit Interface"), pointer_default(unique), local ] interface IDXSurfaceInit : IUnknown { HRESULT InitSurface([in] IUnknown *pDirectDraw, [in] const DDSURFACEDESC *pDDSurfaceDesc, [in] const GUID * pFormatID, [in] const DXBNDS *pBounds, [in] DWORD dwFlags); }; //--- IDXARGBSurfaceInit --------------------------------------------------- [ uuid(9EA3B63A-C37D-11d1-905E-00C04FD9189D), helpstring("IDXARGBSurfaceInit Interface"), pointer_default(unique), local ] interface IDXARGBSurfaceInit : IDXSurfaceInit { HRESULT InitFromDDSurface( [in] IUnknown *pDDrawSurface, [in] const GUID * pFormatID, [in] DWORD dwFlags); HRESULT InitFromRawSurface([in] IDXRawSurface *pRawSurface); }; //--- IDXARGBReadPtr --------------------------------------------------- typedef struct tagDXNATIVETYPEINFO { BYTE * pCurrentData; BYTE * pFirstByte; long lPitch; DWORD dwColorKey; } DXNATIVETYPEINFO; typedef struct tagDXPACKEDRECTDESC { DXBASESAMPLE *pSamples; BOOL bPremult; RECT rect; long lRowPadding; } DXPACKEDRECTDESC; typedef struct tagDXOVERSAMPLEDESC { POINT p; DXPMSAMPLE Color; } DXOVERSAMPLEDESC; [ uuid(EAAAC2D6-C290-11d1-905D-00C04FD9189D), helpstring("IDXARGBReadPtr Interface"), pointer_default(unique), local ] interface IDXARGBReadPtr : IUnknown { HRESULT GetSurface( [in]REFIID riid, [out, iid_is( riid )]void ** ppSurface); DXSAMPLEFORMATENUM GetNativeType( [out]DXNATIVETYPEINFO *pInfo ); void Move( [in]long cSamples ); void MoveToRow( [in]ULONG y ); void MoveToXY( [in]ULONG x, [in]ULONG y); ULONG MoveAndGetRunInfo( [in]ULONG Row, [out] const DXRUNINFO** ppInfo ); // Returns count of runs DXSAMPLE * Unpack( [in]DXSAMPLE* pSamples, [in]ULONG cSamples, [in]BOOL bMove ); DXPMSAMPLE * UnpackPremult( [in]DXPMSAMPLE* pSamples, [in]ULONG cSamples, [in]BOOL bMove ); void UnpackRect([in] const DXPACKEDRECTDESC * pRectDesc); }; //--- IDXARGBReadWritePtr --------------------------------------------------- [ uuid(EAAAC2D7-C290-11d1-905D-00C04FD9189D), helpstring("IDXARGBReadWritePtr Interface"), pointer_default(unique), local ] interface IDXARGBReadWritePtr : IDXARGBReadPtr { void PackAndMove( [in]const DXSAMPLE *pSamples, [in]ULONG cSamples ); void PackPremultAndMove( [in]const DXPMSAMPLE *pSamples, [in]ULONG cSamples ); void PackRect([in]const DXPACKEDRECTDESC *pRectDesc); void CopyAndMoveBoth( [in]DXBASESAMPLE *pScratchBuffer, [in]IDXARGBReadPtr *pSrc, [in]ULONG cSamples, [in]BOOL bIsOpaque ); void CopyRect( [in] DXBASESAMPLE *pScratchBuffer, [in] const RECT *pDestRect, [in]IDXARGBReadPtr *pSrc, [in] const POINT *pSrcOrigin, [in]BOOL bIsOpaque); void FillAndMove( [in]DXBASESAMPLE *pScratchBuffer, [in]DXPMSAMPLE SampVal, [in]ULONG cSamples, [in]BOOL bDoOver ); void FillRect( [in]const RECT *pRect, [in]DXPMSAMPLE SampVal, [in]BOOL bDoOver ); void OverSample( [in]const DXOVERSAMPLEDESC * pOverDesc); void OverArrayAndMove([in]DXBASESAMPLE *pScratchBuffer, [in] const DXPMSAMPLE *pSrc, [in] ULONG cSamples); }; [ uuid(0F619456-CF39-11d1-905E-00C04FD9189D), helpstring("IDXDCLock Interface"), pointer_default(unique), local ] interface IDXDCLock : IUnknown { HDC GetDC(void); } // // Generic interface that any transform can support which allows caller to specify the // desired output bounds. // [ uuid(B2024B50-EE77-11d1-9066-00C04FD9189D), helpstring("IDXTScaleOutput Interface"), pointer_default(unique) ] interface IDXTScaleOutput : IUnknown { HRESULT SetOutputSize([in] const SIZE OutSize, [in] BOOL bMaintainAspect); }; // // Simple gradient // [ uuid(B2024B51-EE77-11d1-9066-00C04FD9189D), helpstring("IDXGradient Interface"), pointer_default(unique) ] interface IDXGradient : IDXTScaleOutput { HRESULT SetGradient(DXSAMPLE StartColor, DXSAMPLE EndColor, BOOL bHorizontal); HRESULT GetOutputSize([out] SIZE *pOutSize); }; //--- IDXTScale -------------------------------------------------------- // This is the control interface for the simple scale transform // [ uuid(B39FD742-E139-11d1-9065-00C04FD9189D), helpstring("IDXTScale Interface"), pointer_default(unique) ] interface IDXTScale : IUnknown { HRESULT SetScales( [in]float Scales[2] ); HRESULT GetScales( [out]float Scales[2] ); HRESULT ScaleFitToSize( [in,out]DXBNDS* pClipBounds, [in]SIZE FitToSize, [in]BOOL bMaintainAspect ); }; //--- IDXEffect ------------------------------------------------- // This interface is used to generically control transforms that // are transition effects. typedef enum DISPIDDXEFFECT { DISPID_DXECAPABILITIES = 10000, // Start at 10000 to avoid conflicts with inhereted interfaces DISPID_DXEPROGRESS, DISPID_DXESTEP, DISPID_DXEDURATION, DISPID_DXE_NEXT_ID } DISPIDDXBOUNDEDEFFECT; typedef enum DXEFFECTTYPE { DXTET_PERIODIC = (1 << 0), // Result at 1 is same as result at 0 DXTET_MORPH = (1 << 1) // Transition between 2 inputs (input 0 to input 1) } DXEFFECTTYPE; [ object, uuid(E31FB81B-1335-11d1-8189-0000F87557DB), dual, helpstring("IDXEffect Interface"), pointer_default(unique) ] interface IDXEffect : IDispatch { [propget, id(DISPID_DXECAPABILITIES)] HRESULT Capabilities([out, retval] long *pVal); [propget, id(DISPID_DXEPROGRESS)] HRESULT Progress([out, retval] float *pVal); [propput, id(DISPID_DXEPROGRESS)] HRESULT Progress([in] float newVal); [propget, id(DISPID_DXESTEP)] HRESULT StepResolution([out, retval] float *pVal); [propget, id(DISPID_DXEDURATION)] HRESULT Duration([out, retval] float *pVal); [propput, id(DISPID_DXEDURATION)] HRESULT Duration([in] float newVal); }; //--- IDXLookupTable --------------------------------------------- [ uuid(01BAFC7F-9E63-11d1-9053-00C04FD9189D), helpstring("IDXLookupTable Interface"), pointer_default(unique) ] interface IDXLookupTable : IDXBaseObject { HRESULT GetTables( [out]BYTE RedLUT[256], [out]BYTE GreenLUT[256], [out]BYTE BlueLUT[256], [out]BYTE AlphaLUT[256] ); HRESULT IsChannelIdentity([out] DXBASESAMPLE * pSampleBools); HRESULT GetIndexValues([in] ULONG Index, [out] DXBASESAMPLE *pSample); HRESULT ApplyTables([in, out] DXSAMPLE *pSamples, [in] ULONG cSamples); }; typedef struct DXRAWSURFACEINFO { BYTE * pFirstByte; long lPitch; ULONG Width; ULONG Height; const GUID * pPixelFormat; HDC hdc; DWORD dwColorKey; // Note: High byte must == 0xFF for color keyed surface. Low 3 bytes are native data type. DXBASESAMPLE * pPalette; } DXRAWSURFACEINFO; // // User created objects support IDXRawSurface // [ uuid(09756C8A-D96A-11d1-9062-00C04FD9189D), helpstring("IDXRawSurface Interface"), pointer_default(unique), local ] interface IDXRawSurface : IUnknown { HRESULT GetSurfaceInfo(DXRAWSURFACEINFO * pSurfaceInfo); } //+----------------------------------------------------------------------------- // // IDXTFilterCollection Interface // //------------------------------------------------------------------------------ [ object, uuid(22B07B33-8BFB-49d4-9B90-0938370C9019), helpstring("IDXTFilterCollection Interface"), pointer_default(unique), local ] interface IDXTFilterCollection : IUnknown { HRESULT Init(void ** ppvFirstNode); HRESULT AddNode(void * pNode); }; //+----------------------------------------------------------------------------- // // IDXTFilterBehavior Interface // //------------------------------------------------------------------------------ [ object, uuid(14D7DDDD-ACA2-4E45-9504-3808ABEB4F92), helpstring("IDXTFilterBehavior Interface"), pointer_default(unique), local ] interface IDXTFilterBehavior : IUnknown { HRESULT Initialize([in] IDXTransformFactory * pDXTransformFactory); HRESULT AddDXTFilter([in] BSTR bstrFilterString); HRESULT GetFilterCollection([out] IDXTFilterCollection ** ppDXTFilterCollection); }; //+----------------------------------------------------------------------------- // // IDXTFilterBehaviorSite Interface // //------------------------------------------------------------------------------ typedef enum DXTFILTER_STATUS { DXTFILTER_STATUS_Stopped = 0, DXTFILTER_STATUS_Applied, DXTFILTER_STATUS_Playing, DXTFILTER_STATUS_MAX } DXTFILTER_STATUS; [ object, uuid(909B23C2-9018-499f-A86D-4E7DA937E931), helpstring("IDXTFilterBehaviorSite Interface"), pointer_default(unique), local ] interface IDXTFilterBehaviorSite : IUnknown { HRESULT InvalidateElement(BOOL fInvalidateSize); HRESULT InvalidateFilterChain(); HRESULT ExecuteFilterChain(); HRESULT FireOnFilterChangeEvent(); HRESULT OnFilterChangeStatus(DXTFILTER_STATUS eStatus); void OnFatalError(HRESULT hrFatalError); HRESULT GetTimer(void **ppvTimer); HRESULT EnsureView(); }; //+----------------------------------------------------------------------------- // // IDXTFilter Interface // //------------------------------------------------------------------------------ typedef enum DXTFILTER_DISPID { DISPID_DXTFilter_Progress = 1, DISPID_DXTFilter_Duration, DISPID_DXTFilter_Enabled, DISPID_DXTFilter_Status, DISPID_DXTFilter_Apply, DISPID_DXTFilter_Play, DISPID_DXTFilter_Stop, DISPID_DXTFilter_MAX } DXTFILTER_DISPID; [ object, uuid(EDA1D7FF-4426-407a-9EA4-DE63A41C09DA), dual, helpstring("IDXTFilter Interface"), pointer_default(unique) ] interface IDXTFilter : IDispatch { [propget, id(DISPID_DXTFilter_Progress)] HRESULT Progress([out, retval] float *pVal); [propput, id(DISPID_DXTFilter_Progress)] HRESULT Progress([in] float newVal); [propget, id(DISPID_DXTFilter_Duration)] HRESULT Duration([out, retval] float *pVal); [propput, id(DISPID_DXTFilter_Duration)] HRESULT Duration([in] float newVal); [propget, id(DISPID_DXTFilter_Enabled)] HRESULT Enabled( [out, retval] VARIANT_BOOL *pfVal); [propput, id(DISPID_DXTFilter_Enabled)] HRESULT Enabled( [in] VARIANT_BOOL fVal); [propget, id(DISPID_DXTFilter_Status)] HRESULT Status( [out, retval] DXTFILTER_STATUS * peVal); [id(DISPID_DXTFilter_Apply)] HRESULT Apply(); [id(DISPID_DXTFilter_Play)] HRESULT Play([in, optional] VARIANT varDuration); [id(DISPID_DXTFilter_Stop)] HRESULT Stop(); [local] HRESULT Initialize([in] IDXTransform * pDXTransform, [in] IDXSurfaceFactory * pDXSurfaceFactory, [in] IDXTFilterBehaviorSite * pDXTFilterBehaviorSite, [in] BOOL fEnabled, [in] BOOL fUsesOldStyleFilterName); [local] HRESULT SetInputSurface([in] IDXSurface * pDXSurface); [local] HRESULT SetOutputSurface([in] IDXSurface * pDXSurface); [local] HRESULT GetOutputSurface([out] IDXSurface ** ppDXSurface); [local] HRESULT MapBoundsIn2Out([in] DXBNDS * pbndsIn, [in, out] DXBNDS * pbndsOut, [in] BOOL fResetOutputSize); [local] HRESULT MapBoundsOut2In([in] DXBNDS * pbndsOut, [in, out] DXBNDS * pbndsIn); [local] HRESULT Execute([in] DXBNDS * pbndsPortion, [in] DXVEC * pvecPlacement, [in] BOOL fFireFilterChange); [local] HRESULT SetMiscFlags([in] DWORD dwMiscFlags); [local] HRESULT HitTest([in] const DXVEC * pvecOut, [in, out] BOOL * pfInactiveInputHit, [in, out] DXVEC * pvecIn); [local] HRESULT Detach(); [local] void HardDisable(); }; //+----------------------------------------------------------------------------- // // IDXTRedirectFilterInit Interface // //------------------------------------------------------------------------------ [ object, uuid(D1A57094-21F7-4e6c-93E5-F5F77F748293), helpstring("IDXTRedirectFilterInit Interface"), pointer_default(unique), local ] interface IDXTRedirectFilterInit : IUnknown { HRESULT SetHTMLPaintSite(void * pvHTMLPaintSite); }; //=== CoClass definitions ================================================= [ uuid(54314D1D-35FE-11d1-81A1-0000F87557DB), version(1.0), helpstring("Microsoft DirectX Transform 1.0 Type Library") ] library DXTRANSLib { importlib("stdole2.tlb"); /////////////////////////////// // DXTransformFactory CoClass /////////////////////////////// [ uuid(D1FE6762-FC48-11D0-883A-3C8B00C10000), helpstring("DXTransformFactory Class") ] coclass DXTransformFactory { [default] interface IDXTransformFactory; interface IDXSurfaceFactory; }; /////////////////////////////// // DXTaskManager CoClass /////////////////////////////// [ uuid(4CB26C03-FF93-11d0-817E-0000F87557DB), helpstring("DXTaskManager Class") ] coclass DXTaskManager { [default] interface IDXTaskManager; }; /////////////////////////////// // DXTScale CoClass /////////////////////////////// [ uuid(555278E2-05DB-11D1-883A-3C8B00C10000), helpstring("DXTScale Class") ] coclass DXTScale { [default] interface IDXTScale; }; /////////////////////////////// // DXSurface CoClass /////////////////////////////// [ uuid(0E890F83-5F79-11D1-9043-00C04FD9189D), helpstring("DXSurface Class") ] coclass DXSurface { [default] interface IDXSurface; }; /////////////////////////////// // DXSurfaceModifier CoClass /////////////////////////////// [ uuid(3E669F1D-9C23-11d1-9053-00C04FD9189D), helpstring("DXSurfaceModifier Class") ] coclass DXSurfaceModifier { [default] interface IDXSurfaceModifier; }; /////////////////////////////// // DXGradient CoClass /////////////////////////////// [ uuid(C6365470-F667-11d1-9067-00C04FD9189D), helpstring("DXGradient Class") ] coclass DXGradient { [default] interface IDXGradient; }; /////////////////////////////// // DXTFilterBehavior CoClass /////////////////////////////// [ uuid(649EEC1E-B579-4E8C-BB3B-4997F8426536), helpstring("DXTFilterBehavior Class") ] coclass DXTFilterBehavior { [default] interface IDXTFilterBehavior; }; /////////////////////////////// // DXTFilter CoClass /////////////////////////////// [ uuid(385A91BC-1E8A-4e4a-A7A6-F4FC1E6CA1BD), helpstring("DXTFilter Class") ] coclass DXTFilter { [default] interface IDXTFilter; }; /////////////////////////////// // DXTFilterFactory CoClass /////////////////////////////// [ uuid(81397204-F51A-4571-8D7B-DC030521AABD), helpstring("DXTFilterFactory Class") ] coclass DXTFilterFactory { [default] interface IUnknown; }; /////////////////////////////// // DXTFilterCollection CoClass /////////////////////////////// [ uuid(A7EE7F34-3BD1-427f-9231-F941E9B7E1FE), helpstring("DXTFilterCollection Class") ] coclass DXTFilterCollection { [default] interface IDispatch; }; };