Samples/multimedia/directshow/baseclasses/videoctl.cpp - deps/third_party/winsdk_samples_v71 - Git at Google

 //------------------------------------------------------------------------------
 // File: VideoCtl.cpp
 //
 // Desc: DirectShow base classes.
 //
 // Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
 //------------------------------------------------------------------------------


 #include <streams.h>
 #include "ddmm.h"

 // Load a string from the resource file string table. The buffer must be at
 // least STR_MAX_LENGTH bytes. The easiest way to use this is to declare a
 // buffer in the property page class and use it for all string loading. It
 // cannot be static as multiple property pages may be active simultaneously

 LPTSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPTSTR pBuffer, int iResourceID)
 {
     if (LoadString(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH) == 0) {
         return TEXT("");
     }
     return pBuffer;
 }

 #ifdef UNICODE
 LPSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPSTR pBuffer, int iResourceID)
 {
     if (LoadStringA(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH) == 0) {
         return "";
     }
     return pBuffer;
 }
 #endif


 // Property pages typically are called through their OLE interfaces. These
 // use UNICODE strings regardless of how the binary is built. So when we
 // load strings from the resource file we sometimes want to convert them
 // to UNICODE. This method is passed the target UNICODE buffer and does a
 // convert after loading the string (if built UNICODE this is not needed)
 // On WinNT we can explicitly call LoadStringW which saves two conversions

 #ifndef UNICODE

 LPWSTR WINAPI WideStringFromResource(__out_ecount(STR_MAX_LENGTH) LPWSTR pBuffer, int iResourceID)
 {
     *pBuffer = 0;

     if (g_amPlatform == VER_PLATFORM_WIN32_NT) {
 	LoadStringW(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH);
     } else {

 	CHAR szBuffer[STR_MAX_LENGTH];
 	DWORD dwStringLength = LoadString(g_hInst,iResourceID,szBuffer,STR_MAX_LENGTH);
 	// if we loaded a string convert it to wide characters, ensuring
 	// that we also null terminate the result.
 	if (dwStringLength++) {
 	    MultiByteToWideChar(CP_ACP,0,szBuffer,dwStringLength,pBuffer,STR_MAX_LENGTH);
 	}
     }
     return pBuffer;
 }

 #endif


 // Helper function to calculate the size of the dialog

 BOOL WINAPI GetDialogSize(int iResourceID,
                           DLGPROC pDlgProc,
                           LPARAM lParam,
                           __out SIZE *pResult)
 {
     RECT rc;
     HWND hwnd;

     // Create a temporary property page

     hwnd = CreateDialogParam(g_hInst,
                              MAKEINTRESOURCE(iResourceID),
                              GetDesktopWindow(),
                              pDlgProc,
                              lParam);
     if (hwnd == NULL) {
         return FALSE;
     }

     GetWindowRect(hwnd, &rc);
     pResult->cx = rc.right - rc.left;
     pResult->cy = rc.bottom - rc.top;

     DestroyWindow(hwnd);
     return TRUE;
 }


 // Class that aggregates on the IDirectDraw interface. Although DirectDraw
 // has the ability in its interfaces to be aggregated they're not currently
 // implemented. This makes it difficult for various parts of Quartz that want
 // to aggregate these interfaces. In particular the video renderer passes out
 // media samples that expose IDirectDraw and IDirectDrawSurface. The filter
 // graph manager also exposes IDirectDraw as a plug in distributor. For these
 // objects we provide these aggregation classes that republish the interfaces

 STDMETHODIMP CAggDirectDraw::NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv)
 {
     ASSERT(m_pDirectDraw);

     // Do we have this interface

     if (riid == IID_IDirectDraw) {
         return GetInterface((IDirectDraw *)this,ppv);
     } else {
         return CUnknown::NonDelegatingQueryInterface(riid,ppv);
     }
 }


 STDMETHODIMP CAggDirectDraw::Compact()
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->Compact();
 }


 STDMETHODIMP CAggDirectDraw::CreateClipper(DWORD dwFlags, __deref_out LPDIRECTDRAWCLIPPER *lplpDDClipper, __inout_opt IUnknown *pUnkOuter)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->CreateClipper(dwFlags,lplpDDClipper,pUnkOuter);
 }


 STDMETHODIMP CAggDirectDraw::CreatePalette(DWORD dwFlags,
                                            __in LPPALETTEENTRY lpColorTable,
                                            __deref_out LPDIRECTDRAWPALETTE *lplpDDPalette,
                                            __inout_opt IUnknown *pUnkOuter)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->CreatePalette(dwFlags,lpColorTable,lplpDDPalette,pUnkOuter);
 }


 STDMETHODIMP CAggDirectDraw::CreateSurface(__in LPDDSURFACEDESC lpDDSurfaceDesc,
                                            __deref_out LPDIRECTDRAWSURFACE *lplpDDSurface,
                                            __inout_opt IUnknown *pUnkOuter)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->CreateSurface(lpDDSurfaceDesc,lplpDDSurface,pUnkOuter);
 }


 STDMETHODIMP CAggDirectDraw::DuplicateSurface(__in LPDIRECTDRAWSURFACE lpDDSurface,
                                               __deref_out LPDIRECTDRAWSURFACE *lplpDupDDSurface)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->DuplicateSurface(lpDDSurface,lplpDupDDSurface);
 }


 STDMETHODIMP CAggDirectDraw::EnumDisplayModes(DWORD dwSurfaceDescCount,
                                               __in LPDDSURFACEDESC lplpDDSurfaceDescList,
                                               __in LPVOID lpContext,
                                               __in LPDDENUMMODESCALLBACK lpEnumCallback)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->EnumDisplayModes(dwSurfaceDescCount,lplpDDSurfaceDescList,lpContext,lpEnumCallback);
 }


 STDMETHODIMP CAggDirectDraw::EnumSurfaces(DWORD dwFlags,
                                           __in LPDDSURFACEDESC lpDDSD,
                                           __in LPVOID lpContext,
                                           __in LPDDENUMSURFACESCALLBACK lpEnumCallback)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->EnumSurfaces(dwFlags,lpDDSD,lpContext,lpEnumCallback);
 }


 STDMETHODIMP CAggDirectDraw::FlipToGDISurface()
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->FlipToGDISurface();
 }


 STDMETHODIMP CAggDirectDraw::GetCaps(__out LPDDCAPS lpDDDriverCaps,__out LPDDCAPS lpDDHELCaps)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetCaps(lpDDDriverCaps,lpDDHELCaps);
 }


 STDMETHODIMP CAggDirectDraw::GetDisplayMode(__out LPDDSURFACEDESC lpDDSurfaceDesc)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetDisplayMode(lpDDSurfaceDesc);
 }


 STDMETHODIMP CAggDirectDraw::GetFourCCCodes(__inout LPDWORD lpNumCodes,__out_ecount(*lpNumCodes) LPDWORD lpCodes)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetFourCCCodes(lpNumCodes,lpCodes);
 }


 STDMETHODIMP CAggDirectDraw::GetGDISurface(__deref_out LPDIRECTDRAWSURFACE *lplpGDIDDSurface)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetGDISurface(lplpGDIDDSurface);
 }


 STDMETHODIMP CAggDirectDraw::GetMonitorFrequency(__out LPDWORD lpdwFrequency)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetMonitorFrequency(lpdwFrequency);
 }


 STDMETHODIMP CAggDirectDraw::GetScanLine(__out LPDWORD lpdwScanLine)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetScanLine(lpdwScanLine);
 }


 STDMETHODIMP CAggDirectDraw::GetVerticalBlankStatus(__out LPBOOL lpblsInVB)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->GetVerticalBlankStatus(lpblsInVB);
 }


 STDMETHODIMP CAggDirectDraw::Initialize(__in GUID *lpGUID)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->Initialize(lpGUID);
 }


 STDMETHODIMP CAggDirectDraw::RestoreDisplayMode()
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->RestoreDisplayMode();
 }


 STDMETHODIMP CAggDirectDraw::SetCooperativeLevel(HWND hWnd,DWORD dwFlags)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->SetCooperativeLevel(hWnd,dwFlags);
 }


 STDMETHODIMP CAggDirectDraw::SetDisplayMode(DWORD dwWidth,DWORD dwHeight,DWORD dwBpp)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->SetDisplayMode(dwWidth,dwHeight,dwBpp);
 }


 STDMETHODIMP CAggDirectDraw::WaitForVerticalBlank(DWORD dwFlags,HANDLE hEvent)
 {
     ASSERT(m_pDirectDraw);
     return m_pDirectDraw->WaitForVerticalBlank(dwFlags,hEvent);
 }


 // Class that aggregates an IDirectDrawSurface interface. Although DirectDraw
 // has the ability in its interfaces to be aggregated they're not currently
 // implemented. This makes it difficult for various parts of Quartz that want
 // to aggregate these interfaces. In particular the video renderer passes out
 // media samples that expose IDirectDraw and IDirectDrawSurface. The filter
 // graph manager also exposes IDirectDraw as a plug in distributor. For these
 // objects we provide these aggregation classes that republish the interfaces

 STDMETHODIMP CAggDrawSurface::NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv)
 {
     ASSERT(m_pDirectDrawSurface);

     // Do we have this interface

     if (riid == IID_IDirectDrawSurface) {
         return GetInterface((IDirectDrawSurface *)this,ppv);
     } else {
         return CUnknown::NonDelegatingQueryInterface(riid,ppv);
     }
 }


 STDMETHODIMP CAggDrawSurface::AddAttachedSurface(__in LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->AddAttachedSurface(lpDDSAttachedSurface);
 }


 STDMETHODIMP CAggDrawSurface::AddOverlayDirtyRect(__in LPRECT lpRect)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->AddOverlayDirtyRect(lpRect);
 }


 STDMETHODIMP CAggDrawSurface::Blt(__in LPRECT lpDestRect,
                                   __in LPDIRECTDRAWSURFACE lpDDSrcSurface,
                                   __in LPRECT lpSrcRect,
                                   DWORD dwFlags,
                                   __in LPDDBLTFX lpDDBltFx)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->Blt(lpDestRect,lpDDSrcSurface,lpSrcRect,dwFlags,lpDDBltFx);
 }


 STDMETHODIMP CAggDrawSurface::BltBatch(__in_ecount(dwCount) LPDDBLTBATCH lpDDBltBatch,DWORD dwCount,DWORD dwFlags)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->BltBatch(lpDDBltBatch,dwCount,dwFlags);
 }


 STDMETHODIMP CAggDrawSurface::BltFast(DWORD dwX,DWORD dwY,
                                       __in LPDIRECTDRAWSURFACE lpDDSrcSurface,
                                       __in LPRECT lpSrcRect,
                                       DWORD dwTrans)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->BltFast(dwX,dwY,lpDDSrcSurface,lpSrcRect,dwTrans);
 }


 STDMETHODIMP CAggDrawSurface::DeleteAttachedSurface(DWORD dwFlags,
                                                     __in LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->DeleteAttachedSurface(dwFlags,lpDDSAttachedSurface);
 }


 STDMETHODIMP CAggDrawSurface::EnumAttachedSurfaces(__in LPVOID lpContext,
                                                    __in LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->EnumAttachedSurfaces(lpContext,lpEnumSurfacesCallback);
 }


 STDMETHODIMP CAggDrawSurface::EnumOverlayZOrders(DWORD dwFlags,
                                                  __in LPVOID lpContext,
                                                  __in LPDDENUMSURFACESCALLBACK lpfnCallback)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->EnumOverlayZOrders(dwFlags,lpContext,lpfnCallback);
 }


 STDMETHODIMP CAggDrawSurface::Flip(__in LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride,DWORD dwFlags)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->Flip(lpDDSurfaceTargetOverride,dwFlags);
 }


 STDMETHODIMP CAggDrawSurface::GetAttachedSurface(__in LPDDSCAPS lpDDSCaps,
                                                  __deref_out LPDIRECTDRAWSURFACE *lplpDDAttachedSurface)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetAttachedSurface(lpDDSCaps,lplpDDAttachedSurface);
 }


 STDMETHODIMP CAggDrawSurface::GetBltStatus(DWORD dwFlags)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetBltStatus(dwFlags);
 }


 STDMETHODIMP CAggDrawSurface::GetCaps(__out LPDDSCAPS lpDDSCaps)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetCaps(lpDDSCaps);
 }


 STDMETHODIMP CAggDrawSurface::GetClipper(__deref_out LPDIRECTDRAWCLIPPER *lplpDDClipper)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetClipper(lplpDDClipper);
 }


 STDMETHODIMP CAggDrawSurface::GetColorKey(DWORD dwFlags,__out LPDDCOLORKEY lpDDColorKey)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetColorKey(dwFlags,lpDDColorKey);
 }


 STDMETHODIMP CAggDrawSurface::GetDC(__out HDC *lphDC)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetDC(lphDC);
 }


 STDMETHODIMP CAggDrawSurface::GetFlipStatus(DWORD dwFlags)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetFlipStatus(dwFlags);
 }


 STDMETHODIMP CAggDrawSurface::GetOverlayPosition(__out LPLONG lpdwX,__out LPLONG lpdwY)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetOverlayPosition(lpdwX,lpdwY);
 }


 STDMETHODIMP CAggDrawSurface::GetPalette(__deref_out LPDIRECTDRAWPALETTE *lplpDDPalette)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetPalette(lplpDDPalette);
 }


 STDMETHODIMP CAggDrawSurface::GetPixelFormat(__out LPDDPIXELFORMAT lpDDPixelFormat)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->GetPixelFormat(lpDDPixelFormat);
 }


 // A bit of a warning here: Our media samples in DirectShow aggregate on
 // IDirectDraw and IDirectDrawSurface (ie are available through IMediaSample
 // by QueryInterface). Unfortunately the underlying DirectDraw code cannot
 // be aggregated so we have to use these classes. The snag is that when we
 // call a different surface and pass in this interface as perhaps the source
 // surface the call will fail because DirectDraw dereferences the pointer to
 // get at its private data structures. Therefore we supply this workaround to give
 // access to the real IDirectDraw surface. A filter can call GetSurfaceDesc
 // and we will fill in the lpSurface pointer with the real underlying surface

 STDMETHODIMP CAggDrawSurface::GetSurfaceDesc(__out LPDDSURFACEDESC lpDDSurfaceDesc)
 {
     ASSERT(m_pDirectDrawSurface);

     // First call down to the underlying DirectDraw

     HRESULT hr = m_pDirectDrawSurface->GetSurfaceDesc(lpDDSurfaceDesc);
     if (FAILED(hr)) {
         return hr;
     }

     // Store the real DirectDrawSurface interface
     lpDDSurfaceDesc->lpSurface = m_pDirectDrawSurface;
     return hr;
 }


 STDMETHODIMP CAggDrawSurface::Initialize(__in LPDIRECTDRAW lpDD,__in LPDDSURFACEDESC lpDDSurfaceDesc)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->Initialize(lpDD,lpDDSurfaceDesc);
 }


 STDMETHODIMP CAggDrawSurface::IsLost()
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->IsLost();
 }


 STDMETHODIMP CAggDrawSurface::Lock(__in LPRECT lpDestRect,
                                    __inout LPDDSURFACEDESC lpDDSurfaceDesc,
                                    DWORD dwFlags,
                                    HANDLE hEvent)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->Lock(lpDestRect,lpDDSurfaceDesc,dwFlags,hEvent);
 }


 STDMETHODIMP CAggDrawSurface::ReleaseDC(HDC hDC)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->ReleaseDC(hDC);
 }


 STDMETHODIMP CAggDrawSurface::Restore()
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->Restore();
 }


 STDMETHODIMP CAggDrawSurface::SetClipper(__in LPDIRECTDRAWCLIPPER lpDDClipper)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->SetClipper(lpDDClipper);
 }


 STDMETHODIMP CAggDrawSurface::SetColorKey(DWORD dwFlags,__in LPDDCOLORKEY lpDDColorKey)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->SetColorKey(dwFlags,lpDDColorKey);
 }


 STDMETHODIMP CAggDrawSurface::SetOverlayPosition(LONG dwX,LONG dwY)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->SetOverlayPosition(dwX,dwY);
 }


 STDMETHODIMP CAggDrawSurface::SetPalette(__in LPDIRECTDRAWPALETTE lpDDPalette)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->SetPalette(lpDDPalette);
 }


 STDMETHODIMP CAggDrawSurface::Unlock(__in LPVOID lpSurfaceData)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->Unlock(lpSurfaceData);
 }


 STDMETHODIMP CAggDrawSurface::UpdateOverlay(__in LPRECT lpSrcRect,
                                             __in LPDIRECTDRAWSURFACE lpDDDestSurface,
                                             __in LPRECT lpDestRect,
                                             DWORD dwFlags,
                                             __in LPDDOVERLAYFX lpDDOverlayFX)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->UpdateOverlay(lpSrcRect,lpDDDestSurface,lpDestRect,dwFlags,lpDDOverlayFX);
 }


 STDMETHODIMP CAggDrawSurface::UpdateOverlayDisplay(DWORD dwFlags)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->UpdateOverlayDisplay(dwFlags);
 }


 STDMETHODIMP CAggDrawSurface::UpdateOverlayZOrder(DWORD dwFlags,__in LPDIRECTDRAWSURFACE lpDDSReference)
 {
     ASSERT(m_pDirectDrawSurface);
     return m_pDirectDrawSurface->UpdateOverlayZOrder(dwFlags,lpDDSReference);
 }


 // DirectShow must work on multiple platforms.  In particular, it also runs on
 // Windows NT 3.51 which does not have DirectDraw capabilities. The filters
 // cannot therefore link statically to the DirectDraw library. To make their
 // lives that little bit easier we provide this class that manages loading
 // and unloading the library and creating the initial IDirectDraw interface

 CLoadDirectDraw::CLoadDirectDraw() :
     m_pDirectDraw(NULL),
     m_hDirectDraw(NULL)
 {
 }


 // Destructor forces unload

 CLoadDirectDraw::~CLoadDirectDraw()
 {
     ReleaseDirectDraw();

     if (m_hDirectDraw) {
         NOTE("Unloading library");
         FreeLibrary(m_hDirectDraw);
     }
 }


 // We can't be sure that DirectDraw is always available so we can't statically
 // link to the library. Therefore we load the library, get the function entry
 // point addresses and call them to create the driver objects. We return S_OK
 // if we manage to load DirectDraw correctly otherwise we return E_NOINTERFACE
 // We initialise a DirectDraw instance by explicitely loading the library and
 // calling GetProcAddress on the DirectDrawCreate entry point that it exports

 // On a multi monitor system, we can get the DirectDraw object for any
 // monitor (device) with the optional szDevice parameter

 HRESULT CLoadDirectDraw::LoadDirectDraw(__in LPSTR szDevice)
 {
     PDRAWCREATE pDrawCreate;
     PDRAWENUM pDrawEnum;
     LPDIRECTDRAWENUMERATEEXA pDrawEnumEx;
     HRESULT hr = NOERROR;

     NOTE("Entering DoLoadDirectDraw");

     // Is DirectDraw already loaded

     if (m_pDirectDraw) {
         NOTE("Already loaded");
         ASSERT(m_hDirectDraw);
         return NOERROR;
     }

     // Make sure the library is available

     if(!m_hDirectDraw)
     {
         UINT ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
         m_hDirectDraw = LoadLibrary(TEXT("DDRAW.DLL"));
         SetErrorMode(ErrorMode);

         if (m_hDirectDraw == NULL) {
             DbgLog((LOG_ERROR,1,TEXT("Can't load DDRAW.DLL")));
             NOTE("No library");
             return E_NOINTERFACE;
         }
     }

     // Get the DLL address for the creator function

     pDrawCreate = (PDRAWCREATE)GetProcAddress(m_hDirectDraw,"DirectDrawCreate");
     // force ANSI, we assume it
     pDrawEnum = (PDRAWENUM)GetProcAddress(m_hDirectDraw,"DirectDrawEnumerateA");
     pDrawEnumEx = (LPDIRECTDRAWENUMERATEEXA)GetProcAddress(m_hDirectDraw,
 						"DirectDrawEnumerateExA");

     // We don't NEED DirectDrawEnumerateEx, that's just for multimon stuff
     if (pDrawCreate == NULL || pDrawEnum == NULL) {
         DbgLog((LOG_ERROR,1,TEXT("Can't get functions: Create=%x Enum=%x"),
 			pDrawCreate, pDrawEnum));
         NOTE("No entry point");
         ReleaseDirectDraw();
         return E_NOINTERFACE;
     }

     DbgLog((LOG_TRACE,3,TEXT("Creating DDraw for device %s"),
 					szDevice ? szDevice : "<NULL>"));

     // Create a DirectDraw display provider for this device, using the fancy
     // multimon-aware version, if it exists
     if (pDrawEnumEx)
         m_pDirectDraw = DirectDrawCreateFromDeviceEx(szDevice, pDrawCreate,
 								pDrawEnumEx);
     else
         m_pDirectDraw = DirectDrawCreateFromDevice(szDevice, pDrawCreate,
 								pDrawEnum);

     if (m_pDirectDraw == NULL) {
             DbgLog((LOG_ERROR,1,TEXT("Can't create DDraw")));
             NOTE("No instance");
             ReleaseDirectDraw();
             return E_NOINTERFACE;
     }
     return NOERROR;
 }


 // Called to release any DirectDraw provider we previously loaded. We may be
 // called at any time especially when something goes horribly wrong and when
 // we need to clean up before returning so we can't guarantee that all state
 // variables are consistent so free only those really allocated allocated
 // This should only be called once all reference counts have been released

 void CLoadDirectDraw::ReleaseDirectDraw()
 {
     NOTE("Releasing DirectDraw driver");

     // Release any DirectDraw provider interface

     if (m_pDirectDraw) {
         NOTE("Releasing instance");
         m_pDirectDraw->Release();
         m_pDirectDraw = NULL;
     }

 }


 // Return NOERROR (S_OK) if DirectDraw has been loaded by this object

 HRESULT CLoadDirectDraw::IsDirectDrawLoaded()
 {
     NOTE("Entering IsDirectDrawLoaded");

     if (m_pDirectDraw == NULL) {
         NOTE("DirectDraw not loaded");
         return S_FALSE;
     }
     return NOERROR;
 }


 // Return the IDirectDraw interface we look after

 LPDIRECTDRAW CLoadDirectDraw::GetDirectDraw()
 {
     NOTE("Entering GetDirectDraw");

     if (m_pDirectDraw == NULL) {
         NOTE("No DirectDraw");
         return NULL;
     }

     NOTE("Returning DirectDraw");
     m_pDirectDraw->AddRef();
     return m_pDirectDraw;
 }


 // Are we running on Direct Draw version 1?  We need to find out as
 // we rely on specific bug fixes in DirectDraw 2 for fullscreen playback. To
 // find out, we simply see if it supports IDirectDraw2.  Only version 2 and
 // higher support this.

 BOOL CLoadDirectDraw::IsDirectDrawVersion1()
 {

     if (m_pDirectDraw == NULL)
 	return FALSE;

     IDirectDraw2 *p = NULL;
     HRESULT hr = m_pDirectDraw->QueryInterface(IID_IDirectDraw2, (void **)&p);
     if (p)
 	p->Release();
     if (hr == NOERROR) {
         DbgLog((LOG_TRACE,3,TEXT("Direct Draw Version 2 or greater")));
 	return FALSE;
     } else {
         DbgLog((LOG_TRACE,3,TEXT("Direct Draw Version 1")));
 	return TRUE;
     }
 }
	//------------------------------------------------------------------------------
	// File: VideoCtl.cpp
	//
	// Desc: DirectShow base classes.
	//
	// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.
	//------------------------------------------------------------------------------


	#include <streams.h>
	#include "ddmm.h"

	// Load a string from the resource file string table. The buffer must be at
	// least STR_MAX_LENGTH bytes. The easiest way to use this is to declare a
	// buffer in the property page class and use it for all string loading. It
	// cannot be static as multiple property pages may be active simultaneously

	LPTSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPTSTR pBuffer, int iResourceID)
	{
	if (LoadString(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH) == 0) {
	return TEXT("");
	}
	return pBuffer;
	}

	#ifdef UNICODE
	LPSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPSTR pBuffer, int iResourceID)
	{
	if (LoadStringA(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH) == 0) {
	return "";
	}
	return pBuffer;
	}
	#endif



	// Property pages typically are called through their OLE interfaces. These
	// use UNICODE strings regardless of how the binary is built. So when we
	// load strings from the resource file we sometimes want to convert them
	// to UNICODE. This method is passed the target UNICODE buffer and does a
	// convert after loading the string (if built UNICODE this is not needed)
	// On WinNT we can explicitly call LoadStringW which saves two conversions

	#ifndef UNICODE

	LPWSTR WINAPI WideStringFromResource(__out_ecount(STR_MAX_LENGTH) LPWSTR pBuffer, int iResourceID)
	{
	*pBuffer = 0;

	if (g_amPlatform == VER_PLATFORM_WIN32_NT) {
	LoadStringW(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH);
	} else {

	CHAR szBuffer[STR_MAX_LENGTH];
	DWORD dwStringLength = LoadString(g_hInst,iResourceID,szBuffer,STR_MAX_LENGTH);
	// if we loaded a string convert it to wide characters, ensuring
	// that we also null terminate the result.
	if (dwStringLength++) {
	MultiByteToWideChar(CP_ACP,0,szBuffer,dwStringLength,pBuffer,STR_MAX_LENGTH);
	}
	}
	return pBuffer;
	}

	#endif


	// Helper function to calculate the size of the dialog

	BOOL WINAPI GetDialogSize(int iResourceID,
	DLGPROC pDlgProc,
	LPARAM lParam,
	__out SIZE *pResult)
	{
	RECT rc;
	HWND hwnd;

	// Create a temporary property page

	hwnd = CreateDialogParam(g_hInst,
	MAKEINTRESOURCE(iResourceID),
	GetDesktopWindow(),
	pDlgProc,
	lParam);
	if (hwnd == NULL) {
	return FALSE;
	}

	GetWindowRect(hwnd, &rc);
	pResult->cx = rc.right - rc.left;
	pResult->cy = rc.bottom - rc.top;

	DestroyWindow(hwnd);
	return TRUE;
	}


	// Class that aggregates on the IDirectDraw interface. Although DirectDraw
	// has the ability in its interfaces to be aggregated they're not currently
	// implemented. This makes it difficult for various parts of Quartz that want
	// to aggregate these interfaces. In particular the video renderer passes out
	// media samples that expose IDirectDraw and IDirectDrawSurface. The filter
	// graph manager also exposes IDirectDraw as a plug in distributor. For these
	// objects we provide these aggregation classes that republish the interfaces

	STDMETHODIMP CAggDirectDraw::NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv)
	{
	ASSERT(m_pDirectDraw);

	// Do we have this interface

	if (riid == IID_IDirectDraw) {
	return GetInterface((IDirectDraw *)this,ppv);
	} else {
	return CUnknown::NonDelegatingQueryInterface(riid,ppv);
	}
	}


	STDMETHODIMP CAggDirectDraw::Compact()
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->Compact();
	}


	STDMETHODIMP CAggDirectDraw::CreateClipper(DWORD dwFlags, __deref_out LPDIRECTDRAWCLIPPER lplpDDClipper, __inout_opt IUnknown pUnkOuter)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->CreateClipper(dwFlags,lplpDDClipper,pUnkOuter);
	}


	STDMETHODIMP CAggDirectDraw::CreatePalette(DWORD dwFlags,
	__in LPPALETTEENTRY lpColorTable,
	__deref_out LPDIRECTDRAWPALETTE *lplpDDPalette,
	__inout_opt IUnknown *pUnkOuter)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->CreatePalette(dwFlags,lpColorTable,lplpDDPalette,pUnkOuter);
	}


	STDMETHODIMP CAggDirectDraw::CreateSurface(__in LPDDSURFACEDESC lpDDSurfaceDesc,
	__deref_out LPDIRECTDRAWSURFACE *lplpDDSurface,
	__inout_opt IUnknown *pUnkOuter)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->CreateSurface(lpDDSurfaceDesc,lplpDDSurface,pUnkOuter);
	}


	STDMETHODIMP CAggDirectDraw::DuplicateSurface(__in LPDIRECTDRAWSURFACE lpDDSurface,
	__deref_out LPDIRECTDRAWSURFACE *lplpDupDDSurface)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->DuplicateSurface(lpDDSurface,lplpDupDDSurface);
	}


	STDMETHODIMP CAggDirectDraw::EnumDisplayModes(DWORD dwSurfaceDescCount,
	__in LPDDSURFACEDESC lplpDDSurfaceDescList,
	__in LPVOID lpContext,
	__in LPDDENUMMODESCALLBACK lpEnumCallback)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->EnumDisplayModes(dwSurfaceDescCount,lplpDDSurfaceDescList,lpContext,lpEnumCallback);
	}


	STDMETHODIMP CAggDirectDraw::EnumSurfaces(DWORD dwFlags,
	__in LPDDSURFACEDESC lpDDSD,
	__in LPVOID lpContext,
	__in LPDDENUMSURFACESCALLBACK lpEnumCallback)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->EnumSurfaces(dwFlags,lpDDSD,lpContext,lpEnumCallback);
	}


	STDMETHODIMP CAggDirectDraw::FlipToGDISurface()
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->FlipToGDISurface();
	}


	STDMETHODIMP CAggDirectDraw::GetCaps(__out LPDDCAPS lpDDDriverCaps,__out LPDDCAPS lpDDHELCaps)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetCaps(lpDDDriverCaps,lpDDHELCaps);
	}


	STDMETHODIMP CAggDirectDraw::GetDisplayMode(__out LPDDSURFACEDESC lpDDSurfaceDesc)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetDisplayMode(lpDDSurfaceDesc);
	}


	STDMETHODIMP CAggDirectDraw::GetFourCCCodes(__inout LPDWORD lpNumCodes,__out_ecount(*lpNumCodes) LPDWORD lpCodes)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetFourCCCodes(lpNumCodes,lpCodes);
	}


	STDMETHODIMP CAggDirectDraw::GetGDISurface(__deref_out LPDIRECTDRAWSURFACE *lplpGDIDDSurface)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetGDISurface(lplpGDIDDSurface);
	}


	STDMETHODIMP CAggDirectDraw::GetMonitorFrequency(__out LPDWORD lpdwFrequency)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetMonitorFrequency(lpdwFrequency);
	}


	STDMETHODIMP CAggDirectDraw::GetScanLine(__out LPDWORD lpdwScanLine)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetScanLine(lpdwScanLine);
	}


	STDMETHODIMP CAggDirectDraw::GetVerticalBlankStatus(__out LPBOOL lpblsInVB)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->GetVerticalBlankStatus(lpblsInVB);
	}


	STDMETHODIMP CAggDirectDraw::Initialize(__in GUID *lpGUID)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->Initialize(lpGUID);
	}


	STDMETHODIMP CAggDirectDraw::RestoreDisplayMode()
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->RestoreDisplayMode();
	}


	STDMETHODIMP CAggDirectDraw::SetCooperativeLevel(HWND hWnd,DWORD dwFlags)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->SetCooperativeLevel(hWnd,dwFlags);
	}


	STDMETHODIMP CAggDirectDraw::SetDisplayMode(DWORD dwWidth,DWORD dwHeight,DWORD dwBpp)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->SetDisplayMode(dwWidth,dwHeight,dwBpp);
	}


	STDMETHODIMP CAggDirectDraw::WaitForVerticalBlank(DWORD dwFlags,HANDLE hEvent)
	{
	ASSERT(m_pDirectDraw);
	return m_pDirectDraw->WaitForVerticalBlank(dwFlags,hEvent);
	}


	// Class that aggregates an IDirectDrawSurface interface. Although DirectDraw
	// has the ability in its interfaces to be aggregated they're not currently
	// implemented. This makes it difficult for various parts of Quartz that want
	// to aggregate these interfaces. In particular the video renderer passes out
	// media samples that expose IDirectDraw and IDirectDrawSurface. The filter
	// graph manager also exposes IDirectDraw as a plug in distributor. For these
	// objects we provide these aggregation classes that republish the interfaces

	STDMETHODIMP CAggDrawSurface::NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv)
	{
	ASSERT(m_pDirectDrawSurface);

	// Do we have this interface

	if (riid == IID_IDirectDrawSurface) {
	return GetInterface((IDirectDrawSurface *)this,ppv);
	} else {
	return CUnknown::NonDelegatingQueryInterface(riid,ppv);
	}
	}


	STDMETHODIMP CAggDrawSurface::AddAttachedSurface(__in LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->AddAttachedSurface(lpDDSAttachedSurface);
	}


	STDMETHODIMP CAggDrawSurface::AddOverlayDirtyRect(__in LPRECT lpRect)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->AddOverlayDirtyRect(lpRect);
	}


	STDMETHODIMP CAggDrawSurface::Blt(__in LPRECT lpDestRect,
	__in LPDIRECTDRAWSURFACE lpDDSrcSurface,
	__in LPRECT lpSrcRect,
	DWORD dwFlags,
	__in LPDDBLTFX lpDDBltFx)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->Blt(lpDestRect,lpDDSrcSurface,lpSrcRect,dwFlags,lpDDBltFx);
	}


	STDMETHODIMP CAggDrawSurface::BltBatch(__in_ecount(dwCount) LPDDBLTBATCH lpDDBltBatch,DWORD dwCount,DWORD dwFlags)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->BltBatch(lpDDBltBatch,dwCount,dwFlags);
	}


	STDMETHODIMP CAggDrawSurface::BltFast(DWORD dwX,DWORD dwY,
	__in LPDIRECTDRAWSURFACE lpDDSrcSurface,
	__in LPRECT lpSrcRect,
	DWORD dwTrans)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->BltFast(dwX,dwY,lpDDSrcSurface,lpSrcRect,dwTrans);
	}


	STDMETHODIMP CAggDrawSurface::DeleteAttachedSurface(DWORD dwFlags,
	__in LPDIRECTDRAWSURFACE lpDDSAttachedSurface)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->DeleteAttachedSurface(dwFlags,lpDDSAttachedSurface);
	}


	STDMETHODIMP CAggDrawSurface::EnumAttachedSurfaces(__in LPVOID lpContext,
	__in LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->EnumAttachedSurfaces(lpContext,lpEnumSurfacesCallback);
	}


	STDMETHODIMP CAggDrawSurface::EnumOverlayZOrders(DWORD dwFlags,
	__in LPVOID lpContext,
	__in LPDDENUMSURFACESCALLBACK lpfnCallback)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->EnumOverlayZOrders(dwFlags,lpContext,lpfnCallback);
	}


	STDMETHODIMP CAggDrawSurface::Flip(__in LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride,DWORD dwFlags)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->Flip(lpDDSurfaceTargetOverride,dwFlags);
	}


	STDMETHODIMP CAggDrawSurface::GetAttachedSurface(__in LPDDSCAPS lpDDSCaps,
	__deref_out LPDIRECTDRAWSURFACE *lplpDDAttachedSurface)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetAttachedSurface(lpDDSCaps,lplpDDAttachedSurface);
	}


	STDMETHODIMP CAggDrawSurface::GetBltStatus(DWORD dwFlags)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetBltStatus(dwFlags);
	}


	STDMETHODIMP CAggDrawSurface::GetCaps(__out LPDDSCAPS lpDDSCaps)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetCaps(lpDDSCaps);
	}


	STDMETHODIMP CAggDrawSurface::GetClipper(__deref_out LPDIRECTDRAWCLIPPER *lplpDDClipper)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetClipper(lplpDDClipper);
	}


	STDMETHODIMP CAggDrawSurface::GetColorKey(DWORD dwFlags,__out LPDDCOLORKEY lpDDColorKey)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetColorKey(dwFlags,lpDDColorKey);
	}


	STDMETHODIMP CAggDrawSurface::GetDC(__out HDC *lphDC)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetDC(lphDC);
	}


	STDMETHODIMP CAggDrawSurface::GetFlipStatus(DWORD dwFlags)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetFlipStatus(dwFlags);
	}


	STDMETHODIMP CAggDrawSurface::GetOverlayPosition(__out LPLONG lpdwX,__out LPLONG lpdwY)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetOverlayPosition(lpdwX,lpdwY);
	}


	STDMETHODIMP CAggDrawSurface::GetPalette(__deref_out LPDIRECTDRAWPALETTE *lplpDDPalette)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetPalette(lplpDDPalette);
	}


	STDMETHODIMP CAggDrawSurface::GetPixelFormat(__out LPDDPIXELFORMAT lpDDPixelFormat)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->GetPixelFormat(lpDDPixelFormat);
	}


	// A bit of a warning here: Our media samples in DirectShow aggregate on
	// IDirectDraw and IDirectDrawSurface (ie are available through IMediaSample
	// by QueryInterface). Unfortunately the underlying DirectDraw code cannot
	// be aggregated so we have to use these classes. The snag is that when we
	// call a different surface and pass in this interface as perhaps the source
	// surface the call will fail because DirectDraw dereferences the pointer to
	// get at its private data structures. Therefore we supply this workaround to give
	// access to the real IDirectDraw surface. A filter can call GetSurfaceDesc
	// and we will fill in the lpSurface pointer with the real underlying surface

	STDMETHODIMP CAggDrawSurface::GetSurfaceDesc(__out LPDDSURFACEDESC lpDDSurfaceDesc)
	{
	ASSERT(m_pDirectDrawSurface);

	// First call down to the underlying DirectDraw

	HRESULT hr = m_pDirectDrawSurface->GetSurfaceDesc(lpDDSurfaceDesc);
	if (FAILED(hr)) {
	return hr;
	}

	// Store the real DirectDrawSurface interface
	lpDDSurfaceDesc->lpSurface = m_pDirectDrawSurface;
	return hr;
	}


	STDMETHODIMP CAggDrawSurface::Initialize(__in LPDIRECTDRAW lpDD,__in LPDDSURFACEDESC lpDDSurfaceDesc)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->Initialize(lpDD,lpDDSurfaceDesc);
	}


	STDMETHODIMP CAggDrawSurface::IsLost()
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->IsLost();
	}


	STDMETHODIMP CAggDrawSurface::Lock(__in LPRECT lpDestRect,
	__inout LPDDSURFACEDESC lpDDSurfaceDesc,
	DWORD dwFlags,
	HANDLE hEvent)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->Lock(lpDestRect,lpDDSurfaceDesc,dwFlags,hEvent);
	}


	STDMETHODIMP CAggDrawSurface::ReleaseDC(HDC hDC)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->ReleaseDC(hDC);
	}


	STDMETHODIMP CAggDrawSurface::Restore()
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->Restore();
	}


	STDMETHODIMP CAggDrawSurface::SetClipper(__in LPDIRECTDRAWCLIPPER lpDDClipper)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->SetClipper(lpDDClipper);
	}


	STDMETHODIMP CAggDrawSurface::SetColorKey(DWORD dwFlags,__in LPDDCOLORKEY lpDDColorKey)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->SetColorKey(dwFlags,lpDDColorKey);
	}


	STDMETHODIMP CAggDrawSurface::SetOverlayPosition(LONG dwX,LONG dwY)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->SetOverlayPosition(dwX,dwY);
	}


	STDMETHODIMP CAggDrawSurface::SetPalette(__in LPDIRECTDRAWPALETTE lpDDPalette)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->SetPalette(lpDDPalette);
	}


	STDMETHODIMP CAggDrawSurface::Unlock(__in LPVOID lpSurfaceData)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->Unlock(lpSurfaceData);
	}


	STDMETHODIMP CAggDrawSurface::UpdateOverlay(__in LPRECT lpSrcRect,
	__in LPDIRECTDRAWSURFACE lpDDDestSurface,
	__in LPRECT lpDestRect,
	DWORD dwFlags,
	__in LPDDOVERLAYFX lpDDOverlayFX)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->UpdateOverlay(lpSrcRect,lpDDDestSurface,lpDestRect,dwFlags,lpDDOverlayFX);
	}


	STDMETHODIMP CAggDrawSurface::UpdateOverlayDisplay(DWORD dwFlags)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->UpdateOverlayDisplay(dwFlags);
	}


	STDMETHODIMP CAggDrawSurface::UpdateOverlayZOrder(DWORD dwFlags,__in LPDIRECTDRAWSURFACE lpDDSReference)
	{
	ASSERT(m_pDirectDrawSurface);
	return m_pDirectDrawSurface->UpdateOverlayZOrder(dwFlags,lpDDSReference);
	}


	// DirectShow must work on multiple platforms. In particular, it also runs on
	// Windows NT 3.51 which does not have DirectDraw capabilities. The filters
	// cannot therefore link statically to the DirectDraw library. To make their
	// lives that little bit easier we provide this class that manages loading
	// and unloading the library and creating the initial IDirectDraw interface

	CLoadDirectDraw::CLoadDirectDraw() :
	m_pDirectDraw(NULL),
	m_hDirectDraw(NULL)
	{
	}


	// Destructor forces unload

	CLoadDirectDraw::~CLoadDirectDraw()
	{
	ReleaseDirectDraw();

	if (m_hDirectDraw) {
	NOTE("Unloading library");
	FreeLibrary(m_hDirectDraw);
	}
	}


	// We can't be sure that DirectDraw is always available so we can't statically
	// link to the library. Therefore we load the library, get the function entry
	// point addresses and call them to create the driver objects. We return S_OK
	// if we manage to load DirectDraw correctly otherwise we return E_NOINTERFACE
	// We initialise a DirectDraw instance by explicitely loading the library and
	// calling GetProcAddress on the DirectDrawCreate entry point that it exports

	// On a multi monitor system, we can get the DirectDraw object for any
	// monitor (device) with the optional szDevice parameter

	HRESULT CLoadDirectDraw::LoadDirectDraw(__in LPSTR szDevice)
	{
	PDRAWCREATE pDrawCreate;
	PDRAWENUM pDrawEnum;
	LPDIRECTDRAWENUMERATEEXA pDrawEnumEx;
	HRESULT hr = NOERROR;

	NOTE("Entering DoLoadDirectDraw");

	// Is DirectDraw already loaded

	if (m_pDirectDraw) {
	NOTE("Already loaded");
	ASSERT(m_hDirectDraw);
	return NOERROR;
	}

	// Make sure the library is available

	if(!m_hDirectDraw)
	{
	UINT ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
	m_hDirectDraw = LoadLibrary(TEXT("DDRAW.DLL"));
	SetErrorMode(ErrorMode);

	if (m_hDirectDraw == NULL) {
	DbgLog((LOG_ERROR,1,TEXT("Can't load DDRAW.DLL")));
	NOTE("No library");
	return E_NOINTERFACE;
	}
	}

	// Get the DLL address for the creator function

	pDrawCreate = (PDRAWCREATE)GetProcAddress(m_hDirectDraw,"DirectDrawCreate");
	// force ANSI, we assume it
	pDrawEnum = (PDRAWENUM)GetProcAddress(m_hDirectDraw,"DirectDrawEnumerateA");
	pDrawEnumEx = (LPDIRECTDRAWENUMERATEEXA)GetProcAddress(m_hDirectDraw,
	"DirectDrawEnumerateExA");

	// We don't NEED DirectDrawEnumerateEx, that's just for multimon stuff
	if (pDrawCreate == NULL \|\| pDrawEnum == NULL) {
	DbgLog((LOG_ERROR,1,TEXT("Can't get functions: Create=%x Enum=%x"),
	pDrawCreate, pDrawEnum));
	NOTE("No entry point");
	ReleaseDirectDraw();
	return E_NOINTERFACE;
	}

	DbgLog((LOG_TRACE,3,TEXT("Creating DDraw for device %s"),
	szDevice ? szDevice : "<NULL>"));

	// Create a DirectDraw display provider for this device, using the fancy
	// multimon-aware version, if it exists
	if (pDrawEnumEx)
	m_pDirectDraw = DirectDrawCreateFromDeviceEx(szDevice, pDrawCreate,
	pDrawEnumEx);
	else
	m_pDirectDraw = DirectDrawCreateFromDevice(szDevice, pDrawCreate,
	pDrawEnum);

	if (m_pDirectDraw == NULL) {
	DbgLog((LOG_ERROR,1,TEXT("Can't create DDraw")));
	NOTE("No instance");
	ReleaseDirectDraw();
	return E_NOINTERFACE;
	}
	return NOERROR;
	}


	// Called to release any DirectDraw provider we previously loaded. We may be
	// called at any time especially when something goes horribly wrong and when
	// we need to clean up before returning so we can't guarantee that all state
	// variables are consistent so free only those really allocated allocated
	// This should only be called once all reference counts have been released

	void CLoadDirectDraw::ReleaseDirectDraw()
	{
	NOTE("Releasing DirectDraw driver");

	// Release any DirectDraw provider interface

	if (m_pDirectDraw) {
	NOTE("Releasing instance");
	m_pDirectDraw->Release();
	m_pDirectDraw = NULL;
	}

	}


	// Return NOERROR (S_OK) if DirectDraw has been loaded by this object

	HRESULT CLoadDirectDraw::IsDirectDrawLoaded()
	{
	NOTE("Entering IsDirectDrawLoaded");

	if (m_pDirectDraw == NULL) {
	NOTE("DirectDraw not loaded");
	return S_FALSE;
	}
	return NOERROR;
	}


	// Return the IDirectDraw interface we look after

	LPDIRECTDRAW CLoadDirectDraw::GetDirectDraw()
	{
	NOTE("Entering GetDirectDraw");

	if (m_pDirectDraw == NULL) {
	NOTE("No DirectDraw");
	return NULL;
	}

	NOTE("Returning DirectDraw");
	m_pDirectDraw->AddRef();
	return m_pDirectDraw;
	}


	// Are we running on Direct Draw version 1? We need to find out as
	// we rely on specific bug fixes in DirectDraw 2 for fullscreen playback. To
	// find out, we simply see if it supports IDirectDraw2. Only version 2 and
	// higher support this.

	BOOL CLoadDirectDraw::IsDirectDrawVersion1()
	{

	if (m_pDirectDraw == NULL)
	return FALSE;

	IDirectDraw2 *p = NULL;
	HRESULT hr = m_pDirectDraw->QueryInterface(IID_IDirectDraw2, (void **)&p);
	if (p)
	p->Release();
	if (hr == NOERROR) {
	DbgLog((LOG_TRACE,3,TEXT("Direct Draw Version 2 or greater")));
	return FALSE;
	} else {
	DbgLog((LOG_TRACE,3,TEXT("Direct Draw Version 1")));
	return TRUE;
	}
	}