You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1058 lines
31 KiB
Plaintext
1058 lines
31 KiB
Plaintext
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Public Interfaces for the DX9 Video Mixing Renderer DShow filter
|
|
//
|
|
// Copyright (c) 1999 - 2002, Microsoft Corporation. All rights reserved.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
import "unknwn.idl";
|
|
|
|
|
|
cpp_quote("#if 0")
|
|
// This is temporary work around to persuade
|
|
// MIDL to allow forward declarations.
|
|
typedef DWORD IDirect3DDevice9;
|
|
typedef DWORD IDirect3DSurface9;
|
|
typedef DWORD D3DFORMAT;
|
|
typedef DWORD D3DCOLOR;
|
|
typedef DWORD D3DPOOL;
|
|
typedef LONGLONG REFERENCE_TIME;
|
|
typedef DWORD* HMONITOR;
|
|
typedef struct {DWORD dw1; DWORD dw2;} AM_MEDIA_TYPE;
|
|
cpp_quote ("#endif")
|
|
|
|
|
|
// public interfaces supported by the VMR9
|
|
|
|
interface IVMRSurface9;
|
|
|
|
interface IVMRSurfaceAllocator9;
|
|
interface IVMRSurfaceAllocatorNotify9;
|
|
interface IVMRImagePresenter9;
|
|
interface IVMRImagePresenterConfig9;
|
|
interface IVMRMonitorConfig9;
|
|
interface IVMRWindowlessControl9;
|
|
|
|
interface IVMRMixerControl9;
|
|
interface IVMRImageCompositor9;
|
|
interface IVMRMixerBitmap9;
|
|
|
|
|
|
interface IVMRFilterConfig9;
|
|
interface IVMRAspectRatioControl9;
|
|
interface IVMRVideoStreamControl9;
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Allocator Presenter interfaces
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRImagePresenter9
|
|
//
|
|
//=====================================================================
|
|
typedef enum {
|
|
VMR9Sample_SyncPoint = 0x00000001,
|
|
VMR9Sample_Preroll = 0x00000002,
|
|
VMR9Sample_Discontinuity = 0x00000004,
|
|
VMR9Sample_TimeValid = 0x00000008,
|
|
VMR9Sample_SrcDstRectsValid= 0x00000010
|
|
} VMR9PresentationFlags;
|
|
|
|
|
|
typedef struct _VMR9PresentationInfo {
|
|
DWORD dwFlags;
|
|
IDirect3DSurface9* lpSurf;
|
|
REFERENCE_TIME rtStart;
|
|
REFERENCE_TIME rtEnd;
|
|
SIZE szAspectRatio;
|
|
RECT rcSrc;
|
|
RECT rcDst;
|
|
DWORD dwReserved1;
|
|
DWORD dwReserved2;
|
|
} VMR9PresentationInfo;
|
|
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(69188c61-12a3-40f0-8ffc-342e7b433fd7),
|
|
helpstring("IVMRImagePresenter9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRImagePresenter9 : IUnknown
|
|
{
|
|
HRESULT StartPresenting(
|
|
[in] DWORD_PTR dwUserID
|
|
);
|
|
|
|
HRESULT StopPresenting(
|
|
[in] DWORD_PTR dwUserID
|
|
);
|
|
|
|
HRESULT PresentImage(
|
|
[in] DWORD_PTR dwUserID,
|
|
[in] VMR9PresentationInfo* lpPresInfo
|
|
);
|
|
};
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRSurfaceAllocator
|
|
//
|
|
//=====================================================================
|
|
typedef enum {
|
|
// surface types/usage
|
|
VMR9AllocFlag_3DRenderTarget = 0x0001,
|
|
VMR9AllocFlag_DXVATarget = 0x0002,
|
|
|
|
//
|
|
// VMR9AllocFlag_TextureSurface can be combined with
|
|
// DXVATarget and 3DRenderTarget
|
|
//
|
|
VMR9AllocFlag_TextureSurface = 0x0004,
|
|
VMR9AllocFlag_OffscreenSurface = 0x0008,
|
|
VMR9AllocFlag_UsageReserved = 0x00F0,
|
|
VMR9AllocFlag_UsageMask = 0x00FF
|
|
|
|
// surface
|
|
} VMR9SurfaceAllocationFlags;
|
|
|
|
|
|
typedef struct _VMR9AllocationInfo {
|
|
DWORD dwFlags; // see VMR9SurfaceAllocationFlags
|
|
DWORD dwWidth;
|
|
DWORD dwHeight;
|
|
D3DFORMAT Format; // 0 means use a format compatible with the display
|
|
D3DPOOL Pool;
|
|
DWORD MinBuffers;
|
|
SIZE szAspectRatio;
|
|
SIZE szNativeSize;
|
|
} VMR9AllocationInfo;
|
|
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(8d5148ea-3f5d-46cf-9df1-d1b896eedb1f),
|
|
helpstring("IVMRSurfaceAllocator9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRSurfaceAllocator9 : IUnknown
|
|
{
|
|
HRESULT InitializeDevice(
|
|
[in] DWORD_PTR dwUserID,
|
|
[in] VMR9AllocationInfo* lpAllocInfo,
|
|
[in, out] DWORD* lpNumBuffers
|
|
);
|
|
|
|
HRESULT TerminateDevice(
|
|
[in] DWORD_PTR dwID
|
|
);
|
|
|
|
HRESULT GetSurface(
|
|
[in] DWORD_PTR dwUserID,
|
|
[in] DWORD SurfaceIndex,
|
|
[in] DWORD SurfaceFlags,
|
|
[out] IDirect3DSurface9** lplpSurface
|
|
);
|
|
|
|
HRESULT AdviseNotify(
|
|
[in] IVMRSurfaceAllocatorNotify9* lpIVMRSurfAllocNotify
|
|
);
|
|
};
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRSurfaceAllocatorNotify9
|
|
//
|
|
//=====================================================================
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(dca3f5df-bb3a-4d03-bd81-84614bfbfa0c),
|
|
helpstring("IVMRSurfaceAllocatorNotify9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRSurfaceAllocatorNotify9 : IUnknown
|
|
{
|
|
HRESULT AdviseSurfaceAllocator(
|
|
[in] DWORD_PTR dwUserID,
|
|
[in] IVMRSurfaceAllocator9* lpIVRMSurfaceAllocator
|
|
);
|
|
|
|
HRESULT SetD3DDevice(
|
|
[in] IDirect3DDevice9* lpD3DDevice,
|
|
[in] HMONITOR hMonitor
|
|
);
|
|
|
|
HRESULT ChangeD3DDevice(
|
|
[in] IDirect3DDevice9* lpD3DDevice,
|
|
[in] HMONITOR hMonitor
|
|
);
|
|
|
|
HRESULT AllocateSurfaceHelper(
|
|
[in] VMR9AllocationInfo* lpAllocInfo,
|
|
[in, out] DWORD* lpNumBuffers,
|
|
[out] IDirect3DSurface9** lplpSurface
|
|
);
|
|
|
|
HRESULT NotifyEvent(
|
|
[in] LONG EventCode,
|
|
[in] LONG_PTR Param1,
|
|
[in] LONG_PTR Param2
|
|
);
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Application control and configuration interfaces
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRWindowlessControl9
|
|
//
|
|
//=====================================================================
|
|
typedef enum {
|
|
VMR9ARMode_None,
|
|
VMR9ARMode_LetterBox
|
|
} VMR9AspectRatioMode;
|
|
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(8f537d09-f85e-4414-b23b-502e54c79927),
|
|
helpstring("IVMRWindowlessControl Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRWindowlessControl9 : 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
|
|
);
|
|
};
|
|
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRMixerControl9
|
|
//
|
|
//=====================================================================
|
|
|
|
typedef enum {
|
|
MixerPref9_NoDecimation = 0x00000001, // No decimation - full size
|
|
MixerPref9_DecimateOutput = 0x00000002, // decimate output by 2 in x & y
|
|
MixerPref9_ARAdjustXorY = 0x00000004, // adjust the aspect ratio in x or y
|
|
MixerPref9_NonSquareMixing = 0x00000008, // assume AP can handle non-square mixing, avoids intermediate scales
|
|
MixerPref9_DecimateMask = 0x0000000F,
|
|
|
|
MixerPref9_BiLinearFiltering = 0x00000010, // use bi-linear filtering
|
|
MixerPref9_PointFiltering = 0x00000020, // use point filtering
|
|
MixerPref9_AnisotropicFiltering = 0x00000040, //
|
|
MixerPref9_PyramidalQuadFiltering = 0x00000080, // 4-sample tent
|
|
MixerPref9_GaussianQuadFiltering = 0x00000100, // 4-sample gaussian
|
|
MixerPref9_FilteringReserved = 0x00000E00, // bits reserved for future use.
|
|
MixerPref9_FilteringMask = 0x00000FF0, // OR of all above flags
|
|
|
|
MixerPref9_RenderTargetRGB = 0x00001000,
|
|
MixerPref9_RenderTargetYUV = 0x00002000, // Uses DXVA to perform mixing
|
|
MixerPref9_RenderTargetReserved = 0x000FC000, // bits reserved for future use.
|
|
MixerPref9_RenderTargetMask = 0x000FF000, // 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.
|
|
//
|
|
MixerPref9_DynamicSwitchToBOB = 0x00100000,
|
|
MixerPref9_DynamicDecimateBy2 = 0x00200000,
|
|
|
|
MixerPref9_DynamicReserved = 0x00C00000,
|
|
MixerPref9_DynamicMask = 0x00F00000
|
|
|
|
} VMR9MixerPrefs;
|
|
|
|
|
|
//
|
|
// 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 _VMR9NormalizedRect
|
|
{
|
|
float left;
|
|
float top;
|
|
float right;
|
|
float bottom;
|
|
} VMR9NormalizedRect;
|
|
|
|
|
|
|
|
typedef enum {
|
|
ProcAmpControl9_Brightness = 0x00000001,
|
|
ProcAmpControl9_Contrast = 0x00000002,
|
|
ProcAmpControl9_Hue = 0x00000004,
|
|
ProcAmpControl9_Saturation = 0x00000008,
|
|
ProcAmpControl9_Mask = 0x0000000F
|
|
} VMR9ProcAmpControlFlags;
|
|
|
|
typedef struct _VMR9ProcAmpControl
|
|
{
|
|
DWORD dwSize;
|
|
DWORD dwFlags;
|
|
float Brightness;
|
|
float Contrast;
|
|
float Hue;
|
|
float Saturation;
|
|
} VMR9ProcAmpControl;
|
|
|
|
typedef struct _VMR9ProcAmpControlRange
|
|
{
|
|
DWORD dwSize;
|
|
VMR9ProcAmpControlFlags dwProperty; // see VMR9ProcAmpControlFlags above
|
|
float MinValue;
|
|
float MaxValue;
|
|
float DefaultValue;
|
|
float StepSize;
|
|
} VMR9ProcAmpControlRange;
|
|
|
|
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(1a777eaa-47c8-4930-b2c9-8fee1c1b0f3b),
|
|
helpstring("IVMRMixerControl9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRMixerControl9 : 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 VMR9NormalizedRect *pRect
|
|
);
|
|
|
|
HRESULT GetOutputRect(
|
|
[in] DWORD dwStreamID,
|
|
[out] VMR9NormalizedRect *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
|
|
);
|
|
|
|
HRESULT SetProcAmpControl(
|
|
[in] DWORD dwStreamID,
|
|
[in] VMR9ProcAmpControl* lpClrControl
|
|
);
|
|
|
|
HRESULT GetProcAmpControl(
|
|
[in] DWORD dwStreamID,
|
|
[in, out] VMR9ProcAmpControl* lpClrControl
|
|
);
|
|
|
|
HRESULT GetProcAmpControlRange(
|
|
[in] DWORD dwStreamID,
|
|
[in, out] VMR9ProcAmpControlRange* lpClrControl
|
|
);
|
|
};
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRMixerBitmap9
|
|
//
|
|
//=====================================================================
|
|
|
|
typedef struct _VMR9AlphaBitmap
|
|
{
|
|
DWORD dwFlags; // flags word
|
|
HDC hdc; // DC for the bitmap to copy
|
|
IDirect3DSurface9* pDDS; // D3D surface to copy
|
|
RECT rSrc; // rectangle to copy from the DC/DDS
|
|
VMR9NormalizedRect rDest; // output rectangle in composition space
|
|
FLOAT fAlpha; // opacity of the bitmap
|
|
COLORREF clrSrcKey; // src color key
|
|
DWORD dwFilterMode; // See "SetMixerPrefs"
|
|
} VMR9AlphaBitmap;
|
|
|
|
|
|
typedef enum {
|
|
|
|
// Disable the alpha bitmap for now
|
|
VMR9AlphaBitmap_Disable = 0x00000001,
|
|
|
|
// Take the bitmap from the HDC rather than the DirectDraw surface
|
|
VMR9AlphaBitmap_hDC = 0x00000002,
|
|
|
|
// Take the entire DDraw surface - rSrc is ignored
|
|
VMR9AlphaBitmap_EntireDDS = 0x00000004,
|
|
|
|
// Indicates that the clrTrans value is valid and should be
|
|
// used when blending
|
|
VMR9AlphaBitmap_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"
|
|
VMR9AlphaBitmap_SrcRect = 0x00000010,
|
|
|
|
// Indicates that dwFilterMode parameter is valid and should be
|
|
// used to overide the default filtering method used by the VMR.
|
|
// MixerPref_PointFiltering is particulaly useful for images that
|
|
// contain text and do not need to be stretch prior to blending with
|
|
// the video content.
|
|
VMR9AlphaBitmap_FilterMode = 0x00000020
|
|
} VMR9AlphaBitmapFlags;
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(ced175e5-1935-4820-81bd-ff6ad00c9108),
|
|
helpstring("IVMRMixerBitmap Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRMixerBitmap9 : IUnknown
|
|
{
|
|
// Set bitmap, location to blend it, and blending value
|
|
HRESULT SetAlphaBitmap(
|
|
[in] const VMR9AlphaBitmap* pBmpParms
|
|
);
|
|
|
|
// Change bitmap location, size and blending value,
|
|
// graph must be running for change to take effect.
|
|
HRESULT UpdateAlphaBitmapParameters(
|
|
[in] const VMR9AlphaBitmap* pBmpParms
|
|
);
|
|
|
|
// Get bitmap, location to blend it, and blending value
|
|
HRESULT GetAlphaBitmapParameters(
|
|
[out] VMR9AlphaBitmap* pBmpParms
|
|
);
|
|
};
|
|
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRSurface9
|
|
//
|
|
//=====================================================================
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(dfc581a1-6e1f-4c3a-8d0a-5e9792ea2afc),
|
|
helpstring("IVMRSurface Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRSurface9 : IUnknown
|
|
{
|
|
HRESULT IsSurfaceLocked();
|
|
|
|
HRESULT LockSurface(
|
|
[out] BYTE** lpSurface
|
|
);
|
|
|
|
HRESULT UnlockSurface();
|
|
|
|
HRESULT GetSurface(
|
|
[out] IDirect3DSurface9** lplpSurface
|
|
);
|
|
};
|
|
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IID_IVMRImagePresenterConfig9 - this interface allows applications
|
|
// to configure the default Microsoft provided allocator-presenter
|
|
// inorder to simplify the implementation of their own
|
|
// allocator-presenter plug-in.
|
|
//
|
|
//=====================================================================
|
|
typedef enum {
|
|
RenderPrefs9_DoNotRenderBorder = 0x00000001, // app paints color keys
|
|
RenderPrefs9_Mask = 0x00000001, // OR of all above flags
|
|
} VMR9RenderPrefs;
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(45c15cab-6e22-420a-8043-ae1f0ac02c7d),
|
|
helpstring("IVMRImagePresenterConfig9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
|
|
interface IVMRImagePresenterConfig9 : IUnknown
|
|
{
|
|
|
|
HRESULT SetRenderingPrefs(
|
|
[in] DWORD dwRenderFlags // see VMRRenderPrefs for valid flags
|
|
);
|
|
|
|
HRESULT GetRenderingPrefs(
|
|
[out] DWORD* dwRenderFlags // see VMRRenderPrefs for valid flags
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRVideoStreamControl9
|
|
//
|
|
//=====================================================================
|
|
[
|
|
object,
|
|
local,
|
|
uuid(d0cfe38b-93e7-4772-8957-0400c49a4485),
|
|
helpstring("IVMRMixerStreamConfig Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRVideoStreamControl9: IUnknown
|
|
{
|
|
|
|
HRESULT SetStreamActiveState(
|
|
[in] BOOL fActive
|
|
);
|
|
|
|
HRESULT GetStreamActiveState(
|
|
[out] BOOL* lpfActive
|
|
);
|
|
};
|
|
|
|
|
|
typedef enum {
|
|
VMR9Mode_Windowed = 0x00000001,
|
|
VMR9Mode_Windowless = 0x00000002,
|
|
VMR9Mode_Renderless = 0x00000004,
|
|
|
|
// not a valid value to pass to SetRenderMode
|
|
VMR9Mode_Mask = 0x00000007, // OR of all above flags
|
|
} VMR9Mode;
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(5a804648-4f66-4867-9c43-4f5c822cf1b8),
|
|
helpstring("IVMRFilterConfig9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRFilterConfig9 : IUnknown
|
|
{
|
|
HRESULT SetImageCompositor(
|
|
[in] IVMRImageCompositor9* lpVMRImgCompositor
|
|
);
|
|
|
|
HRESULT SetNumberOfStreams(
|
|
[in] DWORD dwMaxStreams
|
|
);
|
|
|
|
HRESULT GetNumberOfStreams(
|
|
[out] DWORD* pdwMaxStreams
|
|
);
|
|
|
|
HRESULT SetRenderingPrefs(
|
|
[in] DWORD dwRenderFlags // a combination of VMR9RenderPrefs
|
|
);
|
|
|
|
HRESULT GetRenderingPrefs(
|
|
[out] DWORD* pdwRenderFlags
|
|
);
|
|
|
|
HRESULT SetRenderingMode(
|
|
[in] DWORD Mode // a combination of VMRMode
|
|
);
|
|
|
|
HRESULT GetRenderingMode(
|
|
[out] DWORD* pMode
|
|
);
|
|
}
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRAspectRatioControl9
|
|
//
|
|
//=====================================================================
|
|
[
|
|
object,
|
|
local,
|
|
uuid(00d96c29-bbde-4efc-9901-bb5036392146),
|
|
helpstring("IVMRAspectRatioControl9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRAspectRatioControl9 : IUnknown
|
|
{
|
|
HRESULT GetAspectRatioMode(
|
|
[out] LPDWORD lpdwARMode
|
|
);
|
|
|
|
HRESULT SetAspectRatioMode(
|
|
[in] DWORD dwARMode
|
|
);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// VMR Multimon configuration interface
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define VMR9DEVICENAMELEN 32
|
|
#define VMR9DEVICEDESCRIPTIONLEN 512
|
|
|
|
typedef struct _VMR9MonitorInfo {
|
|
UINT uDevID;
|
|
RECT rcMonitor;
|
|
HMONITOR hMon;
|
|
DWORD dwFlags; // described in MONITORINFOEX, currently only MONITORINFOF_PRIMARY
|
|
wchar_t szDevice[VMR9DEVICENAMELEN];
|
|
wchar_t szDescription[VMR9DEVICEDESCRIPTIONLEN];
|
|
LARGE_INTEGER liDriverVersion;
|
|
DWORD dwVendorId;
|
|
DWORD dwDeviceId;
|
|
DWORD dwSubSysId;
|
|
DWORD dwRevision;
|
|
//
|
|
} VMR9MonitorInfo;
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(46c2e457-8ba0-4eef-b80b-0680f0978749),
|
|
helpstring("IVMRMonitorConfig9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRMonitorConfig9 : 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] UINT uDev
|
|
);
|
|
|
|
// 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] UINT *puDev
|
|
);
|
|
|
|
// 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] UINT uDev
|
|
);
|
|
|
|
// 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] UINT* puDev
|
|
);
|
|
|
|
// 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)] VMR9MonitorInfo* pInfo,
|
|
[in] DWORD dwMaxInfoArraySize, // in array members
|
|
[out] DWORD* pdwNumDevices // actual number of devices retrieved
|
|
);
|
|
};
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// 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 {
|
|
DeinterlacePref9_NextBest = 0x01,
|
|
DeinterlacePref9_BOB = 0x02,
|
|
DeinterlacePref9_Weave = 0x04,
|
|
DeinterlacePref9_Mask = 0x07
|
|
} VMR9DeinterlacePrefs;
|
|
|
|
typedef enum {
|
|
|
|
// the algorithm is unknown or proprietary
|
|
DeinterlaceTech9_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
|
|
DeinterlaceTech9_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.
|
|
DeinterlaceTech9_BOBVerticalStretch = 0x0002,
|
|
|
|
// the pixels in the missing line are recreated by a median filtering operation
|
|
DeinterlaceTech9_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.
|
|
DeinterlaceTech9_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.
|
|
DeinterlaceTech9_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..
|
|
DeinterlaceTech9_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.
|
|
DeinterlaceTech9_MotionVectorSteered = 0x0080
|
|
|
|
} VMR9DeinterlaceTech;
|
|
|
|
typedef struct _VMR9Frequency {
|
|
DWORD dwNumerator;
|
|
DWORD dwDenominator;
|
|
} VMR9Frequency;
|
|
|
|
typedef enum _VMR9_SampleFormat {
|
|
VMR9_SampleReserved = 1,
|
|
VMR9_SampleProgressiveFrame = 2,
|
|
VMR9_SampleFieldInterleavedEvenFirst = 3,
|
|
VMR9_SampleFieldInterleavedOddFirst = 4,
|
|
VMR9_SampleFieldSingleEven = 5,
|
|
VMR9_SampleFieldSingleOdd = 6,
|
|
} VMR9_SampleFormat;
|
|
|
|
typedef struct _VMR9VideoDesc {
|
|
DWORD dwSize;
|
|
DWORD dwSampleWidth;
|
|
DWORD dwSampleHeight;
|
|
VMR9_SampleFormat SampleFormat;
|
|
DWORD dwFourCC;
|
|
VMR9Frequency InputSampleFreq;
|
|
VMR9Frequency OutputFrameFreq;
|
|
} VMR9VideoDesc;
|
|
|
|
|
|
typedef struct _VMR9DeinterlaceCaps {
|
|
DWORD dwSize;
|
|
DWORD dwNumPreviousOutputFrames;
|
|
DWORD dwNumForwardRefSamples;
|
|
DWORD dwNumBackwardRefSamples;
|
|
VMR9DeinterlaceTech DeinterlaceTechnology;
|
|
} VMR9DeinterlaceCaps;
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(a215fb8d-13c2-4f7f-993c-003d6271a459),
|
|
helpstring("IVMRDeinterlaceControl9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRDeinterlaceControl9 : 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] VMR9VideoDesc* 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] VMR9VideoDesc* lpVideoDescription,
|
|
[out] VMR9DeinterlaceCaps* 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
|
|
);
|
|
};
|
|
|
|
|
|
//=====================================================================
|
|
//
|
|
// IVMRImageCompositor9
|
|
//
|
|
//=====================================================================
|
|
|
|
typedef struct _VMR9VideoStreamInfo {
|
|
IDirect3DSurface9* pddsVideoSurface;
|
|
DWORD dwWidth, dwHeight;
|
|
DWORD dwStrmID;
|
|
FLOAT fAlpha;
|
|
VMR9NormalizedRect rNormal;
|
|
REFERENCE_TIME rtStart;
|
|
REFERENCE_TIME rtEnd;
|
|
VMR9_SampleFormat SampleFormat;
|
|
} VMR9VideoStreamInfo;
|
|
[
|
|
local,
|
|
object,
|
|
local,
|
|
uuid(4a5c89eb-df51-4654-ac2a-e48e02bbabf6),
|
|
helpstring("IVMRImageCompositor9 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVMRImageCompositor9 : IUnknown
|
|
{
|
|
HRESULT InitCompositionDevice(
|
|
[in] IUnknown* pD3DDevice
|
|
);
|
|
|
|
HRESULT TermCompositionDevice(
|
|
[in] IUnknown* pD3DDevice
|
|
);
|
|
|
|
HRESULT SetStreamMediaType(
|
|
[in] DWORD dwStrmID,
|
|
[in] AM_MEDIA_TYPE* pmt,
|
|
[in] BOOL fTexture
|
|
);
|
|
|
|
HRESULT CompositeImage(
|
|
[in] IUnknown* pD3DDevice,
|
|
[in] IDirect3DSurface9* pddsRenderTarget,
|
|
[in] AM_MEDIA_TYPE* pmtRenderTarget,
|
|
[in] REFERENCE_TIME rtStart,
|
|
[in] REFERENCE_TIME rtEnd,
|
|
[in] D3DCOLOR dwClrBkGnd,
|
|
[in] VMR9VideoStreamInfo* pVideoStreamInfo,
|
|
[in] UINT cStreams
|
|
);
|
|
};
|