xref: /AOO41X/main/canvas/source/directx/dx_5rm.cxx (revision 79aad27f7f29270c03e208e3d687e8e3850af11d)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_canvas.hxx"

#if DIRECTX_VERSION < 0x0900

// Nvidia GeForce Go 6800 crashes with a bluescreen if we take the
// maximum texture size, which would be twice as large. this behaviors
// has only been observed on directx5.
// This value is simply the maximum size for textures we request from
// the system, it has absolutely nothing to do with the size of primitives
// we're able to render, both concepts are totally independent from each other.
#define MAX_TEXTURE_SIZE (2048)
#define MIN_TEXTURE_SIZE (32)
//#define FAKE_MAX_NUMBER_TEXTURES (2)
//#define FAKE_MAX_TEXTURE_SIZE (512)

//////////////////////////////////////////////////////////////////////////////////
// includes
//////////////////////////////////////////////////////////////////////////////////
#include <vcl/syschild.hxx>
#include <vcl/window.hxx>
#include <canvas/debug.hxx>
#include <canvas/verbosetrace.hxx>
#include <canvas/elapsedtime.hxx>
#include <canvas/canvastools.hxx>
#include <canvas/rendering/icolorbuffer.hxx>
#include <canvas/rendering/isurface.hxx>
#include <canvas/rendering/irendermodule.hxx>
#include <tools/diagnose_ex.h>
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/vector/b2dsize.hxx>
#include <basegfx/vector/b2isize.hxx>
#include <basegfx/point/b2ipoint.hxx>
#include <basegfx/range/b2irectangle.hxx>
#include <boost/scoped_ptr.hpp>
#include <com/sun/star/lang/NoSupportException.hpp>

#define COMPILE_MULTIMON_STUBS

#include "dx_rendermodule.hxx"
#include "dx_surfacegraphics.hxx"
#include <vcl/sysdata.hxx>

#undef WB_LEFT
#undef WB_RIGHT

#include "dx_impltools.hxx"
#include <malloc.h>

#if defined(DX_DEBUG_IMAGES)
# if OSL_DEBUG_LEVEL > 0
#  include <imdebug.h>
#  undef min
#  undef max
# endif
#endif

#undef COMPILE_MULTIMON_STUBS

#include <stdio.h>

#define MONITOR_DEFAULTTONULL       0x00000000
#define MONITOR_DEFAULTTOPRIMARY    0x00000001
#define MONITOR_DEFAULTTONEAREST    0x00000002

using namespace ::com::sun::star;

//////////////////////////////////////////////////////////////////////////////////
// 'dxcanvas' namespace
//////////////////////////////////////////////////////////////////////////////////

namespace dxcanvas
{
	namespace
	{
        bool doBlit( const ::basegfx::B2IPoint& rDestPos,
                     IDirectDrawSurface&        rOutSurface,
                     const ::basegfx::B2IRange& rSourceArea,
                     IDirectDrawSurface&        rSourceSurface,
                     DDBLTFX*                   pBltFx,
                     bool                       bForceSoftware )
        {
            if( !bForceSoftware )
            {
                // blit surface to backbuffer
                RECT aOutRect =
                    {
                        rDestPos.getX(),
                        rDestPos.getY(),
                        rDestPos.getX() + static_cast<sal_Int32>(rSourceArea.getWidth()),
                        rDestPos.getY() + static_cast<sal_Int32>(rSourceArea.getHeight()),
                    };
                RECT aSourceRect =
                    {
                        rSourceArea.getMinX(),
                        rSourceArea.getMinY(),
                        rSourceArea.getMaxX(),
                        rSourceArea.getMaxY()
                    };

                if( SUCCEEDED(rOutSurface.Blt( &aOutRect,
                                               &rSourceSurface,
                                               &aSourceRect,
                                               DDBLT_WAIT,
                                               pBltFx )) )
                {
                    return true;
                }
            }

            // failed, or forced to use SW copy. attempt manual copy.
            bool bResult = false;

            // lock source surface
            DDSURFACEDESC aDescSrc;
            rtl_fillMemory(&aDescSrc,sizeof(DDSURFACEDESC),0);
            aDescSrc.dwSize = sizeof(DDSURFACEDESC);
            const DWORD dwSrcFlags = DDLOCK_NOSYSLOCK|
                DDLOCK_SURFACEMEMORYPTR|
                DDLOCK_WAIT|
                DDLOCK_READONLY;
            if(SUCCEEDED(rSourceSurface.Lock(NULL,
                                             &aDescSrc,
                                             dwSrcFlags,
                                             NULL)))
            {
                // lock destination surface
                DDSURFACEDESC aDescDst;
                rtl_fillMemory(&aDescDst,sizeof(DDSURFACEDESC),0);
                aDescDst.dwSize = sizeof(DDSURFACEDESC);
                const DWORD dwDstFlags = DDLOCK_NOSYSLOCK|
                    DDLOCK_SURFACEMEMORYPTR|
                    DDLOCK_WAIT|
                    DDLOCK_WRITEONLY;
                if(SUCCEEDED(rOutSurface.Lock(NULL,
                                              &aDescDst,
                                              dwDstFlags,
                                              NULL)))
                {
                    sal_uInt32 nSrcFormat;
                    nSrcFormat  = ::canvas::tools::bitcount32(aDescSrc.ddpfPixelFormat.dwRGBAlphaBitMask)<<12;
                    nSrcFormat |= ::canvas::tools::bitcount32(aDescSrc.ddpfPixelFormat.dwRBitMask)<<8;
                    nSrcFormat |= ::canvas::tools::bitcount32(aDescSrc.ddpfPixelFormat.dwGBitMask)<<4;
                    nSrcFormat |= ::canvas::tools::bitcount32(aDescSrc.ddpfPixelFormat.dwBBitMask);

                    sal_uInt32 nDstFormat;
                    nDstFormat  = ::canvas::tools::bitcount32(aDescDst.ddpfPixelFormat.dwRGBAlphaBitMask)<<12;
                    nDstFormat |= ::canvas::tools::bitcount32(aDescDst.ddpfPixelFormat.dwRBitMask)<<8;
                    nDstFormat |= ::canvas::tools::bitcount32(aDescDst.ddpfPixelFormat.dwGBitMask)<<4;
                    nDstFormat |= ::canvas::tools::bitcount32(aDescDst.ddpfPixelFormat.dwBBitMask);

                    // TODO(E1): Use numeric_cast to catch overflow here
                    const sal_uInt32 nWidth( static_cast<sal_uInt32>(
                                                   rSourceArea.getWidth() ) );
                    const sal_uInt32 nHeight( static_cast<sal_uInt32>(
                                                    rSourceArea.getHeight() ) );

                    if((nSrcFormat == 0x8888) && (nDstFormat == 0x0565))
                    {
                        // medium range 8888 to 0565 pixel format conversion.
                        bResult = true;
                        sal_uInt8 *pSrcSurface = (sal_uInt8 *)aDescSrc.lpSurface +
                            rSourceArea.getMinY()*aDescSrc.lPitch +
                            (rSourceArea.getMinX()<<2);
                        sal_uInt8 *pDstSurface = (sal_uInt8 *)aDescDst.lpSurface +
                            rDestPos.getY()*aDescDst.lPitch +
                            (rDestPos.getX()<<1);
                        for(sal_uInt32 y=0; y<nHeight; ++y)
                        {
                            sal_uInt32 *pSrcScanline = (sal_uInt32 *)pSrcSurface;
                            sal_uInt16 *pDstScanline = (sal_uInt16 *)pDstSurface;
                            for(sal_uInt32 x=0; x<nWidth; ++x)
                            {
                                sal_uInt32 srcPixel = *pSrcScanline++;
                                sal_uInt16 dstPixel;
                                dstPixel  = (sal_uInt16)((srcPixel & 0x0000F8) >> 3);
                                dstPixel |= (srcPixel & 0x00FC00) >> 5;
                                dstPixel |= (srcPixel & 0xF80000) >> 8;
                                *pDstScanline++ = dstPixel;
                            }
                            pSrcSurface += aDescSrc.lPitch;
                            pDstSurface += aDescDst.lPitch;
                        }
                    }
                    else if((nSrcFormat == 0x8888) && (nDstFormat == 0x0888))
                    {
                        // medium range 8888 to 0888 pixel format conversion.
                        bResult = true;
                        sal_uInt8 *pSrcSurface = (sal_uInt8 *)aDescSrc.lpSurface +
                            rSourceArea.getMinY()*aDescSrc.lPitch +
                            (rSourceArea.getMinX()<<2);
                        sal_uInt8 *pDstSurface = (sal_uInt8 *)aDescDst.lpSurface +
                            rDestPos.getY()*aDescDst.lPitch +
                            (rDestPos.getX()<<2);
                        for(sal_uInt32 y=0; y<nHeight; ++y)
                        {
                            sal_uInt32 *pSrcScanline = (sal_uInt32 *)pSrcSurface;
                            sal_uInt16 *pDstScanline = (sal_uInt16 *)pDstSurface;
                            for(sal_uInt32 x=0; x<nWidth; ++x)
                            {
                                *pDstScanline++ = (sal_uInt16)*pSrcScanline++;
                            }
                            pSrcSurface += aDescSrc.lPitch;
                            pDstSurface += aDescDst.lPitch;
                        }
                    }
                    else if((nSrcFormat == 0x8888) && (nDstFormat == 0x1555))
                    {
                        // medium range 8888 to 1555 pixel format conversion.
                        bResult = true;
                        sal_uInt8 *pSrcSurface = (sal_uInt8 *)aDescSrc.lpSurface +
                            rSourceArea.getMinY()*aDescSrc.lPitch +
                            (rSourceArea.getMinX()<<2);
                        sal_uInt8 *pDstSurface = (sal_uInt8 *)aDescDst.lpSurface +
                            rDestPos.getY()*aDescDst.lPitch +
                            (rDestPos.getX()<<1);
                        for(sal_uInt32 y=0; y<nHeight; ++y)
                        {
                            sal_uInt32 *pSrcScanline = (sal_uInt32*)pSrcSurface;
                            sal_uInt16 *pDstScanline = (sal_uInt16 *)pDstSurface;
                            for(sal_uInt32 x=0; x<nWidth; ++x)
                            {
                                sal_uInt32 srcPixel = *pSrcScanline++;
                                sal_uInt16 dstPixel;
                                dstPixel  = (sal_uInt16)((srcPixel & 0x000000F8) >> 3);
                                dstPixel |= (srcPixel & 0x0000F800) >> 6;
                                dstPixel |= (srcPixel & 0x00F80000) >> 9;
                                dstPixel |= (srcPixel & 0x80000000) >> 16;
                                *pDstScanline++ = dstPixel;
                            }
                            pSrcSurface += aDescSrc.lPitch;
                            pDstSurface += aDescDst.lPitch;
                        }
                    }

                    // unlock destination surface
                    rOutSurface.Unlock(NULL);
                }

                // unlock source surface
                rSourceSurface.Unlock(NULL);
            }

            return bResult;
        }

