argh i forgot to add new file..

directx driver by Sascha Sommer <saschasommer@freenet.de>


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@7538 b3059339-0415-0410-9bf9-f77b7e298cf2

1 files changed, 1244 insertions, 0 deletions

diff --git a/libvo/vo_directx.c b/libvo/vo_directx.c
new file mode 100644
index 0000000000..a5941076cd
--- /dev/null
+++ b/libvo/vo_directx.c
@@ -0,0 +1,1244 @@
+/******************************************************************************
+ * vo_directx.c: Directx v2 or later DirectDraw interface for MPlayer
+ * Copyright (c) 2002 Sascha Sommer <saschasommer@freenet.de>.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *
+ *****************************************************************************/
+/******************************************************************************
+ * TODO:
+ * -fix dr + implement DMA
+ * -implement mousehiding
+ * -fix undefined symbols when using CreateSolidBrush
+ *  necessary for:
+ *  -correct colorkeying
+ *  -black window background
+ * -better exclusive mode
+ *
+ *****************************************************************************/
+
+#include <windows.h>
+#include <windowsx.h>
+#include <ddraw.h>
+#include <initguid.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "config.h"
+#include "video_out.h"
+#include "video_out_internal.h"
+#include "fastmemcpy.h"
+#include "../input/input.h"
+#include "../linux/keycodes.h"
+#include "../mp_msg.h"
+
+static LPDIRECTDRAW2        g_lpdd = NULL;          //DirectDraw Object
+static LPDIRECTDRAWSURFACE  g_lpddsPrimary = NULL;  //Primary Surface: viewport through the Desktop
+static LPDIRECTDRAWSURFACE  g_lpddsOverlay = NULL;  //Overlay Surface
+static LPDIRECTDRAWSURFACE  g_lpddsBack = NULL;     //Back surface
+static LPDIRECTDRAWCLIPPER  g_lpddclipper;          //clipper object, can only be without overlay
+static DDSURFACEDESC		ddsdsf;                 //surface descripiton needed for locking
+static RECT                 rd;                     //rect of our stretched image
+static RECT                 rs;                     //rect of our source image
+static HWND                 hWnd=NULL;              //handle to the window
+static uint32_t             ontop=0;                //always in foreground
+static uint32_t image_width, image_height;          //image width and height
+static uint32_t d_image_width, d_image_height;      //image width and height zoomed 
+static uint8_t  *image=NULL;                        //image data
+static uint32_t image_format;                       //image format
+static uint32_t vm = 0;                             //exclusive mode, allows resolution switching (not implemented yet)
+static uint32_t fs = 0;                             //display in window or fullscreen 
+static uint32_t dstride;                            //surface stride
+static uint32_t swap = 1;                           //swap u<->v planes set to 1 if you experience bluish faces 
+static uint32_t nooverlay = 1;                      //NonOverlay mode
+
+extern void mplayer_put_key(int code);              //let mplayer handel the keyevents 
+extern int vo_doublebuffering;                      //tribblebuffering    
+
+int          i_colorkey;                            //fix this!!   
+
+/*****************************************************************************
+ * DirectDraw GUIDs.
+ * Defining them here allows us to get rid of the dxguid library during
+ * the linking stage.
+ *****************************************************************************/
+DEFINE_GUID( IID_IDirectDraw2,                  0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+
+typedef struct directx_fourcc_caps
+{
+   char*  img_format_name;      //human readable name
+   uint32_t img_format;         //as MPlayer image format
+   uint32_t drv_caps;           //what hw supports with this format
+   DDPIXELFORMAT g_ddpfOverlay; //as Directx Sourface description
+} directx_fourcc_caps;
+
+
+static directx_fourcc_caps g_ddpf[] =
+{                                                                         
+	{"YV12 ",IMGFMT_YV12 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','V','1','2'),0,0,0,0,0}},
+	{"I420 ",IMGFMT_I420 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('I','4','2','0'),0,0,0,0,0}},   //yv12 with swapped uv 
+	{"IYUV ",IMGFMT_IYUV ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('I','Y','U','V'),0,0,0,0,0}},   //same as i420
+	{"YVU9 ",IMGFMT_YVU9 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','V','U','9'),0,0,0,0,0}},	
+	{"YUY2 ",IMGFMT_YUY2 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0}},
+//	{"UYVY ",IMGFMT_UYVY ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0}},
+	{"RGB15",IMGFMT_RGB15,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x0000001F, 0x000003E0, 0x00007C00, 0}},   //RGB 5:5:5
+	{"BGR15",IMGFMT_BGR15,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x00007C00, 0x000003E0, 0x0000001F, 0}},   
+	{"RGB16",IMGFMT_RGB16,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x0000F800, 0x000007E0, 0x0000001F, 0}},   //RGB 5:6:5
+	{"BGR16",IMGFMT_BGR16,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x0000001F, 0x000007E0, 0x0000F800, 0}},  
+	{"RGB24",IMGFMT_RGB24,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 24,  0x000000FF, 0x0000FF00, 0x00FF0000, 0}},   
+    {"BGR24",IMGFMT_BGR24,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 24,  0x00FF0000, 0x0000FF00, 0x000000FF, 0}},  
+    {"RGB32",IMGFMT_RGB32,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 32,  0x000000FF, 0x0000FF00, 0x00FF0000, 0}},  
+    {"BGR32",IMGFMT_BGR32,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 32,  0x00FF0000, 0x0000FF00, 0x000000FF, 0}}   
+};
+#define NUM_FORMATS (sizeof(g_ddpf) / sizeof(g_ddpf[0]))
+
+
+LIBVO_EXTERN(directx)
+
+static vo_info_t vo_info =
+{
+	"Directx DDraw YUV/RGB/BGR renderer",
+	"directx",
+	"Sascha Sommer <saschasommer@freenet.de>",
+	""
+};
+
+
+static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
+		unsigned char *srca, int stride)
+{
+    switch(image_format) {
+    case IMGFMT_YV12 :
+    case IMGFMT_I420 :
+	case IMGFMT_IYUV :
+	case IMGFMT_YVU9 :
+    	vo_draw_alpha_yv12(w,h,src,srca,stride,((uint8_t *) image) + image_width*y0 + x0,image_width);
+	break;
+	case IMGFMT_YUY2 :
+	    vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) image)+ 2*image_width*y0 + 2*x0 ,2*image_width);
+    break;
+    case IMGFMT_UYVY :
+        vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) image) + 2*image_width*y0 + 2*x0 + 1,dstride);
+    break;
+	case IMGFMT_RGB15:	
+    case IMGFMT_BGR15:
+		vo_draw_alpha_rgb15(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+2*x0,dstride);
+    break;
+    case IMGFMT_RGB16:
+	case IMGFMT_BGR16:
+        vo_draw_alpha_rgb16(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+2*x0,dstride);
+    break;
+    case IMGFMT_RGB24:
+	case IMGFMT_BGR24:
+        vo_draw_alpha_rgb24(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+4*x0,dstride);
+    break;
+    case IMGFMT_RGB32:
+	case IMGFMT_BGR32:
+        vo_draw_alpha_rgb32(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+4*x0,dstride);
+    break;
+    }
+}
+
+static void draw_osd(void)
+{
+    vo_draw_text(image_width,image_height,draw_alpha);
+}
+
+static uint32_t
+query_format(uint32_t format)
+{
+    uint32_t i=0;
+    while ( i < NUM_FORMATS )
+    {
+		if (g_ddpf[i].img_format == format)
+		    return g_ddpf[i].drv_caps;
+	    i++;
+    }
+    return 0;
+}
+
+static uint32_t Directx_CreatePrimarySurface()
+{
+    DDSURFACEDESC   ddsd;
+    //cleanup
+	if(g_lpddsPrimary)g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
+	g_lpddsPrimary=NULL;
+	ZeroMemory(&ddsd, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    //set flags and create a primary surface.
+    ddsd.dwFlags = DDSD_CAPS;
+    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+    if(g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsd, &g_lpddsPrimary, NULL )== DD_OK)
+		mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>primary surface created\n");
+	else
+	{
+		mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>could not create primary surface\n");
+		return 1;
+	}
+	return 0;
+}
+
+static uint32_t Directx_CreateOverlay(uint32_t imgfmt)
+{
+    HRESULT ddrval;
+	DDSURFACEDESC   ddsdOverlay;
+    uint32_t        i=0;
+	while ( i < NUM_FORMATS +1 && imgfmt != g_ddpf[i].img_format)
+	{
+		i++;
+	}
+	if (!g_lpdd || !g_lpddsPrimary)
+        return 1;
+    //cleanup
+	if (g_lpddsOverlay)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
+	if (g_lpddsBack)g_lpddsBack->lpVtbl->Release(g_lpddsBack);
+	g_lpddsOverlay= NULL;
+	g_lpddsBack = NULL;
+	//create our overlay
+    ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
+    ddsdOverlay.dwSize = sizeof(ddsdOverlay);
+    ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_FLIP | DDSCAPS_COMPLEX | DDSCAPS_VIDEOMEMORY;
+    ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT| DDSD_PIXELFORMAT;
+    ddsdOverlay.dwWidth=image_width;
+    ddsdOverlay.dwHeight=image_height;
+    ddsdOverlay.dwBackBufferCount=2;
+	ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay; 
+	if(vo_doublebuffering)   //tribblebuffering
+	{
+		if (g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL)== DD_OK)
+		{
+			mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>overlay with format %s created\n",g_ddpf[i].img_format_name);
+            //get the surface directly attached to the primary (the back buffer)
+            ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; 
+            if(g_lpddsOverlay->lpVtbl->GetAttachedSurface(g_lpddsOverlay,&ddsdOverlay.ddsCaps, &g_lpddsBack) != DD_OK)
+			{
+				mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't get attached surface\n");
+				return 1;
+			}
+			return 0;
+		}
+		vo_doublebuffering=0; //disable tribblebuffering
+		mp_msg(MSGT_VO, MSGL_V,"<vo_directx><WARN>cannot create tribblebuffer overlay with format %s\n",g_ddpf[i].img_format_name);
+	} 
+	//single buffer
+	mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>using singlebuffer overlay\n");
+    ddsdOverlay.dwBackBufferCount=0;
+    ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
+    ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;
+    ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
+	// try to create the overlay surface
+	ddrval = g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL);
+	if(ddrval != DD_OK)
+	{
+	   mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>");
+	   switch(ddrval)
+	   {
+	      case DDERR_INCOMPATIBLEPRIMARY:
+			 {mp_msg(MSGT_VO, MSGL_ERR,"incompatible primary surface\n");break;}
+		  case DDERR_INVALIDCAPS:
+			 {mp_msg(MSGT_VO, MSGL_ERR,"invalid caps\n");break;}
+	      case DDERR_INVALIDOBJECT:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"invalid object\n");break;}
+	      case DDERR_INVALIDPARAMS:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"invalid parameters\n");break;}
+	      case DDERR_INVALIDPIXELFORMAT:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"invalid pixelformat\n");break;}
+	      case DDERR_NODIRECTDRAWHW:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"no directdraw hardware\n");break;}
+	      case DDERR_NOEMULATION:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"cant emulate\n");break;}
+	      case DDERR_NOFLIPHW:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"hardware can't do flip\n");break;}
+	      case DDERR_NOOVERLAYHW:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"hardware can't do overlay\n");break;}
+	      case DDERR_OUTOFMEMORY:
+		     {mp_msg(MSGT_VO, MSGL_ERR,"not enough system memory\n");break;}
+	      case DDERR_UNSUPPORTEDMODE:
+			 {mp_msg(MSGT_VO, MSGL_ERR,"unsupported mode\n");break;}  
+		  case DDERR_OUTOFVIDEOMEMORY:
+			 {mp_msg(MSGT_VO, MSGL_ERR,"not enough video memory\n");break;}
+	   }
+	   return 1;
+	}
+    g_lpddsBack = g_lpddsOverlay;
+	//FIX THIS STUFF !!
+	i_colorkey = (DWORD)((( ((int)((HBRUSH)(COLOR_BACKGROUND + 1))) * g_ddpf[i].g_ddpfOverlay.dwRBitMask) / 255)
+                                       & g_ddpf[i].g_ddpfOverlay.dwRBitMask);
+	return 0;
+}
+
+static uint32_t Directx_CreateBackpuffer()
+{
+	DDSURFACEDESC   ddsd;
+	//cleanup
+	if (g_lpddsBack)g_lpddsBack->lpVtbl->Release(g_lpddsBack); 
+	g_lpddsBack=NULL;
+	ZeroMemory(&ddsd, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.ddsCaps.dwCaps= DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
+    ddsd.dwFlags= DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
+    ddsd.dwWidth=image_width;
+    ddsd.dwHeight=image_height;
+    if(g_lpdd->lpVtbl->CreateSurface( g_lpdd, &ddsd, &g_lpddsBack, 0 ) != DD_OK )
+	{
+		mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't create backpuffer\n");
+		return 1;
+	}
+    mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>backbuffer created\n");
+	return 0;
+}
+
+//create clipper for nonoverlay mode
+static uint32_t Directx_CreateClipper()
+{
+	if(g_lpddclipper)g_lpddclipper->lpVtbl->Release(g_lpddclipper);
+    g_lpddclipper=NULL;
+	if(g_lpdd->lpVtbl->CreateClipper(g_lpdd, 0, &g_lpddclipper,NULL)!= DD_OK){mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't create clipper\n");return 1;}
+    if(g_lpddclipper->lpVtbl->SetHWnd (g_lpddclipper, 0, hWnd)!= DD_OK){mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't associate clipper with window\n");return 1;}
+    if(g_lpddsPrimary->lpVtbl->SetClipper (g_lpddsPrimary,g_lpddclipper)!=DD_OK){mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't associate primary surface with clipper\n");return 1;}
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>clipper succesfully created\n");
+	return 0;
+}
+
+static const vo_info_t*
+get_info(void)
+{
+	return &vo_info;
+}
+
+static void uninit(void)
+{
+	if (g_lpddclipper != NULL) g_lpddclipper->lpVtbl->Release(g_lpddclipper);
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>clipper released\n");
+	CloseWindow(hWnd);
+	if(hWnd != NULL)DestroyWindow(hWnd);
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>window destroyed\n");
+	if (g_lpddsBack != NULL) g_lpddsBack->lpVtbl->Release(g_lpddsBack);
+	g_lpddsBack = NULL;
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>back surface released\n");
+	if(vo_doublebuffering)
+	{
+		if (g_lpddsOverlay != NULL)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
+        g_lpddsOverlay = NULL;
+		mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>overlay surface released\n");
+	}
+	if (g_lpddsPrimary != NULL) g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
+    mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>primary released\n");
+	if (g_lpdd != NULL) g_lpdd->lpVtbl->Release(g_lpdd);
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>directdrawobject released\n");
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>uninited\n");    
+}
+
+static uint32_t Directx_InitDirectDraw()
+{
+    HINSTANCE  hddraw_dll;
+	HRESULT    (WINAPI *OurDirectDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *);
+ 	LPDIRECTDRAW lpDDraw;
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>Initing DirectDraw\n" );
+
+	//load direct draw DLL: based on videolans code
+	hddraw_dll = LoadLibrary("DDRAW.DLL");
+	if( hddraw_dll == NULL )
+    {
+        mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed loading ddraw.dll\n" );
+		return 1;
+    }
+	OurDirectDrawCreate = (void *)GetProcAddress(hddraw_dll, "DirectDrawCreate");
+    if ( OurDirectDrawCreate == NULL )
+    {
+        FreeLibrary( hddraw_dll );
+        hddraw_dll = NULL;
+        mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed geting proc address\n");
+		return 1;
+    }
+	// initialize DirectDraw and create directx v1 object 
+    if (OurDirectDrawCreate( NULL, &lpDDraw, NULL ) != DD_OK )
+    {
+        lpDDraw = NULL;
+        FreeLibrary( hddraw_dll );
+        hddraw_dll = NULL;
+        mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't initialize ddraw\n");
+		return 1;
+    }
+   	// ask IDirectDraw for IDirectDraw2 
+	if (lpDDraw->lpVtbl->QueryInterface(lpDDraw, &IID_IDirectDraw2, (void **)&g_lpdd) != DD_OK)
+    {
+        mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>no directx 2 installed\n");
+		return 1;
+    }
+	//release our old interface and free ddraw.dll
+    lpDDraw->lpVtbl->Release(lpDDraw);
+ 	FreeLibrary( hddraw_dll);
+	hddraw_dll= NULL;
+	mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>lpDDraw released & hddraw freed\n" );
+	//set cooperativelevel: for our tests, no handle to a window is needed
+	if (g_lpdd->lpVtbl->SetCooperativeLevel(g_lpdd, NULL, DDSCL_NORMAL) != DD_OK)
+    {
+        mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>could not set cooperativelevel for hardwarecheck\n");
+		return 1;
+    }
+    mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>DirectDraw Inited\n");
+	return 0;
+}	
+
+static void check_events(void)
+{
+    MSG msg;
+    while (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE))
+    {
+		TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+}
+
+//fullscreen code: centers and zooms image, returns window rect
+static RECT Directx_Fullscreencalc()
+{
+	uint32_t        xscreen = GetSystemMetrics(SM_CXSCREEN);
+    uint32_t        yscreen = GetSystemMetrics(SM_CYSCREEN);
+	uint32_t        xstretch1000,ystretch1000; 
+	RECT            rd_window;
+	rd.top = 0;
+	rd.left=0;
+	rd.right = xscreen;
+	rd.bottom = yscreen;
+	rd_window=rd;
+    xstretch1000 = (xscreen*1000)/d_image_width;           
+    ystretch1000 = (yscreen*1000)/d_image_height;
+    if(xstretch1000 > ystretch1000)
+	{
+		rd.bottom=yscreen;
+		rd.right=(d_image_width*ystretch1000)/1000;
+	}
+	else
+	{
+		rd.right=xscreen;
+		rd.bottom=(d_image_height*xstretch1000)/1000;
+	}
+	//printf("%i,%i,%i,%i,%i,%i\n",xstretch1000,ystretch1000,d_image_height,d_image_width,rd.bottom,rd.right);
+	rd.left = (xscreen-rd.right)/2;
+	rd.right= rd.right+rd.left;
+	rd.top = (yscreen-rd.bottom)/2;
+	rd.bottom = rd.bottom + rd.top;
+    return rd_window;
+}
+
+//this function hopefully takes into account most of those  alignments, minimum stretch, move outside of screen
+//no stretch hw, etc... and displays the overlay
+//I seperated non overlay mode because it is already to much stuff in here
+static uint32_t Directx_DisplayOverlay()
+{   
+    WINDOWPLACEMENT window_placement;
+    RECT            rd_window;  //Rect of the window
+    HRESULT         ddrval;
+    DDCAPS          capsDrv;
+    DDOVERLAYFX     ovfx;
+    DWORD           dwUpdateFlags;
+    HWND            hWndafter;
+	uint32_t        uStretchFactor1000;  //minimum stretch 
+    uint32_t        xstretch1000,ystretch1000; 
+    uint32_t        xscreen = GetSystemMetrics(SM_CXSCREEN);
+    uint32_t        yscreen = GetSystemMetrics(SM_CYSCREEN);
+    POINT           point_window;
+    //get driver capabilities
+    ZeroMemory(&capsDrv, sizeof(capsDrv));
+    capsDrv.dwSize = sizeof(capsDrv);
+    if(g_lpdd->lpVtbl->GetCaps(g_lpdd,&capsDrv, NULL) != DD_OK)return 1;
+    //check minimum stretch, depends on display adaptor and mode (refresh rate!) 
+    uStretchFactor1000 = capsDrv.dwMinOverlayStretch>1000 ? capsDrv.dwMinOverlayStretch : 1000;
+    window_placement.length = sizeof(WINDOWPLACEMENT);
+    GetWindowPlacement(hWnd, &window_placement );
+    if(!fs) //windowed
+    {
+       if (window_placement.showCmd == SW_SHOWMAXIMIZED)   //is our window maximized?
+	   {
+		   CloseWindow(hWnd);  //we do this to prevent the screen being filled with garbage
+		   window_placement.showCmd = SW_SHOWNORMAL;       //restore 		   
+		   SetWindowLong( hWnd,GWL_STYLE , WS_OVERLAPPEDWINDOW| WS_SIZEBOX );       //change Style
+		   SetWindowPlacement( hWnd, &window_placement );
+	   }
+    }
+    else       //fullscreen
+    {
+	   if (window_placement.showCmd == SW_SHOWNORMAL)   //is our window normal?
+	   {
+		   window_placement.showCmd = SW_SHOWMAXIMIZED;       //maximize
+		   SetWindowLong( hWnd, GWL_STYLE, 0 );       //change style
+		   SetWindowPlacement( hWnd, &window_placement );
+	   }
+    }
+
+    if(!fs)
+	{
+		GetClientRect (hWnd, &rd_window);
+        if(rd_window.top == rd_window.bottom)   //window is minimized
+		{
+			ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,NULL, g_lpddsPrimary, NULL, DDOVER_HIDE, NULL); //hide the overlay
+	        return 0;
+		}
+        if (GetWindowTextLength(hWnd)==0)
+		{
+			SetWindowText(hWnd,"MPlayer - DirectX Overlay"); //for the first call: change only title, not the overlay size 
+		}
+        else
+		{
+			d_image_width = rd_window.right - rd_window.left; //calculate new overlay from the window size
+            d_image_height = rd_window.bottom - rd_window.top;
+		}
+	}
+    else  
+	{
+		rd.top = 0;rd.left=0;
+	    rd.bottom = yscreen; rd.right = xscreen;
+	    rs.top = 0;rs.left=0;
+	    rs.bottom = image_height; rs.right = image_width;
+	}
+    //check if hardware can stretch or shrink, if needed
+    //do some cards support only nshrinking or is this a special shrink,stretch feature?
+    if((d_image_width < image_width)&& !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKX))
+    {         
+	    if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKXN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only shrinkN\n");
+	    else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't shrink x\n");
+	    d_image_width=image_width;
+    }
+    else if((d_image_width > image_width)&& !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHX))
+    {	   
+	    if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHXN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only stretchN\n"); 
+	    else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't stretch x\n");
+	    d_image_width = image_width;
+    }
+    if((d_image_height < image_height) && !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKY))
+    {
+	    if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKYN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only shrinkN\n");
+	    else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't shrink y\n");
+	    d_image_height = image_height;
+    }
+    else if((d_image_height > image_height ) && !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHY))
+    {
+   	    if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHYN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only stretchN\n");
+	    else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't stretch y\n");
+	    d_image_height = image_height;
+    }
+
+    if(!fs) //windowed
+	{
+		point_window.x = 0;  //overlayposition relative to the window
+        point_window.y = 0;
+        ClientToScreen(hWnd,&point_window);  
+        rd.left = point_window.x;                    //fill the wanted x1&y1 of the Overlay
+        rd.top = point_window.y;
+        //fix minimum stretch
+        rd.right = ((d_image_width+rd.left)*uStretchFactor1000+999)/1000;
+        rd.bottom = (d_image_height+rd.top)*uStretchFactor1000/1000;
+        //calculate xstretch1000 and ystretch1000
+        xstretch1000 = ((rd.right - rd.left)* 1000)/image_width ;
+        ystretch1000 = ((rd.bottom - rd.top)* 1000)/image_height;
+        //handle move outside of window with cropping
+        rd_window = rd;         //don't crop the window !!!
+        if(rd.left < 0)         //move out left
+		{
+           rs.left=(-rd.left*1000)/xstretch1000;
+           rd.left = 0; 
+		}
+        else rs.left=0;
+        if(rd.top < 0)          //move out up
+		{
+	       rs.top=(-rd.top*1000)/ystretch1000;
+	       rd.top = 0;
+		}
+        else rs.top = 0;
+        if(rd.right > xscreen)  //move out right
+		{
+	       rs.right=((xscreen-rd.left)*1000)/xstretch1000;
+	       rd.right= xscreen;
+		}
+        else rs.right = image_width;
+        if(rd.bottom > yscreen) //move out down
+		{
+	       rs.bottom=((yscreen-rd.top)*1000)/ystretch1000;
+	       rd.bottom= yscreen;
+		}
+        else rs.bottom= image_height;
+	}
+	else
+	{
+		rd_window = Directx_Fullscreencalc();
+	}
+    // check alignment restrictions
+    // these expressions (x & -y) just do alignment by dropping low order bits...
+    // so to round up, we add first, then truncate.
+    if ((capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYSRC) && capsDrv.dwAlignBoundarySrc)
+        rs.left = (rs.left + capsDrv.dwAlignBoundarySrc / 2) & -(signed)(capsDrv.dwAlignBoundarySrc);
+    if ((capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC) && capsDrv.dwAlignSizeSrc)
+        rs.right = rs.left + (rs.right - rs.left + capsDrv.dwAlignSizeSrc / 2) & -(signed) (capsDrv.dwAlignSizeSrc);
+    if ((capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYDEST) && capsDrv.dwAlignBoundaryDest)
+	{
+        rd.left = (rd.left + capsDrv.dwAlignBoundaryDest / 2) & -(signed)(capsDrv.dwAlignBoundaryDest);
+	    if(!fs)rd_window.left = (rd_window.left + capsDrv.dwAlignBoundaryDest / 2) & -(signed)(capsDrv.dwAlignBoundaryDest); //don't forget the window
+	}
+    if ((capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST) && capsDrv.dwAlignSizeDest)
+	{
+        rd.right = rd.left + (rd.right - rd.left) & -(signed) (capsDrv.dwAlignSizeDest);
+	    if(!fs)rd_window.right = rd_window.left + (rd_window.right - rd_window.left) & -(signed) (capsDrv.dwAlignSizeDest); //don't forget the window
+	}
+    if(!fs)AdjustWindowRect(&rd_window,WS_OVERLAPPEDWINDOW|WS_SIZEBOX,0); //calculate window rect
+	/*if((fs) || (!fs && ontop))hWndafter=HWND_TOPMOST;
+	else hWndafter=HWND_NOTOPMOST;*/
+	hWndafter = HWND_TOPMOST;
+	SetWindowPos(hWnd,
+                 hWndafter,
+                 rd_window.left,
+                 rd_window.top,
+                 rd_window.right - rd_window.left,
+                 rd_window.bottom - rd_window.top,
+                 SWP_SHOWWINDOW|SWP_NOOWNERZORDER/*|SWP_NOREDRAW*/);
+
+    //printf("Window:x:%i,y:%i,w:%i,h:%i\n",rd_window.left,rd_window.top,rd_window.right - rd_window.left,rd_window.bottom - rd_window.top);
+    //printf("Overlay:x1:%i,y1:%i,x2:%i,y2:%i,w:%i,h:%i\n",rd.left,rd.top,rd.right,rd.bottom,rd.right - rd.left,rd.bottom - rd.top);
+    //printf("Source:x1:%i,x2:%i,y1:%i,y2:%i\n",rs.left,rs.right,rs.top,rs.bottom);
+    //printf("Image:x:%i->%i,y:%i->%i\n",image_width,d_image_width,image_height,d_image_height);
+   
+    // Create an overlay FX structure so we can specify a source color key.
+    // This information is ignored if the DDOVER_SRCKEYOVERRIDE flag isn't set.
+    ZeroMemory(&ovfx, sizeof(ovfx));
+    ovfx.dwSize = sizeof(ovfx);
+    ovfx.dckSrcColorkey.dwColorSpaceLowValue= i_colorkey;//(int)(HBRUSH)(COLOR_BACKGROUND + 1); 
+    ovfx.dckSrcColorkey.dwColorSpaceHighValue=i_colorkey;///*(HBRUSH) */(COLOR_BACKGROUND + 1);
+    // set the flags we'll send to UpdateOverlay      //DDOVER_AUTOFLIP|DDOVERFX_MIRRORLEFTRIGHT|DDOVERFX_MIRRORUPDOWN could be usefull?;
+    dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX;
+    if (capsDrv.dwCKeyCaps & DDCKEYCAPS_SRCOVERLAY) dwUpdateFlags |= DDOVER_KEYSRCOVERRIDE;
+    ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
+    if(FAILED(ddrval))
+    {
+        // on cause might be the driver lied about minimum stretch 
+        // we should try upping the destination size a bit, or
+        // perhaps shrinking the source size
+	   	mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>UpdateOverlay failed\n" );
+	  	mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>Overlay:x1:%i,y1:%i,x2:%i,y2:%i,w:%i,h:%i\n",rd.left,rd.top,rd.right,rd.bottom,rd.right - rd.left,rd.bottom - rd.top );
+	  	mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>");
+		switch (ddrval)
+		{
+			case DDERR_NOSTRETCHHW:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"hardware can't stretch: try to size the window back\n");break;}
+            case DDERR_INVALIDRECT:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"invalid rectangle\n");break;}
+			case DDERR_INVALIDPARAMS:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"invalid parameters\n");break;}
+			case DDERR_HEIGHTALIGN:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"height align\n");break;}
+			case DDERR_XALIGN:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"x align\n");break;}
+			case DDERR_UNSUPPORTED:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"unsupported\n");break;}
+			case DDERR_INVALIDSURFACETYPE:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"invalid surfacetype\n");break;}
+			case DDERR_INVALIDOBJECT:
+				{mp_msg(MSGT_VO, MSGL_ERR ,"invalid object\n");break;}
+			case DDERR_SURFACELOST:
+				{
+					mp_msg(MSGT_VO, MSGL_ERR ,"surfaces lost\n");
+					g_lpddsOverlay->lpVtbl->Restore( g_lpddsOverlay ); //restore and try again
+			        g_lpddsPrimary->lpVtbl->Restore( g_lpddsPrimary );
+			        ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);   
+					if(ddrval !=DD_OK)mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>UpdateOverlay failed again\n" );
+					break;
+				}
+		}
+		//hide overlay
+		if(ddrval != DD_OK)
+		{
+			ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,NULL, g_lpddsPrimary, NULL, DDOVER_HIDE, NULL);
+            return 1;
+		}
+	}
+    return 0;
+}
+
+static uint32_t Directx_DisplayNonOverlay()
+{
+	WINDOWPLACEMENT window_placement;
+	RECT            rd_window;  //rect of the window
+    HWND            hWndafter;
+	uint32_t        xscreen = GetSystemMetrics(SM_CXSCREEN);
+    uint32_t        yscreen = GetSystemMetrics(SM_CYSCREEN);
+    uint32_t        xstretch1000,ystretch1000;//zoom factors
+	POINT point_window;
+    window_placement.length = sizeof(WINDOWPLACEMENT);
+    GetWindowPlacement(hWnd, &window_placement );
+	
+	if(!fs) //windowed
+    {
+        if (window_placement.showCmd == SW_SHOWMAXIMIZED)   //is our window maximized?
+		{
+		   CloseWindow(hWnd);  //we do this to prevent the screen from being filled with garbage
+		   window_placement.showCmd = SW_SHOWNORMAL;       //restore 		   
+		   SetWindowLong(hWnd,GWL_STYLE , WS_OVERLAPPEDWINDOW| WS_SIZEBOX );       //change style
+		   SetWindowPlacement( hWnd, &window_placement );
+		}
+    }
+    else       //fullscreen
+    {
+	    if (window_placement.showCmd == SW_SHOWNORMAL)    //is our window normal?
+		{
+		   window_placement.showCmd = SW_SHOWMAXIMIZED;   //maximize
+		   SetWindowLong( hWnd, GWL_STYLE, 0 );           //change Style
+		   SetWindowPlacement( hWnd, &window_placement );
+		}
+    }
+	
+    if(!fs)  //windowed
+	{
+		GetClientRect (hWnd, &rd_window);
+		if(rd_window.top == rd_window.bottom)return 0;   //window is minimized
+		if (GetWindowTextLength(hWnd)==0)
+		{
+			SetWindowText(hWnd,"MPlayer - DirectX NoN-Overlay"); //for the first call: change only title, not d_image stuff 
+		}
+        else
+		{
+            d_image_width = rd_window.right - rd_window.left; //Calculate new Imagedimensions
+            d_image_height = rd_window.bottom - rd_window.top;
+		}
+        point_window.x = 0;                          //imageposition relative to the window
+        point_window.y = 0;
+        ClientToScreen(hWnd,&point_window);  
+        rd.left = point_window.x;                    //fill the wanted x1&y1 of the image
+        rd.top = point_window.y;
+        rd.right = d_image_width+rd.left;
+        rd.bottom =d_image_height+rd.top;
+        rd_window = rd;         
+        AdjustWindowRect(&rd_window,WS_OVERLAPPEDWINDOW|WS_SIZEBOX,0);
+	}
+    else    //fullscreen
+	{
+		rd_window=Directx_Fullscreencalc();
+	}
+    if((fs) || (!fs && ontop))hWndafter=HWND_TOPMOST;
+	else hWndafter=HWND_NOTOPMOST;
+	SetWindowPos(hWnd,
+                 hWndafter,           
+                 rd_window.left,
+                 rd_window.top,
+                 rd_window.right - rd_window.left,
+                 rd_window.bottom - rd_window.top,
+                 SWP_SHOWWINDOW|SWP_NOOWNERZORDER);
+	return 0;
+}
+
+//find out supported overlay pixelformats
+static uint32_t Directx_CheckOverlayPixelformats()
+{
+    DDCAPS          capsDrv;
+    HRESULT         ddrval;
+    DDSURFACEDESC   ddsdOverlay;
+	uint32_t        i;
+    uint32_t        formatcount = 0;
+	//get driver caps to determine overlay support
+    ZeroMemory(&capsDrv, sizeof(capsDrv));
+    capsDrv.dwSize = sizeof(capsDrv);
+	ddrval = g_lpdd->lpVtbl->GetCaps(g_lpdd,&capsDrv, NULL);
+    if (FAILED(ddrval))
+	{
+        mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>failed getting ddrawcaps\n");
+		return 1;
+	}
+    if (!(capsDrv.dwCaps & DDCAPS_OVERLAY))
+    {
+		mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>Your card doesn't support overlay\n");
+		return 1;
+	}
+    mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>testing supported overlay pixelformats\n");
+    //it is not possible to query for pixel formats supported by the
+    //overlay hardware: try out various formats till one works  
+    ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
+    ddsdOverlay.dwSize = sizeof(ddsdOverlay);
+    ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
+    ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH| DDSD_PIXELFORMAT;
+    ddsdOverlay.dwWidth=300;
+    ddsdOverlay.dwHeight=280;
+    ddsdOverlay.dwBackBufferCount=0;
+    //try to create an overlay surface using one of the pixel formats in our global list
+	i=0;
+    do 
+    {
+   		ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
+        ddrval = g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL);
+        if (ddrval == DD_OK)
+		{
+			 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT OVERLAY>%i %s supported\n",i,g_ddpf[i].img_format_name);
+			 g_ddpf[i].drv_caps = VFCAP_CSP_SUPPORTED |VFCAP_OSD |VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP;
+			 formatcount++;}
+	    else mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT OVERLAY>%i %s not supported\n",i,g_ddpf[i].img_format_name);
+		if (g_lpddsOverlay != NULL) {g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);g_lpddsOverlay = NULL;}
+	} while( ++i < NUM_FORMATS );
+    mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>Your card supports %i of %i overlayformats\n",formatcount, NUM_FORMATS);
+	if (formatcount == 0)
+	{
+		mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><WARN>Your card supports overlay, but we couldn't create one\n");
+		mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>This can have the following reasons:\n");
+		mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- you are already using an overlay with another app\n");
+		mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- you don't have enough videomemory\n");
+		mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- vo_directx doesn't support the cards overlay pixelformat\n");
+		return 1;
+	}
+    if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYMIRRORLEFTRIGHT)mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>can mirror left right\n"); //I don't have hardware which
+    if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYMIRRORUPDOWN )mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>can mirror up down\n");      //supports those send me one and I'll implement ;)
+	return 0;		
+}
+
+//find out the Pixelformat of the Primary Surface
+static uint32_t Directx_CheckPrimaryPixelformat()
+{	
+	uint32_t i=0;
+    uint32_t formatcount = 0;
+	DDPIXELFORMAT	ddpf;
+	mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>checking primary surface\n");
+	memset( &ddpf, 0, sizeof( DDPIXELFORMAT ));
+    ddpf.dwSize = sizeof( DDPIXELFORMAT );
+    //we have to create a primary surface first
+	if(Directx_CreatePrimarySurface()!=0)return 1;
+	if(g_lpddsPrimary->lpVtbl->GetPixelFormat( g_lpddsPrimary, &ddpf ) != DD_OK )
+	{
+		mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>can't get pixelformat\n");
+		return 1;
+	}
+    while ( i < NUM_FORMATS )
+    {
+	   if (g_ddpf[i].g_ddpfOverlay.dwRGBBitCount == ddpf.dwRGBBitCount)
+	   {
+           if (g_ddpf[i].g_ddpfOverlay.dwRBitMask == ddpf.dwRBitMask)
+		   {
+			   mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT PRIMARY>%i %s supported\n",i,g_ddpf[i].img_format_name);
+			   g_ddpf[i].drv_caps = VFCAP_CSP_SUPPORTED |VFCAP_OSD |VFCAP_CSP_SUPPORTED_BY_HW;
+			   formatcount++;
+		   }
+	   }
+	   i++;
+    }
+	g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
+	g_lpddsPrimary = NULL;
+	if(formatcount==0)
+	{
+		mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>Unknown Pixelformat\n");
+		return 1;
+	}
+	return 0;
+}
+
+//function handles input
+static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch (message)
+    {
+		case WM_DESTROY:
+		{
+			mplayer_put_key('q');
+		    return 0;
+		}
+        case WM_CLOSE:
+		{
+			mplayer_put_key('q');
+			return 0;
+		}
+        case WM_WINDOWPOSCHANGED:
+		{
+			//printf("Windowposchange\n");
+			if(nooverlay)Directx_DisplayNonOverlay();
+		    else Directx_DisplayOverlay();
+		    break;
+		}
+        case WM_SYSCOMMAND:
+		{
+