diff options
Diffstat (limited to 'third_party/BaseClasses/videoctl.cpp')
| -rw-r--r-- | third_party/BaseClasses/videoctl.cpp | 746 |
1 files changed, 0 insertions, 746 deletions
diff --git a/third_party/BaseClasses/videoctl.cpp b/third_party/BaseClasses/videoctl.cpp deleted file mode 100644 index b12ccbd3..00000000 --- a/third_party/BaseClasses/videoctl.cpp +++ /dev/null @@ -1,746 +0,0 @@ -//------------------------------------------------------------------------------
-// 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;
- }
-}
|