		void dumpSurface( const COMReference<IDirectDrawSurface> &pSurface, const char *szFilename )
		{
			if(!(pSurface.get()))
				return;

			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory( &aSurfaceDesc,sizeof(DDSURFACEDESC),0 );
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);

			if( FAILED(pSurface->Lock( NULL,
										&aSurfaceDesc,
										DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY,
										NULL)) )
				return;

			const std::size_t dwBitmapSize(aSurfaceDesc.dwWidth*aSurfaceDesc.dwHeight*4);
			sal_uInt8 *pBuffer = static_cast<sal_uInt8 *>(_alloca(dwBitmapSize));
			if(pBuffer)
			{
				sal_uInt8 *pSource = reinterpret_cast<sal_uInt8 *>(aSurfaceDesc.lpSurface);
				sal_uInt8 *pDest = reinterpret_cast<sal_uInt8 *>(pBuffer);
				const std::size_t dwDestPitch(aSurfaceDesc.dwWidth<<2);
				pDest += aSurfaceDesc.dwHeight*dwDestPitch;
				for(sal_uInt32 y=0; y<aSurfaceDesc.dwHeight; ++y)
				{
					pDest -= dwDestPitch;
					rtl_copyMemory( pDest, pSource, dwDestPitch );
					pSource += aSurfaceDesc.lPitch;
				}

				if(FILE *fp = fopen(szFilename,"wb"))
				{
					BITMAPINFOHEADER bitmapInfo;

					bitmapInfo.biSize = sizeof(BITMAPINFOHEADER);
					bitmapInfo.biWidth = aSurfaceDesc.dwWidth;
					bitmapInfo.biHeight = aSurfaceDesc.dwHeight;
					bitmapInfo.biPlanes = 1;
					bitmapInfo.biBitCount = 32;
					bitmapInfo.biCompression = BI_RGB;
					bitmapInfo.biSizeImage = 0;
					bitmapInfo.biXPelsPerMeter = 0;
					bitmapInfo.biYPelsPerMeter = 0;
					bitmapInfo.biClrUsed = 0;
					bitmapInfo.biClrImportant = 0;

					const std::size_t dwFileSize(sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+dwBitmapSize);

					BITMAPFILEHEADER header;
					header.bfType = 'MB';
					header.bfSize = dwFileSize;
					header.bfReserved1 = 0;
					header.bfReserved2 = 0;
					header.bfOffBits = sizeof(BITMAPFILEHEADER) + bitmapInfo.biSize;

					fwrite(&header,1,sizeof(BITMAPFILEHEADER),fp);
					fwrite(&bitmapInfo,1,sizeof(BITMAPINFOHEADER),fp);
					fwrite(pBuffer,1,dwBitmapSize,fp);

					fclose(fp);
				}
			}

			pSurface->Unlock(NULL);
		}

		void clearSurface( const COMReference<IDirectDrawSurface>& pSurface )
		{
			if(!(pSurface.is()))
				return;

			DDBLTFX aBltFx;

			rtl_fillMemory( &aBltFx,
							sizeof(DDBLTFX), 0 );
			aBltFx.dwSize = sizeof(DDBLTFX);
			aBltFx.dwFillColor = 0;

			pSurface->Blt( NULL,
                           NULL,
                           NULL,
                           DDBLT_COLORFILL | DDBLT_WAIT,
                           &aBltFx );
		}

		// Define struct for MonitorEntry
		struct MonitorEntry
		{
 			GUID                 mnGUID;
 			HMONITOR             mhMonitor;
            MONITORINFO   maMonitorInfo;
		};

		// define type for MonitorList
        typedef ::std::vector< MonitorEntry > MonitorList;

 		// Win32 system callback for DirectDrawEnumerateExA call
 		BOOL WINAPI EnumerateExA_Callback( GUID FAR* lpGUID,
                                           LPSTR     /*lpDriverDescription*/,
                                           LPSTR     /*lpDriverName*/,
                                           LPVOID    lpContext,
                                           HMONITOR  hMonitor )
		{
			if(lpGUID)
			{
 				MonitorList* pMonitorList = (MonitorList*)lpContext;
				MonitorEntry aEntry;

 				aEntry.mnGUID = *lpGUID;
 				aEntry.mhMonitor = hMonitor;
                aEntry.maMonitorInfo.cbSize = sizeof(MONITORINFO);
                GetMonitorInfo( hMonitor,
                                &aEntry.maMonitorInfo );

				pMonitorList->push_back(aEntry);
			}

			return DDENUMRET_OK;
		}

        void fillMonitorList( MonitorList& rMonitorList )
        {
            // Try to fill MonitorList. If neither lib or call to
            // DirectDrawEnumerateExA does not exist, it's an old
            // DX version (< 5.0), or system does not support
            // multiple monitors.
            HINSTANCE hInstance = LoadLibrary("ddraw.dll");

            if(hInstance)
            {
                LPDIRECTDRAWENUMERATEEX lpDDEnumEx =
                    (LPDIRECTDRAWENUMERATEEX)GetProcAddress(hInstance,"DirectDrawEnumerateExA");

                if(lpDDEnumEx)
                    lpDDEnumEx( (LPDDENUMCALLBACKEXA) EnumerateExA_Callback,
                                &rMonitorList,
                                DDENUM_ATTACHEDSECONDARYDEVICES );

                FreeLibrary(hInstance);
            }
        }

        IDirectDraw2* createDirectDraw( const MonitorList& rMonitorList,
                                        MONITORINFO&       rMonitorInfo,
                                        HWND        renderWindow )
        {
 			GUID* gpSelectedDriverGUID = NULL;

            // if we have multiple monitors, choose a gpSelectedDriverGUID from monitor list
            HMONITOR hMonitor = MonitorFromWindow(renderWindow,
                                                  MONITOR_DEFAULTTONEAREST);

            MonitorList::const_iterator       aCurr = rMonitorList.begin();
            const MonitorList::const_iterator aEnd = rMonitorList.end();
            while( !gpSelectedDriverGUID && aCurr != aEnd )
            {
                if(hMonitor == aCurr->mhMonitor)
                {
                    // This is the monitor we are running on
                    gpSelectedDriverGUID = const_cast<GUID*>(&aCurr->mnGUID);
                    rMonitorInfo = aCurr->maMonitorInfo;
                }

                ++aCurr;
            }

            IDirectDraw* pDirectDraw;
            if( FAILED( DirectDrawCreate( gpSelectedDriverGUID, &pDirectDraw, NULL )))
                return NULL;

            IDirectDraw2* pDirectDraw2;
            if( FAILED( pDirectDraw->QueryInterface( IID_IDirectDraw2, (LPVOID*)&pDirectDraw2 )))
                return NULL;

			// queryInterface bumped up the refcount, so release the
			// reference to the original IDirectDraw interface.
			pDirectDraw->Release();

            return pDirectDraw2;
        }

        HRESULT WINAPI EnumTextureFormatsCallback( LPDDSURFACEDESC 	pSurfaceDesc,
                                                   LPVOID			pContext		)
        {
            // dirty cast of given context back to result ModeSelectContext
            DDPIXELFORMAT* pResult = (DDPIXELFORMAT*)pContext;

            if( pResult == NULL || pSurfaceDesc == NULL )
                return DDENUMRET_CANCEL;

            VERBOSE_TRACE( "EnumTextureFormatsCallback: advertised texture format has dwRGBBitCount %d, dwRBitMask %x, "
                           "dwGBitMask %x, dwBBitMask %x and dwRGBAlphaBitMask %x. The format uses %s alpha.",
                           pSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
                           pSurfaceDesc->ddpfPixelFormat.dwRBitMask,
                           pSurfaceDesc->ddpfPixelFormat.dwGBitMask,
                           pSurfaceDesc->ddpfPixelFormat.dwBBitMask,
                           pSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask,
                           pSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHAPREMULT ? "premultiplied" : "non-premultiplied" );

            // Only accept RGB surfaces with alpha channel
            if( (DDPF_ALPHAPIXELS | DDPF_RGB) ==
                (pSurfaceDesc->ddpfPixelFormat.dwFlags & (DDPF_ALPHAPIXELS | DDPF_RGB)) )
            {
				// ignore formats with the DDPF_ALPHAPREMULT flag
				if(!(pSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHAPREMULT))
				{
					// take widest alpha channel available
					if( pSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth > pResult->dwAlphaBitDepth )
					{
						// take new format
						rtl_copyMemory( pResult, &pSurfaceDesc->ddpfPixelFormat, sizeof(DDPIXELFORMAT) );
					}
					else if( pSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth == pResult->dwAlphaBitDepth )
					{
						// tie-breaking: take highest bitcount
						if( pSurfaceDesc->ddpfPixelFormat.dwRGBBitCount > pResult->dwRGBBitCount )
						{
							// take new format
							rtl_copyMemory( pResult, &pSurfaceDesc->ddpfPixelFormat, sizeof(DDPIXELFORMAT) );
						}
					}
				}
            }

            return DDENUMRET_OK;
        }

