?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Split generic OS X API check into separate CoreAudio, CoreVideo, Quartz checks.
[mplayer/glamo.git] / libvo / vo_directx.c
blob224af242c2cb7f2bd37829a03466af4bfbba8a4c
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 "config.h"
30 #include "video_out.h"
31 #include "video_out_internal.h"
32 #include "fastmemcpy.h"
33 #include "input/input.h"
34 #include "osdep/keycodes.h"
35 #include "input/mouse.h"
36 #include "mp_msg.h"
37 #include "aspect.h"
38 #include "geometry.h"
39 #include "mp_fifo.h"
40 #include "sub.h"
41
42 #ifdef CONFIG_GUI
43 #include "gui/interface.h"
44 #endif
45
46 #ifndef WM_XBUTTONDOWN
47 # define WM_XBUTTONDOWN 0x020B
48 # define WM_XBUTTONUP 0x020C
49 # define WM_XBUTTONDBLCLK 0x020D
50 #endif
51
52 #define WNDCLASSNAME_WINDOWED "MPlayer - The Movie Player"
53 #define WNDCLASSNAME_FULLSCREEN "MPlayer - Fullscreen"
54 #define WNDSTYLE WS_OVERLAPPEDWINDOW|WS_SIZEBOX
55
56 static LPDIRECTDRAWCOLORCONTROL g_cc = NULL; //color control interface
57 static LPDIRECTDRAW7 g_lpdd = NULL; //DirectDraw Object
58 static LPDIRECTDRAWSURFACE7 g_lpddsPrimary = NULL; //Primary Surface: viewport through the Desktop
59 static LPDIRECTDRAWSURFACE7 g_lpddsOverlay = NULL; //Overlay Surface
60 static LPDIRECTDRAWSURFACE7 g_lpddsBack = NULL; //Back surface
61 static LPDIRECTDRAWCLIPPER g_lpddclipper; //clipper object, can only be used without overlay
62 static DDSURFACEDESC2 ddsdsf; //surface descripiton needed for locking
63 static HINSTANCE hddraw_dll; //handle to ddraw.dll
64 static RECT rd; //rect of our stretched image
65 static RECT rs; //rect of our source image
66 static HWND hWnd=NULL; //handle to the window
67 static HWND hWndFS=NULL; //fullscreen window
68 static HBRUSH colorbrush = NULL; // Handle to colorkey brush
69 static HBRUSH blackbrush = NULL; // Handle to black brush
70 static HICON mplayericon = NULL; // Handle to mplayer icon
71 static HCURSOR mplayercursor = NULL; // Handle to mplayer cursor
72 static uint32_t image_width, image_height; //image width and height
73 static uint32_t d_image_width, d_image_height; //image width and height zoomed
74 static uint8_t *image=NULL; //image data
75 static void* tmp_image = NULL;
76 static uint32_t image_format=0; //image format
77 static uint32_t primary_image_format;
78 static uint32_t vm_height=0;
79 static uint32_t vm_width=0;
80 static uint32_t vm_bpp=0;
81 static uint32_t dstride; //surface stride
82 static uint32_t nooverlay = 0; //NonOverlay mode
83 static DWORD destcolorkey; //colorkey for our surface
84 static COLORREF windowcolor = RGB(0,0,16); //windowcolor == colorkey
85 static int adapter_count=0;
86 static GUID selected_guid;
87 static GUID *selected_guid_ptr = NULL;
88 static RECT monitor_rect; //monitor coordinates
89 static float window_aspect;
90 static BOOL (WINAPI* myGetMonitorInfo)(HMONITOR, LPMONITORINFO) = NULL;
91 static RECT last_rect = {0xDEADC0DE, 0xDEADC0DE, 0xDEADC0DE, 0xDEADC0DE};
92
93 extern int vidmode;
94
95 /*****************************************************************************
96 * DirectDraw GUIDs.
97 * Defining them here allows us to get rid of the dxguid library during
98 * the linking stage.
99 *****************************************************************************/
100 const GUID IID_IDirectDraw7 =
101 {
102 0x15e65ec0,0x3b9c,0x11d2,{0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b}
103 };
104
105 const GUID IID_IDirectDrawColorControl =
106 {
107 0x4b9f0ee0,0x0d7e,0x11d0,{0x9b,0x06,0x00,0xa0,0xc9,0x03,0xa3,0xb8}
108 };
109
110
111 typedef struct directx_fourcc_caps
112 {
113 char* img_format_name; //human readable name
114 uint32_t img_format; //as MPlayer image format
115 uint32_t drv_caps; //what hw supports with this format
116 DDPIXELFORMAT g_ddpfOverlay; //as Directx Sourface description
117 } directx_fourcc_caps;
118
119
120 static directx_fourcc_caps g_ddpf[] =
121 {
122 {"YV12 ",IMGFMT_YV12 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','V','1','2'),0,0,0,0,0}},
123 {"I420 ",IMGFMT_I420 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('I','4','2','0'),0,0,0,0,0}}, //yv12 with swapped uv
124 {"IYUV ",IMGFMT_IYUV ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('I','Y','U','V'),0,0,0,0,0}}, //same as i420
125 {"YVU9 ",IMGFMT_YVU9 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','V','U','9'),0,0,0,0,0}},
126 {"YUY2 ",IMGFMT_YUY2 ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0}},
127 {"UYVY ",IMGFMT_UYVY ,0,{sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0}},
128 {"BGR8 ",IMGFMT_BGR8 ,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 8, 0x00000000, 0x00000000, 0x00000000, 0}},
129 {"RGB15",IMGFMT_RGB15,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16, 0x0000001F, 0x000003E0, 0x00007C00, 0}}, //RGB 5:5:5
130 {"BGR15",IMGFMT_BGR15,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16, 0x00007C00, 0x000003E0, 0x0000001F, 0}},
131 {"RGB16",IMGFMT_RGB16,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16, 0x0000001F, 0x000007E0, 0x0000F800, 0}}, //RGB 5:6:5
132 {"BGR16",IMGFMT_BGR16,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 16, 0x0000F800, 0x000007E0, 0x0000001F, 0}},
133 {"RGB24",IMGFMT_RGB24,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 24, 0x000000FF, 0x0000FF00, 0x00FF0000, 0}},
134 {"BGR24",IMGFMT_BGR24,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 24, 0x00FF0000, 0x0000FF00, 0x000000FF, 0}},
135 {"RGB32",IMGFMT_RGB32,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0}},
136 {"BGR32",IMGFMT_BGR32,0,{sizeof(DDPIXELFORMAT), DDPF_RGB, 0, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0}}
137 };
138 #define NUM_FORMATS (sizeof(g_ddpf) / sizeof(g_ddpf[0]))
139
140 static const vo_info_t info =
141 {
142 "Directx DDraw YUV/RGB/BGR renderer",
143 "directx",
144 "Sascha Sommer <saschasommer@freenet.de>",
145 ""
146 };
147
148 const LIBVO_EXTERN(directx)
149
150 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
151 unsigned char *srca, int stride)
152 {
153 switch(image_format) {
154 case IMGFMT_YV12 :
155 case IMGFMT_I420 :
156 case IMGFMT_IYUV :
157 case IMGFMT_YVU9 :
158 vo_draw_alpha_yv12(w,h,src,srca,stride,((uint8_t *) image) + dstride*y0 + x0,dstride);
159 break;
160 case IMGFMT_YUY2 :
161 vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) image)+ dstride*y0 + 2*x0 ,dstride);
162 break;
163 case IMGFMT_UYVY :
164 vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) image) + dstride*y0 + 2*x0 + 1,dstride);
165 break;
166 case IMGFMT_RGB15:
167 case IMGFMT_BGR15:
168 vo_draw_alpha_rgb15(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+2*x0,dstride);
169 break;
170 case IMGFMT_RGB16:
171 case IMGFMT_BGR16:
172 vo_draw_alpha_rgb16(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+2*x0,dstride);
173 break;
174 case IMGFMT_RGB24:
175 case IMGFMT_BGR24:
176 vo_draw_alpha_rgb24(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+4*x0,dstride);
177 break;
178 case IMGFMT_RGB32:
179 case IMGFMT_BGR32:
180 vo_draw_alpha_rgb32(w,h,src,srca,stride,((uint8_t *) image)+dstride*y0+4*x0,dstride);
181 break;
182 }
183 }
184
185 static void draw_osd(void)
186 {
187 vo_draw_text(image_width,image_height,draw_alpha);
188 }
189
190 static int
191 query_format(uint32_t format)
192 {
193 uint32_t i=0;
194 while ( i < NUM_FORMATS )
195 {
196 if (g_ddpf[i].img_format == format)
197 return g_ddpf[i].drv_caps;
198 i++;
199 }
200 return 0;
201 }
202
203 static uint32_t Directx_CreatePrimarySurface()
204 {
205 DDSURFACEDESC2 ddsd;
206 //cleanup
207 if(g_lpddsPrimary)g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
208 g_lpddsPrimary=NULL;
209
210 if(vidmode)g_lpdd->lpVtbl->SetDisplayMode(g_lpdd,vm_width,vm_height,vm_bpp,vo_refresh_rate,0);
211 ZeroMemory(&ddsd, sizeof(ddsd));
212 ddsd.dwSize = sizeof(ddsd);
213 //set flags and create a primary surface.
214 ddsd.dwFlags = DDSD_CAPS;
215 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
216 if(g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsd, &g_lpddsPrimary, NULL )== DD_OK)
217 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>primary surface created\n");
218 else
219 {
220 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>could not create primary surface\n");
221 return 1;
222 }
223 return 0;
224 }
225
226 static uint32_t Directx_CreateOverlay(uint32_t imgfmt)
227 {
228 HRESULT ddrval;
229 DDSURFACEDESC2 ddsdOverlay;
230 uint32_t i=0;
231 while ( i < NUM_FORMATS +1 && imgfmt != g_ddpf[i].img_format)
232 {
233 i++;
234 }
235 if (!g_lpdd || !g_lpddsPrimary)
236 return 1;
237 //cleanup
238 if (g_lpddsOverlay)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
239 if (g_lpddsBack)g_lpddsBack->lpVtbl->Release(g_lpddsBack);
240 g_lpddsOverlay= NULL;
241 g_lpddsBack = NULL;
242 //create our overlay
243 ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
244 ddsdOverlay.dwSize = sizeof(ddsdOverlay);
245 ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_FLIP | DDSCAPS_COMPLEX | DDSCAPS_VIDEOMEMORY;
246 ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT| DDSD_PIXELFORMAT;
247 ddsdOverlay.dwWidth=image_width;
248 ddsdOverlay.dwHeight=image_height;
249 ddsdOverlay.dwBackBufferCount=2;
250 ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
251 if(vo_doublebuffering) //tribblebuffering
252 {
253 if (g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL)== DD_OK)
254 {
255 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>overlay with format %s created\n",g_ddpf[i].img_format_name);
256 //get the surface directly attached to the primary (the back buffer)
257 ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
258 if(g_lpddsOverlay->lpVtbl->GetAttachedSurface(g_lpddsOverlay,&ddsdOverlay.ddsCaps, &g_lpddsBack) != DD_OK)
259 {
260 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't get attached surface\n");
261 return 1;
262 }
263 return 0;
264 }
265 vo_doublebuffering=0; //disable tribblebuffering
266 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><WARN>cannot create tribblebuffer overlay with format %s\n",g_ddpf[i].img_format_name);
267 }
268 //single buffer
269 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>using singlebuffer overlay\n");
270 ddsdOverlay.dwBackBufferCount=0;
271 ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
272 ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;
273 ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
274 // try to create the overlay surface
275 ddrval = g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL);
276 if(ddrval != DD_OK)
277 {
278 if(ddrval == DDERR_INVALIDPIXELFORMAT)mp_msg(MSGT_VO,MSGL_V,"<vo_directx><ERROR> invalid pixelformat: %s\n",g_ddpf[i].img_format_name);
279 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>");
280 switch(ddrval)
281 {
282 case DDERR_INCOMPATIBLEPRIMARY:
283 {mp_msg(MSGT_VO, MSGL_ERR,"incompatible primary surface\n");break;}
284 case DDERR_INVALIDCAPS:
285 {mp_msg(MSGT_VO, MSGL_ERR,"invalid caps\n");break;}
286 case DDERR_INVALIDOBJECT:
287 {mp_msg(MSGT_VO, MSGL_ERR,"invalid object\n");break;}
288 case DDERR_INVALIDPARAMS:
289 {mp_msg(MSGT_VO, MSGL_ERR,"invalid parameters\n");break;}
290 case DDERR_NODIRECTDRAWHW:
291 {mp_msg(MSGT_VO, MSGL_ERR,"no directdraw hardware\n");break;}
292 case DDERR_NOEMULATION:
293 {mp_msg(MSGT_VO, MSGL_ERR,"can't emulate\n");break;}
294 case DDERR_NOFLIPHW:
295 {mp_msg(MSGT_VO, MSGL_ERR,"hardware can't do flip\n");break;}
296 case DDERR_NOOVERLAYHW:
297 {mp_msg(MSGT_VO, MSGL_ERR,"hardware can't do overlay\n");break;}
298 case DDERR_OUTOFMEMORY:
299 {mp_msg(MSGT_VO, MSGL_ERR,"not enough system memory\n");break;}
300 case DDERR_UNSUPPORTEDMODE:
301 {mp_msg(MSGT_VO, MSGL_ERR,"unsupported mode\n");break;}
302 case DDERR_OUTOFVIDEOMEMORY:
303 {mp_msg(MSGT_VO, MSGL_ERR,"not enough video memory\n");break;}
304 default:
305 mp_msg(MSGT_VO, MSGL_ERR,"create surface failed with 0x%x\n",ddrval);
306 }
307 return 1;
308 }
309 g_lpddsBack = g_lpddsOverlay;
310 return 0;
311 }
312
313 static uint32_t Directx_CreateBackpuffer()
314 {
315 DDSURFACEDESC2 ddsd;
316 //cleanup
317 if (g_lpddsBack)g_lpddsBack->lpVtbl->Release(g_lpddsBack);
318 g_lpddsBack=NULL;
319 ZeroMemory(&ddsd, sizeof(ddsd));
320 ddsd.dwSize = sizeof(ddsd);
321 ddsd.ddsCaps.dwCaps= DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
322 ddsd.dwFlags= DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
323 ddsd.dwWidth=image_width;
324 ddsd.dwHeight=image_height;
325 if(g_lpdd->lpVtbl->CreateSurface( g_lpdd, &ddsd, &g_lpddsBack, 0 ) != DD_OK )
326 {
327 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't create backpuffer\n");
328 return 1;
329 }
330 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>backbuffer created\n");
331 return 0;
332 }
333
334 static void uninit(void)
335 {
336 if (g_cc != NULL)
337 {
338 g_cc->lpVtbl->Release(g_cc);
339 }
340 g_cc=NULL;
341 if (g_lpddclipper != NULL) g_lpddclipper->lpVtbl->Release(g_lpddclipper);
342 g_lpddclipper = NULL;
343 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>clipper released\n");
344 if (g_lpddsBack != NULL) g_lpddsBack->lpVtbl->Release(g_lpddsBack);
345 g_lpddsBack = NULL;
346 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>back surface released\n");
347 if(vo_doublebuffering && !nooverlay)
348 {
349 if (g_lpddsOverlay != NULL)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
350 g_lpddsOverlay = NULL;
351 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>overlay surface released\n");
352 }
353 if (g_lpddsPrimary != NULL) g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
354 g_lpddsPrimary = NULL;
355 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>primary released\n");
356 if(hWndFS)DestroyWindow(hWndFS);
357 hWndFS = NULL;
358 if((WinID == -1) && hWnd) DestroyWindow(hWnd);
359 hWnd = NULL;
360 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>window destroyed\n");
361 UnregisterClass(WNDCLASSNAME_WINDOWED, GetModuleHandle(NULL));
362 UnregisterClass(WNDCLASSNAME_FULLSCREEN, GetModuleHandle(NULL));
363 if (mplayericon) DestroyIcon(mplayericon);
364 mplayericon = NULL;
365 if (mplayercursor) DestroyCursor(mplayercursor);
366 mplayercursor = NULL;
367 if (blackbrush) DeleteObject(blackbrush);
368 blackbrush = NULL;
369 if (colorbrush) DeleteObject(colorbrush);
370 colorbrush = NULL;
371 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>GDI resources deleted\n");
372 if (g_lpdd != NULL){
373 if(vidmode)g_lpdd->lpVtbl->RestoreDisplayMode(g_lpdd);
374 g_lpdd->lpVtbl->Release(g_lpdd);
375 }
376 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>directdrawobject released\n");
377 FreeLibrary( hddraw_dll);
378 hddraw_dll= NULL;
379 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>ddraw.dll freed\n");
380 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>uninitialized\n");
381 }
382
383 static BOOL WINAPI EnumCallbackEx(GUID FAR *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext, HMONITOR hm)
384 {
385 mp_msg(MSGT_VO, MSGL_INFO ,"<vo_directx> adapter %d: ", adapter_count);
386
387 if (!lpGUID)
388 {
389 mp_msg(MSGT_VO, MSGL_INFO ,"%s", "Primary Display Adapter");
390 }
391 else
392 {
393 mp_msg(MSGT_VO, MSGL_INFO ,"%s", lpDriverDescription);
394 }
395
396 if(adapter_count == vo_adapter_num){
397 MONITORINFO mi;
398 if (!lpGUID)
399 selected_guid_ptr = NULL;
400 else
401 {
402 selected_guid = *lpGUID;
403 selected_guid_ptr = &selected_guid;
404 }
405 mi.cbSize = sizeof(mi);
406
407 if (myGetMonitorInfo(hm, &mi)) {
408 monitor_rect = mi.rcMonitor;
409 }
410 mp_msg(MSGT_VO, MSGL_INFO ,"\t\t<--");
411 }
412 mp_msg(MSGT_VO, MSGL_INFO ,"\n");
413
414 adapter_count++;
415
416 return 1; // list all adapters
417 }
418
419 static uint32_t Directx_InitDirectDraw()
420 {
421 HRESULT (WINAPI *OurDirectDrawCreateEx)(GUID *,LPVOID *, REFIID,IUnknown FAR *);
422 DDSURFACEDESC2 ddsd;
423 LPDIRECTDRAWENUMERATEEX OurDirectDrawEnumerateEx;
424 HINSTANCE user32dll=LoadLibrary("user32.dll");
425
426 adapter_count = 0;
427 if(user32dll){
428 myGetMonitorInfo=GetProcAddress(user32dll,"GetMonitorInfoA");
429 if(!myGetMonitorInfo && vo_adapter_num){
430 mp_msg(MSGT_VO, MSGL_ERR, "<vo_directx> -adapter is not supported on Win95\n");
431 vo_adapter_num = 0;
432 }
433 }
434
435 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>Initing DirectDraw\n" );
436
437 //load direct draw DLL: based on videolans code
438 hddraw_dll = LoadLibrary("DDRAW.DLL");
439 if( hddraw_dll == NULL )
440 {
441 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed loading ddraw.dll\n" );
442 return 1;
443 }
444
445 last_rect.left = 0xDEADC0DE; // reset window position cache
446
447 if(vo_adapter_num){ //display other than default
448 OurDirectDrawEnumerateEx = (LPDIRECTDRAWENUMERATEEX) GetProcAddress(hddraw_dll,"DirectDrawEnumerateExA");
449 if (!OurDirectDrawEnumerateEx){
450 FreeLibrary( hddraw_dll );
451 hddraw_dll = NULL;
452 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed geting proc address: DirectDrawEnumerateEx\n");
453 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>no directx 7 or higher installed\n");
454 return 1;
455 }
456
457 // enumerate all display devices attached to the desktop
458 OurDirectDrawEnumerateEx(EnumCallbackEx, NULL, DDENUM_ATTACHEDSECONDARYDEVICES );
459
460 if(vo_adapter_num >= adapter_count)
461 mp_msg(MSGT_VO, MSGL_ERR,"Selected adapter (%d) doesn't exist: Default Display Adapter selected\n",vo_adapter_num);
462 }
463 FreeLibrary(user32dll);
464
465 OurDirectDrawCreateEx = (void *)GetProcAddress(hddraw_dll, "DirectDrawCreateEx");
466 if ( OurDirectDrawCreateEx == NULL )
467 {
468 FreeLibrary( hddraw_dll );
469 hddraw_dll = NULL;
470 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>failed geting proc address: DirectDrawCreateEx\n");
471 return 1;
472 }
473
474 // initialize DirectDraw and create directx v7 object
475 if (OurDirectDrawCreateEx(selected_guid_ptr, (VOID**)&g_lpdd, &IID_IDirectDraw7, NULL ) != DD_OK )
476 {
477 FreeLibrary( hddraw_dll );
478 hddraw_dll = NULL;
479 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't initialize ddraw\n");
480 return 1;
481 }
482
483 //get current screen siz for selected monitor ...
484 ddsd.dwSize=sizeof(ddsd);
485 ddsd.dwFlags=DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
486 g_lpdd->lpVtbl->GetDisplayMode(g_lpdd, &ddsd);
487 if(vo_screenwidth && vo_screenheight)
488 {
489 vm_height=vo_screenheight;
490 vm_width=vo_screenwidth;
491 }
492 else
493 {
494 vm_height=ddsd.dwHeight;
495 vm_width=ddsd.dwWidth;
496 }
497
498
499 if(vo_dbpp)vm_bpp=vo_dbpp;
500 else vm_bpp=ddsd.ddpfPixelFormat.dwRGBBitCount;
501
502 if(vidmode){
503 if (g_lpdd->lpVtbl->SetCooperativeLevel(g_lpdd, hWnd, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN) != DD_OK)
504 {
505 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't set cooperativelevel for exclusive mode\n");
506 return 1;
507 }
508 /*SetDisplayMode(ddobject,width,height,bpp,refreshrate,aditionalflags)*/
509 if(g_lpdd->lpVtbl->SetDisplayMode(g_lpdd,vm_width, vm_height, vm_bpp,0,0) != DD_OK)
510 {
511 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't set displaymode\n");
512 return 1;
513 }
514 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);
515 return 0;
516 }
517 if (g_lpdd->lpVtbl->SetCooperativeLevel(g_lpdd, hWnd, DDSCL_NORMAL) != DD_OK) // or DDSCL_SETFOCUSWINDOW
518 {
519 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>could not set cooperativelevel for hardwarecheck\n");
520 return 1;
521 }
522 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>DirectDraw Initialized\n");
523 return 0;
524 }
525
526 static void check_events(void)
527 {
528 MSG msg;
529 while (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE))
530 {
531 TranslateMessage(&msg);
532 DispatchMessage(&msg);
533 }
534 }
535
536 static uint32_t Directx_ManageDisplay()
537 {
538 HRESULT ddrval;
539 DDCAPS capsDrv;
540 DDOVERLAYFX ovfx;
541 DWORD dwUpdateFlags=0;
542 int width,height;
543
544 if(!vidmode && !vo_fs && WinID!=-1) {
545 RECT current_rect = {0, 0, 0, 0};
546 GetWindowRect(hWnd, &current_rect);
547 if ((current_rect.left == last_rect.left)
548 && (current_rect.top == last_rect.top)
549 && (current_rect.right == last_rect.right)
550 && (current_rect.bottom == last_rect.bottom))
551 return 0;
552 last_rect = current_rect;
553 }
554
555 if(vo_fs || vidmode){
556 aspect(&width,&height,A_ZOOM);
557 rd.left=(vo_screenwidth-width)/2;
558 rd.top=(vo_screenheight-height)/2;
559 if (WinID == -1)
560 if(ShowCursor(FALSE)>=0)while(ShowCursor(FALSE)>=0){}
561 }
562 else if (WinID != -1 && vo_geometry) {
563 POINT pt;
564 pt.x = vo_dx;
565 pt.y = vo_dy;
566 ClientToScreen(hWnd,&pt);
567 width=d_image_width;
568 height=d_image_height;
569 rd.left = pt.x;
570 rd.top = pt.y;
571 while(ShowCursor(TRUE)<=0){}
572 }
573 else {
574 POINT pt;
575 pt.x = 0; //overlayposition relative to the window
576 pt.y = 0;
577 ClientToScreen(hWnd,&pt);
578 GetClientRect(hWnd, &rd);
579 width=rd.right - rd.left;
580 height=rd.bottom - rd.top;
581 pt.x -= monitor_rect.left; /* move coordinates from global to local monitor space */
582 pt.y -= monitor_rect.top;
583 rd.right -= monitor_rect.left;
584 rd.bottom -= monitor_rect.top;
585 rd.left = pt.x;
586 rd.top = pt.y;
587 if(!nooverlay && (!width || !height)){
588 /*window is minimized*/
589 ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,NULL, g_lpddsPrimary, NULL, DDOVER_HIDE, NULL);
590 return 0;
591 }
592 if(vo_keepaspect){
593 int tmpheight=((float)width/window_aspect);
594 tmpheight+=tmpheight%2;
595 if(tmpheight > height){
596 width=((float)height*window_aspect);
597 width+=width%2;
598 }
599 else height=tmpheight;
600 }
601 if (WinID == -1)
602 while(ShowCursor(TRUE)<=0){}
603 }
604 rd.right=rd.left+width;
605 rd.bottom=rd.top+height;
606
607 /*ok, let's workaround some overlay limitations*/
608 if(!nooverlay)
609 {
610 uint32_t uStretchFactor1000; //minimum stretch
611 uint32_t xstretch1000,ystretch1000;
612 /*get driver capabilities*/
613 ZeroMemory(&capsDrv, sizeof(capsDrv));
614 capsDrv.dwSize = sizeof(capsDrv);
615 if(g_lpdd->lpVtbl->GetCaps(g_lpdd,&capsDrv, NULL) != DD_OK)return 1;
616 /*get minimum stretch, depends on display adaptor and mode (refresh rate!) */
617 uStretchFactor1000 = capsDrv.dwMinOverlayStretch>1000 ? capsDrv.dwMinOverlayStretch : 1000;
618 rd.right = ((width+rd.left)*uStretchFactor1000+999)/1000;
619 rd.bottom = (height+rd.top)*uStretchFactor1000/1000;
620 /*calculate xstretch1000 and ystretch1000*/
621 xstretch1000 = ((rd.right - rd.left)* 1000)/image_width ;
622 ystretch1000 = ((rd.bottom - rd.top)* 1000)/image_height;
623 rs.left=0;
624 rs.right=image_width;
625 rs.top=0;
626 rs.bottom=image_height;
627 if(rd.left < 0)rs.left=(-rd.left*1000)/xstretch1000;
628 if(rd.top < 0)rs.top=(-rd.top*1000)/ystretch1000;
629 if(rd.right > vo_screenwidth)rs.right=((vo_screenwidth-rd.left)*1000)/xstretch1000;
630 if(rd.bottom > vo_screenheight)rs.bottom=((vo_screenheight-rd.top)*1000)/ystretch1000;
631 /*do not allow to zoom or shrink if hardware isn't able to do so*/
632 if((width < image_width)&& !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKX))
633 {
634 if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKXN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only shrinkN\n");
635 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't shrink x\n");
636 rd.right=rd.left+image_width;
637 }
638 else if((width > image_width)&& !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHX))
639 {
640 if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHXN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only stretchN\n");
641 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't stretch x\n");
642 rd.right = rd.left+image_width;
643 }
644 if((height < image_height) && !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKY))
645 {
646 if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSHRINKYN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only shrinkN\n");
647 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't shrink y\n");
648 rd.bottom = rd.top + image_height;
649 }
650 else if((height > image_height ) && !(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHY))
651 {
652 if(capsDrv.dwFXCaps & DDFXCAPS_OVERLAYSTRETCHYN)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can only stretchN\n");
653 else mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't stretch y\n");
654 rd.bottom = rd.top + image_height;
655 }
656 /*the last thing to check are alignment restrictions
657 these expressions (x & -y) just do alignment by dropping low order bits...
658 so to round up, we add first, then truncate*/
659 if((capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYSRC) && capsDrv.dwAlignBoundarySrc)
660 rs.left = (rs.left + capsDrv.dwAlignBoundarySrc / 2) & -(signed)(capsDrv.dwAlignBoundarySrc);
661 if((capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC) && capsDrv.dwAlignSizeSrc)
662 rs.right = rs.left + ((rs.right - rs.left + capsDrv.dwAlignSizeSrc / 2) & -(signed) (capsDrv.dwAlignSizeSrc));
663 if((capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYDEST) && capsDrv.dwAlignBoundaryDest)
664 rd.left = (rd.left + capsDrv.dwAlignBoundaryDest / 2) & -(signed)(capsDrv.dwAlignBoundaryDest);
665 if((capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST) && capsDrv.dwAlignSizeDest)
666 rd.right = rd.left + ((rd.right - rd.left) & -(signed) (capsDrv.dwAlignSizeDest));
667 /*create an overlay FX structure to specify a destination color key*/
668 ZeroMemory(&ovfx, sizeof(ovfx));
669 ovfx.dwSize = sizeof(ovfx);
670 if(vo_fs||vidmode)
671 {
672 ovfx.dckDestColorkey.dwColorSpaceLowValue = 0;
673 ovfx.dckDestColorkey.dwColorSpaceHighValue = 0;
674 }
675 else
676 {
677 ovfx.dckDestColorkey.dwColorSpaceLowValue = destcolorkey;
678 ovfx.dckDestColorkey.dwColorSpaceHighValue = destcolorkey;
679 }
680 // set the flags we'll send to UpdateOverlay //DDOVER_AUTOFLIP|DDOVERFX_MIRRORLEFTRIGHT|DDOVERFX_MIRRORUPDOWN could be useful?;
681 dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX;
682 /*if hardware can't do colorkeying set the window on top*/
683 if(capsDrv.dwCKeyCaps & DDCKEYCAPS_DESTOVERLAY) dwUpdateFlags |= DDOVER_KEYDESTOVERRIDE;
684 else if (!tmp_image) vo_ontop = 1;
685 }
686 else
687 {
688 g_lpddclipper->lpVtbl->SetHWnd(g_lpddclipper, 0,(vo_fs && !vidmode)?hWndFS: hWnd);
689 }
690
691 if(!vidmode && !vo_fs){
692 if(WinID == -1) {
693 RECT rdw=rd;
694 if (vo_border)
695 AdjustWindowRect(&rdw,WNDSTYLE,FALSE);
696 // printf("window: %i %i %ix%i\n",rdw.left,rdw.top,rdw.right - rdw.left,rdw.bottom - rdw.top);
697 rdw.left += monitor_rect.left; /* move to global coordinate space */
698 rdw.top += monitor_rect.top;
699 rdw.right += monitor_rect.left;
700 rdw.bottom += monitor_rect.top;
701 SetWindowPos(hWnd,(vo_ontop)?HWND_TOPMOST:(vo_rootwin?HWND_BOTTOM:HWND_NOTOPMOST),rdw.left,rdw.top,rdw.right-rdw.left,rdw.bottom-rdw.top,SWP_NOOWNERZORDER);
702 }
703 }
704 else SetWindowPos(vidmode?hWnd:hWndFS,vo_rootwin?HWND_BOTTOM:HWND_TOPMOST,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOOWNERZORDER|SWP_NOCOPYBITS);
705
706 /*make sure the overlay is inside the screen*/
707 if(rd.left<0)rd.left=0;
708 if(rd.right>vo_screenwidth)rd.right=vo_screenwidth;
709 if(rd.top<0)rd.top=0;
710 if(rd.bottom>vo_screenheight)rd.bottom=vo_screenheight;
711
712 /*for nonoverlay mode we are finished, for overlay mode we have to display the overlay first*/
713 if(nooverlay)return 0;
714
715 // printf("overlay: %i %i %ix%i\n",rd.left,rd.top,rd.right - rd.left,rd.bottom - rd.top);
716 ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
717 if(FAILED(ddrval))
718 {
719 // one cause might be the driver lied about minimum stretch
720 // we should try upping the destination size a bit, or
721 // perhaps shrinking the source size
722 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>UpdateOverlay failed\n" );
723 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>Overlay:x1:%i,y1:%i,x2:%i,y2:%i,w:%i,h:%i\n",rd.left,rd.top,rd.right,rd.bottom,rd.right - rd.left,rd.bottom - rd.top );
724 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>");
725 switch (ddrval)
726 {
727 case DDERR_NOSTRETCHHW:
728 {mp_msg(MSGT_VO, MSGL_ERR ,"hardware can't stretch: try to size the window back\n");break;}
729 case DDERR_INVALIDRECT:
730 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid rectangle\n");break;}
731 case DDERR_INVALIDPARAMS:
732 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid parameters\n");break;}
733 case DDERR_HEIGHTALIGN:
734 {mp_msg(MSGT_VO, MSGL_ERR ,"height align\n");break;}
735 case DDERR_XALIGN:
736 {mp_msg(MSGT_VO, MSGL_ERR ,"x align\n");break;}
737 case DDERR_UNSUPPORTED:
738 {mp_msg(MSGT_VO, MSGL_ERR ,"unsupported\n");break;}
739 case DDERR_INVALIDSURFACETYPE:
740 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid surfacetype\n");break;}
741 case DDERR_INVALIDOBJECT:
742 {mp_msg(MSGT_VO, MSGL_ERR ,"invalid object\n");break;}
743 case DDERR_SURFACELOST:
744 {
745 mp_msg(MSGT_VO, MSGL_ERR ,"surfaces lost\n");
746 g_lpddsOverlay->lpVtbl->Restore( g_lpddsOverlay ); //restore and try again
747 g_lpddsPrimary->lpVtbl->Restore( g_lpddsPrimary );
748 ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
749 if(ddrval !=DD_OK)mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>UpdateOverlay failed again\n" );
750 break;
751 }
752 default:
753 mp_msg(MSGT_VO, MSGL_ERR ," 0x%x\n",ddrval);
754 }
755 /*ok we can't do anything about it -> hide overlay*/
756 if(ddrval != DD_OK)
757 {
758 ddrval = g_lpddsOverlay->lpVtbl->UpdateOverlay(g_lpddsOverlay,NULL, g_lpddsPrimary, NULL, DDOVER_HIDE, NULL);
759 return 1;
760 }
761 }
762 return 0;
763 }
764
765 //find out supported overlay pixelformats
766 static uint32_t Directx_CheckOverlayPixelformats()
767 {
768 DDCAPS capsDrv;
769 HRESULT ddrval;
770 DDSURFACEDESC2 ddsdOverlay;
771 uint32_t i;
772 uint32_t formatcount = 0;
773 //get driver caps to determine overlay support
774 ZeroMemory(&capsDrv, sizeof(capsDrv));
775 capsDrv.dwSize = sizeof(capsDrv);
776 ddrval = g_lpdd->lpVtbl->GetCaps(g_lpdd,&capsDrv, NULL);
777 if (FAILED(ddrval))
778 {
779 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>failed getting ddrawcaps\n");
780 return 1;
781 }
782 if (!(capsDrv.dwCaps & DDCAPS_OVERLAY))
783 {
784 mp_msg(MSGT_VO, MSGL_ERR ,"<vo_directx><ERROR>Your card doesn't support overlay\n");
785 return 1;
786 }
787 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>testing supported overlay pixelformats\n");
788 //it is not possible to query for pixel formats supported by the
789 //overlay hardware: try out various formats till one works
790 ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
791 ddsdOverlay.dwSize = sizeof(ddsdOverlay);
792 ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
793 ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH| DDSD_PIXELFORMAT;
794 ddsdOverlay.dwWidth=300;
795 ddsdOverlay.dwHeight=280;
796 ddsdOverlay.dwBackBufferCount=0;
797 //try to create an overlay surface using one of the pixel formats in our global list
798 i=0;
799 do
800 {
801 ddsdOverlay.ddpfPixelFormat=g_ddpf[i].g_ddpfOverlay;
802 ddrval = g_lpdd->lpVtbl->CreateSurface(g_lpdd,&ddsdOverlay, &g_lpddsOverlay, NULL);
803 if (ddrval == DD_OK)
804 {
805 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT OVERLAY>%i %s supported\n",i,g_ddpf[i].img_format_name);
806 g_ddpf[i].drv_caps = VFCAP_CSP_SUPPORTED |VFCAP_OSD |VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP;
807 formatcount++;}
808 else mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT OVERLAY>%i %s not supported\n",i,g_ddpf[i].img_format_name);
809 if (g_lpddsOverlay != NULL) {g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);g_lpddsOverlay = NULL;}
810 } while( ++i < NUM_FORMATS );
811 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>Your card supports %i of %i overlayformats\n",formatcount, NUM_FORMATS);
812 if (formatcount == 0)
813 {
814 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><WARN>Your card supports overlay, but we couldn't create one\n");
815 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>This can have the following reasons:\n");
816 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- you are already using an overlay with another app\n");
817 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- you don't have enough videomemory\n");
818 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>- vo_directx doesn't support the cards overlay pixelformat\n");
819 return 1;
820 }
821 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
822 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 ;)
823 return 0;
824 }
825
826 //find out the Pixelformat of the Primary Surface
827 static uint32_t Directx_CheckPrimaryPixelformat()
828 {
829 uint32_t i=0;
830 uint32_t formatcount = 0;
831 DDPIXELFORMAT ddpf;
832 DDSURFACEDESC2 ddsd;
833 HDC hdc;
834 HRESULT hres;
835 COLORREF rgbT=RGB(0,0,0);
836 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>checking primary surface\n");
837 memset( &ddpf, 0, sizeof( DDPIXELFORMAT ));
838 ddpf.dwSize = sizeof( DDPIXELFORMAT );
839 //we have to create a primary surface first
840 if(Directx_CreatePrimarySurface()!=0)return 1;
841 if(g_lpddsPrimary->lpVtbl->GetPixelFormat( g_lpddsPrimary, &ddpf ) != DD_OK )
842 {
843 mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>can't get pixelformat\n");
844 return 1;
845 }
846 while ( i < NUM_FORMATS )
847 {
848 if (g_ddpf[i].g_ddpfOverlay.dwRGBBitCount == ddpf.dwRGBBitCount)
849 {
850 if (g_ddpf[i].g_ddpfOverlay.dwRBitMask == ddpf.dwRBitMask)
851 {
852 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><FORMAT PRIMARY>%i %s supported\n",i,g_ddpf[i].img_format_name);
853 g_ddpf[i].drv_caps = VFCAP_CSP_SUPPORTED |VFCAP_OSD;
854 formatcount++;
855 primary_image_format=g_ddpf[i].img_format;
856 }
857 }
858 i++;
859 }
860 //get the colorkey for overlay mode
861 destcolorkey = CLR_INVALID;
862 if (windowcolor != CLR_INVALID && g_lpddsPrimary->lpVtbl->GetDC(g_lpddsPrimary,&hdc) == DD_OK)
863 {
864 rgbT = GetPixel(hdc, 0, 0);
865 SetPixel(hdc, 0, 0, windowcolor);
866 g_lpddsPrimary->lpVtbl->ReleaseDC(g_lpddsPrimary,hdc);
867 }
868 // read back the converted color
869 ddsd.dwSize = sizeof(ddsd);
870 while ((hres = g_lpddsPrimary->lpVtbl->Lock(g_lpddsPrimary,NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
871 ;
872 if (hres == DD_OK)
873 {
874 destcolorkey = *(DWORD *) ddsd.lpSurface;
875 if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
876 destcolorkey &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;
877 g_lpddsPrimary->lpVtbl->Unlock(g_lpddsPrimary,NULL);
878 }
879 if (windowcolor != CLR_INVALID && g_lpddsPrimary->lpVtbl->GetDC(g_lpddsPrimary,&hdc) == DD_OK)
880 {
881 SetPixel(hdc, 0, 0, rgbT);
882 g_lpddsPrimary->lpVtbl->ReleaseDC(g_lpddsPrimary,hdc);
883 }
884 //release primary
885 g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
886 g_lpddsPrimary = NULL;
887 if(formatcount==0)
888 {
889 mp_msg(MSGT_VO, MSGL_FATAL ,"<vo_directx><FATAL ERROR>Unknown Pixelformat\n");
890 return 1;
891 }
892 return 0;
893 }
894
895 //function handles input
896 static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
897 {
898 switch (message)
899 {
900 case WM_MOUSEACTIVATE:
901 return MA_ACTIVATEANDEAT;
902 case WM_NCACTIVATE:
903 {
904 if(vidmode && adapter_count > 2) //only disable if more than one adapter.
905 return 0;
906 break;
907 }
908 case WM_DESTROY:
909 {
910 PostQuitMessage(0);
911 return 0;
912 }
913 case WM_CLOSE:
914 {
915 mplayer_put_key(KEY_CLOSE_WIN);
916 return 0;
917 }
918 case WM_WINDOWPOSCHANGED:
919 {
920 //printf("Windowposchange\n");
921 if(g_lpddsBack != NULL) //or it will crash with -vm
922 {
923 Directx_ManageDisplay();
924 }
925 break;
926 }
927 case WM_SYSCOMMAND:
928 {
929 switch (wParam)
930 { //kill screensaver etc.
931 //note: works only when the window is active
932 //you can workaround this by disabling the allow screensaver option in
933 //the link to the app
934 case SC_SCREENSAVE:
935 case SC_MONITORPOWER:
936 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>killing screensaver\n" );
937 return 0;
938 case SC_MAXIMIZE:
939 if (!vo_fs) control(VOCTRL_FULLSCREEN, NULL);
940 return 0;
941 }
942 break;
943 }
944 case WM_KEYDOWN:
945 {
946 switch (wParam)
947 {
948 case VK_LEFT:
949 {mplayer_put_key(KEY_LEFT);break;}
950 case VK_UP:
951 {mplayer_put_key(KEY_UP);break;}
952 case VK_RIGHT:
953 {mplayer_put_key(KEY_RIGHT);break;}
954 case VK_DOWN:
955 {mplayer_put_key(KEY_DOWN);break;}
956 case VK_TAB:
957 {mplayer_put_key(KEY_TAB);break;}
958 case VK_BACK:
959 {mplayer_put_key(KEY_BS);break;}
960 case VK_DELETE:
961 {mplayer_put_key(KEY_DELETE);break;}
962 case VK_INSERT:
963 {mplayer_put_key(KEY_INSERT);break;}
964 case VK_HOME:
965 {mplayer_put_key(KEY_HOME);break;}
966 case VK_END:
967 {mplayer_put_key(KEY_END);break;}
968 case VK_PRIOR:
969 {mplayer_put_key(KEY_PAGE_UP);break;}
970 case VK_NEXT:
971 {mplayer_put_key(KEY_PAGE_DOWN);break;}
972 case VK_ESCAPE:
973 {mplayer_put_key(KEY_ESC);break;}
974 }
975 break;
976 }
977 case WM_CHAR:
978 {
979 mplayer_put_key(wParam);
980 break;
981 }
982 case WM_LBUTTONDOWN:
983 {
984 if (!vo_nomouse_input)
985 mplayer_put_key(MOUSE_BTN0);
986 break;
987 }
988 case WM_MBUTTONDOWN:
989 {
990 if (!vo_nomouse_input)
991 mplayer_put_key(MOUSE_BTN1);
992 break;
993 }
994 case WM_RBUTTONDOWN:
995 {
996 if (!vo_nomouse_input)
997 mplayer_put_key(MOUSE_BTN2);
998 break;
999 }
1000 case WM_LBUTTONDBLCLK:
1001 {
1002 if(!vo_nomouse_input)
1003 mplayer_put_key(MOUSE_BTN0_DBL);
1004 break;
1005 }
1006 case WM_MBUTTONDBLCLK:
1007 {
1008 if(!vo_nomouse_input)
1009 mplayer_put_key(MOUSE_BTN1_DBL);
1010 break;
1011 }
1012 case WM_RBUTTONDBLCLK:
1013 {
1014 if(!vo_nomouse_input)
1015 mplayer_put_key(MOUSE_BTN2_DBL);
1016 break;
1017 }
1018 case WM_MOUSEWHEEL:
1019 {
1020 int x;
1021 if (vo_nomouse_input)
1022 break;
1023 x = GET_WHEEL_DELTA_WPARAM(wParam);
1024 if (x > 0)
1025 mplayer_put_key(MOUSE_BTN3);
1026 else
1027 mplayer_put_key(MOUSE_BTN4);
1028 break;
1029 }
1030 case WM_XBUTTONDOWN:
1031 {
1032 if (vo_nomouse_input)
1033 break;
1034 if (HIWORD(wParam) == 1)
1035 mplayer_put_key(MOUSE_BTN5);
1036 else
1037 mplayer_put_key(MOUSE_BTN6);
1038 break;
1039 }
1040 case WM_XBUTTONDBLCLK:
1041 {
1042 if (vo_nomouse_input)
1043 break;
1044 if (HIWORD(wParam) == 1)
1045 mplayer_put_key(MOUSE_BTN5_DBL);
1046 else
1047 mplayer_put_key(MOUSE_BTN6_DBL);
1048 break;
1049 }
1050
1051 }
1052 return DefWindowProc(hWnd, message, wParam, lParam);
1053 }
1054
1055
1056 static int preinit(const char *arg)
1057 {
1058 HINSTANCE hInstance = GetModuleHandle(NULL);
1059 char exedir[MAX_PATH];
1060 WNDCLASS wc;
1061 if(arg)
1062 {
1063 if(strstr(arg,"noaccel"))
1064 {
1065 mp_msg(MSGT_VO,MSGL_V,"<vo_directx><INFO>disabled overlay\n");
1066 nooverlay = 1;
1067 }
1068 }
1069 /*load icon from the main app*/
1070 if(GetModuleFileName(NULL,exedir,MAX_PATH))
1071 {
1072 mplayericon = ExtractIcon( hInstance, exedir, 0 );
1073 }
1074 if(!mplayericon)mplayericon=LoadIcon(NULL,IDI_APPLICATION);
1075 mplayercursor = LoadCursor(NULL, IDC_ARROW);
1076 monitor_rect.right=GetSystemMetrics(SM_CXSCREEN);
1077 monitor_rect.bottom=GetSystemMetrics(SM_CYSCREEN);
1078
1079 windowcolor = vo_colorkey;
1080 colorbrush = CreateSolidBrush(windowcolor);
1081 blackbrush = (HBRUSH)GetStockObject(BLACK_BRUSH);
1082 wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
1083 wc.lpfnWndProc = WndProc;
1084 wc.cbClsExtra = 0;
1085 wc.cbWndExtra = 0;
1086 wc.hInstance = hInstance;
1087 wc.hCursor = mplayercursor;
1088 wc.hIcon = mplayericon;
1089 wc.hbrBackground = vidmode ? blackbrush : colorbrush;
1090 wc.lpszClassName = WNDCLASSNAME_WINDOWED;
1091 wc.lpszMenuName = NULL;
1092 RegisterClass(&wc);
1093 if (WinID != -1) hWnd = WinID;
1094 else
1095 hWnd = CreateWindowEx(vidmode?WS_EX_TOPMOST:0,
1096 WNDCLASSNAME_WINDOWED,"",(vidmode || !vo_border)?WS_POPUP:WNDSTYLE,
1097 CW_USEDEFAULT, CW_USEDEFAULT, 100, 100,NULL,NULL,hInstance,NULL);
1098 wc.hbrBackground = blackbrush;
1099 wc.lpszClassName = WNDCLASSNAME_FULLSCREEN;
1100 RegisterClass(&wc);
1101
1102 if (Directx_InitDirectDraw()!= 0)return 1; //init DirectDraw
1103
1104 if(!vidmode)hWndFS = CreateWindow(WNDCLASSNAME_FULLSCREEN,"MPlayer Fullscreen",WS_POPUP,monitor_rect.left,monitor_rect.top,monitor_rect.right-monitor_rect.left,monitor_rect.bottom-monitor_rect.top,hWnd,NULL,hInstance,NULL);
1105 mp_msg(MSGT_VO, MSGL_DBG3 ,"<vo_directx><INFO>initial mplayer windows created\n");
1106
1107 if (Directx_CheckPrimaryPixelformat()!=0)return 1;
1108 if (!nooverlay && Directx_CheckOverlayPixelformats() == 0) //check for supported hardware
1109 {
1110 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>hardware supports overlay\n");
1111 nooverlay = 0;
1112 }
1113 else //if we can't have overlay we create a backpuffer with the same imageformat as the primary surface
1114 {
1115 mp_msg(MSGT_VO, MSGL_V ,"<vo_directx><INFO>using backpuffer\n");
1116 nooverlay = 1;
1117 }
1118 mp_msg(MSGT_VO, MSGL_DBG3 ,"<vo_directx><INFO>preinit succesfully finished\n");
1119 return 0;
1120 }
1121
1122 static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y )
1123 {
1124 uint8_t *s;
1125 uint8_t *d;
1126 uint32_t uvstride=dstride/2;
1127 // copy Y
1128 d=image+dstride*y+x;
1129 s=src[0];
1130 mem2agpcpy_pic(d,s,w,h,dstride,stride[0]);
1131
1132 w/=2;h/=2;x/=2;y/=2;
1133
1134 // copy U
1135 d=image+dstride*image_height + uvstride*y+x;
1136 if(image_format == IMGFMT_YV12)s=src[2];
1137 else s=src[1];
1138 mem2agpcpy_pic(d,s,w,h,uvstride,stride[1]);
1139
1140 // copy V
1141 d=image+dstride*image_height +uvstride*(image_height/2) + uvstride*y+x;
1142 if(image_format == IMGFMT_YV12)s=src[1];
1143 else s=src[2];
1144 mem2agpcpy_pic(d,s,w,h,uvstride,stride[2]);
1145 return 0;
1146 }
1147
1148 static void flip_page(void)
1149 {
1150 HRESULT dxresult;
1151 g_lpddsBack->lpVtbl->Unlock (g_lpddsBack,NULL);
1152 if (vo_doublebuffering)
1153 {
1154 // flip to the next image in the sequence
1155 dxresult = g_lpddsOverlay->lpVtbl->Flip( g_lpddsOverlay,NULL, DDFLIP_WAIT);
1156 if(dxresult == DDERR_SURFACELOST)
1157 {
1158 mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR><vo_directx><INFO>Restoring Surface\n");
1159 g_lpddsBack->lpVtbl->Restore( g_lpddsBack );
1160 // restore overlay and primary before calling
1161 // Directx_ManageDisplay() to avoid error messages
1162 g_lpddsOverlay->lpVtbl->Restore( g_lpddsOverlay );
1163 g_lpddsPrimary->lpVtbl->Restore( g_lpddsPrimary );
1164 // update overlay in case we return from screensaver
1165 Directx_ManageDisplay();
1166 dxresult = g_lpddsOverlay->lpVtbl->Flip( g_lpddsOverlay,NULL, DDFLIP_WAIT);
1167 }
1168 if(dxresult != DD_OK)mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>can't flip page\n");
1169 }
1170 if(nooverlay)
1171 {
1172 DDBLTFX ddbltfx;
1173 // ask for the "NOTEARING" option
1174 memset( &ddbltfx, 0, sizeof(DDBLTFX) );
1175 ddbltfx.dwSize = sizeof(DDBLTFX);
1176 ddbltfx.dwDDFX = DDBLTFX_NOTEARING;
1177 g_lpddsPrimary->lpVtbl->Blt(g_lpddsPrimary, &rd, g_lpddsBack, NULL, DDBLT_WAIT, &ddbltfx);
1178 }
1179 if (g_lpddsBack->lpVtbl->Lock(g_lpddsBack,NULL,&ddsdsf, DDLOCK_NOSYSLOCK | DDLOCK_WAIT , NULL) == DD_OK) {
1180 if(vo_directrendering && (dstride != ddsdsf.lPitch)){
1181 mp_msg(MSGT_VO,MSGL_WARN,"<vo_directx><WARN>stride changed !!!! disabling direct rendering\n");
1182 vo_directrendering=0;
1183 }
1184 if (tmp_image)
1185 free(tmp_image);
1186 tmp_image = NULL;
1187 dstride = ddsdsf.lPitch;
1188 image = ddsdsf.lpSurface;
1189 } else if (!tmp_image) {
1190 mp_msg(MSGT_VO, MSGL_WARN, "<vo_directx><WARN>Locking the surface failed, rendering to a hidden surface!\n");
1191 tmp_image = image = calloc(1, image_height * dstride * 2);
1192 }
1193 }
1194
1195 static int draw_frame(uint8_t *src[])
1196 {
1197 fast_memcpy( image, *src, dstride * image_height );
1198 return 0;
1199 }
1200
1201 static uint32_t get_image(mp_image_t *mpi)
1202 {
1203 if(mpi->flags&MP_IMGFLAG_READABLE) {mp_msg(MSGT_VO, MSGL_V,"<vo_directx><ERROR>slow video ram\n");return VO_FALSE;}
1204 if(mpi->type==MP_IMGTYPE_STATIC) {mp_msg(MSGT_VO, MSGL_V,"<vo_directx><ERROR>not static\n");return VO_FALSE;}
1205 if((mpi->width==dstride) || (mpi->flags&(MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_ACCEPT_WIDTH)))
1206 {
1207 if(mpi->flags&MP_IMGFLAG_PLANAR)
1208 {
1209 if(image_format == IMGFMT_YV12)
1210 {
1211 mpi->planes[2]= image + dstride*image_height;
1212 mpi->planes[1]= image + dstride*image_height+ dstride*image_height/4;
1213 mpi->stride[1]=mpi->stride[2]=dstride/2;
1214 }
1215 else if(image_format == IMGFMT_IYUV || image_format == IMGFMT_I420)
1216 {
1217 mpi->planes[1]= image + dstride*image_height;
1218 mpi->planes[2]= image + dstride*image_height+ dstride*image_height/4;
1219 mpi->stride[1]=mpi->stride[2]=dstride/2;
1220 }
1221 else if(image_format == IMGFMT_YVU9)
1222 {
1223 mpi->planes[2] = image + dstride*image_height;
1224 mpi->planes[1] = image + dstride*image_height+ dstride*image_height/16;
1225 mpi->stride[1]=mpi->stride[2]=dstride/4;
1226 }
1227 }
1228 mpi->planes[0]=image;
1229 mpi->stride[0]=dstride;
1230 mpi->width=image_width;
1231 mpi->height=image_height;
1232 mpi->flags|=MP_IMGFLAG_DIRECT;
1233 mp_msg(MSGT_VO, MSGL_DBG3, "<vo_directx><INFO>Direct Rendering ENABLED\n");
1234 return VO_TRUE;
1235 }
1236 return VO_FALSE;
1237 }
1238
1239 static uint32_t put_image(mp_image_t *mpi){
1240
1241 uint8_t *d;
1242 uint8_t *s;
1243 uint32_t x = mpi->x;
1244 uint32_t y = mpi->y;
1245 uint32_t w = mpi->w;
1246 uint32_t h = mpi->h;
1247
1248 if (WinID != -1) Directx_ManageDisplay();
1249
1250 if((mpi->flags&MP_IMGFLAG_DIRECT)||(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK))
1251 {
1252 mp_msg(MSGT_VO, MSGL_DBG3 ,"<vo_directx><INFO>put_image: nothing to do: drawslices\n");
1253 return VO_TRUE;
1254 }
1255
1256 if (mpi->flags&MP_IMGFLAG_PLANAR)
1257 {
1258
1259 if(image_format!=IMGFMT_YVU9)draw_slice(mpi->planes,mpi->stride,mpi->w,mpi->h,0,0);
1260 else
1261 {
1262 // copy Y
1263 d=image+dstride*y+x;
1264 s=mpi->planes[0];
1265 mem2agpcpy_pic(d,s,w,h,dstride,mpi->stride[0]);
1266 w/=4;h/=4;x/=4;y/=4;
1267 // copy V
1268 d=image+dstride*image_height + dstride*y/4+x;
1269 s=mpi->planes[2];
1270 mem2agpcpy_pic(d,s,w,h,dstride/4,mpi->stride[1]);
1271 // copy U
1272 d=image+dstride*image_height + dstride*image_height/16 + dstride/4*y+x;
1273 s=mpi->planes[1];
1274 mem2agpcpy_pic(d,s,w,h,dstride/4,mpi->stride[2]);
1275 }
1276 }
1277 else //packed
1278 {
1279 mem2agpcpy_pic(image, mpi->planes[0], w * (mpi->bpp / 8), h, dstride, mpi->stride[0]);
1280 }
1281 return VO_TRUE;
1282 }
1283
1284 static int
1285 config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t options, char *title, uint32_t format)
1286 {
1287 RECT rd;
1288 vo_fs = options & 0x01;
1289 image_format = format;
1290 image_width = width;
1291 image_height = height;
1292 d_image_width = d_width;
1293 d_image_height = d_height;
1294 if(format != primary_image_format)nooverlay = 0;
1295 window_aspect= (float)d_image_width / (float)d_image_height;
1296
1297 #ifdef CONFIG_GUI
1298 if(use_gui){
1299 guiGetEvent(guiSetShVideo, 0);
1300 }
1301 #endif
1302 /*release all directx objects*/
1303 if (g_cc != NULL)g_cc->lpVtbl->Release(g_cc);
1304 g_cc=NULL;
1305 if(g_lpddclipper)g_lpddclipper->lpVtbl->Release(g_lpddclipper);
1306 g_lpddclipper=NULL;
1307 if (g_lpddsBack != NULL) g_lpddsBack->lpVtbl->Release(g_lpddsBack);
1308 g_lpddsBack = NULL;
1309 if(vo_doublebuffering)
1310 if (g_lpddsOverlay != NULL)g_lpddsOverlay->lpVtbl->Release(g_lpddsOverlay);
1311 g_lpddsOverlay = NULL;
1312 if (g_lpddsPrimary != NULL) g_lpddsPrimary->lpVtbl->Release(g_lpddsPrimary);
1313 g_lpddsPrimary = NULL;
1314 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>overlay surfaces released\n");
1315
1316 if(!vidmode){
1317 if(!vo_geometry){
1318 GetWindowRect(hWnd,&rd);
1319 vo_dx=rd.left;
1320 vo_dy=rd.top;
1321 }
1322 vo_dx += monitor_rect.left; /* move position to global window space */
1323 vo_dy += monitor_rect.top;
1324 rd.left = vo_dx;
1325 rd.top = vo_dy;
1326 rd.right = rd.left + d_image_width;
1327 rd.bottom = rd.top + d_image_height;
1328 if (WinID == -1) {
1329 if (vo_border)
1330 AdjustWindowRect(&rd,WNDSTYLE,FALSE);
1331 SetWindowPos(hWnd,NULL, vo_dx, vo_dy,rd.right-rd.left,rd.bottom-rd.top,SWP_SHOWWINDOW|SWP_NOOWNERZORDER);
1332 }
1333 }
1334 else ShowWindow(hWnd,SW_SHOW);
1335
1336 if(vo_fs && !vidmode)ShowWindow(hWndFS,SW_SHOW);
1337 if (WinID == -1)
1338 SetWindowText(hWnd,title);
1339
1340
1341 if(vidmode)vo_fs=0;
1342
1343
1344 /*create the surfaces*/
1345 if(Directx_CreatePrimarySurface())return 1;
1346
1347 //create palette for 256 color mode
1348 if(image_format==IMGFMT_BGR8){
1349 LPDIRECTDRAWPALETTE ddpalette=NULL;
1350 char* palette=malloc(4*256);
1351 int i;
1352 for(i=0; i<256; i++){
1353 palette[4*i+0] = ((i >> 5) & 0x07) * 255 / 7;
1354 palette[4*i+1] = ((i >> 2) & 0x07) * 255 / 7;
1355 palette[4*i+2] = ((i >> 0) & 0x03) * 255 / 3;
1356 palette[4*i+3] = PC_NOCOLLAPSE;
1357 }
1358 g_lpdd->lpVtbl->CreatePalette(g_lpdd,DDPCAPS_8BIT|DDPCAPS_INITIALIZE,palette,&ddpalette,NULL);
1359 g_lpddsPrimary->lpVtbl->SetPalette(g_lpddsPrimary,ddpalette);
1360 free(palette);
1361 ddpalette->lpVtbl->Release(ddpalette);
1362 }
1363
1364 if (!nooverlay && Directx_CreateOverlay(image_format))
1365 {
1366 if(format == primary_image_format)nooverlay=1; /*overlay creation failed*/
1367 else {
1368 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't use overlay mode: please use -vo directx:noaccel\n");
1369 return 1;
1370 }
1371 }
1372 if(nooverlay)
1373 {
1374 if(Directx_CreateBackpuffer())
1375 {
1376 mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't get the driver to work on your system :(\n");
1377 return 1;
1378 }
1379 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><INFO>back surface created\n");
1380 vo_doublebuffering = 0;
1381 /*create clipper for nonoverlay mode*/
1382 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;}
1383 if(g_lpddclipper->lpVtbl->SetHWnd (g_lpddclipper, 0, hWnd)!= DD_OK){mp_msg(MSGT_VO, MSGL_FATAL,"<vo_directx><FATAL ERROR>can't associate clipper with window\n");return 1;}
1384 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;}
1385 mp_msg(MSGT_VO, MSGL_DBG3,"<vo_directx><INFO>clipper succesfully created\n");
1386 }else{
1387 if(DD_OK != g_lpddsOverlay->lpVtbl->QueryInterface(g_lpddsOverlay,&IID_IDirectDrawColorControl,(void**)&g_cc))
1388 mp_msg(MSGT_VO, MSGL_V,"<vo_directx><WARN>unable to get DirectDraw ColorControl interface\n");
1389 }
1390 Directx_ManageDisplay();
1391 memset(&ddsdsf, 0,sizeof(DDSURFACEDESC2));
1392 ddsdsf.dwSize = sizeof (DDSURFACEDESC2);
1393 if (g_lpddsBack->lpVtbl->Lock(g_lpddsBack,NULL,&ddsdsf, DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL) == DD_OK) {
1394 dstride = ddsdsf.lPitch;
1395 image = ddsdsf.lpSurface;
1396 return 0;
1397 }
1398 mp_msg(MSGT_VO, MSGL_V, "<vo_directx><ERROR>Initial Lock on the Surface failed.\n");
1399 return 1;
1400 }
1401
1402 //function to set color controls
1403 // brightness [0, 10000]
1404 // contrast [0, 20000]
1405 // hue [-180, 180]
1406 // saturation [0, 20000]
1407 static uint32_t color_ctrl_set(char *what, int value)
1408 {
1409 uint32_t r = VO_NOTIMPL;
1410 DDCOLORCONTROL dcc;
1411 //printf("\n*** %s = %d\n", what, value);
1412 if (!g_cc) {
1413 //printf("\n *** could not get color control interface!!!\n");
1414 return VO_NOTIMPL;
1415 }
1416 ZeroMemory(&dcc, sizeof(dcc));
1417 dcc.dwSize = sizeof(dcc);
1418
1419 if (!strcmp(what, "brightness")) {
1420 dcc.dwFlags = DDCOLOR_BRIGHTNESS;
1421 dcc.lBrightness = (value + 100) * 10000 / 200;
1422 r = VO_TRUE;
1423 } else if (!strcmp(what, "contrast")) {
1424 dcc.dwFlags = DDCOLOR_CONTRAST;
1425 dcc.lContrast = (value + 100) * 20000 / 200;
1426 r = VO_TRUE;
1427 } else if (!strcmp(what, "hue")) {
1428 dcc.dwFlags = DDCOLOR_HUE;
1429 dcc.lHue = value * 180 / 100;
1430 r = VO_TRUE;
1431 } else if (!strcmp(what, "saturation")) {
1432 dcc.dwFlags = DDCOLOR_SATURATION;
1433 dcc.lSaturation = (value + 100) * 20000 / 200;
1434 r = VO_TRUE;
1435 }
1436
1437 if (r == VO_TRUE) {
1438 g_cc->lpVtbl->SetColorControls(g_cc, &dcc);
1439 }
1440 return r;
1441 }
1442
1443 //analoguous to color_ctrl_set
1444 static uint32_t color_ctrl_get(char *what, int *value)
1445 {
1446 uint32_t r = VO_NOTIMPL;
1447 DDCOLORCONTROL dcc;
1448 if (!g_cc) {
1449 //printf("\n *** could not get color control interface!!!\n");
1450 return VO_NOTIMPL;
1451 }
1452 ZeroMemory(&dcc, sizeof(dcc));
1453 dcc.dwSize = sizeof(dcc);
1454
1455 if (g_cc->lpVtbl->GetColorControls(g_cc, &dcc) != DD_OK) {
1456 return r;
1457 }
1458
1459 if (!strcmp(what, "brightness") && (dcc.dwFlags & DDCOLOR_BRIGHTNESS)) {
1460 *value = dcc.lBrightness * 200 / 10000 - 100;
1461 r = VO_TRUE;
1462 } else if (!strcmp(what, "contrast") && (dcc.dwFlags & DDCOLOR_CONTRAST)) {
1463 *value = dcc.lContrast * 200 / 20000 - 100;
1464 r = VO_TRUE;
1465 } else if (!strcmp(what, "hue") && (dcc.dwFlags & DDCOLOR_HUE)) {
1466 *value = dcc.lHue * 100 / 180;
1467 r = VO_TRUE;
1468 } else if (!strcmp(what, "saturation") && (dcc.dwFlags & DDCOLOR_SATURATION)) {
1469 *value = dcc.lSaturation * 200 / 20000 - 100;
1470 r = VO_TRUE;
1471 }
1472 // printf("\n*** %s = %d\n", what, *value);
1473
1474 return r;
1475 }
1476
1477 static int control(uint32_t request, void *data, ...)
1478 {
1479 switch (request) {
1480
1481 case VOCTRL_GET_IMAGE:
1482 return get_image(data);
1483 case VOCTRL_QUERY_FORMAT:
1484 last_rect.left = 0xDEADC0DE; // reset window position cache
1485 return query_format(*((uint32_t*)data));
1486 case VOCTRL_DRAW_IMAGE:
1487 return put_image(data);
1488 case VOCTRL_BORDER:
1489 if(WinID != -1) return VO_TRUE;
1490 if(vidmode)
1491 {
1492 mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>border has no meaning in exclusive mode\n");
1493 }
1494 else
1495 {
1496 if(vo_border) {
1497 vo_border = 0;
1498 SetWindowLong(hWnd, GWL_STYLE, WS_POPUP);
1499 } else {
1500 vo_border = 1;
1501 SetWindowLong(hWnd, GWL_STYLE, WNDSTYLE);
1502 }
1503 // needed AFAICT to force the window to
1504 // redisplay with the new style. --Joey
1505 if (!vo_fs) {
1506 ShowWindow(hWnd,SW_HIDE);
1507 ShowWindow(hWnd,SW_SHOW);
1508 }
1509 last_rect.left = 0xDEADC0DE; // reset window position cache
1510 Directx_ManageDisplay();
1511 }
1512 return VO_TRUE;
1513 case VOCTRL_ONTOP:
1514 if(WinID != -1) return VO_TRUE;
1515 if(vidmode)
1516 {
1517 mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>ontop has no meaning in exclusive mode\n");
1518 }
1519 else
1520 {
1521 if(vo_ontop) vo_ontop = 0;
1522 else vo_ontop = 1;
1523 last_rect.left = 0xDEADC0DE; // reset window position cache
1524 Directx_ManageDisplay();
1525 }
1526 return VO_TRUE;
1527 case VOCTRL_ROOTWIN:
1528 if(WinID != -1) return VO_TRUE;
1529 if(vidmode)
1530 {
1531 mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>rootwin has no meaning in exclusive mode\n");
1532 }
1533 else
1534 {
1535 if(vo_rootwin) vo_rootwin = 0;
1536 else vo_rootwin = 1;
1537 last_rect.left = 0xDEADC0DE; // reset window position cache
1538 Directx_ManageDisplay();
1539 }
1540 return VO_TRUE;
1541 case VOCTRL_FULLSCREEN:
1542 {
1543 if(vidmode)
1544 {
1545 mp_msg(MSGT_VO, MSGL_ERR,"<vo_directx><ERROR>currently we do not allow to switch from exclusive to windowed mode\n");
1546 }
1547 else
1548 {
1549 if(!vo_fs)
1550 {
1551 vo_fs=1;
1552 ShowWindow(hWndFS,SW_SHOW);
1553 ShowWindow(hWnd,SW_HIDE);
1554 SetForegroundWindow(hWndFS);
1555 }
1556 else
1557 {
1558 vo_fs=0;
1559 ShowWindow(hWndFS,SW_HIDE);
1560 ShowWindow(hWnd,SW_SHOW);
1561 }
1562 last_rect.left = 0xDEADC0DE; // reset window position cache
1563 Directx_ManageDisplay();
1564 break;
1565 }
1566 return VO_TRUE;
1567 }
1568 case VOCTRL_SET_EQUALIZER: {
1569 va_list ap;
1570 int value;
1571
1572 va_start(ap, data);
1573 value = va_arg(ap, int);
1574 va_end(ap);
1575 return color_ctrl_set(data, value);
1576 }
1577 case VOCTRL_GET_EQUALIZER: {
1578 va_list ap;
1579 int *value;
1580
1581 va_start(ap, data);
1582 value = va_arg(ap, int*);
1583 va_end(ap);
1584 return color_ctrl_get(data, value);
1585 }
1586 case VOCTRL_UPDATE_SCREENINFO:
1587 if (vidmode) {
1588 vo_screenwidth = vm_width;
1589 vo_screenheight = vm_height;
1590 } else {
1591 vo_screenwidth = monitor_rect.right - monitor_rect.left;
1592 vo_screenheight = monitor_rect.bottom - monitor_rect.top;
1593 }
1594 aspect_save_screenres(vo_screenwidth, vo_screenheight);
1595 return VO_TRUE;
1596 case VOCTRL_RESET:
1597 last_rect.left = 0xDEADC0DE; // reset window position cache
1598 // fall-through intended
1599 };
1600 return VO_NOTIMPL;
1601 }
mplayer with SMedia Glamo drivers