diff options
Diffstat (limited to 'dxsdk/Include/DShowIDL/Vmrender.idl')
| -rw-r--r-- | dxsdk/Include/DShowIDL/Vmrender.idl | 1092 |
1 files changed, 1092 insertions, 0 deletions
diff --git a/dxsdk/Include/DShowIDL/Vmrender.idl b/dxsdk/Include/DShowIDL/Vmrender.idl new file mode 100644 index 00000000..ed5e50ec --- /dev/null +++ b/dxsdk/Include/DShowIDL/Vmrender.idl @@ -0,0 +1,1092 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Public Interfaces for the Video Mixing Renderer DShow filter +// +// Copyright (c) 1999 - 2002, Microsoft Corporation. All rights reserved. +/////////////////////////////////////////////////////////////////////////////// + +cpp_quote("#if 0") +// This is temporary work around to persuade +// MIDL to allow forward declarations. +typedef DWORD* LPDIRECTDRAW7; +typedef DWORD* LPDIRECTDRAWSURFACE7; +typedef DWORD* LPDDPIXELFORMAT; +typedef DWORD* LPBITMAPINFOHEADER; +typedef struct {DWORD dw1; DWORD dw2;} DDCOLORKEY; +typedef DDCOLORKEY* LPDDCOLORKEY; +cpp_quote ("#endif") +cpp_quote("#include <ddraw.h>") + + +// public interfaces supported by the VMR +interface IVMRSurface; + +interface IVMRSurfaceAllocator; +interface IVMRSurfaceAllocatorNotify; +interface IVMRImagePresenter; +interface IVMRImagePresenterConfig; + +interface IVMRWindowlessControl; +interface IVMRMixerControl; +interface IVMRMixerBitmap; +interface IVMRFilterConfig; +interface IVMRAspectRatioControl; +interface IVMRDeinterlaceControl; +interface IVMRMonitorConfig; + +interface IVMRImageCompositor; + +interface IVMRVideoStreamControl; + + + + +/////////////////////////////////////////////////////////////////////////////// +// +// Allocator Presenter interfaces +// +/////////////////////////////////////////////////////////////////////////////// + + + +//===================================================================== +// +// IVMRImagePresenter +// +//===================================================================== +typedef enum { + VMRSample_SyncPoint = 0x00000001, + VMRSample_Preroll = 0x00000002, + VMRSample_Discontinuity = 0x00000004, + VMRSample_TimeValid = 0x00000008, + VMRSample_SrcDstRectsValid= 0x00000010 +} VMRPresentationFlags; + + +typedef struct tagVMRPRESENTATIONINFO { + DWORD dwFlags; + LPDIRECTDRAWSURFACE7 lpSurf; + REFERENCE_TIME rtStart; + REFERENCE_TIME rtEnd; + SIZE szAspectRatio; + RECT rcSrc; + RECT rcDst; + DWORD dwTypeSpecificFlags; + DWORD dwInterlaceFlags; +} VMRPRESENTATIONINFO; + +[ + local, + object, + local, + uuid(CE704FE7-E71E-41fb-BAA2-C4403E1182F5), + helpstring("IVMRImagePresenter Interface"), + pointer_default(unique) +] +interface IVMRImagePresenter : IUnknown +{ + HRESULT StartPresenting( + [in] DWORD_PTR dwUserID + ); + + HRESULT StopPresenting( + [in] DWORD_PTR dwUserID + ); + + + HRESULT PresentImage( + [in] DWORD_PTR dwUserID, + [in] VMRPRESENTATIONINFO* lpPresInfo + ); +}; + + +//===================================================================== +// +// IVMRSurfaceAllocator +// +//===================================================================== + +typedef enum { + AMAP_PIXELFORMAT_VALID = 0x01, + AMAP_3D_TARGET = 0x02, + AMAP_ALLOW_SYSMEM = 0x04, + AMAP_FORCE_SYSMEM = 0x08, + AMAP_DIRECTED_FLIP = 0x10, + AMAP_DXVA_TARGET = 0x20 +} VMRSurfaceAllocationFlags; + +typedef struct tagVMRALLOCATIONINFO { + DWORD dwFlags; + LPBITMAPINFOHEADER lpHdr; + LPDDPIXELFORMAT lpPixFmt; + SIZE szAspectRatio; + DWORD dwMinBuffers; + DWORD dwMaxBuffers; + DWORD dwInterlaceFlags; + SIZE szNativeSize; +} VMRALLOCATIONINFO; + +[ + local, + object, + local, + uuid(31ce832e-4484-458b-8cca-f4d7e3db0b52), + helpstring("IVMRSurfaceAllocator Interface"), + pointer_default(unique) +] +interface IVMRSurfaceAllocator : IUnknown +{ + HRESULT AllocateSurface( + [in] DWORD_PTR dwUserID, + [in] VMRALLOCATIONINFO* lpAllocInfo, + [in] [out] DWORD* lpdwActualBuffers, + [out] LPDIRECTDRAWSURFACE7 *lplpSurface + ); + + HRESULT FreeSurface( + [in] DWORD_PTR dwID + ); + + HRESULT PrepareSurface( + [in] DWORD_PTR dwUserID, + [in] LPDIRECTDRAWSURFACE7 lpSurface, + [in] DWORD dwSurfaceFlags + ); + + HRESULT AdviseNotify( + [in] IVMRSurfaceAllocatorNotify* lpIVMRSurfAllocNotify + ); +}; + + +//===================================================================== +// +// IVMRSurfaceAllocatorNotify +// +//===================================================================== +[ + local, + object, + local, + uuid(aada05a8-5a4e-4729-af0b-cea27aed51e2), + helpstring("IVMRSurfaceAllocatorNotify Interface"), + pointer_default(unique) +] +interface IVMRSurfaceAllocatorNotify : IUnknown +{ + HRESULT AdviseSurfaceAllocator( + [in] DWORD_PTR dwUserID, + [in] IVMRSurfaceAllocator* lpIVRMSurfaceAllocator + ); + + HRESULT SetDDrawDevice( + [in] LPDIRECTDRAW7 lpDDrawDevice, + [in] HMONITOR hMonitor + ); + + HRESULT ChangeDDrawDevice( + [in] LPDIRECTDRAW7 lpDDrawDevice, + [in] HMONITOR hMonitor + ); + + HRESULT RestoreDDrawSurfaces(); + + HRESULT NotifyEvent( + [in] LONG EventCode, + [in] LONG_PTR Param1, + [in] LONG_PTR Param2 + ); + + HRESULT SetBorderColor( + [in] COLORREF clrBorder + ); +}; + + + +/////////////////////////////////////////////////////////////////////////////// +// +// Application control and configuration interfaces +// +/////////////////////////////////////////////////////////////////////////////// + + +//===================================================================== +// +// IVMRWindowlessControl +// +//===================================================================== +typedef enum { + VMR_ARMODE_NONE, + VMR_ARMODE_LETTER_BOX +} VMR_ASPECT_RATIO_MODE; + +[ + local, + object, + local, + uuid(0eb1088c-4dcd-46f0-878f-39dae86a51b7), + helpstring("IVMRWindowlessControl Interface"), + pointer_default(unique) +] +interface IVMRWindowlessControl : IUnknown +{ + // + ////////////////////////////////////////////////////////// + // Video size and position information + ////////////////////////////////////////////////////////// + // + HRESULT GetNativeVideoSize( + [out] LONG* lpWidth, + [out] LONG* lpHeight, + [out] LONG* lpARWidth, + [out] LONG* lpARHeight + ); + + HRESULT GetMinIdealVideoSize( + [out] LONG* lpWidth, + [out] LONG* lpHeight + ); + + HRESULT GetMaxIdealVideoSize( + [out] LONG* lpWidth, + [out] LONG* lpHeight + ); + + HRESULT SetVideoPosition( + [in] const LPRECT lpSRCRect, + [in] const LPRECT lpDSTRect + ); + + HRESULT GetVideoPosition( + [out] LPRECT lpSRCRect, + [out] LPRECT lpDSTRect + ); + + HRESULT GetAspectRatioMode( + [out] DWORD* lpAspectRatioMode + ); + + HRESULT SetAspectRatioMode( + [in] DWORD AspectRatioMode + ); + + // + ////////////////////////////////////////////////////////// + // Display and clipping management + ////////////////////////////////////////////////////////// + // + HRESULT SetVideoClippingWindow( + [in] HWND hwnd + ); + + HRESULT RepaintVideo( + [in] HWND hwnd, + [in] HDC hdc + ); + + HRESULT DisplayModeChanged(); + + + // + ////////////////////////////////////////////////////////// + // GetCurrentImage + // + // Returns the current image being displayed. This images + // is returned in the form of packed Windows DIB. + // + // GetCurrentImage can be called at any time, also + // the caller is responsible for free the returned memory + // by calling CoTaskMemFree. + // + // Excessive use of this function will degrade video + // playback performed. + ////////////////////////////////////////////////////////// + // + HRESULT GetCurrentImage( + [out] BYTE** lpDib + ); + + // + ////////////////////////////////////////////////////////// + // Border Color control + // + // The border color is color used to fill any area of the + // the destination rectangle that does not contain video. + // It is typically used in two instances. When the video + // straddles two monitors and when the VMR is trying + // to maintain the aspect ratio of the movies by letter + // boxing the video to fit within the specified destination + // rectangle. See SetAspectRatioMode above. + ////////////////////////////////////////////////////////// + // + HRESULT SetBorderColor( + [in] COLORREF Clr + ); + + HRESULT GetBorderColor( + [out] COLORREF* lpClr + ); + + // + ////////////////////////////////////////////////////////// + // Color key control only meaningful when the VMR is using + // and overlay + ////////////////////////////////////////////////////////// + // + HRESULT SetColorKey( + [in] COLORREF Clr + ); + + HRESULT GetColorKey( + [out] COLORREF* lpClr + ); +}; + + + +//===================================================================== +// +// IVMRMixerControl +// +//===================================================================== + +typedef enum { + MixerPref_NoDecimation = 0x00000001, // No decimation - full size + MixerPref_DecimateOutput = 0x00000002, // decimate output by 2 in x & y + MixerPref_ARAdjustXorY = 0x00000004, // adjust the aspect ratio in x or y + MixerPref_DecimationReserved = 0x00000008, // bits reserved for future use. + MixerPref_DecimateMask = 0x0000000F, + + MixerPref_BiLinearFiltering = 0x00000010, // use bi-linear filtering + MixerPref_PointFiltering = 0x00000020, // use point filtering + MixerPref_FilteringMask = 0x000000F0, // OR of all above flags + + MixerPref_RenderTargetRGB = 0x00000100, // Uses D3D to perform mixing + MixerPref_RenderTargetYUV = 0x00001000, // Uses DXVA to perform mixing + + MixerPref_RenderTargetYUV420 = 0x00000200, // Deprecated render target + MixerPref_RenderTargetYUV422 = 0x00000400, // Deprecated render target + MixerPref_RenderTargetYUV444 = 0x00000800, // Deprecated render target + MixerPref_RenderTargetReserved = 0x0000E000, // 3 bits reserved for future use. + MixerPref_RenderTargetMask = 0x0000FF00, // OR of all above flags + + // + // Dynamic changes that can be performed when the VMR's mixer is + // configured to use the YUV Render target (see MixerPref_RenderTargetYUV) + // These preferences can be applied while the graph is running and take effect + // when the next frame is composed by the mixer. + // + MixerPref_DynamicSwitchToBOB = 0x00010000, + MixerPref_DynamicDecimateBy2 = 0x00020000, + + MixerPref_DynamicReserved = 0x000C0000, + MixerPref_DynamicMask = 0x000F0000 + +} VMRMixerPrefs; + +// +// Normalized relative rectangle +// Coordinate ranges: x=[0...1) y=[0...1) +// Where the output window goes from 0,0 (closed inclusive lower bound) +// to 1,1 (open exclusive upper bound) +// +typedef struct _NORMALIZEDRECT +{ + float left; + float top; + float right; + float bottom; +} NORMALIZEDRECT, *PNORMALIZEDRECT; + +[ + local, + object, + local, + uuid(1c1a17b0-bed0-415d-974b-dc6696131599), + helpstring("IVMRMixerControl Interface"), + pointer_default(unique) +] +interface IVMRMixerControl : IUnknown +{ + HRESULT SetAlpha( + [in] DWORD dwStreamID, + [in] float Alpha // Source alpha premultication factor (global alpha for source) + ); + + HRESULT GetAlpha( + [in] DWORD dwStreamID, + [out] float* pAlpha + ); + + HRESULT SetZOrder( + [in] DWORD dwStreamID, + [in] DWORD dwZ + ); + + HRESULT GetZOrder( + [in] DWORD dwStreamID, + [out] DWORD* pZ + ); + + HRESULT SetOutputRect( + [in] DWORD dwStreamID, + [in] const NORMALIZEDRECT *pRect + ); + + HRESULT GetOutputRect( + [in] DWORD dwStreamID, + [out] NORMALIZEDRECT *pRect + ); + + HRESULT SetBackgroundClr( + [in] COLORREF ClrBkg + ); + + HRESULT GetBackgroundClr( + [in] COLORREF* lpClrBkg + ); + + HRESULT SetMixingPrefs( + [in] DWORD dwMixerPrefs // a combination of VMRMixingPrefFlags + ); + + HRESULT GetMixingPrefs( + [out] DWORD* pdwMixerPrefs + ); +}; + + +/////////////////////////////////////////////////////////////////////////////// +// +// VMR Multimon configuration interface +// +/////////////////////////////////////////////////////////////////////////////// +typedef struct tagVMRGUID { + GUID* pGUID; // is NULL if the default DDraw device + GUID GUID; // otherwise points to this GUID +} VMRGUID; + +#define VMRDEVICENAMELEN 32 +#define VMRDEVICEDESCRIPTIONLEN 256 + +typedef struct tagVMRMONITORINFO { + VMRGUID guid; + RECT rcMonitor; + HMONITOR hMon; + DWORD dwFlags; // described in MONITORINFOEX, currently only MONITORINFOF_PRIMARY + wchar_t szDevice[VMRDEVICENAMELEN]; + wchar_t szDescription[VMRDEVICEDESCRIPTIONLEN]; + LARGE_INTEGER liDriverVersion; + DWORD dwVendorId; + DWORD dwDeviceId; + DWORD dwSubSysId; + DWORD dwRevision; + // find out the DDCAPS using DDrawCreate on the monitor GUID +} VMRMONITORINFO; + +[ + object, + local, + uuid(9cf0b1b6-fbaa-4b7f-88cf-cf1f130a0dce), + helpstring("IVMRMonitorConfig Interface"), + pointer_default(unique) +] +interface IVMRMonitorConfig : IUnknown +{ + // Use this method on a Multi-Monitor system to specify to the + // mixer filter which Direct Draw driver should be used when connecting + // to an upstream decoder filter. + // + HRESULT SetMonitor( + [in] const VMRGUID *pGUID + ); + + // Use this method to determine the direct draw object that will be used when + // connecting the mixer filter to an upstream decoder filter. + // + HRESULT GetMonitor( + [out] VMRGUID *pGUID + ); + + // Use this method on a multi-monitor system to specify to the + // mixer filter the default Direct Draw device to use when + // connecting to an upstream filter. The default direct draw device + // can be overriden for a particular connection by SetMonitor method + // described above. + // + HRESULT SetDefaultMonitor( + [in] const VMRGUID *pGUID + ); + + // Use this method on a multi-monitor system to determine which + // is the default direct draw device the overlay mixer filter + // will use when connecting to an upstream filter. + // + HRESULT GetDefaultMonitor( + [out] VMRGUID *pGUID + ); + + // Use this method to get a list of Direct Draw device GUIDs and thier + // associated monitor information that the mixer can use when + // connecting to an upstream decoder filter. Passing down a NULL pInfo + // parameter allows the app to determine the required array size (returned + // in pdwNumDevices). Otherwise, dwNumDevices returns the actual + // number of devices retrieved. + // + HRESULT GetAvailableMonitors( + [out, size_is(dwMaxInfoArraySize)] VMRMONITORINFO* pInfo, + [in] DWORD dwMaxInfoArraySize, // in array members + [out] DWORD* pdwNumDevices // actual number of devices retrieved + ); +}; + + + + +/////////////////////////////////////////////////////////////////////////////// +// +// VMR Filter configuration interfaces +// +/////////////////////////////////////////////////////////////////////////////// + + +typedef enum { + RenderPrefs_RestrictToInitialMonitor = 0x00000000, // not implemented do not use + RenderPrefs_ForceOffscreen = 0x00000001, + RenderPrefs_ForceOverlays = 0x00000002, // fail if no overlays + RenderPrefs_AllowOverlays = 0x00000000, // overlay used by default + RenderPrefs_AllowOffscreen = 0x00000000, // offscreen used if no overlay + RenderPrefs_DoNotRenderColorKeyAndBorder = 0x00000008, // app paints color keys + RenderPrefs_Reserved = 0x00000010, // note: used to be RestrictToInitialMonitor + RenderPrefs_PreferAGPMemWhenMixing = 0x00000020, // try agp mem when allocating textures + + RenderPrefs_Mask = 0x0000003f, // OR of all above flags +} VMRRenderPrefs; + +typedef enum { + VMRMode_Windowed = 0x00000001, + VMRMode_Windowless = 0x00000002, + VMRMode_Renderless = 0x00000004, + + // not a valid value to pass to SetRenderMode + VMRMode_Mask = 0x00000007, // OR of all above flags +} VMRMode; + +enum { + MAX_NUMBER_OF_STREAMS = 16 +}; + +[ + object, + local, + uuid(9e5530c5-7034-48b4-bb46-0b8a6efc8e36), + helpstring("IVMRFilterConfig Interface"), + pointer_default(unique) +] +interface IVMRFilterConfig : IUnknown +{ + HRESULT SetImageCompositor( + [in] IVMRImageCompositor* lpVMRImgCompositor + ); + + HRESULT SetNumberOfStreams( + [in] DWORD dwMaxStreams + ); + + HRESULT GetNumberOfStreams( + [out] DWORD* pdwMaxStreams + ); + + HRESULT SetRenderingPrefs( + [in] DWORD dwRenderFlags // a combination of VMRRenderingPrefFlags + ); + + HRESULT GetRenderingPrefs( + [out] DWORD* pdwRenderFlags + ); + + HRESULT SetRenderingMode( + [in] DWORD Mode // a combination of VMRMode + ); + + HRESULT GetRenderingMode( + [out] DWORD* pMode + ); +} + + +//===================================================================== +// +// IVMRAspectRatioControl +// +//===================================================================== +[ + object, + local, + uuid(ede80b5c-bad6-4623-b537-65586c9f8dfd), + helpstring("IVMRAspectRatioControl Interface"), + pointer_default(unique) +] +interface IVMRAspectRatioControl : IUnknown +{ + HRESULT GetAspectRatioMode( + [out] LPDWORD lpdwARMode + ); + + HRESULT SetAspectRatioMode( + [in] DWORD dwARMode + ); +} + + +//===================================================================== +// +// IVMRDeinterlaceControl +// +// New interfaced introduced into the WindowsXP SP1 release of the VMR. +// This interface allows applications to control the DX-VA deinterlacing +// support provided by the VMR. +// +// The VMR needs to be set into "mixing" mode for this interface to work. +// +// SetDeinterlaceMode is only effective for new connections made to the +// VMR. It should be noted that the graphics device driver may refuse +// to use the specified deinterlace mode, in which case 3 fallback +// policies are offered by the VMR, these being: +// +// 1. Fallback to the next best mode offered by the driver. +// 2. Fallback to the BOB deinterlace mode. +// 3. Fallback to the WEAVE deinterlace mode (ie. turn deinterlacing off). +// +//===================================================================== + +typedef enum { + DeinterlacePref_NextBest = 0x01, + DeinterlacePref_BOB = 0x02, + DeinterlacePref_Weave = 0x04, + DeinterlacePref_Mask = 0x07 +} VMRDeinterlacePrefs; + +typedef enum { + + // the algorithm is unknown or proprietary + DeinterlaceTech_Unknown = 0x0000, + + // the algorithm creates the missing lines by repeating + // the line either above or below it - this method will look very jaggy and + // isn't recommended + DeinterlaceTech_BOBLineReplicate = 0x0001, + + + // the algorithm creates the missing lines by vertically stretching each + // video field by a factor of two, for example by averaging two lines or + // using a [-1, 9, 9, -1]/16 filter across four lines. + // Slight vertical adjustments are made to ensure that the resulting image + // does not "bob" up and down. + DeinterlaceTech_BOBVerticalStretch = 0x0002, + + // the pixels in the missing line are recreated by a median filtering operation + DeinterlaceTech_MedianFiltering = 0x0004, + + // the pixels in the missing line are recreated by an edge filter. + // In this process, spatial directional filters are applied to determine + // the orientation of edges in the picture content, and missing + // pixels are created by filtering along (rather than across) the + // detected edges. + DeinterlaceTech_EdgeFiltering = 0x0010, + + // the pixels in the missing line are recreated by switching on a field by + // field basis between using either spatial or temporal interpolation + // depending on the amount of motion. + DeinterlaceTech_FieldAdaptive = 0x0020, + + // the pixels in the missing line are recreated by switching on a pixel by pixel + // basis between using either spatial or temporal interpolation depending on + // the amount of motion.. + DeinterlaceTech_PixelAdaptive = 0x0040, + + // Motion Vector Steering identifies objects within a sequence of video + // fields. The missing pixels are recreated after first aligning the + // movement axes of the individual objects in the scene to make them + // parallel with the time axis. + DeinterlaceTech_MotionVectorSteered = 0x0080 + +} VMRDeinterlaceTech; + +typedef struct _VMRFrequency { + DWORD dwNumerator; + DWORD dwDenominator; +} VMRFrequency; + +typedef struct _VMRVideoDesc { + DWORD dwSize; + DWORD dwSampleWidth; + DWORD dwSampleHeight; + BOOL SingleFieldPerSample; + DWORD dwFourCC; + VMRFrequency InputSampleFreq; + VMRFrequency OutputFrameFreq; +} VMRVideoDesc; + +typedef struct _VMRDeinterlaceCaps { + DWORD dwSize; + DWORD dwNumPreviousOutputFrames; + DWORD dwNumForwardRefSamples; + DWORD dwNumBackwardRefSamples; + VMRDeinterlaceTech DeinterlaceTechnology; +} VMRDeinterlaceCaps; + +[ + object, + local, + uuid(bb057577-0db8-4e6a-87a7-1a8c9a505a0f), + helpstring("IVMRDeinterlaceControl Interface"), + pointer_default(unique) +] +interface IVMRDeinterlaceControl : IUnknown +{ + // + // For the specified video description returns the + // number of deinterlacing modes available to the VMR. + // The deinterlacing modes are returned in descending + // quality order ie. the best quality mode is at + // lpdwNumDeinterlaceModes[0], the next best at + // lpdwNumDeinterlaceModes[1] and so on. + // + // To determine how big an array of guids to pass to the + // GetNumberOfDeinterlaceModes method call + // GetNumberOfDeinterlaceModes(lpVideoDescription, &dwNumModes, NULL); + // + HRESULT GetNumberOfDeinterlaceModes( + [in] VMRVideoDesc* lpVideoDescription, + [in] [out] LPDWORD lpdwNumDeinterlaceModes, + [out] LPGUID lpDeinterlaceModes + ); + + // + // For the given video description get the capabilities of the + // specified de-interlace mode. + // + HRESULT GetDeinterlaceModeCaps( + [in] LPGUID lpDeinterlaceMode, + [in] VMRVideoDesc* lpVideoDescription, + [in] [out] VMRDeinterlaceCaps* lpDeinterlaceCaps + ); + + // + // Get/Set the deinterlace mode that you would like the + // VMR to use when de-interlacing the specified stream. + // It should be noted that the VMR may not actually be able + // to use the requested deinterlace mode, in which case the + // the VMR will fall back to other de-interlace modes as specified + // by the de-interlace preferences (see SetDeinterlacePrefs below). + // + HRESULT GetDeinterlaceMode( + [in] DWORD dwStreamID, + [out] LPGUID lpDeinterlaceMode // returns GUID_NULL if SetDeinterlaceMode + ); // has not been called yet. + + HRESULT SetDeinterlaceMode( + [in] DWORD dwStreamID, // use 0xFFFFFFFF to set mode for all streams + [in] LPGUID lpDeinterlaceMode // GUID_NULL == turn deinterlacing off + ); + + + HRESULT GetDeinterlacePrefs( + [out] LPDWORD lpdwDeinterlacePrefs + ); + + HRESULT SetDeinterlacePrefs( + [in] DWORD dwDeinterlacePrefs + ); + + // + // Get the DeinterlaceMode currently in use for the specified + // video stream (ie. pin). The returned GUID will be NULL if + // the de-interlacing h/w has not been created by the VMR at the + // time the function is called, or if the VMR determines that + // this stream should not or can be de-interlaced. + // + HRESULT GetActualDeinterlaceMode( + [in] DWORD dwStreamID, + [out] LPGUID lpDeinterlaceMode + ); +} + + +//===================================================================== +// +// IVMRMixerBitmap +// +//===================================================================== +typedef struct _VMRALPHABITMAP +{ + DWORD dwFlags; // flags word + HDC hdc; // DC for the bitmap to copy + LPDIRECTDRAWSURFACE7 pDDS; // DirectDraw surface to copy + RECT rSrc; // rectangle to copy from the DC/DDS + NORMALIZEDRECT rDest; // output rectangle in composition space + FLOAT fAlpha; // opacity of the bitmap + COLORREF clrSrcKey; // src color key +} VMRALPHABITMAP, *PVMRALPHABITMAP; + +// Disable the alpha bitmap for now +cpp_quote("#define VMRBITMAP_DISABLE 0x00000001") + +// Take the bitmap from the HDC rather than the DirectDraw surface +cpp_quote("#define VMRBITMAP_HDC 0x00000002") + +// Take the entire DDraw surface - rSrc is ignored +cpp_quote("#define VMRBITMAP_ENTIREDDS 0x00000004") + +// Indicates that the clrTrans value is valid and should be +// used when blending +cpp_quote("#define VMRBITMAP_SRCCOLORKEY 0x00000008") + +// Indicates that the rSrc rectangle is valid and specifies a +// sub-rectangle of the of original app image to be blended. +// Use of this parameter enables "Image Strips" +cpp_quote("#define VMRBITMAP_SRCRECT 0x00000010") + +[ + object, + local, + uuid(1E673275-0257-40aa-AF20-7C608D4A0428), + helpstring("IVMRMixerBitmap Interface"), + pointer_default(unique) +] +interface IVMRMixerBitmap : IUnknown +{ + // Set bitmap, location to blend it, and blending value + HRESULT SetAlphaBitmap( + [in] const VMRALPHABITMAP *pBmpParms + ); + + // Change bitmap location, size and blending value, + // graph must be running for change to take effect. + HRESULT UpdateAlphaBitmapParameters( + [in] PVMRALPHABITMAP pBmpParms + ); + + // Get bitmap, location to blend it, and blending value + HRESULT GetAlphaBitmapParameters( + [out] PVMRALPHABITMAP pBmpParms + ); +}; + + + + + +//===================================================================== +// +// IVMRImageCompositor +// +//===================================================================== + +typedef struct _VMRVIDEOSTREAMINFO { + LPDIRECTDRAWSURFACE7 pddsVideoSurface; + DWORD dwWidth, dwHeight; + DWORD dwStrmID; + FLOAT fAlpha; + DDCOLORKEY ddClrKey; + NORMALIZEDRECT rNormal; +} VMRVIDEOSTREAMINFO; +[ + local, + object, + local, + uuid(7a4fb5af-479f-4074-bb40-ce6722e43c82), + helpstring("IVMRImageCompositor Interface"), + pointer_default(unique) +] +interface IVMRImageCompositor : IUnknown +{ + HRESULT InitCompositionTarget( + [in] IUnknown* pD3DDevice, + [in] LPDIRECTDRAWSURFACE7 pddsRenderTarget + ); + + HRESULT TermCompositionTarget( + [in] IUnknown* pD3DDevice, + [in] LPDIRECTDRAWSURFACE7 pddsRenderTarget + ); + + HRESULT SetStreamMediaType( + [in] DWORD dwStrmID, + [in] AM_MEDIA_TYPE* pmt, + [in] BOOL fTexture + ); + + HRESULT CompositeImage( + [in] IUnknown* pD3DDevice, + [in] LPDIRECTDRAWSURFACE7 pddsRenderTarget, + [in] AM_MEDIA_TYPE* pmtRenderTarget, + [in] REFERENCE_TIME rtStart, + [in] REFERENCE_TIME rtEnd, + [in] DWORD dwClrBkGnd, + [in] VMRVIDEOSTREAMINFO* pVideoStreamInfo, + [in] UINT cStreams + ); +}; + + + +//===================================================================== +// +// IVMRVideoStreamControl +// +//===================================================================== +[ + object, + local, + uuid(058d1f11-2a54-4bef-bd54-df706626b727), + helpstring("IVMRMixerStreamConfig Interface"), + pointer_default(unique) +] +interface IVMRVideoStreamControl: IUnknown +{ + HRESULT SetColorKey( + [in] LPDDCOLORKEY lpClrKey // Source color key, set to 0xFFFFFFFF to disable + ); + + HRESULT GetColorKey( + [out] LPDDCOLORKEY lpClrKey + ); + + + HRESULT SetStreamActiveState( + [in] BOOL fActive + ); + + HRESULT GetStreamActiveState( + [out] BOOL* lpfActive + ); +}; + + + +//===================================================================== +// +// IVMRSurface +// +//===================================================================== +[ + local, + object, + local, + uuid(a9849bbe-9ec8-4263-b764-62730f0d15d0), + helpstring("IVMRSurface Interface"), + pointer_default(unique) +] +interface IVMRSurface : IUnknown +{ + HRESULT IsSurfaceLocked(); + + HRESULT LockSurface( + [out] BYTE** lpSurface + ); + + HRESULT UnlockSurface(); + + HRESULT GetSurface( + [out] LPDIRECTDRAWSURFACE7 *lplpSurface + ); +}; + + + +//===================================================================== +// +// IID_IVMRImagePresenterConfig - this interface allows applications +// to configure the default Microsoft provided allocator-presenter +// inorder to simplify the implementation of their own +// allocator-presenter plug-in. +// +//===================================================================== +[ + local, + object, + local, + uuid(9f3a1c85-8555-49ba-935f-be5b5b29d178), + helpstring("IVMRImagePresenterConfig Interface"), + pointer_default(unique) +] + +interface IVMRImagePresenterConfig : IUnknown +{ + + HRESULT SetRenderingPrefs( + [in] DWORD dwRenderFlags // see VMRRenderPrefs for valid flags + ); + + HRESULT GetRenderingPrefs( + [out] DWORD* dwRenderFlags // see VMRRenderPrefs for valid flags + ); + +} + +//===================================================================== +// +// IID_IVMRImagePresenterExclModeConfig - this interface allows applications +// to configure the DDraw exclusive mode allocator-presenter. This +// interface extends the IVMRImagePresenterConfig interface defined +// above and is only implemented by the CLSID_AllocPresenterDDXclMode +// allocator-presenter object. +// +//===================================================================== +[ + local, + object, + local, + uuid(e6f7ce40-4673-44f1-8f77-5499d68cb4ea), + helpstring("IVMRImagePresenterExclModeConfig Interface"), + pointer_default(unique) +] + +interface IVMRImagePresenterExclModeConfig : IVMRImagePresenterConfig +{ + HRESULT SetXlcModeDDObjAndPrimarySurface( + [in] LPDIRECTDRAW7 lpDDObj, + [in] LPDIRECTDRAWSURFACE7 lpPrimarySurf + ); + + HRESULT GetXlcModeDDObjAndPrimarySurface( + [out] LPDIRECTDRAW7* lpDDObj, + [out] LPDIRECTDRAWSURFACE7* lpPrimarySurf + ); +} + + +//===================================================================== +// +// IVPManager +// +//===================================================================== +[ + local, + object, + local, + uuid(aac18c18-e186-46d2-825d-a1f8dc8e395a), + helpstring("IVPManager Interface"), + pointer_default(unique) +] +interface IVPManager : IUnknown +{ + // Use this method on a Multi-Monitor system to specify to the + // video port manager filter which videoport index is used + // to an upstream decoder filter. + // + HRESULT SetVideoPortIndex( + [in] DWORD dwVideoPortIndex // the video port number that this is connected to + ); + + // This method returns the current video port index being used by the VPM. + // + HRESULT GetVideoPortIndex( + [out] DWORD* pdwVideoPortIndex // the video port number that this is connected to + ); +}; + |