archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/multimedia/dshow/filters/image2/video/vmrenderer.h

880 lines
29 KiB
Raw Blame History

/******************************Module*Header*******************************\
* Module Name: VMRenderer.h
*
*
*
*
* Created: Tue 02/15/2000
* Author: Stephen Estrop [StEstrop]
*
* Copyright (c) 2000 Microsoft Corporation
\**************************************************************************/
#include "VMRuuids.h"
#include "alloclib.h"
#include "CVMRMediaSample.h"
#include "vmrwinctrl.h"
#include "vmrwindow.h"
#include "vmrp.h"
#include "ddva.h"
#include "videoacc.h"
class CVMRInputPin;
class CVMRFilter;
class CVMRAllocator;
class CVMRRendererMacroVision;
class CVMRDeinterlaceContainer;
extern const AMOVIESETUP_FILTER sudVMRFilter;
class CVMRDeinterlaceContainer {
public:
CVMRDeinterlaceContainer(LPDIRECTDRAW7 pDD, HRESULT* phr);
~CVMRDeinterlaceContainer();
HRESULT QueryAvailableModes(
LPDXVA_VideoDesc lpVideoDescription,
LPDWORD lpdwNumModesSupported,
LPGUID pGuidsDeinterlaceModes
);
HRESULT QueryModeCaps(
LPGUID pGuidDeinterlaceMode,
LPDXVA_VideoDesc lpVideoDescription,
LPDXVA_DeinterlaceCaps lpDeinterlaceCaps
);
private:
IDDVideoAcceleratorContainer* m_pIDDVAContainer;
IDirectDrawVideoAccelerator* m_pIDDVideoAccelerator;
};
//
// Combination of all the VP_TV_XXX flags (w/o _WIN_VGA) gives 0x7FFF
//
#define ValidTVStandard(dw) (dw & 0x7FFF)
//
// MacroVision implementation wrapped in a class for Video Renderer
//
class CVMRRendererMacroVision {
public:
CVMRRendererMacroVision(void) ;
~CVMRRendererMacroVision(void) ;
BOOL SetMacroVision(HMONITOR hMon, DWORD dwCPBits) ;
BOOL StopMacroVision();
HMONITOR GetCPHMonitor(void) { return m_hMon; };
private:
DWORD m_dwCPKey;
HMONITOR m_hMon;
};
/* -------------------------------------------------------------------------
** Dedicated Mixer Pin allocator class
** -------------------------------------------------------------------------
*/
class CVMRPinAllocator :
public CBaseAllocator
{
friend class CVMRFilter;
friend class CVMRInputPin;
public:
CVMRPinAllocator(CVMRInputPin* pPin, CCritSec *pLock, HRESULT *phr);
// Overriden to delegate reference counts to the pin
STDMETHODIMP_(ULONG) NonDelegatingAddRef();
STDMETHODIMP_(ULONG) NonDelegatingRelease();
STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,VOID **ppv);
STDMETHODIMP SetProperties(
ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual);
STDMETHODIMP GetBuffer(
IMediaSample **ppSample, REFERENCE_TIME *pStartTime,
REFERENCE_TIME *pEndTime, DWORD dwFlags);
STDMETHODIMP ReleaseBuffer(IMediaSample *pMediaSample);
// Check all samples are returned
BOOL CanFree() const
{
return m_lFree.GetCount() == m_lAllocated;
}
private:
void Free();
HRESULT Alloc();
private:
CVMRInputPin* m_pPin;
CCritSec* m_pInterfaceLock;
};
//
// these values are used to do sanity checking mostly
//
#define MAX_COMPRESSED_TYPES 10
#define MAX_COMPRESSED_BUFFERS 20
typedef struct _tag_SURFACE_INFO {
LPDIRECTDRAWSURFACE7 pSurface;
union {
LPVOID pBuffer; // NULL if not locked
DWORD_PTR InUse;
};
} SURFACE_INFO, *LPSURFACE_INFO;
typedef struct _tag_COMP_SURFACE_INFO {
DWORD dwAllocated;
LPSURFACE_INFO pSurfInfo;
} COMP_SURFACE_INFO, *LPCOMP_SURFACE_INFO;
enum {
AM_VIDEOACCELERATOR = 0x01,
AM_IMEMINPUTPIN = 0x02
};
/* -------------------------------------------------------------------------
** New Renderer's input pin
** -------------------------------------------------------------------------
*/
class CVMRInputPin :
public CBaseInputPin,
public IPinConnection,
public IAMVideoAccelerator,
public IVMRVideoStreamControl
{
public:
DECLARE_IUNKNOWN
CVMRInputPin(DWORD dwID, CVMRFilter* pRenderer,
CCritSec *pLock, HRESULT *phr, LPCWSTR Name);
virtual ~CVMRInputPin();
// Overriden to delegate reference counts to the filter
STDMETHODIMP_(ULONG) NonDelegatingAddRef();
STDMETHODIMP_(ULONG) NonDelegatingRelease();
STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,VOID **ppv);
// IPinConnection
//
// This interface is implemented to allow the VMR to support dynamice
// pin reconnections.
//
STDMETHODIMP DynamicQueryAccept(const AM_MEDIA_TYPE *pmt);
STDMETHODIMP NotifyEndOfStream(HANDLE hNotifyEvent);
STDMETHODIMP IsEndPin();
STDMETHODIMP DynamicDisconnect();
// IOverlay
//
// This interface is only added to support old applications that want to
// know the VMR's window handle. This interface is only obtainable when
// the VMR is in Window'ed mode. New applications should be written to the
// WindowLess mode and therefore already know the window handle of the
// playback window (because they created the thing!).
//
// The VMR will not allow upstream filters to connect using this interface,
// that is the VMR should only expose the interface after a connection
// (via IMemInputPin or IAMVideoAccelerator) has been made. Note that
// this interface is implemented as a nested class, this is so that we
// we can have "proper" Set/GetColorKey functions on the IVMRPinConfig
// interface that don't clash with the functions of the same name in this
// interface.
//
class CIIOverlay : public IOverlay {
LONG m_cRef;
CVMRInputPin* m_pObj;
public:
CIIOverlay(CVMRInputPin* pObj) :
m_cRef(0), m_pObj(pObj) {}
STDMETHODIMP_(ULONG) AddRef()
{
return (ULONG)++m_cRef;
}
STDMETHODIMP_(ULONG) Release()
{
return (ULONG)--m_cRef;
}
STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
{
return m_pObj->QueryInterface(riid, ppv);
}
STDMETHODIMP GetPalette(DWORD *, PALETTEENTRY**) { return E_NOTIMPL;}
STDMETHODIMP SetPalette(DWORD, PALETTEENTRY*) { return E_NOTIMPL;}
STDMETHODIMP GetDefaultColorKey(COLORKEY*) { return E_NOTIMPL;}
STDMETHODIMP GetColorKey(COLORKEY*) { return E_NOTIMPL;}
STDMETHODIMP SetColorKey(COLORKEY*) { return E_NOTIMPL;}
STDMETHODIMP GetWindowHandle(HWND* pHwnd) {
return m_pObj->GetWindowHandle(pHwnd);
}
STDMETHODIMP GetClipList(RECT*, RECT*, RGNDATA**) { return E_NOTIMPL;}
STDMETHODIMP GetVideoPosition(RECT*, RECT*) { return E_NOTIMPL;}
STDMETHODIMP Advise(IOverlayNotify*, DWORD) { return E_NOTIMPL;}
STDMETHODIMP Unadvise() { return E_NOTIMPL;}
};
// IAMVideoAccelerator
STDMETHODIMP GetVideoAcceleratorGUIDs(
LPDWORD pdwNumGuidsSupported,
LPGUID pGuidsSupported
);
STDMETHODIMP GetUncompFormatsSupported(
const GUID* pGuid,
LPDWORD pdwNumFormatsSupported,
LPDDPIXELFORMAT pFormatsSupported
);
STDMETHODIMP GetInternalMemInfo(
const GUID* pGuid,
const AMVAUncompDataInfo* pamvaUncompDataInfo,
LPAMVAInternalMemInfo pamvaInternalMemInfo
);
STDMETHODIMP GetCompBufferInfo(
const GUID* pGuid,
const AMVAUncompDataInfo* pamvaUncompDataInfo,
LPDWORD pdwNumTypesCompBuffers,
LPAMVACompBufferInfo pamvaCCompBufferInfo
);
STDMETHODIMP GetInternalCompBufferInfo(
LPDWORD pdwNumTypesCompBuffers,
LPAMVACompBufferInfo pamvaCCompBufferInfo
);
STDMETHODIMP BeginFrame(
const AMVABeginFrameInfo* pamvaBeginFrameInfo
);
STDMETHODIMP EndFrame(
const AMVAEndFrameInfo* pEndFrameInfo
);
STDMETHODIMP GetBuffer(
DWORD dwTypeIndex,
DWORD dwBufferIndex,
BOOL bReadOnly,
LPVOID* ppBuffer,
LPLONG lpStride
);
STDMETHODIMP ReleaseBuffer(
DWORD dwTypeIndex,
DWORD dwBufferIndex
);
STDMETHODIMP Execute(
DWORD dwFunction,
LPVOID lpPrivateInputData,
DWORD cbPrivateInputData,
LPVOID lpPrivateOutputData,
DWORD cbPrivateOutputData,
DWORD dwNumBuffers,
const AMVABUFFERINFO *pAMVABufferInfo
);
STDMETHODIMP QueryRenderStatus(
DWORD dwTypeIndex,
DWORD dwBufferIndex,
DWORD dwFlags
);
STDMETHODIMP DisplayFrame(
DWORD dwFlipToIndex,
IMediaSample *pMediaSample
);
// Override ReceiveConnection to allow format changes while running
STDMETHODIMP ReceiveConnection(IPin * pConnector, const AM_MEDIA_TYPE *pmt);
STDMETHODIMP Disconnect();
// connection related functions
HRESULT BreakConnect();
HRESULT CompleteConnect(IPin *pReceivePin);
HRESULT SetMediaType(const CMediaType *pmt);
HRESULT CheckMediaType(const CMediaType* mtOut);
HRESULT DynamicCheckMediaType(const CMediaType* pmt);
HRESULT CheckInterlaceFlags(DWORD dwInterlaceFlags);
HRESULT OnAlloc(
CVMRMediaSample **ppSampleList,
LONG lSampleCount);
HRESULT OnSetProperties(
ALLOCATOR_PROPERTIES* pReq, ALLOCATOR_PROPERTIES* pAct);
HRESULT AllocateSurfaceWorker(
SURFACE_INFO* lplpDDSurf,
DDSURFACEDESC2* lpddsd,
DWORD* lpdwBuffCount,
bool fInterlaced
);
HRESULT AllocateSurface(
const AM_MEDIA_TYPE* cmt,
SURFACE_INFO** lplpDDSurfInfo,
DWORD* lpdwBackBuffer,
DWORD* lpdwSurfFlags,
DWORD Pool,
AM_MEDIA_TYPE** ppmt);
HRESULT OnGetBuffer(
IMediaSample *pSamp,REFERENCE_TIME *pSTime,
REFERENCE_TIME *pETime,DWORD dwFlags);
// allocator control
STDMETHODIMP GetAllocator(IMemAllocator **ppAllocator);
STDMETHODIMP NotifyAllocator(IMemAllocator *pAllocator,BOOL bReadOnly);
// streaming functions
HRESULT Active();
HRESULT Inactive();
STDMETHODIMP BeginFlush();
STDMETHODIMP EndFlush();
STDMETHODIMP Receive(IMediaSample *pMediaSample);
STDMETHODIMP EndOfStream();
// IVMRVideoStreamControl
// - uses p_Mixer & dwPin ID to map to the corresponding SetStreamXXX call
STDMETHODIMP SetColorKey(DDCOLORKEY* Clr);
STDMETHODIMP GetColorKey(DDCOLORKEY* pClr);
STDMETHODIMP SetStreamActiveState(BOOL fActive);
STDMETHODIMP GetStreamActiveState(BOOL* lpfActive);
HRESULT GetWindowHandle(HWND* pHwnd);
DWORD GetPinID() {
return m_dwPinID;
}
private:
friend class CVMRPinAllocator;
friend class CVMRFilter;
friend class CIIOverlay;
void DoQualityMessage();
HRESULT TryDynamicReconfiguration(IPin* pConnector,const AM_MEDIA_TYPE *pmt);
HRESULT DynamicReconfigureMEM(IPin* pConnector,const AM_MEDIA_TYPE *pmt);
HRESULT DynamicReconfigureDVA(IPin* pConnector,const AM_MEDIA_TYPE *pmt);
//
// Helper functions for the IAMVideoAccelerator connection protocol
//
SURFACE_INFO* SurfaceInfoFromTypeAndIndex(DWORD dwTypeIdx, DWORD dwBuffIdx);
HRESULT CheckValidMCConnection();
void FlipDVASurface(DWORD dwFlipToIndex,DWORD dwFlipFromIndex);
HRESULT VABreakConnect();
HRESULT VACompleteConnect(IPin *pReceivePin,const CMediaType *pMediaType);
HRESULT CreateVideoAcceleratorObject();
HRESULT InitializeUncompDataInfo(BITMAPINFOHEADER *pbmiHeader);
BOOL IsSuitableVideoAcceleratorGuid(const GUID * pGuid);
HRESULT AllocateVACompSurfaces(LPDIRECTDRAW7 pDDraw, BITMAPINFOHEADER *pbmiHdr);
HRESULT AllocateMCUncompSurfaces(const CMediaType *pMediaType,
LPDIRECTDRAW7 pDDraw, BITMAPINFOHEADER *pbmiHdr);
//
// motion comp related variables
//
HANDLE m_hDXVAEvent;
BOOL m_bVideoAcceleratorSupported;
DWORD m_dwBackBufferCount;
GUID m_mcGuid;
DDVAUncompDataInfo m_ddUncompDataInfo;
DDVAInternalMemInfo m_ddvaInternalMemInfo;
DWORD m_dwCompSurfTypes;
LPCOMP_SURFACE_INFO m_pCompSurfInfo;
IDDVideoAcceleratorContainer* m_pIDDVAContainer;
IDirectDrawVideoAccelerator* m_pIDDVideoAccelerator;
IAMVideoAcceleratorNotify* m_pIVANotify;
//
// DShow filter related variables
//
CVMRFilter* m_pRenderer;
CCritSec* m_pInterfaceLock;
CVMRPinAllocator m_PinAllocator;
CMediaType m_mtNew;
LONG m_lSampleSize;
enum {DELTA_DECODE_CHECKED = 0x01, DELTA_DECODE_MODE_SET = 0x02};
DWORD m_dwDeltaDecode;
BOOL m_fInDFC;
bool m_bDynamicFormatNeeded;
bool m_bActive;
DWORD m_dwPinID;
LPDIRECTDRAWSURFACE7 m_pDDS;
CIIOverlay m_pIOverlay;
DWORD m_RenderTransport;
//
// De-interlace variables, only relevant in mixing mode.
//
DXVA_DeinterlaceCaps m_DeinterlaceCaps;
GUID m_DeinterlaceGUID;
BOOL m_DeinterlaceUserGUIDSet;
GUID m_DeinterlaceUserGUID;
// array of DDraw surfaces in allocation order, if pBuffer is non-NULL
// then the surface is in use, the array is m_dwNumSamples big.
SURFACE_INFO* m_pVidSurfs;
// array of video samples in temporal order, the array
// is only allocated when we are de-interlacing, the array
// is m_dwNumHistorySamples big.
DXVA_VideoSample* m_pVidHistorySamps;
DWORD m_dwNumSamples;
DWORD m_dwNumHistorySamples;
BOOL m_InterlacedStream;
REFERENCE_TIME m_SamplePeriod;
DWORD m_SampleCount;
CCritSec m_DeinterlaceLock;
HRESULT GetStreamInterlaceProperties(
const AM_MEDIA_TYPE *pMT,
BOOL* lpIsInterlaced,
GUID* lpDeintGuid,
DXVA_DeinterlaceCaps* pCaps);
void ReleaseAllocatedSurfaces() {
if (m_pVidSurfs) {
//
// delete the surfaces in reverse order.
//
DWORD dwNumSamples = m_dwNumSamples - 1;
for (DWORD i = 0; i < m_dwNumSamples; i++) {
RELEASE(m_pVidSurfs[dwNumSamples - i].pSurface);
}
m_dwNumSamples = 0;
delete [] m_pVidSurfs;
m_pVidSurfs = NULL;
}
if (m_pVidHistorySamps) {
m_dwNumHistorySamples = 0;
delete [] m_pVidHistorySamps;
m_pVidHistorySamps = NULL;
}
}
BOOL m_FrontBufferStale;
void FrontBufferStale(BOOL bStale) {
if (bStale) {
m_dwDeltaDecode = 0;
}
m_FrontBufferStale = bStale;
}
BOOL IsFrontBufferStale() {
return m_FrontBufferStale;
}
BOOL m_bConnected;
void CompletelyConnected(BOOL bConnected) {
m_bConnected = bConnected;
}
BOOL IsCompletelyConnected() {
return m_bConnected;
}
//
// IPinConnection stuff
//
HANDLE m_hEndOfStream;
};
/* -------------------------------------------------------------------------
** New Renderer's filter
** -------------------------------------------------------------------------
*/
class CVMRFilter :
public CBaseFilter,
public CPersistStream,
public IQualProp,
public IQualityControl,
public IAMFilterMiscFlags,
public IKsPropertySet,
public IVMRWindowlessControl,
public IVMRMixerControl,
public IVMRFilterConfig,
public IVMRFilterConfigInternal,
public IVMRMonitorConfig,
public IVMRMixerBitmap,
public IVMRDeinterlaceControl,
public ISpecifyPropertyPages
{
public:
DECLARE_IUNKNOWN
STDMETHODIMP NonDelegatingQueryInterface(REFIID, void**);
static CUnknown *CreateInstance(LPUNKNOWN, HRESULT *);
static CUnknown *CreateInstance2(LPUNKNOWN, HRESULT *);
static void InitClass(BOOL bLoading, const CLSID *clsid);
int NumInputPinsConnected() const;
CVMRFilter(TCHAR *pName, LPUNKNOWN pUnk, HRESULT *phr, BOOL fDefault);
virtual ~CVMRFilter();
void VMRCleanUp();
CBasePin *GetPin(int n);
int GetPinCount();
// Override the filter and pin interface functions
STDMETHODIMP JoinFilterGraph(IFilterGraph *pGraph,LPCWSTR pName);
STDMETHODIMP SetSyncSource(IReferenceClock *pClock);
STDMETHODIMP Stop();
STDMETHODIMP Pause();
STDMETHODIMP Run(REFERENCE_TIME StartTime);
STDMETHODIMP GetState(DWORD dwMSecs,FILTER_STATE *State);
HRESULT Receive(DWORD dwPinID, IMediaSample *pMediaSample);
// called when the filter changes state
HRESULT Active(DWORD dwPinID);
HRESULT Inactive(DWORD dwPinID);
HRESULT BeginFlush(DWORD dwPinID);
HRESULT EndFlush(DWORD dwPinID);
HRESULT EndOfStream(DWORD dwPinID);
HRESULT CompleteConnect(DWORD dwPinID, const CMediaType& cmt);
HRESULT RuntimeAbortPlayback(HRESULT hr);
// deal with connections
HRESULT BreakConnect(DWORD dwPinID);
HRESULT CheckMediaType(const CMediaType *);
HRESULT SetMediaType(const CMediaType *pmt);
HRESULT OnSetProperties(CVMRInputPin* pReceivePin);
// IQualProp property page support
STDMETHODIMP get_FramesDroppedInRenderer(int *cFramesDropped);
STDMETHODIMP get_FramesDrawn(int *pcFramesDrawn);
STDMETHODIMP get_AvgFrameRate(int *piAvgFrameRate);
STDMETHODIMP get_Jitter(int *piJitter);
STDMETHODIMP get_AvgSyncOffset(int *piAvg);
STDMETHODIMP get_DevSyncOffset(int *piDev);
// IQualityControl methods - Notify allows audio-video throttling
STDMETHODIMP SetSink( IQualityControl * piqc);
STDMETHODIMP Notify( IBaseFilter * pSelf, Quality q);
// IAMFilterMiscFlags
STDMETHODIMP_(ULONG) GetMiscFlags(void)
{
return AM_FILTER_MISC_FLAGS_IS_RENDERER;
}
// IVMRWindowlessControl
STDMETHODIMP GetNativeVideoSize(LONG* lWidth, LONG* lHeight,
LONG* lARWidth, LONG* lARHeight);
STDMETHODIMP GetMinIdealVideoSize(LONG* lWidth, LONG* lHeight);
STDMETHODIMP GetMaxIdealVideoSize(LONG* lWidth, LONG* lHeight);
STDMETHODIMP SetVideoPosition(const LPRECT lpSRCRect,
const LPRECT lpDSTRect);
STDMETHODIMP GetVideoPosition(LPRECT lpSRCRect,LPRECT lpDSTRect);
STDMETHODIMP GetAspectRatioMode(DWORD* lpAspectRatioMode);
STDMETHODIMP SetAspectRatioMode(DWORD AspectRatioMode);
STDMETHODIMP SetVideoClippingWindow(HWND hwnd);
STDMETHODIMP RepaintVideo(HWND hwnd, HDC hdc);
STDMETHODIMP DisplayModeChanged();
STDMETHODIMP GetCurrentImage(BYTE** lpDib);
STDMETHODIMP SetBorderColor(COLORREF Clr);
STDMETHODIMP GetBorderColor(COLORREF* lpClr);
STDMETHODIMP SetColorKey(COLORREF Clr);
STDMETHODIMP GetColorKey(COLORREF* lpClr);
// IVMRMixerControl
STDMETHODIMP SetAlpha(DWORD dwID, float Alpha);
STDMETHODIMP GetAlpha(DWORD dwID, float* Alpha);
STDMETHODIMP SetZOrder(DWORD dwID, DWORD zOrder);
STDMETHODIMP GetZOrder(DWORD dwID, DWORD* zOrder);
STDMETHODIMP SetOutputRect(DWORD dwID, const NORMALIZEDRECT *pRect);
STDMETHODIMP GetOutputRect(DWORD dwID, NORMALIZEDRECT *pRect);
STDMETHODIMP SetBackgroundClr(COLORREF clrBkg);
STDMETHODIMP GetBackgroundClr(COLORREF* lpClrBkg);
STDMETHODIMP SetMixingPrefs(DWORD dwRenderFlags);
STDMETHODIMP GetMixingPrefs(DWORD* pdwRenderFlags);
// IVMRDeinterlaceControl
STDMETHODIMP GetNumberOfDeinterlaceModes(VMRVideoDesc* lpVideoDesc,
LPDWORD lpdwNumDeinterlaceModes,
LPGUID lpDeinterlaceModes);
STDMETHODIMP GetDeinterlaceModeCaps(LPGUID lpDeinterlaceMode,
VMRVideoDesc* lpVideoDesc,
VMRDeinterlaceCaps* lpDeinterlaceCaps);
STDMETHODIMP GetDeinterlaceMode(DWORD dwStreamID,
LPGUID lpDeinterlaceMode);
STDMETHODIMP SetDeinterlaceMode(DWORD dwStreamID,
LPGUID lpDeinterlaceMode);
STDMETHODIMP GetDeinterlacePrefs(LPDWORD lpdwDeinterlacePrefs);
STDMETHODIMP SetDeinterlacePrefs(DWORD dwDeinterlacePrefs);
STDMETHODIMP GetActualDeinterlaceMode(DWORD dwStreamID,
LPGUID lpDeinterlaceMode);
//
// IKsPropertySet interface methods
//
STDMETHODIMP Set(REFGUID guidPropSet, DWORD PropID, LPVOID pInstanceData,
DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData);
STDMETHODIMP Get(REFGUID guidPropSet, DWORD PropID, LPVOID pInstanceData,
DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData,
DWORD *pcbReturned);
STDMETHODIMP QuerySupported(REFGUID guidPropSet, DWORD PropID, DWORD *pTypeSupport);
// IVMRSurfaceAllocatorNotify
class CIVMRSurfaceAllocatorNotify : public IVMRSurfaceAllocatorNotify {
LONG m_cRef;
CVMRFilter* m_pObj;
public:
CIVMRSurfaceAllocatorNotify(CVMRFilter* pObj) :
m_cRef(0), m_pObj(pObj) {}
~CIVMRSurfaceAllocatorNotify();
STDMETHODIMP_(ULONG) AddRef()
{
return InterlockedIncrement(&m_cRef);
}
STDMETHODIMP_(ULONG) Release()
{
return InterlockedDecrement(&m_cRef);
}
STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
{
return m_pObj->QueryInterface(riid, ppv);
}
STDMETHODIMP AdviseSurfaceAllocator(
DWORD_PTR dwUserID,
IVMRSurfaceAllocator* lpIVRMSurfaceAllocator
);
STDMETHODIMP SetDDrawDevice(LPDIRECTDRAW7 lpDDrawDevice, HMONITOR hMon);
STDMETHODIMP ChangeDDrawDevice(LPDIRECTDRAW7 lpDDrawDevice, HMONITOR hMon);
STDMETHODIMP RestoreDDrawSurfaces();
STDMETHODIMP NotifyEvent(LONG EventCode, LONG_PTR lp1, LONG_PTR lp2);
STDMETHODIMP SetBorderColor(COLORREF clr);
};
// IVMRImagePresenter
class CIVMRImagePresenter : public IVMRImagePresenter {
LONG m_cRef;
CVMRFilter* m_pObj;
public:
CIVMRImagePresenter(CVMRFilter* pObj) :
m_cRef(0), m_pObj(pObj) {}
STDMETHODIMP_(ULONG) AddRef()
{
return (ULONG)++m_cRef;
}
STDMETHODIMP_(ULONG) Release()
{
return (ULONG)--m_cRef;
}
STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
{
return m_pObj->QueryInterface(riid, ppv);
}
STDMETHODIMP StartPresenting(DWORD_PTR dwUserID);
STDMETHODIMP StopPresenting(DWORD_PTR dwUserID);
STDMETHODIMP PresentImage(
DWORD_PTR dwUserID,
VMRPRESENTATIONINFO* lpPresInfo
);
};
// IImageSyncNotifyEvent
class CIImageSyncNotifyEvent : public IImageSyncNotifyEvent {
LONG m_cRef;
CVMRFilter* m_pObj;
public:
CIImageSyncNotifyEvent(CVMRFilter* pObj) :
m_cRef(0), m_pObj(pObj) {}
STDMETHODIMP_(ULONG) AddRef()
{
return (ULONG)++m_cRef;
}
STDMETHODIMP_(ULONG) Release()
{
return (ULONG)--m_cRef;
}
STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
{
return m_pObj->QueryInterface(riid, ppv);
}
STDMETHODIMP NotifyEvent(long EventCode, LONG_PTR lp1, LONG_PTR lp2);
};
// CPersistStream
HRESULT WriteToStream(IStream *pStream);
HRESULT ReadFromStream(IStream *pStream);
int SizeMax();
STDMETHODIMP GetClassID(CLSID *pClsid);
// IVMRFilterConfig
STDMETHODIMP SetImageCompositor(IVMRImageCompositor* lpVMRImgCompositor);
STDMETHODIMP SetNumberOfStreams(DWORD dwMaxStreams);
STDMETHODIMP GetNumberOfStreams(DWORD* lpdwMaxStreams);
STDMETHODIMP SetRenderingPrefs(DWORD dwRenderFlags);
STDMETHODIMP GetRenderingPrefs(DWORD* pdwRenderFlags);
STDMETHODIMP SetRenderingMode(DWORD Mode);
STDMETHODIMP GetRenderingMode(DWORD* pMode);
// IVMRFilterConfigInternal
STDMETHODIMP GetAspectRatioModePrivate(DWORD* lpAspectRatioMode);
STDMETHODIMP SetAspectRatioModePrivate(DWORD AspectRatioMode);
// IVMRMonitorConfig ... proxied to To the app-presenter if it supports it
STDMETHODIMP SetMonitor( const VMRGUID *pGUID );
STDMETHODIMP GetMonitor( VMRGUID *pGUID );
STDMETHODIMP SetDefaultMonitor( const VMRGUID *pGUID );
STDMETHODIMP GetDefaultMonitor( VMRGUID *pGUID );
STDMETHODIMP GetAvailableMonitors( VMRMONITORINFO* pInfo, DWORD dwMaxInfoArraySize,
DWORD* pdwNumDevices );
// IVMRMixerBitmap
STDMETHODIMP SetAlphaBitmap( const VMRALPHABITMAP *pBmpParms );
STDMETHODIMP UpdateAlphaBitmapParameters( PVMRALPHABITMAP pBmpParms );
STDMETHODIMP GetAlphaBitmapParameters( PVMRALPHABITMAP pBmpParms );
// ISpecifyPropertyPages
STDMETHODIMP GetPages(CAUUID *pPages);
// helper for the window manager
IVMRWindowlessControl* GetWLControl() {
return m_lpWLControl;
}
HRESULT SetAbortSignal(BOOL fAbort) {
return m_lpISControl->SetAbortSignal(fAbort);
}
private:
friend class CVMRInputPin;
friend class CIVMRWindowlessControl;
friend class CIVMRSurfaceAllocatorNotify;
friend class CIVMRImagePresenter;
friend class CIImageSyncNotifyEvent;
CVMRInputPin* m_pInputPins[MAX_MIXER_PINS];
CCritSec m_InterfaceLock;// Critical section for interfaces
CCritSec m_RendererLock; // Controls access to internals
IVMRWindowlessControl* m_lpWLControl;
IVMRSurfaceAllocator* m_lpRLNotify;
IVMRImagePresenter* m_lpPresenter;
IVMRImagePresenterConfig* m_pPresenterConfig;
IVMRMonitorConfig* m_pPresenterMonitorConfig;
IVMRMixerControlInternal* m_lpMixControl;
IVMRMixerBitmap* m_lpMixBitmap;
IVMRMixerStream* m_lpMixStream;
IImageSyncControl* m_lpISControl;
IImageSync* m_lpIS;
IQualProp* m_lpISQualProp;
DWORD_PTR m_dwUserID;
DWORD m_VMRMode;
BOOL m_VMRCreateAsDefaultRenderer;
BOOL m_VMRModePassThru;
BOOL m_bModeChangeAllowed;
BOOL m_fInputPinCountSet;
DWORD m_dwNumPins;
CVMRRendererMacroVision m_MacroVision;
HMONITOR m_hMonitor;
LPDIRECTDRAW7 m_lpDirectDraw;
DDCAPS_DX7 m_ddHWCaps;
HRESULT m_hrSurfaceFlipped;
HRESULT m_hr3D;
DWORD m_ARMode;
BOOL m_bARModeDefaultSet;
DWORD m_TexCaps;
DDPIXELFORMAT m_ddpfMonitor;
DWORD m_dwDisplayChangeMask;
DWORD m_dwEndOfStreamMask;
DWORD m_dwRenderPrefs;
CRendererPosPassThru* m_pPosition; // Support IMediaSeeking
CVMRVideoWindow* m_pVideoWindow;
CVMRDeinterlaceContainer* m_pDeinterlace;
DWORD m_dwDeinterlacePrefs;
CIVMRSurfaceAllocatorNotify m_pIVMRSurfaceAllocatorNotify;
CIVMRImagePresenter m_pIVMRImagePresenter;
CIImageSyncNotifyEvent m_pIImageSyncNotifyEvent;
HRESULT ValidateIVRWindowlessControlState();
HRESULT GetMediaPositionInterface(REFIID riid, void** ppv);
HRESULT CreateDefaultAllocatorPresenter();
HRESULT SetDDrawDeviceWorker(LPDIRECTDRAW7 lpDDrawDevice, HMONITOR hMon);
HRESULT CreateExtraInputPins(DWORD dwNumPins);
void DestroyExtraInputPins();
HRESULT CreateInputPin();
HRESULT ImageSyncInit();
HRESULT MixerInit(DWORD dwNumStreams);
void AutoShowWindow();
BOOL ModeChangeAllowed();
void SetVMRMode(DWORD mode);
BOOL IsVPMConnectedToUs();
};