		class DXRenderModule;

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface
		//////////////////////////////////////////////////////////////////////////////////

		/** ISurface implemenation.

			@attention holds the DXRenderModule via non-refcounted
			reference! This is safe with current state of affairs, since
			the canvas::PageManager holds surface and render module via
			shared_ptr (and makes sure all surfaces are deleted before its
			render module member goes out of scope).
		*/
		class DXSurface : public canvas::ISurface
		{
		public:
			DXSurface( DXRenderModule&           rRenderModule,
                       const ::basegfx::B2ISize& rSize );
			~DXSurface();

			virtual bool selectTexture();
			virtual bool isValid();
			virtual bool update( const ::basegfx::B2IPoint& rDestPos,
                                 const ::basegfx::B2IRange& rSourceRect,
                                 ::canvas::IColorBuffer&    rSource );
			virtual ::basegfx::B2IVector getSize();

		private:
			/// Guard local methods against concurrent acces to RenderModule
			class ImplRenderModuleGuard : private ::boost::noncopyable
			{
			public:
				explicit inline ImplRenderModuleGuard( DXRenderModule& rRenderModule );
				inline ~ImplRenderModuleGuard();

			private:
				DXRenderModule& mrRenderModule;
			};

			DXRenderModule&                         mrRenderModule;

			COMReference<IDirectDrawSurface> mpSurface;
			COMReference<IDirect3DTexture2>  mpTexture;

			::basegfx::B2IVector maSize;
		};

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule
		//////////////////////////////////////////////////////////////////////////////////

		/// Default implementation of IDXRenderModule
		class DXRenderModule : public IDXRenderModule
		{
        public:
            explicit DXRenderModule( const ::Window& rWindow );

            virtual void lock() const { maMutex.acquire(); }
            virtual void unlock() const { maMutex.release(); }

            virtual COMReference<IDirectDrawSurface>
                createSystemMemorySurface( const ::basegfx::B2IVector& rSize );

            virtual bool flip( const ::basegfx::B2IRectangle& rUpdateArea,
                               const ::basegfx::B2IRectangle& rCurrWindowArea );

            virtual void resize( const ::basegfx::B2IRange& rect );
			virtual HWND getHWND() const { return mhWnd; }
			virtual void disposing();
			virtual void screenShot();
            virtual ::basegfx::B2IVector getPageSize();
            virtual ::canvas::ISurfaceSharedPtr createSurface( const ::basegfx::B2IVector& surfaceSize );
            virtual void beginPrimitive( PrimitiveType eType );
            virtual void endPrimitive();
            virtual void pushVertex( const ::canvas::Vertex& vertex );
            virtual bool isError();

            const D3DDEVICEDESC&             getDeviceDesc() const { return maDeviceDesc; }
            const DDPIXELFORMAT&             getTextureFormat() const { return maTextureFormat; }
            COMReference<IDirectDraw2>       getDirectDraw() { return mpDirectDraw; }
            COMReference< IDirect3DDevice2 > getDevice() { return mpDirect3DDevice; }

            void flushVertexCache();

            struct ModeSelectContext
            {
                DDSURFACEDESC selectedDesc;
                ::basegfx::B2ISize	 requestedSize;
            };

            /** Query actual size of the device

                This is especially interesting for fullscreen devices
            */
            ::basegfx::B2ISize getFramebufferSize() const;

            /** Query the amount of memory available for new surfaces

                This might differ from getAvailableTextureMem()
                @see getAvailableTextureMem()

                @param bWithAGPMema
                When true, returned value includes non-local,
                i.e. AGP-able memory, too.

                @return the amount of free surface mem
            */
            std::size_t	  getAvailableSurfaceMem( bool bWithAGPMem=true ) const;

            /** Query the amount of memory available for new textures

                This might differ from getAvailableSurfaceMem()
                @see getAvailableSurfaceMem()

                @param bWithAGPMema
                When true, returned value includes non-local,
                i.e. AGP-able memory, too.

                @return the amount of free texture mem
            */
            std::size_t     getAvailableTextureMem( bool bWithAGPMem=true ) const;

        private:
            bool queryCaps();
            bool validateCaps();
            bool setup3DDevice();
            unsigned int getDisplayFormat() const;

            void convert2Screen( ::basegfx::B2IPoint& io_rDestPos,
                                 ::basegfx::B2IRange& io_rDestArea );

            void renderInfoText( const ::rtl::OUString& rStr,
                                 const Gdiplus::PointF& rPos ) const;
            void renderFPSCounter() const;
            void renderMemAvailable() const;

            bool create( const ::Window& rWindow );
            bool validateMainSurfaces();

            /** This object represents the DirectX state machine.  In order
                to serialize access to DirectX's global state, a global
                mutex is required.
            */
            static ::osl::Mutex						maMutex;

            HWND                                    mhWnd;
			::boost::scoped_ptr<SystemChildWindow>	mpWindow;
			::basegfx::B2IVector					maSize;

            ModeSelectContext						maSelectedFullscreenMode;
            DDPIXELFORMAT                           maTextureFormat;

            MONITORINFO                             maMonitorInfo; // monitor info for mpDirectDraw's monitor
            COMReference<IDirectDraw2>              mpDirectDraw;
            COMReference<IDirectDrawSurface>        mpPrimarySurface;
            COMReference<IDirectDrawSurface>        mpBackBufferSurface;

            COMReference< IDirect3D2 >              mpDirect3D;
            COMReference< IDirect3DDevice2 >        mpDirect3DDevice;

            mutable ::canvas::tools::ElapsedTime	maLastUpdate;	// for the frame counter

            D3DDEVICEDESC                           maDeviceDesc;

            typedef std::vector<canvas::Vertex>	    vertexCache_t;
            vertexCache_t							maVertexCache;
            std::size_t								mnCount;

            int                                     mnBeginSceneCount;

            const bool								mbPageFlipping;
            bool 									mbHasNoTearingBlt;
            bool									mbError;
            PrimitiveType							meType;

			::canvas::ISurfaceSharedPtr				mpTexture;
			::basegfx::B2IVector					maPageSize;
		};

		::osl::Mutex DXRenderModule::maMutex;

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::ImplRenderModuleGuard
		//////////////////////////////////////////////////////////////////////////////////

		inline DXSurface::ImplRenderModuleGuard::ImplRenderModuleGuard(
			DXRenderModule& rRenderModule ) :
			mrRenderModule( rRenderModule )
		{
			mrRenderModule.lock();
		}

		inline DXSurface::ImplRenderModuleGuard::~ImplRenderModuleGuard()
		{
			mrRenderModule.unlock();
		}

#ifdef FAKE_MAX_NUMBER_TEXTURES
		static sal_uInt32 gNumSurfaces = 0;
#endif

        void fillRect( sal_uInt32 *pDest,
                       sal_uInt32 dwWidth,
                       sal_uInt32 dwHeight,
                       sal_uInt32 dwPitch,
                       sal_uInt32 dwColor )
        {
            for(sal_uInt32 i=0; i<dwWidth; ++i)
            {
                pDest[i]=dwColor;
                pDest[((dwHeight-1)*dwPitch)+i]=dwColor;
            }

            for(sal_uInt32 j=0; j<dwHeight; ++j)
            {
                pDest[0]=dwColor;
                pDest[dwWidth-1]=dwColor;
                pDest += dwPitch;
            }
        }

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::DXSurface
		//////////////////////////////////////////////////////////////////////////////////

