libvo/vo_directx.c

   1 /*
   2  * Directx v2 or later DirectDraw interface
   3  *
   4  * Copyright (c) 2002 - 2005 Sascha Sommer <saschasommer@freenet.de>
   5  *
   6  * This file is part of MPlayer.
   7  *
   8  * MPlayer is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * MPlayer is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include <windows.h>
  24 #include <windowsx.h>
  25 #include <ddraw.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <libavutil/common.h>
  30 #include "config.h"
  31 #include "video_out.h"
  32 #include "video_out_internal.h"
  33 #include "fastmemcpy.h"
  34 #include "mp_msg.h"
  35 #include "aspect.h"
  36 #include "sub/sub.h"
  37 #include "w32_common.h"
  38
  39 static LPDIRECTDRAWCOLORCONTROL g_cc = NULL;            //color control interface
  40 static LPDIRECTDRAW7        g_lpdd = NULL;          //DirectDraw Object
  41 static LPDIRECTDRAWSURFACE7  g_lpddsPrimary = NULL;  //Primary Surface: viewport through the Desktop
  42 static LPDIRECTDRAWSURFACE7  g_lpddsOverlay = NULL;  //Overlay Surface
  43 static LPDIRECTDRAWSURFACE7  g_lpddsBack = NULL;     //Back surface
  44 static LPDIRECTDRAWCLIPPER  g_lpddclipper;          //clipper object, can only be used without overlay
  45 static DDSURFACEDESC2           ddsdsf;                 //surface descripiton needed for locking
  46 static HINSTANCE            hddraw_dll;             //handle to ddraw.dll
  47 static RECT                 rd;                     //rect of our stretched image
  48 static RECT                 rs;                     //rect of our source image
  49 static HBRUSH               colorbrush = NULL;      // Handle to colorkey brush
  50 static HBRUSH               blackbrush = NULL;      // Handle to black brush
  51 static uint32_t image_width, image_height;          //image width and height
  52 static uint8_t  *image=NULL;                        //image data
  53 static void* tmp_image = NULL;
  54 static uint32_t image_format=0;                       //image format
  55 static uint32_t primary_image_format;
  56 static uint32_t vm_height=0;
  57 static uint32_t vm_width=0;
  58 static uint32_t vm_bpp=0;
  59 static uint32_t dstride;                            //surface stride
  60 static uint32_t nooverlay = 0;                      //NonOverlay mode
  61 static DWORD    destcolorkey;                       //colorkey for our surface
  62 static COLORREF windowcolor = RGB(0,0,16);          //windowcolor == colorkey
  63 static int adapter_count=0;
  64 static GUID selected_guid;
  65 static GUID *selected_guid_ptr = NULL;
  66
  67 /*****************************************************************************
  68  * DirectDraw GUIDs.
  69  * Defining them here allows us to get rid of the dxguid library during
  70  * the linking stage.
  71  *****************************************************************************/
  72 #define IID_IDirectDraw7 MP_IID_IDirectDraw7
  73 static const GUID MP_IID_IDirectDraw7 =
  74 {
  75         0x15e65ec0,0x3b9c,0x11d2,{0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b}
  76 };
  77
  78 #define IID_IDirectDrawColorControl MP_IID_IDirectDrawColorControl
  79 static const GUID MP_IID_IDirectDrawColorControl =
  80 {
  81         0x4b9f0ee0,0x0d7e,0x11d0,{0x9b,0x06,0x00,0xa0,0xc9,0x03,0xa3,0xb8}
  82 };
  83
  84
  85 typedef struct directx_fourcc_caps
  86 {
  87    char*  img_format_name;      //human readable name
  88    uint32_t img_format;         //as MPlayer image format
  89    uint32_t drv_caps;           //what hw supports with this format
  90    DDPIXELFORMAT g_ddpfOverlay; //as Directx Sourface description
  91 } directx_fourcc_caps;
  92
  93
  94 static directx_fourcc_caps g_ddpf[] =
  95 {
  96         {"YV12 ",IMGFMT_YV12 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','V','1','2'),0,0,0,0,0}},
  97         {"I420 ",IMGFMT_I420 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('I','4','2','0'),0,0,0,0,0}},   //yv12 with swapped uv
  98         {"IYUV ",IMGFMT_IYUV ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('I','Y','U','V'),0,0,0,0,0}},   //same as i420
  99         {"YVU9 ",IMGFMT_YVU9 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','V','U','9'),0,0,0,0,0}},
 100         {"YUY2 ",IMGFMT_YUY2 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0}},
 101         {"UYVY ",IMGFMT_UYVY ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0}},
 102         {"BGR8 ",IMGFMT_BGR8 ,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 8,  0x00000000, 0x00000000, 0x00000000, 0}},
 103         {"RGB15",IMGFMT_RGB15,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x0000001F, 0x000003E0, 0x00007C00, 0}},   //RGB 5:5:5
 104         {"BGR15",IMGFMT_BGR15,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x00007C00, 0x000003E0, 0x0000001F, 0}},
 105         {"RGB16",IMGFMT_RGB16,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x0000001F, 0x000007E0, 0x0000F800, 0}},   //RGB 5:6:5
 106     {"BGR16",IMGFMT_BGR16,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16,  0x0000F800, 0x000007E0, 0x0000001F, 0}},
 107         {"RGB24",IMGFMT_RGB24,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 24,  0x000000FF, 0x0000FF00, 0x00FF0000, 0}},
 108     {"BGR24",IMGFMT_BGR24,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 24,  0x00FF0000, 0x0000FF00, 0x000000FF, 0}},
 109     {"RGB32",IMGFMT_RGB32,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 32,  0x000000FF, 0x0000FF00, 0x00FF0000, 0}},
 110     {"BGR32",IMGFMT_BGR32,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 32,  0x00FF0000, 0x0000FF00, 0x000000FF, 0}}
 111 };
 112 #define NUM_FORMATS (sizeof(g_ddpf) / sizeof(g_ddpf[0]))
 113
 114 static const vo_info_t info =
 115 {
 116         "Directx DDraw YUV/RGB/BGR renderer",
 117         "directx",
 118         "Sascha Sommer <saschasommer@freenet.de>",
 119         ""
 120 };
 121
 122 const LIBVO_EXTERN(directx)
 123
 124 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
 125                 unsigned char *srca, int stride)
 126 {
 127     switch(image_format) {
 128     case IMGFMT_YV12 :
 129     case IMGFMT_I420 :
 130         case IMGFMT_IYUV :
 131         case IMGFMT_YVU9 :
 132         vo_draw_alpha_yv12(w,h,src,srca,stride,((uint8_t *) image) + dstride*y0 + x0,dstride);
 133         break;
 134         case IMGFMT_YUY2 :
 135             vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) image)+ dstride*y0 + 2*x0 ,dstride);
 136     break;
 137     case IMGFMT_UYVY :
 138         vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) image) + dstride*y0 + 2*x0 + 1,dstride);
 139     break;
 140         case IMGFMT_RGB15:
 141     case IMGFMT_BGR15:
 142                 vo_draw_alpha_rgb15(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+2*x0,dstride);
 143     break;
 144     case IMGFMT_RGB16:
 145         case IMGFMT_BGR16:
 146         vo_draw_alpha_rgb16(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+2*x0,dstride);
 147     break;
 148     case IMGFMT_RGB24:
 149         case IMGFMT_BGR24:
 150         vo_draw_alpha_rgb24(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+4*x0,dstride);
 151     break;
 152     case IMGFMT_RGB32:
 153         case IMGFMT_BGR32:
 154         vo_draw_alpha_rgb32(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+4*x0,dstride);
 155     break;
 156     }
 157 }
 158
 159 static void draw_osd(void)
 160 {
 161     vo_draw_text(image_width,image_height,draw_alpha);
 162 }
 163
 164 static int
 165 query_format(uint32_t format)
 166 {
 167     uint32_t i=0;
 168     while ( i < NUM_FORMATS )
 169     {
 170                 if (g_ddpf[i].img_format == format)
 171                     return g_ddpf[i].drv_caps;
 172             i++;
 173     }
 174     return 0;
 175 }
 176
 177 static uint32_t Directx_CreatePrimarySurface(void)
 178 {
 179     DDSURFACEDESC2   ddsd;
 180     //cleanup
 181         if(g_lpddsPrimary)g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
 182         g_lpddsPrimary=NULL;
 183
 184     if(vidmode)g_lpdd->lpVtbl->SetDisplayMode(g_lpdd,vm_width,vm_height,vm_bpp,vo_refresh_rate,0);
 185     ZeroMemory(&ddsd, sizeof(ddsd));
 186     ddsd.dwSize = sizeof(ddsd);
 187     //set flags and create a primary surface.
 188     ddsd.dwFlags = DDSD_CAPS;
 189     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
 190     if(g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsd, &g_lpddsPrimary, NULL )== DD_OK)
 191                 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>primary surface created\n");
 192         else
 193         {
 194                 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>could not create primary surface\n");
 195                 return 1;
 196         }
 197         return 0;
 198 }
 199
 200 static uint32_t Directx_CreateOverlay(uint32_t imgfmt)
 201 {
 202     HRESULT ddrval;
 203     DDSURFACEDESC2   ddsdOverlay;
 204     uint32_t        i=0;
 205         while ( i < NUM_FORMATS && imgfmt != g_ddpf[i].img_format)
 206         {
 207                 i++;
 208         }
 209         if (!g_lpdd || !g_lpddsPrimary || i == NUM_FORMATS)
 210         return 1;
 211     //cleanup
 212         if (g_lpddsOverlay)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
 213         if (g_lpddsBack)g_lpddsBack->lpVtbl->Release(g_lpddsBack);
 214         g_lpddsOverlay= NULL;
 215         g_lpddsBack = NULL;
 216         //create our overlay
 217     ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
 218     ddsdOverlay.dwSize = sizeof(ddsdOverlay);
 219     ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_FLIP | DDSCAPS_COMPLEX | DDSCAPS_VIDEOMEMORY;
 220     ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT| DDSD_PIXELFORMAT;
 221     ddsdOverlay.dwWidth=image_width;
 222     ddsdOverlay.dwHeight=image_height;
 223     ddsdOverlay.dwBackBufferCount=2;
 224         ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
 225         if(vo_doublebuffering)   //tribblebuffering
 226         {
 227                 if (g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL)== DD_OK)
 228                 {
 229                         mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>overlay with format %s created\n",g_ddpf[i].img_format_name);
 230             //get the surface directly attached to the primary (the back buffer)
 231             ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
 232             if(g_lpddsOverlay->lpVtbl->GetAttachedSurface(g_lpddsOverlay,&ddsdOverlay.ddsCaps, &g_lpddsBack) != DD_OK)
 233                         {
 234                                 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't get attached surface\n");
 235                                 return 1;
 236                         }
 237                         return 0;
 238                 }
 239                 vo_doublebuffering=0; //disable tribblebuffering
 240                 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><WARN>cannot create tribblebuffer overlay with format %s\n",g_ddpf[i].img_format_name);
 241         }
 242         //single buffer
 243         mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>using singlebuffer overlay\n");
 244     ddsdOverlay.dwBackBufferCount=0;
 245     ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
 246     ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;
 247     ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
 248         // try to create the overlay surface
 249         ddrval = g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL);
 250         if(ddrval != DD_OK)
 251         {
 252            if(ddrval == DDERR_INVALIDPIXELFORMAT)mp_msg(MSGT_VO,MSGL_V,"<vo_directx><ERROR> invalid pixelformat: %s\n",g_ddpf[i].img_format_name);
 253        else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>");
 254        switch(ddrval)
 255            {
 256               case DDERR_INCOMPATIBLEPRIMARY:
 257                          {mp_msg(MSGT_VO, MSGL_ERR,"incompatible primary surface\n");break;}
 258                   case DDERR_INVALIDCAPS:
 259                          {mp_msg(MSGT_VO, MSGL_ERR,"invalid caps\n");break;}
 260               case DDERR_INVALIDOBJECT:
 261                      {mp_msg(MSGT_VO, MSGL_ERR,"invalid object\n");break;}
 262               case DDERR_INVALIDPARAMS:
 263                      {mp_msg(MSGT_VO, MSGL_ERR,"invalid parameters\n");break;}
 264               case DDERR_NODIRECTDRAWHW:
 265                      {mp_msg(MSGT_VO, MSGL_ERR,"no directdraw hardware\n");break;}
 266               case DDERR_NOEMULATION:
 267                      {mp_msg(MSGT_VO, MSGL_ERR,"can't emulate\n");break;}
 268               case DDERR_NOFLIPHW:
 269                      {mp_msg(MSGT_VO, MSGL_ERR,"hardware can't do flip\n");break;}
 270               case DDERR_NOOVERLAYHW:
 271                      {mp_msg(MSGT_VO, MSGL_ERR,"hardware can't do overlay\n");break;}
 272               case DDERR_OUTOFMEMORY:
 273                      {mp_msg(MSGT_VO, MSGL_ERR,"not enough system memory\n");break;}
 274               case DDERR_UNSUPPORTEDMODE:
 275                          {mp_msg(MSGT_VO, MSGL_ERR,"unsupported mode\n");break;}
 276                   case DDERR_OUTOFVIDEOMEMORY:
 277                          {mp_msg(MSGT_VO, MSGL_ERR,"not enough video memory\n");break;}
 278           default:
 279              mp_msg(MSGT_VO, MSGL_ERR,"create surface failed with 0x%xu\n",(unsigned)ddrval);
 280            }
 281            return 1;
 282         }
 283     g_lpddsBack = g_lpddsOverlay;
 284         return 0;
 285 }
 286
 287 static uint32_t Directx_CreateBackpuffer(void)
 288 {
 289     DDSURFACEDESC2   ddsd;
 290         //cleanup
 291         if (g_lpddsBack)g_lpddsBack->lpVtbl->Release(g_lpddsBack);
 292         g_lpddsBack=NULL;
 293         ZeroMemory(&ddsd, sizeof(ddsd));
 294     ddsd.dwSize = sizeof(ddsd);
 295     ddsd.ddsCaps.dwCaps= DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
 296     ddsd.dwFlags= DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
 297     ddsd.dwWidth=image_width;
 298     ddsd.dwHeight=image_height;
 299     if(g_lpdd->lpVtbl->CreateSurface( g_lpdd, &ddsd, &g_lpddsBack, 0 ) != DD_OK )
 300         {
 301                 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't create backpuffer\n");
 302                 return 1;
 303         }
 304     mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>backbuffer created\n");
 305         return 0;
 306 }
 307
 308 static void uninit(void)
 309 {
 310         if (g_cc != NULL)
 311         {
 312                 g_cc->lpVtbl->Release(g_cc);
 313         }
 314         g_cc=NULL;
 315         if (g_lpddclipper != NULL) g_lpddclipper->lpVtbl->Release(g_lpddclipper);
 316         g_lpddclipper = NULL;
 317         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>clipper released\n");
 318         if (g_lpddsBack != NULL) g_lpddsBack->lpVtbl->Release(g_lpddsBack);
 319         g_lpddsBack = NULL;
 320         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>back surface released\n");
 321         if(vo_doublebuffering && !nooverlay)
 322         {
 323                 if (g_lpddsOverlay != NULL)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
 324         g_lpddsOverlay = NULL;
 325                 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>overlay surface released\n");
 326         }
 327         if (g_lpddsPrimary != NULL) g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
 328     g_lpddsPrimary = NULL;
 329         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>primary released\n");
 330         if (colorbrush) DeleteObject(colorbrush);
 331         colorbrush = NULL;
 332         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>GDI resources deleted\n");
 333         if (g_lpdd != NULL){
 334             if(vidmode)g_lpdd->lpVtbl->RestoreDisplayMode(g_lpdd);
 335             g_lpdd->lpVtbl->Release(g_lpdd);
 336         }
 337         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>directdrawobject released\n");
 338         FreeLibrary( hddraw_dll);
 339         hddraw_dll= NULL;
 340         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>ddraw.dll freed\n");
 341         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>uninitialized\n");
 342         vo_w32_uninit();
 343 }
 344
 345 static BOOL WINAPI EnumCallbackEx(GUID FAR *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext, HMONITOR  hm)
 346 {
 347     if (!lpGUID)
 348         lpDriverDescription = "Primary Display Adapter";
 349     mp_msg(MSGT_VO, MSGL_INFO ,"<vo_directx> adapter %d: %s", adapter_count, lpDriverDescription);
 350
 351     if(adapter_count == vo_adapter_num){
 352         if (!lpGUID)
 353             selected_guid_ptr = NULL;
 354         else
 355         {
 356             selected_guid = *lpGUID;
 357             selected_guid_ptr = &selected_guid;
 358         }
 359
 360         mp_msg(MSGT_VO, MSGL_INFO ,"\t\t<--");
 361     }
 362     mp_msg(MSGT_VO, MSGL_INFO ,"\n");
 363
 364     adapter_count++;
 365
 366     return 1; // list all adapters
 367 }
 368
 369 static uint32_t Directx_InitDirectDraw(void)
 370 {
 371         HRESULT    (WINAPI *OurDirectDrawCreateEx)(GUID *,LPVOID *, REFIID,IUnknown FAR *);
 372         DDSURFACEDESC2 ddsd;
 373         LPDIRECTDRAWENUMERATEEX OurDirectDrawEnumerateEx;
 374
 375         adapter_count = 0;
 376
 377         mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>Initing DirectDraw\n" );
 378
 379         //load direct draw DLL: based on videolans code
 380         hddraw_dll = LoadLibrary("DDRAW.DLL");
 381         if( hddraw_dll == NULL )
 382     {
 383         mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed loading ddraw.dll\n" );
 384                 return 1;
 385     }
 386
 387         if(vo_adapter_num){ //display other than default
 388         OurDirectDrawEnumerateEx = (LPDIRECTDRAWENUMERATEEX) GetProcAddress(hddraw_dll,"DirectDrawEnumerateExA");
 389         if (!OurDirectDrawEnumerateEx){
 390             FreeLibrary( hddraw_dll );
 391             hddraw_dll = NULL;
 392             mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed geting proc address: DirectDrawEnumerateEx\n");
 393             mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>no directx 7 or higher installed\n");
 394             return 1;
 395         }
 396
 397         // enumerate all display devices attached to the desktop
 398         OurDirectDrawEnumerateEx(EnumCallbackEx, NULL, DDENUM_ATTACHEDSECONDARYDEVICES );
 399
 400         if(vo_adapter_num >= adapter_count)
 401             mp_msg(MSGT_VO, MSGL_ERR,"Selected adapter (%d) doesn't exist: Default Display Adapter selected\n",vo_adapter_num);
 402     }
 403
 404         OurDirectDrawCreateEx = (void *)GetProcAddress(hddraw_dll, "DirectDrawCreateEx");
 405     if ( OurDirectDrawCreateEx == NULL )
 406      {
 407          FreeLibrary( hddraw_dll );
 408          hddraw_dll = NULL;
 409         mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed geting proc address: DirectDrawCreateEx\n");
 410                 return 1;
 411      }
 412
 413         // initialize DirectDraw and create directx v7 object
 414     if (OurDirectDrawCreateEx(selected_guid_ptr, (VOID**)&g_lpdd, &IID_IDirectDraw7, NULL ) != DD_OK )
 415     {
 416         FreeLibrary( hddraw_dll );
 417         hddraw_dll = NULL;
 418         mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't initialize ddraw\n");
 419                 return 1;
 420     }
 421
 422         //get current screen siz for selected monitor ...
 423         ddsd.dwSize=sizeof(ddsd);
 424         ddsd.dwFlags=DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
 425         g_lpdd->lpVtbl->GetDisplayMode(g_lpdd, &ddsd);
 426         if(vo_screenwidth && vo_screenheight)
 427         {
 428             vm_height=vo_screenheight;
 429             vm_width=vo_screenwidth;
 430         }
 431     else
 432     {
 433             vm_height=ddsd.dwHeight;
 434             vm_width=ddsd.dwWidth;
 435         }
 436
 437
 438         if(vo_dbpp)vm_bpp=vo_dbpp;
 439         else vm_bpp=ddsd.ddpfPixelFormat.dwRGBBitCount;
 440
 441         if(vidmode){
 442                 if (g_lpdd->lpVtbl->SetCooperativeLevel(g_lpdd, vo_w32_window, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN) != DD_OK)
 443                 {
 444                 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't set cooperativelevel for exclusive mode\n");
 445             return 1;
 446                 }
 447                 /*SetDisplayMode(ddobject,width,height,bpp,refreshrate,aditionalflags)*/
 448                 if(g_lpdd->lpVtbl->SetDisplayMode(g_lpdd,vm_width, vm_height, vm_bpp,0,0) != DD_OK)
 449                 {
 450                 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't set displaymode\n");
 451                 return 1;
 452                 }
 453             mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>Initialized adapter %i for %i x %i @ %i \n",vo_adapter_num,vm_width,vm_height,vm_bpp);
 454             return 0;
 455         }
 456         if (g_lpdd->lpVtbl->SetCooperativeLevel(g_lpdd, vo_w32_window, DDSCL_NORMAL) != DD_OK) // or DDSCL_SETFOCUSWINDOW
 457      {
 458         mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>could not set cooperativelevel for hardwarecheck\n");
 459                 return 1;
 460     }
 461     mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>DirectDraw Initialized\n");
 462         return 0;
 463 }
 464
 465 static uint32_t Directx_ManageDisplay(void)
 466 {
 467     HRESULT         ddrval;
 468     DDCAPS          capsDrv;
 469     DDOVERLAYFX     ovfx;
 470     DWORD           dwUpdateFlags=0;
 471     int width,height;
 472
 473     rd.left = vo_dx - xinerama_x;
 474     rd.top  = vo_dy - xinerama_y;
 475     width  = vo_dwidth;
 476     height = vo_dheight;
 477
 478     aspect(&width, &height, A_WINZOOM);
 479     panscan_calc_windowed();
 480     width  += vo_panscan_x;
 481     height += vo_panscan_y;
 482     width  = FFMIN(width,  vo_screenwidth);
 483     height = FFMIN(height, vo_screenheight);
 484     rd.left += (vo_dwidth  - width ) / 2;
 485     rd.top  += (vo_dheight - height) / 2;
 486
 487     rd.right=rd.left+width;
 488     rd.bottom=rd.top+height;
 489
 490         /*ok, let's workaround some overlay limitations*/
 491         if(!nooverlay)
 492         {
 493                 uint32_t        uStretchFactor1000;  //minimum stretch
 494         uint32_t        xstretch1000,ystretch1000;
 495                 /*get driver capabilities*/
 496         ZeroMemory(&capsDrv, sizeof(capsDrv));
 497         capsDrv.dwSize = sizeof(capsDrv);
 498         if(g_lpdd->lpVtbl->GetCaps(g_lpdd,&capsDrv, NULL) != DD_OK)return 1;
 499                 /*get minimum stretch, depends on display adaptor and mode (refresh rate!) */
 500         uStretchFactor1000 = capsDrv.dwMinOverlayStretch>1000 ? capsDrv.dwMinOverlayStretch : 1000;
 501         rd.right = ((width+rd.left)*uStretchFactor1000+999)/1000;
 502         rd.bottom = (height+rd.top)*uStretchFactor1000/1000;
 503         /*calculate xstretch1000 and ystretch1000*/
 504         xstretch1000 = ((rd.right - rd.left)* 1000)/image_width ;
 505         ystretch1000 = ((rd.bottom - rd.top)* 1000)/image_height;
 506                 rs.left=0;
 507                 rs.right=image_width;
 508                 rs.top=0;
 509                 rs.bottom=image_height;
 510         if(rd.left < 0)rs.left=(-rd.left*1000)/xstretch1000;
 511         if(rd.top < 0)rs.top=(-rd.top*1000)/ystretch1000;
 512         if(rd.right > vo_screenwidth)rs.right=((vo_screenwidth-rd.left)*1000)/xstretch1000;
 513         if(rd.bottom > vo_screenheight)rs.bottom=((vo_screenheight-rd.top)*1000)/ystretch1000;
 514                 /*do not allow to zoom or shrink if hardware isn't able to do so*/
 515                 if((width < image_width)&& !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKX))
 516                 {
 517                         if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKXN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only shrinkN\n");
 518                 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't shrink x\n");
 519                 rd.right=rd.left+image_width;
 520                 }
 521                 else if((width > image_width)&& !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHX))
 522                 {
 523                         if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHXN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only stretchN\n");
 524                 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't stretch x\n");
 525                 rd.right = rd.left+image_width;
 526                 }
 527                 if((height < image_height) && !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKY))
 528                 {
 529                         if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKYN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only shrinkN\n");
 530                 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't shrink y\n");
 531                 rd.bottom = rd.top + image_height;
 532                 }
 533                 else if((height > image_height ) && !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHY))
 534                 {
 535                         if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHYN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only stretchN\n");
 536                 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't stretch y\n");
 537                 rd.bottom = rd.top + image_height;
 538                 }
 539                 /*the last thing to check are alignment restrictions
 540           these expressions (x & -y) just do alignment by dropping low order bits...
 541           so to round up, we add first, then truncate*/
 542                 if((capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYSRC) && capsDrv.dwAlignBoundarySrc)
 543                   rs.left = (rs.left + capsDrv.dwAlignBoundarySrc / 2) & -(signed)(capsDrv.dwAlignBoundarySrc);
 544         if((capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC) && capsDrv.dwAlignSizeSrc)
 545                   rs.right = rs.left + ((rs.right - rs.left + capsDrv.dwAlignSizeSrc / 2) & -(signed) (capsDrv.dwAlignSizeSrc));
 546         if((capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYDEST) && capsDrv.dwAlignBoundaryDest)
 547                   rd.left = (rd.left + capsDrv.dwAlignBoundaryDest / 2) & -(signed)(capsDrv.dwAlignBoundaryDest);
 548         if((capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST) && capsDrv.dwAlignSizeDest)
 549                   rd.right = rd.left + ((rd.right - rd.left) & -(signed) (capsDrv.dwAlignSizeDest));
 550                 /*create an overlay FX structure to specify a destination color key*/
 551                 ZeroMemory(&ovfx, sizeof(ovfx));
 552         ovfx.dwSize = sizeof(ovfx);
 553         if(vo_fs||vidmode)
 554                 {
 555                         ovfx.dckDestColorkey.dwColorSpaceLowValue = 0;
 556             ovfx.dckDestColorkey.dwColorSpaceHighValue = 0;
 557                 }
 558                 else
 559                 {
 560                         ovfx.dckDestColorkey.dwColorSpaceLowValue = destcolorkey;
 561             ovfx.dckDestColorkey.dwColorSpaceHighValue = destcolorkey;
 562                 }
 563         // set the flags we'll send to UpdateOverlay      //DDOVER_AUTOFLIP|DDOVERFX_MIRRORLEFTRIGHT|DDOVERFX_MIRRORUPDOWN could be useful?;
 564         dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX;
 565         /*if hardware can't do colorkeying set the window on top*/
 566                 if(capsDrv.dwCKeyCaps & DDCKEYCAPS_DESTOVERLAY) dwUpdateFlags |= DDOVER_KEYDESTOVERRIDE;
 567         else if (!tmp_image) vo_ontop = 1;
 568         }
 569     else
 570     {
 571         g_lpddclipper->lpVtbl->SetHWnd(g_lpddclipper, 0, vo_w32_window);
 572     }
 573
 574     /*make sure the overlay is inside the screen*/
 575     if(rd.left<0)rd.left=0;
 576     if(rd.right>vo_screenwidth)rd.right=vo_screenwidth;
 577     if(rd.top<0)rd.top=0;
 578     if(rd.bottom>vo_screenheight)rd.bottom=vo_screenheight;
 579
 580         /*for nonoverlay mode we are finished, for overlay mode we have to display the overlay first*/
 581         if(nooverlay)return 0;
 582
 583 //    printf("overlay: %i %i %ix%i\n",rd.left,rd.top,rd.right - rd.left,rd.bottom - rd.top);
 584         ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
 585     if(FAILED(ddrval))
 586     {
 587         // one cause might be the driver lied about minimum stretch
 588         // we should try upping the destination size a bit, or
 589         // perhaps shrinking the source size
 590                 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>UpdateOverlay failed\n" );
 591                 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>Overlay:x1:%li,y1:%li,x2:%li,y2:%li,w:%li,h:%li\n",rd.left,rd.top,rd.right,rd.bottom,rd.right - rd.left,rd.bottom - rd.top );
 592                 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>");
 593                 switch (ddrval)
 594                 {
 595                         case DDERR_NOSTRETCHHW:
 596                                 {mp_msg(MSGT_VO, MSGL_ERR ,"hardware can't stretch: try to size the window back\n");break;}
 597             case DDERR_INVALIDRECT:
 598                                 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid rectangle\n");break;}
 599                         case DDERR_INVALIDPARAMS:
 600                                 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid parameters\n");break;}
 601                         case DDERR_HEIGHTALIGN:
 602                                 {mp_msg(MSGT_VO, MSGL_ERR ,"height align\n");break;}
 603                         case DDERR_XALIGN:
 604                                 {mp_msg(MSGT_VO, MSGL_ERR ,"x align\n");break;}
 605                         case DDERR_UNSUPPORTED:
 606                                 {mp_msg(MSGT_VO, MSGL_ERR ,"unsupported\n");break;}
 607                         case DDERR_INVALIDSURFACETYPE:
 608                                 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid surfacetype\n");break;}
 609                         case DDERR_INVALIDOBJECT:
 610                                 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid object\n");break;}
 611                         case DDERR_SURFACELOST:
 612                                 {
 613                                         mp_msg(MSGT_VO, MSGL_ERR ,"surfaces lost\n");
 614                                         g_lpddsOverlay->lpVtbl->Restore( g_lpddsOverlay ); //restore and try again
 615                                 g_lpddsPrimary->lpVtbl->Restore( g_lpddsPrimary );
 616                                 ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
 617                                         if(ddrval !=DD_OK)mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>UpdateOverlay failed again\n" );
 618                                         break;
 619                                 }
 620             default:
 621                 mp_msg(MSGT_VO, MSGL_ERR ," 0x%xu\n",(unsigned)ddrval);
 622                 }
 623             /*ok we can't do anything about it -> hide overlay*/
 624                 if(ddrval != DD_OK)
 625                 {
 626                         ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,NULL, g_lpddsPrimary, NULL, DDOVER_HIDE, NULL);
 627             return 1;
 628                 }
 629         }
 630     return 0;
 631 }
 632
 633 static void check_events(void)
 634 {
 635     int evt = vo_w32_check_events();
 636     if (evt & (VO_EVENT_RESIZE | VO_EVENT_MOVE))
 637         Directx_ManageDisplay();
 638     if (evt & (VO_EVENT_RESIZE | VO_EVENT_MOVE | VO_EVENT_EXPOSE)) {
 639         HDC dc = vo_w32_get_dc(vo_w32_window);
 640         RECT r;
 641         GetClientRect(vo_w32_window, &r);
 642         FillRect(dc, &r, vo_fs || vidmode ? blackbrush : colorbrush);
 643         vo_w32_release_dc(vo_w32_window, dc);
 644     }
 645 }
 646
 647 //find out supported overlay pixelformats
 648 static uint32_t Directx_CheckOverlayPixelformats(void)
 649 {
 650     DDCAPS          capsDrv;
 651     HRESULT         ddrval;
 652     DDSURFACEDESC2   ddsdOverlay;
 653         uint32_t        i;
 654     uint32_t        formatcount = 0;
 655         //get driver caps to determine overlay support
 656     ZeroMemory(&capsDrv, sizeof(capsDrv));
 657     capsDrv.dwSize = sizeof(capsDrv);
 658         ddrval = g_lpdd->lpVtbl->GetCaps(g_lpdd,&capsDrv, NULL);
 659     if (FAILED(ddrval))
 660         {
 661         mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>failed getting ddrawcaps\n");
 662                 return 1;
 663         }
 664     if (!(capsDrv.dwCaps & DDCAPS_OVERLAY))
 665     {
 666                 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>Your card doesn't support overlay\n");
 667                 return 1;
 668         }
 669     mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>testing supported overlay pixelformats\n");
 670     //it is not possible to query for pixel formats supported by the
 671     //overlay hardware: try out various formats till one works
 672     ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
 673     ddsdOverlay.dwSize = sizeof(ddsdOverlay);
 674     ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
 675     ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH| DDSD_PIXELFORMAT;
 676     ddsdOverlay.dwWidth=300;
 677     ddsdOverlay.dwHeight=280;
 678     ddsdOverlay.dwBackBufferCount=0;
 679     //try to create an overlay surface using one of the pixel formats in our global list
 680         i=0;
 681     do
 682     {
 683                 ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
 684         ddrval = g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL);
 685         if (ddrval == DD_OK)
 686                 {
 687                          mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT OVERLAY>%i %s supported\n",i,g_ddpf[i].img_format_name);
 688                          g_ddpf[i].drv_caps = VFCAP_CSP_SUPPORTED |VFCAP_OSD |VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP;
 689                          formatcount++;}
 690             else mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT OVERLAY>%i %s not supported\n",i,g_ddpf[i].img_format_name);
 691                 if (g_lpddsOverlay != NULL) {g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);g_lpddsOverlay = NULL;}
 692         } while( ++i < NUM_FORMATS );
 693     mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>Your card supports %i of %i overlayformats\n",formatcount, NUM_FORMATS);
 694         if (formatcount == 0)
 695         {
 696                 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><WARN>Your card supports overlay, but we couldn't create one\n");
 697                 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>This can have the following reasons:\n");
 698                 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- you are already using an overlay with another app\n");
 699                 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- you don't have enough videomemory\n");
 700                 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- vo_directx doesn't support the cards overlay pixelformat\n");
 701                 return 1;
 702         }
 703     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
 704     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 ;)
 705         return 0;
 706 }
 707
 708 //find out the Pixelformat of the Primary Surface
 709 static uint32_t Directx_CheckPrimaryPixelformat(void)
 710 {
 711         uint32_t i=0;
 712     uint32_t formatcount = 0;
 713         DDPIXELFORMAT   ddpf;
 714         DDSURFACEDESC2   ddsd;
 715     HDC             hdc;
 716     HRESULT         hres;
 717         COLORREF        rgbT=RGB(0,0,0);
 718         mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>checking primary surface\n");
 719         memset( &ddpf, 0, sizeof( DDPIXELFORMAT ));
 720     ddpf.dwSize = sizeof( DDPIXELFORMAT );
 721     //we have to create a primary surface first
 722         if(Directx_CreatePrimarySurface()!=0)return 1;
 723         if(g_lpddsPrimary->lpVtbl->GetPixelFormat( g_lpddsPrimary, &ddpf ) != DD_OK )
 724         {
 725                 mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>can't get pixelformat\n");
 726                 return 1;
 727         }
 728     while ( i < NUM_FORMATS )
 729     {
 730            if (g_ddpf[i].g_ddpfOverlay.dwRGBBitCount == ddpf.dwRGBBitCount)
 731            {
 732            if (g_ddpf[i].g_ddpfOverlay.dwRBitMask == ddpf.dwRBitMask)
 733                    {
 734                            mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT PRIMARY>%i %s supported\n",i,g_ddpf[i].img_format_name);
 735                            g_ddpf[i].drv_caps = VFCAP_CSP_SUPPORTED |VFCAP_OSD;
 736                            formatcount++;
 737                primary_image_format=g_ddpf[i].img_format;
 738                    }
 739            }
 740            i++;
 741     }
 742     //get the colorkey for overlay mode
 743         destcolorkey = CLR_INVALID;
 744     if (windowcolor != CLR_INVALID && g_lpddsPrimary->lpVtbl->GetDC(g_lpddsPrimary,&hdc) == DD_OK)
 745     {
 746         rgbT = GetPixel(hdc, 0, 0);
 747         SetPixel(hdc, 0, 0, windowcolor);
 748         g_lpddsPrimary->lpVtbl->ReleaseDC(g_lpddsPrimary,hdc);
 749     }
 750     // read back the converted color
 751     ddsd.dwSize = sizeof(ddsd);
 752     while ((hres = g_lpddsPrimary->lpVtbl->Lock(g_lpddsPrimary,NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
 753         ;
 754     if (hres == DD_OK)
 755     {
 756         destcolorkey = *(DWORD *) ddsd.lpSurface;
 757         if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
 758             destcolorkey &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;
 759         g_lpddsPrimary->lpVtbl->Unlock(g_lpddsPrimary,NULL);
 760     }
 761     if (windowcolor != CLR_INVALID && g_lpddsPrimary->lpVtbl->GetDC(g_lpddsPrimary,&hdc) == DD_OK)
 762     {
 763         SetPixel(hdc, 0, 0, rgbT);
 764         g_lpddsPrimary->lpVtbl->ReleaseDC(g_lpddsPrimary,hdc);
 765     }
 766         //release primary
 767         g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
 768         g_lpddsPrimary = NULL;
 769         if(formatcount==0)
 770         {
 771                 mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>Unknown Pixelformat\n");
 772                 return 1;
 773         }
 774         return 0;
 775 }
 776
 777 static int preinit(const char *arg)
 778 {
 779         if(arg)
 780         {
 781                 if(strstr(arg,"noaccel"))
 782                 {
 783                         mp_msg(MSGT_VO,MSGL_V,"<vo_directx><INFO>disabled overlay\n");
 784                     nooverlay = 1;
 785                 }
 786         }
 787
 788     windowcolor = vo_colorkey;
 789     colorbrush = CreateSolidBrush(windowcolor);
 790     blackbrush = (HBRUSH)GetStockObject(BLACK_BRUSH);
 791         if (!vo_w32_init())
 792             return 1;
 793         if (!vo_w32_config(100, 100, VOFLAG_HIDDEN))
 794             return 1;
 795
 796         if (Directx_InitDirectDraw()!= 0)return 1;          //init DirectDraw
 797
 798     if (Directx_CheckPrimaryPixelformat()!=0)return 1;
 799         if (!nooverlay && Directx_CheckOverlayPixelformats() == 0)        //check for supported hardware
 800         {
 801                 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>hardware supports overlay\n");
 802                 nooverlay = 0;
 803         }
 804         else   //if we can't have overlay we create a backpuffer with the same imageformat as the primary surface
 805         {
 806         mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>using backpuffer\n");
 807                 nooverlay = 1;
 808         }
 809         mp_msg(MSGT_VO, MSGL_DBG3 ,"<vo_directx><INFO>preinit succesfully finished\n");
 810         return 0;
 811 }
 812
 813 static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y )
 814 {
 815         uint8_t *s;
 816     uint8_t *d;
 817     uint32_t uvstride=dstride/2;
 818         // copy Y
 819     d=image+dstride*y+x;
 820     s=src[0];
 821     mem2agpcpy_pic(d,s,w,h,dstride,stride[0]);
 822
 823         w/=2;h/=2;x/=2;y/=2;
 824
 825         // copy U
 826     d=image+dstride*image_height + uvstride*y+x;
 827     if(image_format == IMGFMT_YV12)s=src[2];
 828         else s=src[1];
 829     mem2agpcpy_pic(d,s,w,h,uvstride,stride[1]);
 830
 831         // copy V
 832     d=image+dstride*image_height +uvstride*(image_height/2) + uvstride*y+x;
 833     if(image_format == IMGFMT_YV12)s=src[1];
 834         else s=src[2];
 835     mem2agpcpy_pic(d,s,w,h,uvstride,stride[2]);
 836     return 0;
 837 }
 838
 839 static void flip_page(void)
 840 {
 841         HRESULT dxresult;
 842         g_lpddsBack->lpVtbl->Unlock (g_lpddsBack,NULL);
 843         if (vo_doublebuffering)
 844     {
 845                 // flip to the next image in the sequence
 846                 dxresult = g_lpddsOverlay->lpVtbl->Flip( g_lpddsOverlay,NULL, DDFLIP_WAIT);
 847                 if(dxresult == DDERR_SURFACELOST)
 848                 {
 849                         mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR><vo_directx><INFO>Restoring Surface\n");
 850                         g_lpddsBack->lpVtbl->Restore( g_lpddsBack );
 851                         // restore overlay and primary before calling
 852                         // Directx_ManageDisplay() to avoid error messages
 853                         g_lpddsOverlay->lpVtbl->Restore( g_lpddsOverlay );
 854                         g_lpddsPrimary->lpVtbl->Restore( g_lpddsPrimary );
 855                         // update overlay in case we return from screensaver
 856                         Directx_ManageDisplay();
 857                     dxresult = g_lpddsOverlay->lpVtbl->Flip( g_lpddsOverlay,NULL, DDFLIP_WAIT);
 858                 }
 859                 if(dxresult != DD_OK)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't flip page\n");
 860     }
 861         if(nooverlay)
 862         {
 863                 DDBLTFX  ddbltfx;
 864         // ask for the "NOTEARING" option
 865             memset( &ddbltfx, 0, sizeof(DDBLTFX) );
 866         ddbltfx.dwSize = sizeof(DDBLTFX);
 867         ddbltfx.dwDDFX = DDBLTFX_NOTEARING;
 868         g_lpddsPrimary->lpVtbl->Blt(g_lpddsPrimary, &rd, g_lpddsBack, NULL, DDBLT_WAIT, &ddbltfx);
 869         }
 870         if (g_lpddsBack->lpVtbl->Lock(g_lpddsBack,NULL,&ddsdsf, DDLOCK_NOSYSLOCK | DDLOCK_WAIT , NULL) == DD_OK) {
 871             if(vo_directrendering && (dstride != ddsdsf.lPitch)){
 872                 mp_msg(MSGT_VO,MSGL_WARN,"<vo_directx><WARN>stride changed !!!! disabling direct rendering\n");
 873                 vo_directrendering=0;
 874             }
 875             free(tmp_image);
 876             tmp_image = NULL;
 877             dstride = ddsdsf.lPitch;
 878             image = ddsdsf.lpSurface;
 879         } else if (!tmp_image) {
 880                 mp_msg(MSGT_VO, MSGL_WARN, "<vo_directx><WARN>Locking the surface failed, rendering to a hidden surface!\n");
 881                 tmp_image = image = calloc(1, image_height * dstride * 2);
 882         }
 883 }
 884
 885 static int draw_frame(uint8_t *src[])
 886 {
 887         fast_memcpy( image, *src, dstride * image_height );
 888         return 0;
 889 }
 890
 891 static uint32_t get_image(mp_image_t *mpi)
 892 {
 893     if(mpi->flags&MP_IMGFLAG_READABLE) {mp_msg(MSGT_VO, MSGL_V,"<vo_directx><ERROR>slow video ram\n");return VO_FALSE;}
 894     if(mpi->type==MP_IMGTYPE_STATIC) {mp_msg(MSGT_VO, MSGL_V,"<vo_directx><ERROR>not static\n");return VO_FALSE;}
 895     if((mpi->width==dstride) || (mpi->flags&(MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_ACCEPT_WIDTH)))
 896         {
 897                 if(mpi->flags&MP_IMGFLAG_PLANAR)
 898                 {
 899                     if(image_format == IMGFMT_YV12)
 900                         {
 901                                 mpi->planes[2]= image + dstride*image_height;
 902                     mpi->planes[1]= image + dstride*image_height+ dstride*image_height/4;
 903                 mpi->stride[1]=mpi->stride[2]=dstride/2;
 904                         }
 905                         else if(image_format == IMGFMT_IYUV || image_format == IMGFMT_I420)
 906                         {
 907                                 mpi->planes[1]= image + dstride*image_height;
 908                     mpi->planes[2]= image + dstride*image_height+ dstride*image_height/4;
 909                             mpi->stride[1]=mpi->stride[2]=dstride/2;
 910                         }
 911                         else if(image_format == IMGFMT_YVU9)
 912                         {
 913                                 mpi->planes[2] = image + dstride*image_height;
 914                                 mpi->planes[1] = image + dstride*image_height+ dstride*image_height/16;
 915                             mpi->stride[1]=mpi->stride[2]=dstride/4;
 916                         }
 917                 }
 918                 mpi->planes[0]=image;
 919         mpi->stride[0]=dstride;
 920                 mpi->width=image_width;
 921                 mpi->height=image_height;
 922         mpi->flags|=MP_IMGFLAG_DIRECT;
 923         mp_msg(MSGT_VO, MSGL_DBG3, "<vo_directx><INFO>Direct Rendering ENABLED\n");
 924         return VO_TRUE;
 925     }
 926     return VO_FALSE;
 927 }
 928
 929 static uint32_t put_image(mp_image_t *mpi){
 930
 931     uint8_t   *d;
 932         uint8_t   *s;
 933     uint32_t x = 0;
 934         uint32_t y = 0;
 935         uint32_t w = mpi->w;
 936         uint32_t h = mpi->h;
 937
 938     if((mpi->flags&MP_IMGFLAG_DIRECT)||(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK))
 939         {
 940                 mp_msg(MSGT_VO, MSGL_DBG3 ,"<vo_directx><INFO>put_image: nothing to do: drawslices\n");
 941                 return VO_TRUE;
 942     }
 943
 944     if (mpi->flags&MP_IMGFLAG_PLANAR)
 945         {
 946
 947                 if(image_format!=IMGFMT_YVU9)draw_slice(mpi->planes,mpi->stride,mpi->w,mpi->h,0,0);
 948                 else
 949                 {
 950                         // copy Y
 951             d=image+dstride*y+x;
 952             s=mpi->planes[0];
 953             mem2agpcpy_pic(d,s,w,h,dstride,mpi->stride[0]);
 954             w/=4;h/=4;x/=4;y/=4;
 955             // copy V
 956             d=image+dstride*image_height + dstride*y/4+x;
 957                 s=mpi->planes[2];
 958             mem2agpcpy_pic(d,s,w,h,dstride/4,mpi->stride[1]);
 959                 // copy U
 960             d=image+dstride*image_height + dstride*image_height/16 + dstride/4*y+x;
 961                     s=mpi->planes[1];
 962             mem2agpcpy_pic(d,s,w,h,dstride/4,mpi->stride[2]);
 963                 }
 964         }
 965         else //packed
 966         {
 967                 mem2agpcpy_pic(image, mpi->planes[0], w * (mpi->bpp / 8), h, dstride, mpi->stride[0]);
 968         }
 969         return VO_TRUE;
 970 }
 971
 972 static int
 973 config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t options, char *title, uint32_t format)
 974 {
 975         image_format =  format;
 976         image_width = width;
 977         image_height = height;
 978     if(format != primary_image_format)nooverlay = 0;
 979
 980     /*release all directx objects*/
 981     if (g_cc != NULL)g_cc->lpVtbl->Release(g_cc);
 982     g_cc=NULL;
 983     if(g_lpddclipper)g_lpddclipper->lpVtbl->Release(g_lpddclipper);
 984         g_lpddclipper=NULL;
 985     if (g_lpddsBack != NULL) g_lpddsBack->lpVtbl->Release(g_lpddsBack);
 986     g_lpddsBack = NULL;
 987     if(vo_doublebuffering)
 988         if (g_lpddsOverlay != NULL)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
 989     g_lpddsOverlay = NULL;
 990     if (g_lpddsPrimary != NULL) g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
 991     g_lpddsPrimary = NULL;
 992     mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>overlay surfaces released\n");
 993
 994         if (!vo_w32_config(d_width, d_height, options))
 995                 return 1;
 996
 997         if (WinID == -1)
 998         SetWindowText(vo_w32_window,title);
 999
1000
1001         /*create the surfaces*/
1002     if(Directx_CreatePrimarySurface())return 1;
1003
1004         //create palette for 256 color mode
1005         if(image_format==IMGFMT_BGR8){
1006                 LPDIRECTDRAWPALETTE ddpalette=NULL;
1007                 LPPALETTEENTRY palette=calloc(256, sizeof(*palette));
1008                 int i;
1009                 for(i=0; i<256; i++){
1010                         palette[i].peRed   = ((i >> 5) & 0x07) * 255 / 7;
1011                         palette[i].peGreen = ((i >> 2) & 0x07) * 255 / 7;
1012                         palette[i].peBlue  = ((i >> 0) & 0x03) * 255 / 3;
1013                         palette[i].peFlags = PC_NOCOLLAPSE;
1014                 }
1015                 g_lpdd->lpVtbl->CreatePalette(g_lpdd,DDPCAPS_8BIT|DDPCAPS_INITIALIZE,palette,&ddpalette,NULL);
1016                 g_lpddsPrimary->lpVtbl->SetPalette(g_lpddsPrimary,ddpalette);
1017                 free(palette);
1018                 ddpalette->lpVtbl->Release(ddpalette);
1019         }
1020
1021         if (!nooverlay && Directx_CreateOverlay(image_format))
1022         {
1023                         if(format == primary_image_format)nooverlay=1; /*overlay creation failed*/
1024                         else {
1025               mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't use overlay mode: please use -vo directx:noaccel\n");
1026                           return 1;
1027             }
1028         }
1029         if(nooverlay)
1030         {
1031                 if(Directx_CreateBackpuffer())
1032                 {
1033                         mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't get the driver to work on your system :(\n");
1034                         return 1;
1035                 }
1036                 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>back surface created\n");
1037                 vo_doublebuffering = 0;
1038                 /*create clipper for nonoverlay mode*/
1039             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;}
1040         if(g_lpddclipper->lpVtbl->SetHWnd (g_lpddclipper, 0, vo_w32_window)!= DD_OK){mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't associate clipper with window\n");return 1;}
1041         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;}
1042             mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>clipper succesfully created\n");
1043         }else{
1044                 if(DD_OK != g_lpddsOverlay->lpVtbl->QueryInterface(g_lpddsOverlay,&IID_IDirectDrawColorControl,(void**)&g_cc))
1045                         mp_msg(MSGT_VO, MSGL_V,"<vo_directx><WARN>unable to get DirectDraw ColorControl interface\n");
1046         }
1047         Directx_ManageDisplay();
1048         memset(&ddsdsf, 0,sizeof(DDSURFACEDESC2));
1049         ddsdsf.dwSize = sizeof (DDSURFACEDESC2);
1050         if (g_lpddsBack->lpVtbl->Lock(g_lpddsBack,NULL,&ddsdsf, DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL) == DD_OK) {
1051         dstride = ddsdsf.lPitch;
1052         image = ddsdsf.lpSurface;
1053         return 0;
1054         }
1055         mp_msg(MSGT_VO, MSGL_V, "<vo_directx><ERROR>Initial Lock on the Surface failed.\n");
1056         return 1;
1057 }
1058
1059 //function to set color controls
1060 //  brightness  [0, 10000]
1061 //  contrast    [0, 20000]
1062 //  hue         [-180, 180]
1063 //  saturation  [0, 20000]
1064 static uint32_t color_ctrl_set(const char *what, int value)
1065 {
1066         uint32_t        r = VO_NOTIMPL;
1067         DDCOLORCONTROL  dcc;
1068         //printf("\n*** %s = %d\n", what, value);
1069         if (!g_cc) {
1070                 //printf("\n *** could not get color control interface!!!\n");
1071                 return VO_NOTIMPL;
1072         }
1073         ZeroMemory(&dcc, sizeof(dcc));
1074         dcc.dwSize = sizeof(dcc);
1075
1076         if (!strcmp(what, "brightness")) {
1077                 dcc.dwFlags = DDCOLOR_BRIGHTNESS;
1078                 dcc.lBrightness = (value + 100) * 10000 / 200;
1079                 r = VO_TRUE;
1080         } else if (!strcmp(what, "contrast")) {
1081                 dcc.dwFlags = DDCOLOR_CONTRAST;
1082                 dcc.lContrast = (value + 100) * 20000 / 200;
1083                 r = VO_TRUE;
1084         } else if (!strcmp(what, "hue")) {
1085                 dcc.dwFlags = DDCOLOR_HUE;
1086                 dcc.lHue = value * 180 / 100;
1087                 r = VO_TRUE;
1088         } else if (!strcmp(what, "saturation")) {
1089                 dcc.dwFlags = DDCOLOR_SATURATION;
1090                 dcc.lSaturation = (value + 100) * 20000 / 200;
1091                 r = VO_TRUE;
1092         }
1093
1094         if (r == VO_TRUE) {
1095                 g_cc->lpVtbl->SetColorControls(g_cc, &dcc);
1096         }
1097         return r;
1098 }
1099
1100 //analoguous to color_ctrl_set
1101 static uint32_t color_ctrl_get(const char *what, int *value)
1102 {
1103         uint32_t        r = VO_NOTIMPL;
1104         DDCOLORCONTROL  dcc;
1105         if (!g_cc) {
1106                 //printf("\n *** could not get color control interface!!!\n");
1107                 return VO_NOTIMPL;
1108         }
1109         ZeroMemory(&dcc, sizeof(dcc));
1110         dcc.dwSize = sizeof(dcc);
1111
1112         if (g_cc->lpVtbl->GetColorControls(g_cc, &dcc) != DD_OK) {
1113                 return r;
1114         }
1115
1116         if (!strcmp(what, "brightness") && (dcc.dwFlags & DDCOLOR_BRIGHTNESS)) {
1117                 *value = dcc.lBrightness * 200 / 10000 - 100;
1118                 r = VO_TRUE;
1119         } else if (!strcmp(what, "contrast") && (dcc.dwFlags & DDCOLOR_CONTRAST)) {
1120                 *value = dcc.lContrast * 200 / 20000 - 100;
1121                 r = VO_TRUE;
1122         } else if (!strcmp(what, "hue") && (dcc.dwFlags & DDCOLOR_HUE)) {
1123                 *value = dcc.lHue * 100 / 180;
1124                 r = VO_TRUE;
1125         } else if (!strcmp(what, "saturation") && (dcc.dwFlags & DDCOLOR_SATURATION)) {
1126                 *value = dcc.lSaturation * 200 / 20000 - 100;
1127                 r = VO_TRUE;
1128         }
1129 //      printf("\n*** %s = %d\n", what, *value);
1130
1131         return r;
1132 }
1133
1134 static int control(uint32_t request, void *data)
1135 {
1136     switch (request) {
1137
1138         case VOCTRL_GET_IMAGE:
1139         return get_image(data);
1140     case VOCTRL_QUERY_FORMAT:
1141         return query_format(*((uint32_t*)data));
1142         case VOCTRL_DRAW_IMAGE:
1143         return put_image(data);
1144     case VOCTRL_BORDER:
1145         vo_w32_border();
1146         Directx_ManageDisplay();
1147                 return VO_TRUE;
1148     case VOCTRL_ONTOP:
1149         vo_w32_ontop();
1150                 return VO_TRUE;
1151     case VOCTRL_ROOTWIN:
1152                         if(WinID != -1) return VO_TRUE;
1153                 if(vidmode)
1154                         {
1155                                 mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>rootwin has no meaning in exclusive mode\n");
1156                         }
1157                 else
1158                         {
1159                                 if(vo_rootwin) vo_rootwin = 0;
1160                                 else vo_rootwin = 1;
1161                                 Directx_ManageDisplay();
1162                         }
1163                 return VO_TRUE;
1164     case VOCTRL_FULLSCREEN:
1165                 {
1166             vo_w32_fullscreen();
1167             Directx_ManageDisplay();
1168                     return VO_TRUE;
1169                 }
1170         case VOCTRL_SET_EQUALIZER: {
1171                 struct voctrl_set_equalizer_args *args = data;
1172                 return color_ctrl_set(args->name, args->value);
1173         }
1174         case VOCTRL_GET_EQUALIZER: {
1175                 struct voctrl_get_equalizer_args *args = data;
1176                 return color_ctrl_get(args->name, args->valueptr);
1177         }
1178     case VOCTRL_UPDATE_SCREENINFO:
1179         w32_update_xinerama_info();
1180         return VO_TRUE;
1181     };
1182     return VO_NOTIMPL;
1183 }