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