		DXSurface::DXSurface( DXRenderModule&           rRenderModule,
							  const ::basegfx::B2ISize& rSize ) :
            mrRenderModule(rRenderModule),
            mpTexture(NULL),
            mpSurface(NULL),
			maSize()
		{
			ImplRenderModuleGuard aGuard( mrRenderModule );

#ifdef FAKE_MAX_NUMBER_TEXTURES
			++gNumSurfaces;
			if(gNumSurfaces >= FAKE_MAX_NUMBER_TEXTURES)
				return;
#endif

#ifdef FAKE_MAX_TEXTURE_SIZE
			if(rSize.getX() > FAKE_MAX_TEXTURE_SIZE)
				return;
			if(rSize.getY() > FAKE_MAX_TEXTURE_SIZE)
				return;
#endif

			ENSURE_ARG_OR_THROW(rSize.getX() > 0 && rSize.getY() > 0,
							"DXSurface::DXSurface(): request for zero-sized surface");

			const D3DDEVICEDESC &deviceDesc = rRenderModule.getDeviceDesc();

			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory( &aSurfaceDesc,sizeof(DDSURFACEDESC),0 );
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			aSurfaceDesc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
			aSurfaceDesc.dwWidth = ::std::min(deviceDesc.dwMaxTextureWidth,::canvas::tools::nextPow2(rSize.getX()));
			aSurfaceDesc.dwHeight = ::std::min(deviceDesc.dwMaxTextureHeight,::canvas::tools::nextPow2(rSize.getY()));
			aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE |
										  DDSCAPS_VIDEOMEMORY |
										  DDSCAPS_LOCALVIDMEM;
			rtl_copyMemory(&aSurfaceDesc.ddpfPixelFormat,&rRenderModule.getTextureFormat(),sizeof(DDPIXELFORMAT));

	        IDirectDrawSurface *pSurface;
			COMReference<IDirectDraw2> pDirectDraw(rRenderModule.getDirectDraw());
			HRESULT hr = pDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL);
			if(FAILED(hr))
			{
				// if the call failed due to 'out of videomemory',
				// retry with request for AGP memory.
				if(DDERR_OUTOFVIDEOMEMORY == hr)
				{
					aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE |
												  DDSCAPS_VIDEOMEMORY |
												  DDSCAPS_NONLOCALVIDMEM;
					hr = pDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL);
				}
			}

			if(SUCCEEDED(hr))
			{
				IDirect3DTexture2* pTexture;
				if( FAILED(pSurface->QueryInterface(IID_IDirect3DTexture2, (LPVOID *)&pTexture)) )
				{
					pSurface->Release();
					return;
				}

				maSize.setX(aSurfaceDesc.dwWidth);
				maSize.setY(aSurfaceDesc.dwHeight);

				mpSurface=COMReference<IDirectDrawSurface>(pSurface);
				mpTexture=COMReference<IDirect3DTexture2>(pTexture);

				// #122683# Clear texture, to avoid ugly artifacts at the
				// border to invisible sprite areas (note that the textures
				// are usually only partly utilized).
				clearSurface( mpSurface );
			}
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::~DXSurface
		//////////////////////////////////////////////////////////////////////////////////

		DXSurface::~DXSurface()
		{
			ImplRenderModuleGuard aGuard( mrRenderModule );

#ifdef FAKE_MAX_NUMBER_TEXTURES
			gNumSurfaces--;
#endif
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::selectTexture
		//////////////////////////////////////////////////////////////////////////////////

		bool DXSurface::selectTexture()
		{
			ImplRenderModuleGuard aGuard( mrRenderModule );

			mrRenderModule.flushVertexCache();

            D3DTEXTUREHANDLE aTextureHandle;
            if(FAILED(mpTexture->GetHandle(
                          mrRenderModule.getDevice().get(),
                          &aTextureHandle)))
            {
				return false;
            }

			// select texture for next primitive
            if(FAILED(mrRenderModule.getDevice()->SetRenderState(
                          D3DRENDERSTATE_TEXTUREHANDLE,aTextureHandle)))
            {
				return false;
            }

#if defined(DX_DEBUG_IMAGES)
# if OSL_DEBUG_LEVEL > 0
			if( mpSurface.is() )
            {
                DDSURFACEDESC aSurfaceDesc;
                rtl_fillMemory( &aSurfaceDesc,sizeof(DDSURFACEDESC),0 );
                aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);

                if( SUCCEEDED(mpSurface->Lock( NULL,
                                               &aSurfaceDesc,
                                               DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY,
                                               NULL)) )
                {
                    imdebug( "rgba w=%d h=%d %p",
                             aSurfaceDesc.dwWidth,
                             aSurfaceDesc.dwHeight,
                             aSurfaceDesc.lpSurface );

                    mpSurface->Unlock(NULL);
                }
            }
# endif
#endif

			return true;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::isValid
		//////////////////////////////////////////////////////////////////////////////////

		bool DXSurface::isValid()
		{
			ImplRenderModuleGuard aGuard( mrRenderModule );

			if(!(mpSurface.is()))
				return false;

			if(mpSurface->IsLost() == DDERR_SURFACELOST)
            {
				mpSurface->Restore();
				return false;
			}

			return true;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::update
		//////////////////////////////////////////////////////////////////////////////////

		bool DXSurface::update( const ::basegfx::B2IPoint& rDestPos,
								const ::basegfx::B2IRange& rSourceRect,
								::canvas::IColorBuffer&    rSource )
		{
			ImplRenderModuleGuard aGuard( mrRenderModule );

			// can't update if surface is not valid, that means
			// either not existent nor restored...
			if(!(isValid()))
				return false;

			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory( &aSurfaceDesc,sizeof(DDSURFACEDESC),0 );
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);

			// TODO(P2): only lock the region we want to update
			if( FAILED(mpSurface->Lock( NULL,
                                        &aSurfaceDesc,
                                        DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_WRITEONLY,
                                        NULL)) )
				return false;

			if(sal_uInt8* pImage = rSource.lock())
			{
				switch( rSource.getFormat() )
				{
					case ::canvas::IColorBuffer::FMT_A8R8G8B8:
                    {
                        const std::size_t nSourceBytesPerPixel(4);
                        const std::size_t nSourcePitchInBytes(rSource.getStride());
                        pImage += rSourceRect.getMinY()*nSourcePitchInBytes;
                        pImage += rSourceRect.getMinX()*nSourceBytesPerPixel;

                        // calculate the destination memory address
                        sal_uInt8 *pDst = ((sal_uInt8*)aSurfaceDesc.lpSurface+
                                           (rDestPos.getY()*aSurfaceDesc.lPitch) +
                                           (4*rDestPos.getX()));

                        const sal_uInt32 nNumBytesToCopy(
                            static_cast<sal_uInt32>(
                                rSourceRect.getWidth())*
                            nSourceBytesPerPixel);
                        const sal_uInt64 nNumLines(rSourceRect.getHeight());

                        for(sal_uInt32 i=0; i<nNumLines; ++i)
                        {
                            rtl_copyMemory(pDst,pImage,nNumBytesToCopy);

                            pDst += aSurfaceDesc.lPitch;
                            pImage += nSourcePitchInBytes;
                        }
                    }
                    break;

					case ::canvas::IColorBuffer::FMT_R8G8B8:
                    {
                        const std::size_t nSourceBytesPerPixel(3);
                        const std::size_t nSourcePitchInBytes(rSource.getStride());
                        pImage += rSourceRect.getMinY()*nSourcePitchInBytes;
                        pImage += rSourceRect.getMinX()*nSourceBytesPerPixel;

                        // calculate the destination memory address
                        sal_uInt8 *pDst = ((sal_uInt8*)aSurfaceDesc.lpSurface+
                                           (rDestPos.getY()*aSurfaceDesc.lPitch) +
                                           (4*rDestPos.getX()));

                        const sal_uInt64 nNumColumns(rSourceRect.getWidth());
                        const sal_uInt64 nNumLines(rSourceRect.getHeight());
                        for(sal_uInt32 i=0; i<nNumLines; ++i)
                        {
                            sal_uInt32 *pDstScanline = reinterpret_cast<sal_uInt32 *>(pDst);
                            sal_uInt8 *pSrcScanline = reinterpret_cast<sal_uInt8 *>(pImage);
                            for(sal_uInt32 x=0; x<nNumColumns; ++x)
                            {
                                sal_uInt32 color(0xFF000000);
                                color |= pSrcScanline[2]<<16;
                                color |= pSrcScanline[1]<<8;
                                color |= pSrcScanline[0];
                                pSrcScanline += 3;
                                *pDstScanline++ = color;
                            }

                            pDst += aSurfaceDesc.lPitch;
                            pImage += nSourcePitchInBytes;
                        }
                    }
                    break;

					case ::canvas::IColorBuffer::FMT_X8R8G8B8:
                    {
                        const std::size_t nSourceBytesPerPixel(4);
                        const std::size_t nSourcePitchInBytes(rSource.getStride());
                        pImage += rSourceRect.getMinY()*nSourcePitchInBytes;
                        pImage += rSourceRect.getMinX()*nSourceBytesPerPixel;

                        // calculate the destination memory address
                        sal_uInt8 *pDst = ((sal_uInt8*)aSurfaceDesc.lpSurface+
                                           (rDestPos.getY()*aSurfaceDesc.lPitch) +
                                           (4*rDestPos.getX()));

                        const sal_uInt64 nNumLines(rSourceRect.getHeight());

                        for(sal_uInt32 i=0; i<nNumLines; ++i)
                        {
                            sal_uInt32 *pSrc32 = reinterpret_cast<sal_uInt32 *>(pImage);
                            sal_uInt32 *pDst32 = reinterpret_cast<sal_uInt32 *>(pDst);
                            for(sal_uInt32 j=0; j<rSourceRect.getWidth(); ++j)
                                pDst32[j] = 0xFF000000 | pSrc32[j];

                            pDst += aSurfaceDesc.lPitch;
                            pImage += nSourcePitchInBytes;
                        }
                    }
                    break;

					default:
						ENSURE_OR_RETURN_FALSE(false,
                                          "DXSurface::update(): Unknown/unimplemented buffer format" );
						break;
				}

				rSource.unlock();
			}

			return SUCCEEDED(mpSurface->Unlock(NULL));
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXSurface::getSize
		//////////////////////////////////////////////////////////////////////////////////

		::basegfx::B2IVector DXSurface::getSize()
		{
			return maSize;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::DXRenderModule
		//////////////////////////////////////////////////////////////////////////////////

		DXRenderModule::DXRenderModule( const ::Window& rWindow ) :
	        mhWnd(0),
            mpWindow(),
            maSize(),
			maSelectedFullscreenMode(),
	        maTextureFormat(),
            maMonitorInfo(),
	        mpDirectDraw(),
			mpPrimarySurface(),
			mpBackBufferSurface(),
			mpDirect3D(),
			mpDirect3DDevice(),
			maLastUpdate(),
			maDeviceDesc(),
            maVertexCache(),
			mnCount(0),
			mnBeginSceneCount(0),
			mbPageFlipping( false ),
			mbHasNoTearingBlt( false ),
			mbError( false ),
			meType( PRIMITIVE_TYPE_UNKNOWN ),
			mpTexture(),
			maPageSize()
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			if(!(create(rWindow)))
			{
				throw lang::NoSupportException(
					::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
                                         "Could not create DirectX device!") ),NULL);
			}

			// allocate a single texture surface which can be used later.
			// we also use this to calibrate the page size.
			::basegfx::B2IVector aPageSize(
				::std::min(
					static_cast<sal_uInt32>(maDeviceDesc.dwMaxTextureWidth),
					static_cast<sal_uInt32>(MAX_TEXTURE_SIZE)),
				::std::min(
					static_cast<sal_uInt32>(maDeviceDesc.dwMaxTextureHeight),
					static_cast<sal_uInt32>(MAX_TEXTURE_SIZE)));
			while(true)
			{
				mpTexture = ::canvas::ISurfaceSharedPtr(
					new DXSurface(*this,aPageSize));
				if(mpTexture->isValid())
					break;

				aPageSize.setX(aPageSize.getX()>>1);
				aPageSize.setY(aPageSize.getY()>>1);
				if((aPageSize.getX() < MIN_TEXTURE_SIZE) ||
				   (aPageSize.getY() < MIN_TEXTURE_SIZE))
				{
					throw lang::NoSupportException(
						::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
											"Could not create DirectX device!") ),NULL);
				}
			}
			maPageSize=aPageSize;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::create
		//////////////////////////////////////////////////////////////////////////////////

		bool DXRenderModule::create( const ::Window& rWindow )
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			maVertexCache.reserve(1024);

			mpWindow.reset(
				new SystemChildWindow(
				const_cast<Window *>(&rWindow), 0) );

			// system child window must not receive mouse events
			mpWindow->SetMouseTransparent( sal_True );

			// parent should receive paint messages as well
			// [PARENTCLIPMODE_NOCLIP], the argument is here
			// passed as plain numeric value since the stupid
			// define utilizes a USHORT cast.
			mpWindow->SetParentClipMode(0x0002);

			// the system child window must not clear its background
			mpWindow->EnableEraseBackground( sal_False );

			mpWindow->SetControlForeground();
			mpWindow->SetControlBackground();
			mpWindow->EnablePaint(sal_False);

			const SystemEnvData *pData = mpWindow->GetSystemData();
			const HWND hwnd(reinterpret_cast<HWND>(pData->hWnd));
			mhWnd = const_cast<HWND>(hwnd);

			ENSURE_OR_THROW( IsWindow( reinterpret_cast<HWND>(mhWnd) ),
                              "DXRenderModuleDXRenderModuleWin32() No valid HWND given." );

			// retrieve position and size of the parent window
			const ::Size &rSizePixel(rWindow.GetSizePixel());

			// remember the size of the parent window, since we
			// need to use this for our child window.
			maSize.setX(static_cast<sal_Int32>(rSizePixel.Width()));
			maSize.setY(static_cast<sal_Int32>(rSizePixel.Height()));

			// let the child window cover the same size as the parent window.
			mpWindow->SetPosSizePixel(0,0,maSize.getX(),maSize.getY());

            MonitorList aMonitorList;
            fillMonitorList( aMonitorList );

 			mpDirectDraw = COMReference<IDirectDraw2>(
                createDirectDraw(aMonitorList, maMonitorInfo, mhWnd));

			if(!mpDirectDraw.is())
				return false;

			if( !queryCaps() )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): GetCaps failed" );
				mpDirectDraw.reset();
				return false;
			}

			if( !validateCaps() )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): Insufficient DirectX capabilities, failed" );
				mpDirectDraw.reset();
				return false;
			}

			if( FAILED( mpDirectDraw->SetCooperativeLevel( mhWnd,
                                                           DDSCL_NORMAL|DDSCL_MULTITHREADED|DDSCL_FPUPRESERVE ) ) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): SetCooperativeLevel failed" );
				mpDirectDraw.reset();
				return false;
			}

			// setup query struct
			rtl_fillMemory( &maSelectedFullscreenMode.selectedDesc,
							sizeof(DDSURFACEDESC), 0 );
			maSelectedFullscreenMode.selectedDesc.dwSize = sizeof(DDSURFACEDESC);

			// read current display mode, e.g. for screen dimension
			if( FAILED( mpDirectDraw->GetDisplayMode( &maSelectedFullscreenMode.selectedDesc )) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): GetDisplayMode failed" );
				mpDirectDraw.reset();
				return false;
			}

			// check for supported primary surface formats...
			unsigned int nDisplayFormat = getDisplayFormat() & 0x00000FFF;
			if(nDisplayFormat != 0x888 && nDisplayFormat != 0x565)
            {
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): Unsupported DisplayFormat" );
				mpDirectDraw.reset();
				return false;
			}

			// create primary surface reference
			DDSURFACEDESC 		aSurfaceDesc;
			IDirectDrawSurface* pPrimarySurface;

			rtl_fillMemory( &aSurfaceDesc,
							sizeof(DDSURFACEDESC), 0 );
			aSurfaceDesc.dwSize = sizeof(aSurfaceDesc);
			aSurfaceDesc.dwFlags = DDSD_CAPS;
			aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE;

			if( FAILED(mpDirectDraw->CreateSurface(&aSurfaceDesc, &pPrimarySurface, NULL)) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): CreateSurface failed" );
				mpDirectDraw.reset();
				return false;
			}

			mpPrimarySurface = COMReference< IDirectDrawSurface >(pPrimarySurface);

			// create a Clipper and associate it with the primary surface
			// and the render window
			LPDIRECTDRAWCLIPPER pClipper;
			if( FAILED(mpDirectDraw->CreateClipper( 0, &pClipper, NULL )) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): CreateClipper failed" );
				mpPrimarySurface.reset();
				mpDirectDraw.reset();
				return false;
			}
			if( FAILED(pClipper->SetHWnd(0, mhWnd)) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): Clipper->SetHWnd failed" );
				pClipper->Release();
				mpPrimarySurface.reset();
				mpDirectDraw.reset();
				return false;
			}
			if( FAILED(mpPrimarySurface->SetClipper( pClipper )) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): SetClipper failed" );
				pClipper->Release();
				mpPrimarySurface.reset();
				mpDirectDraw.reset();
				return false;
			}

			// clipper is now owned by mpPrimarySurface, release our reference
			pClipper->Release();

			// TODO(F3): Check whether palette needs any setup here

			// get us a backbuffer for simulated flipping
			IDirectDrawSurface* pSurface;

			// Strictly speaking, we don't need a full screen worth of
			// backbuffer here. We could also scale dynamically with
			// the current window size, but this will make it
			// necessary to temporarily have two buffers while copying
			// from the old to the new one. What's more, at the time
			// we need a larger buffer, DX might not have sufficient
			// resources available, and we're then left with too small
			// a back buffer, and no way of falling back to a
			// different canvas implementation.
			const ::basegfx::B2ISize aSize( getFramebufferSize() );

			rtl_fillMemory( &aSurfaceDesc,
							sizeof(DDSURFACEDESC), 0 );
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			aSurfaceDesc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
			aSurfaceDesc.dwHeight= aSize.getY();
			aSurfaceDesc.dwWidth = aSize.getX();

			aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;

			HRESULT nRes = mpDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL);

			if( FAILED( nRes ) )
			{
				if( nRes == DDERR_OUTOFVIDEOMEMORY )
				{
					// local vid mem failed. Maybe AGP mem works?
					aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY | DDSCAPS_NONLOCALVIDMEM;
					if( FAILED(mpDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL)) )
					{
						// no chance, go defunct, and exit
						VERBOSE_TRACE( "Device::Device(): CreateSurface for backbuffer failed" );
						mpPrimarySurface.reset();
						mpDirectDraw.reset();
						return false;
					}

					VERBOSE_TRACE( "Device::Device(): CreateSurface for backbuffer reverted to non-local video mem" );
				}
				else
				{
					// no chance, go defunct, and exit
					VERBOSE_TRACE( "Device::Device(): CreateSurface for backbuffer failed" );
					mpPrimarySurface.reset();
					mpDirectDraw.reset();
					return false;
				}
			}

			VERBOSE_TRACE( "Device::Device(): created backbuffer of size %d times %d pixel",
                           aSurfaceDesc.dwWidth,
                           aSurfaceDesc.dwHeight );

			mpBackBufferSurface = COMReference< IDirectDrawSurface >(pSurface);
			clearSurface(mpBackBufferSurface);

			if( !setup3DDevice() )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::Device(): setup3DDevice failed" );
				mpBackBufferSurface.reset();
				mpPrimarySurface.reset();
				mpDirectDraw.reset();
				return false;
			}

			mpWindow->Show();

			return true;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::getSize
		//////////////////////////////////////////////////////////////////////////////////

		::basegfx::B2ISize DXRenderModule::getFramebufferSize() const
		{
            return mpDirectDraw.is() ?
                ::basegfx::B2ISize( maSelectedFullscreenMode.selectedDesc.dwWidth,
                                    maSelectedFullscreenMode.selectedDesc.dwHeight ) :
                ::basegfx::B2ISize();
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::setup3DDevice
		//////////////////////////////////////////////////////////////////////////////////

		bool DXRenderModule::setup3DDevice()
		{
			// create and setup 3D device
			// ==========================
			LPDIRECT3D2	pDirect3D;
			if( FAILED( mpDirectDraw->QueryInterface( IID_IDirect3D2, (LPVOID*)&pDirect3D ) ) )
			{
				// go defunct, and exit
				VERBOSE_TRACE( "Device::setup3DDevice(): QueryInterface() for Direct3D failed" );
				return false;
			}

			mpDirect3D = COMReference< IDirect3D2 >(pDirect3D);

			LPDIRECT3DDEVICE2 pDirect3DDevice;
			// try HW-accelerated device first
			if( FAILED(mpDirect3D->CreateDevice( IID_IDirect3DHALDevice,
                                                 mpBackBufferSurface.get(),
                                                 &pDirect3DDevice )) )
			{
				// no HW 3D support - go defunct, and exit
				VERBOSE_TRACE( "Device::setup3DDevice(): CreateDevice() for HW Direct3D rendering failed" );
				mpDirect3D.reset();
				return false;
			}

			D3DDEVICEDESC aHELDeviceDesc;
			rtl_fillMemory(&maDeviceDesc,sizeof(maDeviceDesc),0);
			rtl_fillMemory(&aHELDeviceDesc,sizeof(aHELDeviceDesc),0);
			maDeviceDesc.dwSize = sizeof(maDeviceDesc);
			aHELDeviceDesc.dwSize = sizeof(aHELDeviceDesc);
			if(FAILED(pDirect3DDevice->GetCaps(&maDeviceDesc,&aHELDeviceDesc)))
            {
				// go defunct, and exit
				VERBOSE_TRACE( "Device::setup3DDevice(): GetCaps() for Direct3DDevice failed" );
				mpDirect3D.reset();
				return false;
			}

			mpDirect3DDevice = COMReference< IDirect3DDevice2 >(pDirect3DDevice);

			// select appropriate texture format (_need_ alpha channel here)
			rtl_fillMemory( &maTextureFormat,
							sizeof(DDPIXELFORMAT), 0 );
			maTextureFormat.dwSize = sizeof(DDPIXELFORMAT);
			if( SUCCEEDED(mpDirect3DDevice->EnumTextureFormats( EnumTextureFormatsCallback, &maTextureFormat )) )
			{
				bool bSupportedFormat = true;
				if((maTextureFormat.dwFlags & (DDPF_ALPHAPIXELS | DDPF_RGB)) != (DDPF_ALPHAPIXELS | DDPF_RGB))
					bSupportedFormat = false;
				else if(maTextureFormat.dwRGBAlphaBitMask != 0xFF000000)
					bSupportedFormat = false;
				else if(maTextureFormat.dwRBitMask != 0x00FF0000)
					bSupportedFormat = false;
				else if(maTextureFormat.dwGBitMask != 0x0000FF00)
					bSupportedFormat = false;
				else if(maTextureFormat.dwBBitMask != 0x000000FF)
					bSupportedFormat = false;

				if(bSupportedFormat)
                {
					VERBOSE_TRACE( "Device::setup3DDevice(): chose texture format dwRGBBitCount %d, dwRBitMask %x, "
                                   "dwGBitMask %x, dwBBitMask %x and dwRGBAlphaBitMask %x. The texture uses %s alpha.",
                                   maTextureFormat.dwRGBBitCount,
                                   maTextureFormat.dwRBitMask,
                                   maTextureFormat.dwGBitMask,
                                   maTextureFormat.dwBBitMask,
                                   maTextureFormat.dwRGBAlphaBitMask,
                                   maTextureFormat.dwFlags & DDPF_ALPHAPREMULT ? "premultiplied" : "non-premultiplied" );

					// setup the device (with as much as we can possibly do here)
					// ==========================================================

					LPDIRECT3DVIEWPORT2	pViewport;

					if( SUCCEEDED(mpDirect3D->CreateViewport( &pViewport, NULL )) )
					{
						if( SUCCEEDED(mpDirect3DDevice->AddViewport( pViewport )) )
						{
							// setup viewport (to whole backbuffer)
							D3DVIEWPORT2 aViewport;

							aViewport.dwSize = sizeof(D3DVIEWPORT2);
							aViewport.dwX = 0;
							aViewport.dwY = 0;
							aViewport.dwWidth = maSelectedFullscreenMode.selectedDesc.dwWidth;
							aViewport.dwHeight = maSelectedFullscreenMode.selectedDesc.dwHeight;
							aViewport.dvClipX = -1.0;
							aViewport.dvClipY =  -1.0;
							aViewport.dvClipWidth  = 2.0;
							aViewport.dvClipHeight = 2.0;
							aViewport.dvMinZ = 0.0;
							aViewport.dvMaxZ = 1.0;

							if( SUCCEEDED(pViewport->SetViewport2( &aViewport )) )
							{
								if( SUCCEEDED(mpDirect3DDevice->SetCurrentViewport( pViewport )) )
								{
									// Viewport was handed over to 3DDevice, thus we can release now
									pViewport->Release();

									// currently, no need for any
									// matrix or light source
									// setup, since we only render
									// transformed&lighted
									// vertices

									// done; successfully
									return true;
								}
								else
								{
									VERBOSE_TRACE( "Device::setup3DDevice(): SetCurrentViewport failed" );
								}
							}
							else
							{
								VERBOSE_TRACE( "Device::setup3DDevice(): SetViewport2 failed" );
							}
						}
						else
						{
							VERBOSE_TRACE( "Device::setup3DDevice(): AddViewport failed" );
						}

						pViewport->Release();
					}
					else
					{
						VERBOSE_TRACE( "Device::setup3DDevice(): CreateViewport failed" );
					}
				}
				else
				{
					VERBOSE_TRACE( "Device::setup3DDevice(): No supported pixelformat" );
				}
			}
			else
			{
				VERBOSE_TRACE( "Device::setup3DDevice(): EnumTextureFormats failed" );
			}

			// go defunct, and exit
			mpDirect3DDevice.reset();
			mpDirect3D.reset();

			return false;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::queryCaps
		//////////////////////////////////////////////////////////////////////////////////

		bool DXRenderModule::queryCaps()
		{
			DDCAPS	aHWCaps;
			DDCAPS	aHELCaps;

			rtl_fillMemory( &aHWCaps,
							sizeof(aHWCaps), 0 );
			rtl_fillMemory( &aHELCaps,
							sizeof(aHELCaps), 0 );
			aHWCaps.dwSize = sizeof( aHWCaps );
			aHELCaps.dwSize = sizeof( aHELCaps );

			if( FAILED( mpDirectDraw->GetCaps( &aHWCaps,
											&aHELCaps ) ) )
			{
				return false;
			}

			mbHasNoTearingBlt = aHWCaps.dwFXCaps & DDBLTFX_NOTEARING;

			VERBOSE_TRACE( "dxcanvas initialization: %d bytes VRAM free for surfaces (%d with AGP mem), "
                           "%d bytes VRAM free for textures (%d with AGP mem)",
                           getAvailableSurfaceMem( false ),
                           getAvailableSurfaceMem( true ),
                           getAvailableTextureMem( false ),
                           getAvailableTextureMem( true ) );

			return true;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::validateCaps
		//////////////////////////////////////////////////////////////////////////////////

		bool DXRenderModule::validateCaps()
		{
			// TODO(E3): Validate HW capabilities. Depending on primary
			// surface size, reject HW e.g. on the grounds of insufficient
			// VRAM.

			// setup query struct
			DDSURFACEDESC desc;
			rtl_fillMemory(&desc,sizeof(DDSURFACEDESC),0);
			desc.dwSize = sizeof(DDSURFACEDESC);

			// read current display mode, e.g. for screen dimension
			if(FAILED( mpDirectDraw->GetDisplayMode(&desc)))
				return false;

			// simple heuristic: we need at least 3 times the desktop
			// resolution based on ARGB color values...
			std::size_t nMinimumVRAMSize = ((desc.dwWidth*desc.dwHeight)<<2)*3;
			if(getAvailableSurfaceMem() < nMinimumVRAMSize)
				return false;

			return true;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::getDisplayFormat
		//////////////////////////////////////////////////////////////////////////////////

		unsigned int DXRenderModule::getDisplayFormat() const
		{
			unsigned int nFormat;
			nFormat  = ::canvas::tools::bitcount32(maSelectedFullscreenMode.selectedDesc.ddpfPixelFormat.dwRGBAlphaBitMask)<<12;
			nFormat |= ::canvas::tools::bitcount32(maSelectedFullscreenMode.selectedDesc.ddpfPixelFormat.dwRBitMask)<<8;
			nFormat |= ::canvas::tools::bitcount32(maSelectedFullscreenMode.selectedDesc.ddpfPixelFormat.dwGBitMask)<<4;
			nFormat |= ::canvas::tools::bitcount32(maSelectedFullscreenMode.selectedDesc.ddpfPixelFormat.dwBBitMask);
			return nFormat;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::getAvailableSurfaceMem
		//////////////////////////////////////////////////////////////////////////////////

		std::size_t DXRenderModule::getAvailableSurfaceMem( bool bWithAGPMem ) const
		{
			if( !mpDirectDraw.is() )
				return 0;

			std::size_t nRes( 0 );

			DDSCAPS aSurfaceCaps;
			DWORD	nTotal, nFree;

			// real VRAM (const_cast, since GetAvailableVidMem is non-const)
			aSurfaceCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;
			if( FAILED(const_cast<IDirectDraw2&>(*mpDirectDraw).GetAvailableVidMem( &aSurfaceCaps, &nTotal, &nFree )) )
				return 0;

			nRes += nFree;

			if( bWithAGPMem )
			{
				// AGP RAM (const_cast, since GetAvailableVidMem is non-const)
				aSurfaceCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY | DDSCAPS_NONLOCALVIDMEM;
				if( FAILED(const_cast<IDirectDraw2&>(*mpDirectDraw).GetAvailableVidMem( &aSurfaceCaps, &nTotal, &nFree )) )
					return 0;

				nRes += nFree;
			}

			return nRes;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::getAvailableTextureMem
		//////////////////////////////////////////////////////////////////////////////////

		std::size_t DXRenderModule::getAvailableTextureMem( bool bWithAGPMem ) const
		{
			if( !mpDirectDraw.is() )
				return 0;

			std::size_t nRes( 0 );

			DDSCAPS aSurfaceCaps;
			DWORD	nTotal, nFree;

			// TODO(F1): Check if flags are applicable

			// real VRAM (const_cast, since GetAvailableVidMem is non-const)
			aSurfaceCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;
			if( FAILED(const_cast<IDirectDraw2&>(*mpDirectDraw).GetAvailableVidMem( &aSurfaceCaps, &nTotal, &nFree )) )
				return 0;

			nRes += nFree;

			if( bWithAGPMem )
			{
				// AGP RAM (const_cast, since GetAvailableVidMem is non-const)
				aSurfaceCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_NONLOCALVIDMEM;
				if( FAILED(const_cast<IDirectDraw2&>(*mpDirectDraw).GetAvailableVidMem( &aSurfaceCaps, &nTotal, &nFree )) )
					return 0;

				nRes += nFree;
			}

			// TODO(F1): Add pool mem

			return nRes;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::convert2Screen
		//////////////////////////////////////////////////////////////////////////////////

		void DXRenderModule::convert2Screen( ::basegfx::B2IPoint& io_rDestPos,
											 ::basegfx::B2IRange& io_rDestArea )
		{
			POINT aPoint = { 0, 0 };
			ClientToScreen( mhWnd, &aPoint );

            // i52230 make sure given screen coordinate is relative to
            // this monitor's area (the device rendering is always
            // contained to a single monitor)
            aPoint.x -= maMonitorInfo.rcMonitor.left;
            aPoint.y -= maMonitorInfo.rcMonitor.top;

			io_rDestPos.setX( io_rDestPos.getX() + aPoint.x );
			io_rDestPos.setY( io_rDestPos.getY() + aPoint.y );

			const ::basegfx::B2ISize& rSize( getFramebufferSize() );

			// calc output bounds (clip against framebuffer bounds)
			io_rDestArea = ::basegfx::B2IRange(
				::std::max( sal_Int32(0),
							::std::min( sal_Int32(rSize.getX()),
                                        sal_Int32(io_rDestArea.getMinX() + aPoint.x) ) ),
				::std::max( sal_Int32(0),
							::std::min( sal_Int32(rSize.getY()),
										sal_Int32(io_rDestArea.getMinY() + aPoint.y) ) ),
				::std::max( sal_Int32(0),
							::std::min( sal_Int32(rSize.getX()),
										sal_Int32(io_rDestArea.getMaxX() + aPoint.x) ) ),
				::std::max( sal_Int32(0),
							::std::min( sal_Int32(rSize.getY()),
										sal_Int32(io_rDestArea.getMaxY() + aPoint.y) ) ) );
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::createSystemMemorySurface
		//////////////////////////////////////////////////////////////////////////////////

		COMReference<IDirectDrawSurface> DXRenderModule::createSystemMemorySurface( const ::basegfx::B2IVector& rSize )
		{
			DDSURFACEDESC 		aSurfaceDesc;
			IDirectDrawSurface* pSurface;

			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			aSurfaceDesc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;;
			aSurfaceDesc.dwWidth = rSize.getX();
			aSurfaceDesc.dwHeight= rSize.getY();

			rtl_copyMemory( &aSurfaceDesc.ddpfPixelFormat, &maTextureFormat, sizeof(DDPIXELFORMAT) );

			aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;

			HRESULT nRes = mpDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL);
			if(FAILED(nRes))
				return COMReference<IDirectDrawSurface>(NULL);

			return COMReference<IDirectDrawSurface>(pSurface);
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::flip
		//////////////////////////////////////////////////////////////////////////////////

		bool DXRenderModule::flip( const ::basegfx::B2IRectangle& rUpdateArea,
								   const ::basegfx::B2IRectangle& rCurrWindowArea )
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			// see if the main surfaces got lost. if so, try to
			// restore them. bail out if this operation fails.
			if(!(validateMainSurfaces()))
				return false;

			flushVertexCache();

			ENSURE_OR_THROW( !mnBeginSceneCount,
                              "Device::flip(): within 3D scene" );

			// TODO(E3): handle DX errors more thoroughly. For fullscreen
			// exclusive mode, actually even our primary surface can get
			// lost and needs restore!

			if( mpDirectDraw.is() &&
				mpPrimarySurface.is() &&
				mpBackBufferSurface.is() )
			{
				// ignore area and offset for page flipping device
				if( mbPageFlipping )
				{
#if defined(VERBOSE) && defined(DBG_UTIL)
					renderFPSCounter();
					renderMemAvailable();
#endif
					VERBOSE_TRACE( "Device::flip(): Using true page flipping" );

					// use true page flipping. Hopefully, the 3D hardware
					// is flushed on this flip call (rumours have it that
					// way), otherwise, perform the Lock hack as for the
					// Blt below.
					if( SUCCEEDED(mpPrimarySurface->Flip( NULL, DDFLIP_WAIT )) )
						return true;
				}
				else
				{
					VERBOSE_TRACE( "Device::flip(): Using blt for page flipping" );

					// determine actual window position
					::basegfx::B2IPoint aDestPoint( rUpdateArea.getMinimum() );
					::basegfx::B2IRange aSourceArea( rUpdateArea );
					::basegfx::B2IRange aDestArea( 0,0,
                                                   static_cast<sal_Int32>(rCurrWindowArea.getWidth()),
                                                   static_cast<sal_Int32>(rCurrWindowArea.getHeight()) );
					convert2Screen( aDestPoint, aDestArea );

					// perform clipping
					if( !::canvas::tools::clipBlit( aSourceArea,
													aDestPoint,
													rUpdateArea,
													aDestArea ) )
						return true; // fully clipped, but still, in a way,
									 // successful.

					// TODO(P1): Rumours have it that the 3D hardware
					// _might_ still be rendering with flaky drivers,
					// which don't flush properly on Blt(). It was said,
					// that 'usually', it works to lock the 3D render
					// target (the backbuffer in this case). OTOH, I've
					// found that this tends to degrade performance
					// significantly on complying cards...

					// TODO(P1): Up until rev. 1.3, this method contained
					// code to make sure the blit will start _immediately_
					// after the Blt call. If this is not warranted, wait
					// for the next vsync. As this case was found to be
					// extremely seldom, kicked out (what's more, there's
					// simply no guarantee that the blitter will be
					// available at any point in the code - Windows still
					// is a preemptive multi-processing environment. And
					// _if_ we're competing with someone over the blitter,
					// we will do so the next VBLANK interval, and the
					// following...)

                    // screen update seems to be smoother when waiting
                    // for vblank in every case - even when blitter
                    // supports the DDBLTFX_NOTEARING flag.
                    if( FAILED(mpDirectDraw->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,
                                                                  NULL)) )
                        return false;

					DDBLTFX  aBltFx;
					DDBLTFX* pBltFX = NULL;
					if( mbHasNoTearingBlt )
					{
						// Blt can internally schedule for no-tearing
						// ===========================================

						rtl_fillMemory( &aBltFx,
										sizeof(aBltFx), 0 );
						aBltFx.dwSize = sizeof(aBltFx);
						aBltFx.dwDDFX = DDBLTFX_NOTEARING;

						pBltFX = &aBltFx;
					}

					if( doBlit( aDestPoint,
                                *mpPrimarySurface,
                                aSourceArea,
                                *mpBackBufferSurface,
                                pBltFX,false ) )
					{
#if defined(VERBOSE) && defined(DBG_UTIL)
						renderFPSCounter();
						renderMemAvailable();
#endif
						return true;
					}
				}
			}
			return false;
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::disposing
		//////////////////////////////////////////////////////////////////////////////////

		void DXRenderModule::disposing()
		{
			if(!(mhWnd))
				return;

			mpTexture.reset();
			mpWindow.reset();
			mhWnd=NULL;

            // refrain from releasing the DX5 objects - deleting the
            // DX5 device seems to kill the whole engine, including
            // all objects we might still hold references to
            // (surfaces, e.g.)
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::screenshot
		//////////////////////////////////////////////////////////////////////////////////

		void DXRenderModule::screenShot()
		{
			if(!(mpBackBufferSurface.get()))
				return;
			char filename[256];
			static sal_uInt32 counter = 0;
			sprintf(filename,"c:\\shot%d.bmp",counter++);
			dumpSurface(mpBackBufferSurface,filename);
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::validateMainSurfaces
		//////////////////////////////////////////////////////////////////////////////////

		bool DXRenderModule::validateMainSurfaces()
		{
			if(mpPrimarySurface.get()) {
				if(mpPrimarySurface->IsLost() == DDERR_SURFACELOST) {
					if(FAILED(mpPrimarySurface->Restore()))
						return false;
				}
			}

			if(mpBackBufferSurface.get()) {
				if(mpBackBufferSurface->IsLost() == DDERR_SURFACELOST)
                {
					// TODO(F1): simply restoring the backbuffer does not
					// work as expected, we need to re-create everything
					// from scratch. find out why...
					//if(SUCCEEDED(mpBackBufferSurface->Restore()))
					//	return setup3DDevice();

					mpBackBufferSurface.reset();

					// get us a backbuffer for simulated flipping
					IDirectDrawSurface* pSurface;

					// TODO(P2): Strictly speaking, we don't need a full screen worth of
					// backbuffer here. We could also scale dynamically with the current
					// window size, but this will make it necessary to temporarily have two
					// buffers while copying from the old to the new one. YMMV.
					const ::basegfx::B2ISize aSize( getFramebufferSize() );

					DDSURFACEDESC aSurfaceDesc;
					rtl_fillMemory( &aSurfaceDesc, sizeof(DDSURFACEDESC), 0 );
					aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
					aSurfaceDesc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
					aSurfaceDesc.dwHeight= aSize.getY();
					aSurfaceDesc.dwWidth = aSize.getX();

					aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;

					HRESULT nRes = mpDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL);

					if( FAILED( nRes ) )
					{
						if( nRes == DDERR_OUTOFVIDEOMEMORY )
						{
							// local vid mem failed. Maybe AGP mem works?
							aSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY | DDSCAPS_NONLOCALVIDMEM;
							if( FAILED(mpDirectDraw->CreateSurface(&aSurfaceDesc, &pSurface, NULL)) )
							{
								// no chance
								return false;
							}

							VERBOSE_TRACE( "Device::Device(): CreateSurface for backbuffer reverted to non-local video mem" );
						}
						else
						{
							// no chance
							VERBOSE_TRACE( "Device::Device(): CreateSurface for backbuffer failed" );
							return false;
						}
					}

					VERBOSE_TRACE( "Device::Device(): created backbuffer of size %d times %d pixel",
                                   aSurfaceDesc.dwWidth,
                                   aSurfaceDesc.dwHeight );

					mpBackBufferSurface = COMReference< IDirectDrawSurface >(pSurface);

					return setup3DDevice();
				}
			}

			return true;
		}

        void DXRenderModule::renderInfoText( const ::rtl::OUString& rStr,
                                             const Gdiplus::PointF& rPos ) const
        {
            ENSURE_OR_THROW( !mnBeginSceneCount,
                              "Device::renderInfoText(): within 3D scene" );

            // render text directly to primary surface
            GraphicsSharedPtr pGraphics;

            if( mbPageFlipping )
            {
                // render on top of backbuffer. We have
                // page flipping, anyway, thus this will
                // cost us nothing.
                pGraphics = createSurfaceGraphics( mpBackBufferSurface );
            }
            else
            {
                // render FPS directly to front buffer.
                // That saves us another explicit blit,
                // and for me, the FPS counter can blink,
                // if it likes to...
                pGraphics = createSurfaceGraphics( mpPrimarySurface );
            }

            if( !mbPageFlipping )
            {
                // clear background. We might be doing optimized redraws,
                // and the background under the FPS count will then not be
                // cleared.
                Gdiplus::SolidBrush aBrush(
                    Gdiplus::Color( 255, 255, 255 ) );

                pGraphics->FillRectangle( &aBrush,
                                          rPos.X, rPos.Y, 80.0, 20.0 );
            }

            Gdiplus::SolidBrush aBrush(
                Gdiplus::Color( 255, 0, 255 ) );
            Gdiplus::Font aFont( NULL,
                                 16,
                                 Gdiplus::FontStyleRegular,
                                 Gdiplus::UnitWorld,
                                 NULL );
            pGraphics->DrawString( reinterpret_cast<LPCWSTR>(rStr.getStr()),
                                   rStr.getLength(),
                                   &aFont,
                                   rPos,
                                   &aBrush );
        }

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::renderMemAvailable
		//////////////////////////////////////////////////////////////////////////////////

		void DXRenderModule::renderMemAvailable() const
		{
			ENSURE_OR_THROW( !mnBeginSceneCount,
                              "DXRenderModule::renderMemAvailable(): within 3D scene" );

			const double nSurfaceMem( getAvailableSurfaceMem()/1024 );

			::rtl::OUString text( ::rtl::math::doubleToUString( nSurfaceMem,
																rtl_math_StringFormat_F,
																2,'.',NULL,' ') );

			// pad with leading space
			while( text.getLength() < 6 )
				text = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM (" ")) + text;

			text = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM ("S: ")) + text;

			renderInfoText( text,
							Gdiplus::PointF( 0.0, 20) );


			const double nTexMem( getAvailableTextureMem()/1024 );

			text = ::rtl::math::doubleToUString( nTexMem,
												rtl_math_StringFormat_F,
												2,'.',NULL,' ');
			// pad with leading space
			while( text.getLength() < 6 )
				text = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM (" ")) + text;

			text = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM ("T: ")) + text;

			renderInfoText( text,
							Gdiplus::PointF( 0.0, 40) );

			VERBOSE_TRACE( "dxcanvas: %f free surface mem, %f free texture mem",
                           nSurfaceMem, nTexMem );
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::renderFPSCounter
		//////////////////////////////////////////////////////////////////////////////////

		void DXRenderModule::renderFPSCounter() const
		{
			ENSURE_OR_THROW( !mnBeginSceneCount,
                              "DXRenderModule::ren    derFPSCounter(): within 3D scene" );

			const double denominator( maLastUpdate.getElapsedTime() );
			maLastUpdate.reset();

			::rtl::OUString text( ::rtl::math::doubleToUString( denominator == 0.0 ? 100.0 : 1.0/denominator,
																rtl_math_StringFormat_F,
																2,'.',NULL,' ') );

			// pad with leading space
			while( text.getLength() < 6 )
				text = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM (" ")) + text;

			text += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM (" fps"));

			renderInfoText( text,
							Gdiplus::PointF() );

			VERBOSE_TRACE( "dxcanvas: %f FPS",
                           denominator == 0.0 ? 100.0 : 1.0/denominator );
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::resize
		//////////////////////////////////////////////////////////////////////////////////

		void DXRenderModule::resize( const ::basegfx::B2IRange& rect )
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			if( mhWnd==0 )
				return;

			// don't do anything if the size didn't change.
			if(maSize.getX() == static_cast<sal_Int32>(rect.getWidth()) &&
			   maSize.getY() == static_cast<sal_Int32>(rect.getHeight()))
			   return;

			// TODO(Q2): use numeric cast to prevent overflow
			maSize.setX(static_cast<sal_Int32>(rect.getWidth()));
			maSize.setY(static_cast<sal_Int32>(rect.getHeight()));

			mpWindow->SetPosSizePixel(0,0,maSize.getX(),maSize.getY());
		}

		//////////////////////////////////////////////////////////////////////////////////
		// DXRenderModule::getPageSize
		//////////////////////////////////////////////////////////////////////////////////

		::basegfx::B2IVector DXRenderModule::getPageSize()
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );
			return maPageSize;
		}

		::canvas::ISurfaceSharedPtr DXRenderModule::createSurface( const ::basegfx::B2IVector& surfaceSize )
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			const ::basegfx::B2IVector& rPageSize( getPageSize() );
			::basegfx::B2ISize aSize(surfaceSize);
			if(!(aSize.getX()))
				aSize.setX(rPageSize.getX());
			if(!(aSize.getY()))
				aSize.setY(rPageSize.getY());

			if(mpTexture.use_count() == 1)
				return mpTexture;

			return ::canvas::ISurfaceSharedPtr(
				new DXSurface(*this,
                              aSize) );
		}

		void DXRenderModule::beginPrimitive( PrimitiveType eType )
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			ENSURE_OR_THROW( !mnBeginSceneCount,
                              "DXRenderModule::beginPrimitive(): nested call" );

			++mnBeginSceneCount;
			meType=eType;
			mnCount=0;
		}

		void DXRenderModule::endPrimitive()
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			--mnBeginSceneCount;
			meType=PRIMITIVE_TYPE_UNKNOWN;
			mnCount=0;
		}

		void DXRenderModule::pushVertex( const ::canvas::Vertex& vertex )
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			switch(meType)
			{
				case PRIMITIVE_TYPE_TRIANGLE:
                {
					maVertexCache.push_back(vertex);
					++mnCount;
					mnCount &= 3;
					break;
                }

				case PRIMITIVE_TYPE_QUAD:
                {
					if(mnCount == 3)
					{
						const std::size_t size(maVertexCache.size());
						::canvas::Vertex v0(maVertexCache[size-1]);
						::canvas::Vertex v2(maVertexCache[size-3]);
						maVertexCache.push_back(v0);
						maVertexCache.push_back(vertex);
						maVertexCache.push_back(v2);
						mnCount=0;
					}
					else
					{
						maVertexCache.push_back(vertex);
						++mnCount;
					}
					break;
                }

                default:
                    OSL_ENSURE( false,
                                "DXRenderModule::pushVertex(): unexpected primitive types" );
                    break;
			}
		}

		bool DXRenderModule::isError()
		{
            // TODO(P2): get rid of those fine-grained locking
			::osl::MutexGuard aGuard( maMutex );

			return mbError;
		}

		void DXRenderModule::flushVertexCache()
		{
			if(!(maVertexCache.size()))
				return;

			mbError=true;

			if( FAILED(mpDirect3DDevice->BeginScene()) )
				return;

			// enable texture alpha blending
			if( FAILED(mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE,TRUE)))
				return;

			// enable texture alpha modulation, for honoring fAlpha
			if( FAILED(mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_TEXTUREMAPBLEND,
														D3DTBLEND_MODULATEALPHA)) )
				return;

			// enable texture magnification filtering (don't care if this
			// fails, it's just visually more pleasant)
			mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_TEXTUREMAG,
                                             D3DFILTER_LINEAR);

			// enable texture minification filtering (don't care if this
			// fails, it's just visually more pleasant)
			mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_TEXTUREMIN,
                                             D3DFILTER_LINEAR);

			// enable subpixel texture output (don't care if this
			// fails, it's just visually more pleasant)
 			mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_SUBPIXEL,
                                             TRUE);

			// normal combination of object...
			if( FAILED(mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND,
														D3DBLEND_SRCALPHA)) )
				return;

			// ..and background color
			if( FAILED(mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND,
														D3DBLEND_INVSRCALPHA)) )
				return;

			// disable backface culling; this enables us to mirror sprites
			// by simply reverting the triangles, which, with enabled
			// culling, would be invisible otherwise
			if( FAILED(mpDirect3DDevice->SetRenderState(D3DRENDERSTATE_CULLMODE,
														D3DCULL_NONE)) )
				return;

			mbError=false;

 			const float nHalfPixelSizeX(0.5f/maPageSize.getX());
 			const float nHalfPixelSizeY(0.5f/maPageSize.getY());
			sal_uInt32 nIndex(0);
			const std::size_t size(maVertexCache.size());
            D3DTLVERTEX *vertices = static_cast<D3DTLVERTEX *>(_alloca(sizeof(D3DTLVERTEX)*size));
			vertexCache_t::const_iterator it(maVertexCache.begin());
			while(it != maVertexCache.end())
			{
				vertices[nIndex++] = D3DTLVERTEX(
					D3DVECTOR(static_cast<D3DVALUE>(it->x),
							  static_cast<D3DVALUE>(it->y),
							  static_cast<D3DVALUE>(it->z)),
					1,
					D3DRGBA(1,1,1,it->a),
					D3DRGBA(0,0,0,0),
					static_cast<float>(it->u + nHalfPixelSizeX),
					static_cast<float>(it->v + nHalfPixelSizeY));
				++it;
			}

			maVertexCache.clear();

			mbError |= FAILED(mpDirect3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST,
															  D3DVT_TLVERTEX,
															  (LPVOID)vertices,
															  size,
															  0));

			mbError |= FAILED(mpDirect3DDevice->EndScene());
		}
	}

	IDXRenderModuleSharedPtr createRenderModule( const ::Window& rParent )
	{
		return IDXRenderModuleSharedPtr( new DXRenderModule(rParent) );
	}
}

#endif