diff options
Diffstat (limited to 'sdk/dx8sdk/Include/DShowIDL/dxtrans.idl')
| -rw-r--r-- | sdk/dx8sdk/Include/DShowIDL/dxtrans.idl | 1289 |
1 files changed, 1289 insertions, 0 deletions
diff --git a/sdk/dx8sdk/Include/DShowIDL/dxtrans.idl b/sdk/dx8sdk/Include/DShowIDL/dxtrans.idl new file mode 100644 index 00000000..6395d325 --- /dev/null +++ b/sdk/dx8sdk/Include/DShowIDL/dxtrans.idl @@ -0,0 +1,1289 @@ +//------------------------------------------------------------------------------ +// +// Copyright Microsoft Corporation 1997-2000 +// All rights reserved. +// +// File: dxtrans.idl +// +// Overview: +// This is the IDL file for DirectX installable transform coclass, +// interface, and type definitions. +// +//------------------------------------------------------------------------------ + +cpp_quote("#include <servprov.h>") +cpp_quote("#include <ddraw.h>") +cpp_quote("#include <d3d.h>") +cpp_quote("#include <d3drm.h>") +cpp_quote("#include <urlmon.h>") + +//--- 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") +cpp_quote("#define SID_SDXTransformFactory IID_IDXTransformFactory") +cpp_quote("//") +cpp_quote("// DXTransforms Core Type Library Version Info") +cpp_quote("//") +cpp_quote("#define DXTRANS_TLB_MAJOR_VER 1") +cpp_quote("#define DXTRANS_TLB_MINOR_VER 1") + +//=== Struct & Enum definitions ============================================= + +//=== Interface definitions ================================================= + + +//+----------------------------------------------------------------------------- +// +// IDXBaseObject +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(17B59B2B-9CC8-11d1-9053-00C04FD9189D), + helpstring("IDXBaseObject Interface"), + pointer_default(unique), + local + ] + interface IDXBaseObject : IUnknown + { + HRESULT GetGenerationId( [out]ULONG *pID); + HRESULT IncrementGenerationId([in] BOOL bRefresh); + HRESULT GetObjectSize( [out] ULONG *pcbSize); + }; + + +//+----------------------------------------------------------------------------- +// +// Bounding rectangle and vector structures. +// +//------------------------------------------------------------------------------ + + //--- 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 +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(6A950B2B-A971-11d1-81C8-0000F87557DB), + helpstring("IDXTransformFactory Interface"), + pointer_default(unique), + local + ] + 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; + + [ + object, + uuid(30A5FB78-E11F-11d1-9064-00C04FD9189D), + helpstring("IDXTransform Interface"), + pointer_default(unique), + local + ] + 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 ); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXSurfacePick +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(30A5FB79-E11F-11d1-9064-00C04FD9189D), + helpstring("IDXSurfacePick Interface"), + pointer_default(unique), + local + ] + interface IDXSurfacePick : IUnknown + { + HRESULT PointPick([in]const DXVEC *pPoint, + [out]ULONG * pulInputSurfaceIndex, + [out]DXVEC *pInputPoint); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXTBindHost +// +// Overview: +// 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. +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(D26BCE55-E9DC-11d1-9066-00C04FD9189D), + helpstring("IDXTBindHost Interface"), + pointer_default(unique), + local + ] + interface IDXTBindHost : IUnknown + { + HRESULT SetBindHost([in] IBindHost * pBindHost); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXTaskManager +// +// Overview: +// This interface is used to implement a task managment service provider to +// optimize thread usage. +// +//------------------------------------------------------------------------------ + + 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") + + [ + object, + uuid(254DBBC1-F922-11d0-883A-3C8B00C10000), + helpstring("IDXTaskManager Interface"), + pointer_default(unique), + local + ] + 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 ); + }; + + +//+----------------------------------------------------------------------------- +// +// Sample structures (C++) +// +// Overview: +// 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); }") + + +//+----------------------------------------------------------------------------- +// +// Sample structures (IDL, C) +// +//------------------------------------------------------------------------------ + +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") + +//+----------------------------------------------------------------------------- +// +// DXRUNINFO structures. +// +//------------------------------------------------------------------------------ + + 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; + + +//+----------------------------------------------------------------------------- +// +// IDXSurfaceModifier +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(144946F5-C4D4-11d1-81D1-0000F87557DB), + helpstring("IDXSurfaceFactory Interface"), + pointer_default(unique), + local + ] + interface IDXSurfaceFactory : IUnknown + { + 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); + + 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); + + 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); + + HRESULT CopySurfaceToNewFormat( [in]IDXSurface* pSrc, + [in] IUnknown *pDirectDraw, + [in] const DDSURFACEDESC * pDDSurfaceDesc, + [in] const GUID *pDestFormatID, + [out] IDXSurface** ppNewSurface ); + + 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); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXSurfaceModifier +// +//------------------------------------------------------------------------------ + + typedef enum DXSURFMODCOMPOP + { + DXSURFMOD_COMP_OVER = 0, + DXSURFMOD_COMP_ALPHA_MASK = 1, + DXSURFMOD_COMP_MAX_VALID = 1 + } DXSURFMODCOMPOP; + + [ + object, + uuid(9EA3B637-C37D-11d1-905E-00C04FD9189D), + helpstring("IDXSurfaceModifier Interface"), + pointer_default(unique), + local + ] + 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; + + [ + object, + uuid(B39FD73F-E139-11d1-9065-00C04FD9189D), + helpstring("IDXSurface Interface"), + pointer_default(unique), + local + ] + 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_PTR dwAppData); + HRESULT GetAppData(DWORD_PTR *pdwAppData); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXSurfaceInit +// +//------------------------------------------------------------------------------ + + [ + object, + 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 +// +//------------------------------------------------------------------------------ + + [ + object, + 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; + + [ + object, + 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 +// +//------------------------------------------------------------------------------ + + [ + object, + 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); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXDCLock +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(0F619456-CF39-11d1-905E-00C04FD9189D), + helpstring("IDXDCLock Interface"), + pointer_default(unique), + local + ] + interface IDXDCLock : IUnknown + { + HDC GetDC(void); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXTScaleOutput +// +// Overview: +// Generic interface that any transform can support which allows caller to +// specify the desired output bounds. +//------------------------------------------------------------------------------ + + [ + object, + uuid(B2024B50-EE77-11d1-9066-00C04FD9189D), + helpstring("IDXTScaleOutput Interface"), + pointer_default(unique), + local + ] + interface IDXTScaleOutput : IUnknown + { + HRESULT SetOutputSize([in] const SIZE OutSize, [in] BOOL bMaintainAspect); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXGradient +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(B2024B51-EE77-11d1-9066-00C04FD9189D), + helpstring("IDXGradient Interface"), + pointer_default(unique), + local + ] + interface IDXGradient : IDXTScaleOutput + { + HRESULT SetGradient(DXSAMPLE StartColor, DXSAMPLE EndColor, BOOL bHorizontal); + HRESULT GetOutputSize([out] SIZE *pOutSize); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXTScale +// +// Overview: +// This is the control interface for the simple scale transform. +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(B39FD742-E139-11d1-9065-00C04FD9189D), + helpstring("IDXTScale Interface"), + pointer_default(unique), + local + ] + 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 +// +// Overview: +// 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), + helpstring("IDXEffect Interface"), + pointer_default(unique), + dual + ] + 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 +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(01BAFC7F-9E63-11d1-9053-00C04FD9189D), + helpstring("IDXLookupTable Interface"), + pointer_default(unique), + local + ] + 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); + }; + + +//+----------------------------------------------------------------------------- +// +// IDXRawSurface +// +// Overview: +// User created objects support IDXRawSurface +// +//------------------------------------------------------------------------------ + + 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; + + [ + object, + uuid(09756C8A-D96A-11d1-9062-00C04FD9189D), + helpstring("IDXRawSurface Interface"), + pointer_default(unique), + local + ] + interface IDXRawSurface : IUnknown + { + HRESULT GetSurfaceInfo(DXRAWSURFACEINFO * pSurfaceInfo); + }; + + +//+----------------------------------------------------------------------------- +// +// IHTMLDXTransform +// +//------------------------------------------------------------------------------ + + [ + object, + uuid(30E2AB7D-4FDD-4159-B7EA-DC722BF4ADE5), + helpstring("IHTMLDXTransform Interface"), + pointer_default(unique), + local + ] + interface IHTMLDXTransform : IUnknown + { + HRESULT SetHostUrl(BSTR bstrHostUrl); + }; + + +//+----------------------------------------------------------------------------- +// +// ICSSFilterDispatch +// +//------------------------------------------------------------------------------ + + typedef enum DXTFILTER_STATUS + { + DXTFILTER_STATUS_Stopped = 0, + DXTFILTER_STATUS_Applied, + DXTFILTER_STATUS_Playing, + DXTFILTER_STATUS_MAX + } DXTFILTER_STATUS; + + typedef enum DXTFILTER_DISPID + { + DISPID_DXTFilter_Percent = 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(9519152B-9484-4A6C-B6A7-4F25E92D6C6B), + helpstring("ICSSFilterDispatch Interface"), + pointer_default(unique), + dual + ] + interface ICSSFilterDispatch : IDispatch + { + [propget, id(DISPID_DXTFilter_Percent)] HRESULT Percent( [out, retval] float *pVal); + [propput, id(DISPID_DXTFilter_Percent)] HRESULT Percent( [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(); + }; + + +//=== CoClass definitions ================================================= + +[ + uuid(54314D1D-35FE-11d1-81A1-0000F87557DB), + version(1.1), + helpstring("Microsoft DirectX Transforms Core 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; + }; + + + /////////////////////////////// + // DXTFilter CoClass + /////////////////////////////// + [ + uuid(385A91BC-1E8A-4e4a-A7A6-F4FC1E6CA1BD), + helpstring("DXTFilter Class") + ] + coclass DXTFilter + { + [default] interface ICSSFilterDispatch; + }; +}; |