2 * Directx v2 or later DirectDraw interface
4 * Copyright (c) 2002 - 2005 Sascha Sommer <saschasommer@freenet.de>
6 * This file is part of MPlayer.
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.
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.
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.
29 #include <libavutil/common.h>
31 #include "video_out.h"
32 #include "video_out_internal.h"
33 #include "fastmemcpy.h"
37 #include "w32_common.h"
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
;
67 /*****************************************************************************
69 * Defining them here allows us to get rid of the dxguid library during
71 *****************************************************************************/
72 #define IID_IDirectDraw7 MP_IID_IDirectDraw7
73 static const GUID MP_IID_IDirectDraw7
=
75 0x15e65ec0,0x3b9c,0x11d2,{0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b}
78 #define IID_IDirectDrawColorControl MP_IID_IDirectDrawColorControl
79 static const GUID MP_IID_IDirectDrawColorControl
=
81 0x4b9f0ee0,0x0d7e,0x11d0,{0x9b,0x06,0x00,0xa0,0xc9,0x03,0xa3,0xb8}
85 typedef struct directx_fourcc_caps
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
;
94 static directx_fourcc_caps g_ddpf
[] =
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}}
112 #define NUM_FORMATS (sizeof(g_ddpf) / sizeof(g_ddpf[0]))
114 static const vo_info_t info
=
116 "Directx DDraw YUV/RGB/BGR renderer",
118 "Sascha Sommer <saschasommer@freenet.de>",
122 const LIBVO_EXTERN(directx
)
124 static void draw_alpha(int x0
, int y0
, int w
, int h
, unsigned char *src
,
125 unsigned char *srca
, int stride
)
127 switch(image_format
) {
132 vo_draw_alpha_yv12(w
,h
,src
,srca
,stride
,((uint8_t *) image
) + dstride
*y0
+ x0
,dstride
);
135 vo_draw_alpha_yuy2(w
,h
,src
,srca
,stride
,((uint8_t *) image
)+ dstride
*y0
+ 2*x0
,dstride
);
138 vo_draw_alpha_yuy2(w
,h
,src
,srca
,stride
,((uint8_t *) image
) + dstride
*y0
+ 2*x0
+ 1,dstride
);
142 vo_draw_alpha_rgb15(w
,h
,src
,srca
,stride
,((uint8_t *) image
)+dstride
*y0
+2*x0
,dstride
);
146 vo_draw_alpha_rgb16(w
,h
,src
,srca
,stride
,((uint8_t *) image
)+dstride
*y0
+2*x0
,dstride
);
150 vo_draw_alpha_rgb24(w
,h
,src
,srca
,stride
,((uint8_t *) image
)+dstride
*y0
+4*x0
,dstride
);
154 vo_draw_alpha_rgb32(w
,h
,src
,srca
,stride
,((uint8_t *) image
)+dstride
*y0
+4*x0
,dstride
);
159 static void draw_osd(void)
161 vo_draw_text(image_width
,image_height
,draw_alpha
);
165 query_format(uint32_t format
)
168 while ( i
< NUM_FORMATS
)
170 if (g_ddpf
[i
].img_format
== format
)
171 return g_ddpf
[i
].drv_caps
;
177 static uint32_t Directx_CreatePrimarySurface(void)
181 if(g_lpddsPrimary
)g_lpddsPrimary
->lpVtbl
->Release(g_lpddsPrimary
);
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");
194 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>could not create primary surface\n");
200 static uint32_t Directx_CreateOverlay(uint32_t imgfmt
)
203 DDSURFACEDESC2 ddsdOverlay
;
205 while ( i
< NUM_FORMATS
&& imgfmt
!= g_ddpf
[i
].img_format
)
209 if (!g_lpdd
|| !g_lpddsPrimary
|| i
== NUM_FORMATS
)
212 if (g_lpddsOverlay
)g_lpddsOverlay
->lpVtbl
->Release(g_lpddsOverlay
);
213 if (g_lpddsBack
)g_lpddsBack
->lpVtbl
->Release(g_lpddsBack
);
214 g_lpddsOverlay
= NULL
;
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
227 if (g_lpdd
->lpVtbl
->CreateSurface(g_lpdd
,&ddsdOverlay
, &g_lpddsOverlay
, NULL
)== DD_OK
)
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
)
234 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't get attached surface\n");
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
);
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
);
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>");
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;}
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;}
279 mp_msg(MSGT_VO
, MSGL_ERR
,"create surface failed with 0x%xu\n",(unsigned)ddrval
);
283 g_lpddsBack
= g_lpddsOverlay
;
287 static uint32_t Directx_CreateBackpuffer(void)
291 if (g_lpddsBack
)g_lpddsBack
->lpVtbl
->Release(g_lpddsBack
);
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
)
301 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't create backpuffer\n");
304 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>backbuffer created\n");
308 static void uninit(void)
312 g_cc
->lpVtbl
->Release(g_cc
);
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
);
320 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>back surface released\n");
321 if(vo_doublebuffering
&& !nooverlay
)
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");
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
);
332 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>GDI resources deleted\n");
334 if(vidmode
)g_lpdd
->lpVtbl
->RestoreDisplayMode(g_lpdd
);
335 g_lpdd
->lpVtbl
->Release(g_lpdd
);
337 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>directdrawobject released\n");
338 FreeLibrary( hddraw_dll
);
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");
345 static BOOL WINAPI
EnumCallbackEx(GUID FAR
*lpGUID
, LPSTR lpDriverDescription
, LPSTR lpDriverName
, LPVOID lpContext
, HMONITOR hm
)
348 lpDriverDescription
= "Primary Display Adapter";
349 mp_msg(MSGT_VO
, MSGL_INFO
,"<vo_directx> adapter %d: %s", adapter_count
, lpDriverDescription
);
351 if(adapter_count
== vo_adapter_num
){
353 selected_guid_ptr
= NULL
;
356 selected_guid
= *lpGUID
;
357 selected_guid_ptr
= &selected_guid
;
360 mp_msg(MSGT_VO
, MSGL_INFO
,"\t\t<--");
362 mp_msg(MSGT_VO
, MSGL_INFO
,"\n");
366 return 1; // list all adapters
369 static uint32_t Directx_InitDirectDraw(void)
371 HRESULT (WINAPI
*OurDirectDrawCreateEx
)(GUID
*,LPVOID
*, REFIID
,IUnknown FAR
*);
373 LPDIRECTDRAWENUMERATEEX OurDirectDrawEnumerateEx
;
377 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>Initing DirectDraw\n" );
379 //load direct draw DLL: based on videolans code
380 hddraw_dll
= LoadLibrary("DDRAW.DLL");
381 if( hddraw_dll
== NULL
)
383 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>failed loading ddraw.dll\n" );
387 if(vo_adapter_num
){ //display other than default
388 OurDirectDrawEnumerateEx
= (LPDIRECTDRAWENUMERATEEX
) GetProcAddress(hddraw_dll
,"DirectDrawEnumerateExA");
389 if (!OurDirectDrawEnumerateEx
){
390 FreeLibrary( hddraw_dll
);
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");
397 // enumerate all display devices attached to the desktop
398 OurDirectDrawEnumerateEx(EnumCallbackEx
, NULL
, DDENUM_ATTACHEDSECONDARYDEVICES
);
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
);
404 OurDirectDrawCreateEx
= (void *)GetProcAddress(hddraw_dll
, "DirectDrawCreateEx");
405 if ( OurDirectDrawCreateEx
== NULL
)
407 FreeLibrary( hddraw_dll
);
409 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>failed geting proc address: DirectDrawCreateEx\n");
413 // initialize DirectDraw and create directx v7 object
414 if (OurDirectDrawCreateEx(selected_guid_ptr
, (VOID
**)&g_lpdd
, &IID_IDirectDraw7
, NULL
) != DD_OK
)
416 FreeLibrary( hddraw_dll
);
418 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't initialize ddraw\n");
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
)
428 vm_height
=vo_screenheight
;
429 vm_width
=vo_screenwidth
;
433 vm_height
=ddsd
.dwHeight
;
434 vm_width
=ddsd
.dwWidth
;
438 if(vo_dbpp
)vm_bpp
=vo_dbpp
;
439 else vm_bpp
=ddsd
.ddpfPixelFormat
.dwRGBBitCount
;
442 if (g_lpdd
->lpVtbl
->SetCooperativeLevel(g_lpdd
, vo_w32_window
, DDSCL_EXCLUSIVE
|DDSCL_FULLSCREEN
) != DD_OK
)
444 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't set cooperativelevel for exclusive mode\n");
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
)
450 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't set displaymode\n");
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
);
456 if (g_lpdd
->lpVtbl
->SetCooperativeLevel(g_lpdd
, vo_w32_window
, DDSCL_NORMAL
) != DD_OK
) // or DDSCL_SETFOCUSWINDOW
458 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>could not set cooperativelevel for hardwarecheck\n");
461 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>DirectDraw Initialized\n");
465 static uint32_t Directx_ManageDisplay(void)
470 DWORD dwUpdateFlags
=0;
473 rd
.left
= vo_dx
- xinerama_x
;
474 rd
.top
= vo_dy
- xinerama_y
;
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;
487 rd
.right
=rd
.left
+width
;
488 rd
.bottom
=rd
.top
+height
;
490 /*ok, let's workaround some overlay limitations*/
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
;
507 rs
.right
=image_width
;
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
))
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
;
521 else if((width
> image_width
)&& !(capsDrv
.dwFXCaps
& DDFXCAPS_OVERLAYSTRETCHX
))
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
;
527 if((height
< image_height
) && !(capsDrv
.dwFXCaps
& DDFXCAPS_OVERLAYSHRINKY
))
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
;
533 else if((height
> image_height
) && !(capsDrv
.dwFXCaps
& DDFXCAPS_OVERLAYSTRETCHY
))
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
;
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
);
555 ovfx
.dckDestColorkey
.dwColorSpaceLowValue
= 0;
556 ovfx
.dckDestColorkey
.dwColorSpaceHighValue
= 0;
560 ovfx
.dckDestColorkey
.dwColorSpaceLowValue
= destcolorkey
;
561 ovfx
.dckDestColorkey
.dwColorSpaceHighValue
= destcolorkey
;
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;
571 g_lpddclipper
->lpVtbl
->SetHWnd(g_lpddclipper
, 0, vo_w32_window
);
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
;
580 /*for nonoverlay mode we are finished, for overlay mode we have to display the overlay first*/
581 if(nooverlay
)return 0;
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
);
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>");
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;}
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
:
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" );
621 mp_msg(MSGT_VO
, MSGL_ERR
," 0x%xu\n",(unsigned)ddrval
);
623 /*ok we can't do anything about it -> hide overlay*/
626 ddrval
= g_lpddsOverlay
->lpVtbl
->UpdateOverlay(g_lpddsOverlay
,NULL
, g_lpddsPrimary
, NULL
, DDOVER_HIDE
, NULL
);
633 static void check_events(void)
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
);
641 GetClientRect(vo_w32_window
, &r
);
642 FillRect(dc
, &r
, vo_fs
|| vidmode
? blackbrush
: colorbrush
);
643 vo_w32_release_dc(vo_w32_window
, dc
);
647 //find out supported overlay pixelformats
648 static uint32_t Directx_CheckOverlayPixelformats(void)
652 DDSURFACEDESC2 ddsdOverlay
;
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
);
661 mp_msg(MSGT_VO
, MSGL_ERR
,"<vo_directx><ERROR>failed getting ddrawcaps\n");
664 if (!(capsDrv
.dwCaps
& DDCAPS_OVERLAY
))
666 mp_msg(MSGT_VO
, MSGL_ERR
,"<vo_directx><ERROR>Your card doesn't support overlay\n");
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
683 ddsdOverlay
.ddpfPixelFormat
=g_ddpf
[i
].g_ddpfOverlay
;
684 ddrval
= g_lpdd
->lpVtbl
->CreateSurface(g_lpdd
,&ddsdOverlay
, &g_lpddsOverlay
, NULL
);
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
;
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)
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");
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 ;)
708 //find out the Pixelformat of the Primary Surface
709 static uint32_t Directx_CheckPrimaryPixelformat(void)
712 uint32_t formatcount
= 0;
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
)
725 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't get pixelformat\n");
728 while ( i
< NUM_FORMATS
)
730 if (g_ddpf
[i
].g_ddpfOverlay
.dwRGBBitCount
== ddpf
.dwRGBBitCount
)
732 if (g_ddpf
[i
].g_ddpfOverlay
.dwRBitMask
== ddpf
.dwRBitMask
)
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
;
737 primary_image_format
=g_ddpf
[i
].img_format
;
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
)
746 rgbT
= GetPixel(hdc
, 0, 0);
747 SetPixel(hdc
, 0, 0, windowcolor
);
748 g_lpddsPrimary
->lpVtbl
->ReleaseDC(g_lpddsPrimary
,hdc
);
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
)
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
);
761 if (windowcolor
!= CLR_INVALID
&& g_lpddsPrimary
->lpVtbl
->GetDC(g_lpddsPrimary
,&hdc
) == DD_OK
)
763 SetPixel(hdc
, 0, 0, rgbT
);
764 g_lpddsPrimary
->lpVtbl
->ReleaseDC(g_lpddsPrimary
,hdc
);
767 g_lpddsPrimary
->lpVtbl
->Release(g_lpddsPrimary
);
768 g_lpddsPrimary
= NULL
;
771 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>Unknown Pixelformat\n");
777 static int preinit(const char *arg
)
781 if(strstr(arg
,"noaccel"))
783 mp_msg(MSGT_VO
,MSGL_V
,"<vo_directx><INFO>disabled overlay\n");
788 windowcolor
= vo_colorkey
;
789 colorbrush
= CreateSolidBrush(windowcolor
);
790 blackbrush
= (HBRUSH
)GetStockObject(BLACK_BRUSH
);
793 if (!vo_w32_config(100, 100, VOFLAG_HIDDEN
))
796 if (Directx_InitDirectDraw()!= 0)return 1; //init DirectDraw
798 if (Directx_CheckPrimaryPixelformat()!=0)return 1;
799 if (!nooverlay
&& Directx_CheckOverlayPixelformats() == 0) //check for supported hardware
801 mp_msg(MSGT_VO
, MSGL_V
,"<vo_directx><INFO>hardware supports overlay\n");
804 else //if we can't have overlay we create a backpuffer with the same imageformat as the primary surface
806 mp_msg(MSGT_VO
, MSGL_V
,"<vo_directx><INFO>using backpuffer\n");
809 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>preinit succesfully finished\n");
813 static int draw_slice(uint8_t *src
[], int stride
[], int w
,int h
,int x
,int y
)
817 uint32_t uvstride
=dstride
/2;
821 mem2agpcpy_pic(d
,s
,w
,h
,dstride
,stride
[0]);
826 d
=image
+dstride
*image_height
+ uvstride
*y
+x
;
827 if(image_format
== IMGFMT_YV12
)s
=src
[2];
829 mem2agpcpy_pic(d
,s
,w
,h
,uvstride
,stride
[1]);
832 d
=image
+dstride
*image_height
+uvstride
*(image_height
/2) + uvstride
*y
+x
;
833 if(image_format
== IMGFMT_YV12
)s
=src
[1];
835 mem2agpcpy_pic(d
,s
,w
,h
,uvstride
,stride
[2]);
839 static void flip_page(void)
842 g_lpddsBack
->lpVtbl
->Unlock (g_lpddsBack
,NULL
);
843 if (vo_doublebuffering
)
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
)
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
);
859 if(dxresult
!= DD_OK
)mp_msg(MSGT_VO
, MSGL_ERR
,"<vo_directx><ERROR>can't flip page\n");
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
);
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;
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);
885 static int draw_frame(uint8_t *src
[])
887 fast_memcpy( image
, *src
, dstride
* image_height
);
891 static uint32_t get_image(mp_image_t
*mpi
)
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
)))
897 if(mpi
->flags
&MP_IMGFLAG_PLANAR
)
899 if(image_format
== IMGFMT_YV12
)
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;
905 else if(image_format
== IMGFMT_IYUV
|| image_format
== IMGFMT_I420
)
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;
911 else if(image_format
== IMGFMT_YVU9
)
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;
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");
929 static uint32_t put_image(mp_image_t
*mpi
){
938 if((mpi
->flags
&MP_IMGFLAG_DIRECT
)||(mpi
->flags
&MP_IMGFLAG_DRAW_CALLBACK
))
940 mp_msg(MSGT_VO
, MSGL_DBG3
,"<vo_directx><INFO>put_image: nothing to do: drawslices\n");
944 if (mpi
->flags
&MP_IMGFLAG_PLANAR
)
947 if(image_format
!=IMGFMT_YVU9
)draw_slice(mpi
->planes
,mpi
->stride
,mpi
->w
,mpi
->h
,0,0);
953 mem2agpcpy_pic(d
,s
,w
,h
,dstride
,mpi
->stride
[0]);
956 d
=image
+dstride
*image_height
+ dstride
*y
/4+x
;
958 mem2agpcpy_pic(d
,s
,w
,h
,dstride
/4,mpi
->stride
[1]);
960 d
=image
+dstride
*image_height
+ dstride
*image_height
/16 + dstride
/4*y
+x
;
962 mem2agpcpy_pic(d
,s
,w
,h
,dstride
/4,mpi
->stride
[2]);
967 mem2agpcpy_pic(image
, mpi
->planes
[0], w
* (mpi
->bpp
/ 8), h
, dstride
, mpi
->stride
[0]);
973 config(uint32_t width
, uint32_t height
, uint32_t d_width
, uint32_t d_height
, uint32_t options
, char *title
, uint32_t format
)
975 image_format
= format
;
977 image_height
= height
;
978 if(format
!= primary_image_format
)nooverlay
= 0;
980 /*release all directx objects*/
981 if (g_cc
!= NULL
)g_cc
->lpVtbl
->Release(g_cc
);
983 if(g_lpddclipper
)g_lpddclipper
->lpVtbl
->Release(g_lpddclipper
);
985 if (g_lpddsBack
!= NULL
) g_lpddsBack
->lpVtbl
->Release(g_lpddsBack
);
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");
994 if (!vo_w32_config(d_width
, d_height
, options
))
998 SetWindowText(vo_w32_window
,title
);
1001 /*create the surfaces*/
1002 if(Directx_CreatePrimarySurface())return 1;
1004 //create palette for 256 color mode
1005 if(image_format
==IMGFMT_BGR8
){
1006 LPDIRECTDRAWPALETTE ddpalette
=NULL
;
1007 LPPALETTEENTRY palette
=calloc(256, sizeof(*palette
));
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
;
1015 g_lpdd
->lpVtbl
->CreatePalette(g_lpdd
,DDPCAPS_8BIT
|DDPCAPS_INITIALIZE
,palette
,&ddpalette
,NULL
);
1016 g_lpddsPrimary
->lpVtbl
->SetPalette(g_lpddsPrimary
,ddpalette
);
1018 ddpalette
->lpVtbl
->Release(ddpalette
);
1021 if (!nooverlay
&& Directx_CreateOverlay(image_format
))
1023 if(format
== primary_image_format
)nooverlay
=1; /*overlay creation failed*/
1025 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't use overlay mode: please use -vo directx:noaccel\n");
1031 if(Directx_CreateBackpuffer())
1033 mp_msg(MSGT_VO
, MSGL_FATAL
,"<vo_directx><FATAL ERROR>can't get the driver to work on your system :(\n");
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");
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");
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
;
1055 mp_msg(MSGT_VO
, MSGL_V
, "<vo_directx><ERROR>Initial Lock on the Surface failed.\n");
1059 //function to set color controls
1060 // brightness [0, 10000]
1061 // contrast [0, 20000]
1063 // saturation [0, 20000]
1064 static uint32_t color_ctrl_set(const char *what
, int value
)
1066 uint32_t r
= VO_NOTIMPL
;
1068 //printf("\n*** %s = %d\n", what, value);
1070 //printf("\n *** could not get color control interface!!!\n");
1073 ZeroMemory(&dcc
, sizeof(dcc
));
1074 dcc
.dwSize
= sizeof(dcc
);
1076 if (!strcmp(what
, "brightness")) {
1077 dcc
.dwFlags
= DDCOLOR_BRIGHTNESS
;
1078 dcc
.lBrightness
= (value
+ 100) * 10000 / 200;
1080 } else if (!strcmp(what
, "contrast")) {
1081 dcc
.dwFlags
= DDCOLOR_CONTRAST
;
1082 dcc
.lContrast
= (value
+ 100) * 20000 / 200;
1084 } else if (!strcmp(what
, "hue")) {
1085 dcc
.dwFlags
= DDCOLOR_HUE
;
1086 dcc
.lHue
= value
* 180 / 100;
1088 } else if (!strcmp(what
, "saturation")) {
1089 dcc
.dwFlags
= DDCOLOR_SATURATION
;
1090 dcc
.lSaturation
= (value
+ 100) * 20000 / 200;
1095 g_cc
->lpVtbl
->SetColorControls(g_cc
, &dcc
);
1100 //analoguous to color_ctrl_set
1101 static uint32_t color_ctrl_get(const char *what
, int *value
)
1103 uint32_t r
= VO_NOTIMPL
;
1106 //printf("\n *** could not get color control interface!!!\n");
1109 ZeroMemory(&dcc
, sizeof(dcc
));
1110 dcc
.dwSize
= sizeof(dcc
);
1112 if (g_cc
->lpVtbl
->GetColorControls(g_cc
, &dcc
) != DD_OK
) {
1116 if (!strcmp(what
, "brightness") && (dcc
.dwFlags
& DDCOLOR_BRIGHTNESS
)) {
1117 *value
= dcc
.lBrightness
* 200 / 10000 - 100;
1119 } else if (!strcmp(what
, "contrast") && (dcc
.dwFlags
& DDCOLOR_CONTRAST
)) {
1120 *value
= dcc
.lContrast
* 200 / 20000 - 100;
1122 } else if (!strcmp(what
, "hue") && (dcc
.dwFlags
& DDCOLOR_HUE
)) {
1123 *value
= dcc
.lHue
* 100 / 180;
1125 } else if (!strcmp(what
, "saturation") && (dcc
.dwFlags
& DDCOLOR_SATURATION
)) {
1126 *value
= dcc
.lSaturation
* 200 / 20000 - 100;
1129 // printf("\n*** %s = %d\n", what, *value);
1134 static int control(uint32_t request
, void *data
)
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
);
1146 Directx_ManageDisplay();
1151 case VOCTRL_ROOTWIN
:
1152 if(WinID
!= -1) return VO_TRUE
;
1155 mp_msg(MSGT_VO
, MSGL_ERR
,"<vo_directx><ERROR>rootwin has no meaning in exclusive mode\n");
1159 if(vo_rootwin
) vo_rootwin
= 0;
1160 else vo_rootwin
= 1;
1161 Directx_ManageDisplay();
1164 case VOCTRL_FULLSCREEN
:
1166 vo_w32_fullscreen();
1167 Directx_ManageDisplay();
1170 case VOCTRL_SET_EQUALIZER
: {
1171 struct voctrl_set_equalizer_args
*args
= data
;
1172 return color_ctrl_set(args
->name
, args
->value
);
1174 case VOCTRL_GET_EQUALIZER
: {
1175 struct voctrl_get_equalizer_args
*args
= data
;
1176 return color_ctrl_get(args
->name
, args
->valueptr
);
1178 case VOCTRL_UPDATE_SCREENINFO
:
1179 w32_update_xinerama_info();