Mercurial > mplayer.hg
annotate libvo/vo_direct3d.c @ 28028:62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
author | reimar |
---|---|
date | Tue, 02 Dec 2008 09:40:09 +0000 |
parents | f210d48c4396 |
children | 07ae7bc7487b |
rev | line source |
---|---|
27921 | 1 /* |
2 * Copyright (c) 2008 Georgi Petrov (gogothebee) <gogothebee@gmail.com> | |
3 * | |
4 * This file is part of MPlayer. | |
5 * | |
6 * MPlayer is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
10 * | |
11 * MPlayer is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License along | |
17 * with MPlayer; if not, write to the Free Software Foundation, Inc., | |
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
19 */ | |
20 | |
21 #include <windows.h> | |
22 #include <errno.h> | |
23 #include <stdio.h> | |
24 #include <d3d9.h> | |
25 #include "config.h" | |
26 #include "video_out.h" | |
27 #include "video_out_internal.h" | |
28 #include "fastmemcpy.h" | |
29 #include "mp_msg.h" | |
30 #include "aspect.h" | |
31 #include "w32_common.h" | |
27937 | 32 #include "libavutil/common.h" |
27921 | 33 |
34 static const vo_info_t info = | |
35 { | |
36 "Direct3D 9 Renderer", | |
37 "direct3d", | |
38 "Georgi Petrov (gogothebee) <gogothebee@gmail.com>", | |
39 "" | |
40 }; | |
41 | |
42 /* | |
43 * Link essential libvo functions: preinit, config, control, draw_frame, | |
44 * draw_slice, draw_osd, flip_page, check_events, uninit and | |
45 * the structure info. | |
46 */ | |
47 const LIBVO_EXTERN(direct3d) | |
48 | |
49 | |
27928 | 50 /* Global variables "priv" structure. I try to keep their count low. |
27921 | 51 */ |
27928 | 52 static struct global_priv { |
53 int is_paused; /**< 1 = Movie is paused, | |
54 0 = Movie is not paused */ | |
27984
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
55 int is_clear_needed; /**< 1 = Clear the backbuffer before StretchRect |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
56 0 = (default) Don't clear it */ |
27968
1081658aa871
Move locked_rect from stack to priv struct in preparation for following patch.
reimar
parents:
27967
diff
changeset
|
57 D3DLOCKED_RECT locked_rect; /**< The locked Offscreen surface */ |
27928 | 58 RECT fs_movie_rect; /**< Rect (upscaled) of the movie when displayed |
59 in fullscreen */ | |
60 RECT fs_panscan_rect; /**< PanScan source surface cropping in | |
61 fullscreen */ | |
62 int src_width; /**< Source (movie) width */ | |
63 int src_height; /**< Source (movie) heigth */ | |
27921 | 64 |
27928 | 65 D3DFORMAT movie_src_fmt; /**< Movie colorspace format (depends on |
66 the movie's codec) */ | |
67 D3DFORMAT desktop_fmt; /**< Desktop (screen) colorspace format. | |
68 Usually XRGB */ | |
69 LPDIRECT3D9 d3d_handle; /**< Direct3D Handle */ | |
70 LPDIRECT3DDEVICE9 d3d_device; /**< The Direct3D Adapter */ | |
71 IDirect3DSurface9 *d3d_surface; /**< Offscreen Direct3D Surface. MPlayer | |
72 renders inside it. Uses colorspace | |
73 priv->movie_src_fmt */ | |
74 IDirect3DSurface9 *d3d_backbuf; /**< Video card's back buffer (used to | |
75 display next frame) */ | |
76 } *priv; | |
77 | |
78 typedef struct { | |
79 const unsigned int mplayer_fmt; /**< Given by MPlayer */ | |
80 const D3DFORMAT fourcc; /**< Required by D3D's test function */ | |
81 } struct_fmt_table; | |
27921 | 82 |
83 /* Map table from reported MPlayer format to the required | |
27928 | 84 fourcc. This is needed to perform the format query. */ |
27921 | 85 |
27928 | 86 static const struct_fmt_table fmt_table[] = { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
87 {IMGFMT_YV12, MAKEFOURCC('Y','V','1','2')}, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
88 {IMGFMT_I420, MAKEFOURCC('I','4','2','0')}, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
89 {IMGFMT_IYUV, MAKEFOURCC('I','Y','U','V')}, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
90 {IMGFMT_YVU9, MAKEFOURCC('Y','V','U','9')}, |
28007
16b39ef63bb5
Use D3DFMT_ constants where possible instead of MAKEFOURCC
reimar
parents:
28006
diff
changeset
|
91 {IMGFMT_YUY2, D3DFMT_YUY2}, |
16b39ef63bb5
Use D3DFMT_ constants where possible instead of MAKEFOURCC
reimar
parents:
28006
diff
changeset
|
92 {IMGFMT_UYVY, D3DFMT_UYVY}, |
28006 | 93 {IMGFMT_BGR32, D3DFMT_X8R8G8B8}, |
94 {IMGFMT_RGB32, D3DFMT_X8B8G8R8}, | |
95 {IMGFMT_BGR24, D3DFMT_R8G8B8}, //untested | |
96 {IMGFMT_BGR16, D3DFMT_R5G6B5}, | |
97 {IMGFMT_BGR15, D3DFMT_X1R5G5B5}, | |
98 {IMGFMT_BGR8 , D3DFMT_R3G3B2}, //untested | |
27921 | 99 }; |
100 | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
101 #define DISPLAY_FORMAT_TABLE_ENTRIES (sizeof(fmt_table) / sizeof(fmt_table[0])) |
27921 | 102 |
103 /**************************************************************************** | |
104 * * | |
105 * * | |
106 * * | |
107 * Direct3D specific implementation functions * | |
108 * * | |
109 * * | |
110 * * | |
111 ****************************************************************************/ | |
112 | |
113 /** @brief Calculate scaled fullscreen movie rectangle with | |
114 * preserved aspect ratio. | |
115 */ | |
27928 | 116 static void calc_fs_rect(void) |
27921 | 117 { |
27928 | 118 int scaled_height = 0; |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
119 int scaled_width = 0; |
27921 | 120 |
27937 | 121 // set default values |
122 priv->fs_movie_rect.left = 0; | |
123 priv->fs_movie_rect.right = vo_dwidth; | |
124 priv->fs_movie_rect.top = 0; | |
125 priv->fs_movie_rect.bottom = vo_dheight; | |
126 priv->fs_panscan_rect.left = 0; | |
127 priv->fs_panscan_rect.right = priv->src_width; | |
128 priv->fs_panscan_rect.top = 0; | |
129 priv->fs_panscan_rect.bottom = priv->src_height; | |
130 if (!vo_fs) return; | |
131 | |
132 // adjust for fullscreen aspect and panscan | |
27928 | 133 aspect(&scaled_width, &scaled_height, A_ZOOM); |
27937 | 134 panscan_calc(); |
135 scaled_width += vo_panscan_x; | |
136 scaled_height += vo_panscan_y; | |
27921 | 137 |
27937 | 138 // note: border is rounded to a multiple of two since at least |
139 // ATI drivers can not handle odd values with YV12 input | |
140 if (scaled_width > vo_dwidth) { | |
141 int border = priv->src_width * (scaled_width - vo_dwidth) / scaled_width; | |
142 border = (border / 2 + 1) & ~1; | |
143 priv->fs_panscan_rect.left = border; | |
144 priv->fs_panscan_rect.right = priv->src_width - border; | |
145 } else { | |
146 priv->fs_movie_rect.left = (vo_dwidth - scaled_width) / 2; | |
147 priv->fs_movie_rect.right = priv->fs_movie_rect.left + scaled_width; | |
148 } | |
149 if (scaled_height > vo_dheight) { | |
150 int border = priv->src_height * (scaled_height - vo_dheight) / scaled_height; | |
151 border = (border / 2 + 1) & ~1; | |
152 priv->fs_panscan_rect.top = border; | |
153 priv->fs_panscan_rect.bottom = priv->src_height - border; | |
154 } else { | |
155 priv->fs_movie_rect.top = (vo_dheight - scaled_height) / 2; | |
156 priv->fs_movie_rect.bottom = priv->fs_movie_rect.top + scaled_height; | |
157 } | |
27921 | 158 |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
159 mp_msg(MSGT_VO, MSGL_V, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
160 "<vo_direct3d>Fullscreen Movie Rect: t: %ld, l: %ld, r: %ld, b:%ld\r\n", |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
161 priv->fs_movie_rect.top, priv->fs_movie_rect.left, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
162 priv->fs_movie_rect.right, priv->fs_movie_rect.bottom); |
27984
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
163 |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
164 /* The backbuffer should be cleared before next StretchRect. This is |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
165 * necessary because our new draw area could be smaller than the |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
166 * previous one used by StretchRect and without it, leftovers from the |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
167 * previous frame will be left. */ |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
168 priv->is_clear_needed = 1; |
27921 | 169 } |
170 | |
28026 | 171 /** @brief Destroy D3D Offscreen and Backbuffer surfaces. |
27921 | 172 */ |
28026 | 173 static void destroy_d3d_surfaces(void) |
27921 | 174 { |
28026 | 175 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>destroy_d3d_surfaces called\r\n"); |
176 /* Let's destroy the old (if any) D3D Surfaces */ | |
27921 | 177 |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
178 if (priv->locked_rect.pBits) { |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
179 IDirect3DSurface9_UnlockRect(priv->d3d_surface); |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
180 priv->locked_rect.pBits = NULL; |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
181 } |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
182 |
28028
62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
reimar
parents:
28027
diff
changeset
|
183 if (priv->d3d_surface) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
184 IDirect3DSurface9_Release(priv->d3d_surface); |
27928 | 185 priv->d3d_surface = NULL; |
27921 | 186 } |
187 | |
28028
62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
reimar
parents:
28027
diff
changeset
|
188 if (priv->d3d_backbuf) { |
28026 | 189 IDirect3DSurface9_Release(priv->d3d_backbuf); |
190 priv->d3d_backbuf = NULL; | |
191 } | |
192 } | |
193 | |
194 /** @brief Create D3D Offscreen and Backbuffer surfaces. | |
195 * @return 1 on success, 0 on failure | |
196 */ | |
197 static int create_d3d_surfaces(void) | |
198 { | |
199 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d><INFO>create_d3d_surfaces called.\n"); | |
200 | |
201 if (FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface( | |
202 priv->d3d_device, priv->src_width, priv->src_height, | |
203 priv->movie_src_fmt, D3DPOOL_DEFAULT, &priv->d3d_surface, NULL))) { | |
204 mp_msg(MSGT_VO, MSGL_ERR, | |
205 "<vo_direct3d><INFO>IDirect3D9_CreateOffscreenPlainSurface Failed.\n"); | |
206 return 0; | |
207 } | |
208 | |
209 if (FAILED(IDirect3DDevice9_GetBackBuffer(priv->d3d_device, 0, 0, | |
210 D3DBACKBUFFER_TYPE_MONO, | |
211 &(priv->d3d_backbuf)))) { | |
212 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Back Buffer address get failed\n"); | |
213 return 0; | |
27921 | 214 } |
215 | |
28026 | 216 return 1; |
27921 | 217 } |
218 | |
28026 | 219 /** @brief Fill D3D Presentation parameters |
220 */ | |
221 static void fill_d3d_presentparams(D3DPRESENT_PARAMETERS *present_params) | |
222 { | |
223 /* Prepare Direct3D initialization parameters. */ | |
224 memset(present_params, 0, sizeof(D3DPRESENT_PARAMETERS)); | |
225 present_params->Windowed = TRUE; | |
226 present_params->SwapEffect = D3DSWAPEFFECT_COPY; | |
227 present_params->Flags = D3DPRESENTFLAG_VIDEO; | |
228 present_params->hDeviceWindow = vo_w32_window; /* w32_common var */ | |
229 present_params->BackBufferWidth = 0; /* Fill up window Width */ | |
230 present_params->BackBufferHeight = 0; /* Fill up window Height */ | |
231 present_params->MultiSampleType = D3DMULTISAMPLE_NONE; | |
232 /* D3DPRESENT_INTERVAL_ONE = vsync */ | |
233 present_params->PresentationInterval = D3DPRESENT_INTERVAL_ONE; | |
234 present_params->BackBufferFormat = priv->desktop_fmt; | |
235 present_params->BackBufferCount = 1; | |
236 present_params->EnableAutoDepthStencil = FALSE; | |
237 } | |
27921 | 238 |
28026 | 239 /** @brief Configure initial Direct3D context. The first |
240 * function called to initialize the D3D context. | |
27921 | 241 * @return 1 on success, 0 on failure |
242 */ | |
28026 | 243 static int configure_d3d(void) |
27921 | 244 { |
27928 | 245 D3DPRESENT_PARAMETERS present_params; |
246 D3DDISPLAYMODE disp_mode; | |
27921 | 247 |
28026 | 248 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d><INFO>configure_d3d called\n"); |
27921 | 249 |
250 /* Get the current desktop display mode, so we can set up a back buffer | |
251 * of the same format. */ | |
27928 | 252 if (FAILED(IDirect3D9_GetAdapterDisplayMode(priv->d3d_handle, |
253 D3DADAPTER_DEFAULT, | |
254 &disp_mode))) { | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
255 mp_msg(MSGT_VO, MSGL_ERR, |
27921 | 256 "<vo_direct3d><INFO>Could not read adapter display mode.\n"); |
257 return 0; | |
258 } | |
259 | |
260 /* Write current Desktop's colorspace format in the global storage. */ | |
27928 | 261 priv->desktop_fmt = disp_mode.Format; |
27921 | 262 |
28026 | 263 fill_d3d_presentparams(&present_params); |
27921 | 264 |
265 /* vo_w32_window is w32_common variable. It's a handle to the window. */ | |
27928 | 266 if (FAILED(IDirect3D9_CreateDevice(priv->d3d_handle, |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
267 D3DADAPTER_DEFAULT, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
268 D3DDEVTYPE_HAL, vo_w32_window, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
269 D3DCREATE_SOFTWARE_VERTEXPROCESSING, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
270 &present_params, &priv->d3d_device))) { |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
271 mp_msg(MSGT_VO, MSGL_ERR, |
27921 | 272 "<vo_direct3d><INFO>Could not create the D3D device\n"); |
273 return 0; | |
274 } | |
275 | |
28026 | 276 if (!create_d3d_surfaces()) |
277 return 0; | |
278 | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
279 mp_msg(MSGT_VO, MSGL_V, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
280 "New BackBuffer: Width: %d, Height:%d. VO Dest Width:%d, Height: %d\n", |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
281 present_params.BackBufferWidth, present_params.BackBufferHeight, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
282 vo_dwidth, vo_dheight); |
27921 | 283 |
28026 | 284 calc_fs_rect(); |
285 | |
286 return 1; | |
287 } | |
288 | |
289 /** @brief Reconfigure the whole Direct3D. Called only | |
290 * when the video adapter becomes uncooperative. | |
291 * @return 1 on success, 0 on failure | |
292 */ | |
293 static int reconfigure_d3d(void) | |
294 { | |
295 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d><INFO>reconfigure_d3d called.\n"); | |
296 | |
297 /* Destroy the Offscreen and Backbuffer surfaces */ | |
298 destroy_d3d_surfaces(); | |
299 | |
300 /* Destroy the D3D Device */ | |
28028
62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
reimar
parents:
28027
diff
changeset
|
301 if (priv->d3d_device) { |
28026 | 302 IDirect3DDevice9_Release(priv->d3d_device); |
303 priv->d3d_device = NULL; | |
304 } | |
305 | |
306 /* Stop the whole Direct3D */ | |
307 IDirect3D9_Release(priv->d3d_handle); | |
308 | |
309 /* Initialize Direct3D from the beginning */ | |
310 priv->d3d_handle = Direct3DCreate9(D3D_SDK_VERSION); | |
311 if (!priv->d3d_handle) { | |
312 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Unable to initialize Direct3D\n"); | |
313 return -1; | |
314 } | |
315 | |
316 /* Configure Direct3D */ | |
317 if (!configure_d3d()) | |
318 return 0; | |
319 | |
320 return 1; | |
321 } | |
322 | |
323 | |
324 /** @brief Resize Direct3D context on window resize. | |
325 * @return 1 on success, 0 on failure | |
326 */ | |
327 static int resize_d3d(void) | |
328 { | |
329 D3DPRESENT_PARAMETERS present_params; | |
330 | |
331 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d><INFO>resize_d3d called.\n"); | |
332 | |
333 | |
334 check_events(); | |
335 | |
336 destroy_d3d_surfaces(); | |
337 | |
338 /* Reset the D3D Device with all parameters the same except the new | |
339 * width/height. | |
340 */ | |
341 fill_d3d_presentparams(&present_params); | |
342 if (FAILED(IDirect3DDevice9_Reset(priv->d3d_device, &present_params))) { | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
343 mp_msg(MSGT_VO, MSGL_ERR, |
28026 | 344 "<vo_direct3d><INFO>Could not reset the D3D device\n"); |
27921 | 345 return 0; |
346 } | |
347 | |
28026 | 348 if (!create_d3d_surfaces()) |
27921 | 349 return 0; |
28026 | 350 |
351 mp_msg(MSGT_VO, MSGL_V, | |
352 "New BackBuffer: Width: %d, Height:%d. VO Dest Width:%d, Height: %d\n", | |
353 present_params.BackBufferWidth, present_params.BackBufferHeight, | |
354 vo_dwidth, vo_dheight); | |
27921 | 355 |
27937 | 356 calc_fs_rect(); |
27921 | 357 |
358 return 1; | |
359 } | |
360 | |
361 /** @brief Uninitialize Direct3D and close the window. | |
362 */ | |
27928 | 363 static void uninit_d3d(void) |
27921 | 364 { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
365 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>uninit_d3d called\r\n"); |
27921 | 366 |
28026 | 367 destroy_d3d_surfaces(); |
368 | |
369 /* Destroy the D3D Device */ | |
28028
62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
reimar
parents:
28027
diff
changeset
|
370 if (priv->d3d_device) { |
28026 | 371 IDirect3DDevice9_Release(priv->d3d_device); |
372 priv->d3d_device = NULL; | |
373 } | |
27921 | 374 |
375 /* Stop the whole D3D. */ | |
28028
62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
reimar
parents:
28027
diff
changeset
|
376 if (priv->d3d_handle) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
377 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Calling IDirect3D9_Release\r\n"); |
27928 | 378 IDirect3D9_Release(priv->d3d_handle); |
27921 | 379 } |
380 } | |
381 | |
382 /** @brief Render a frame on the screen. | |
383 * @param mpi mpi structure with the decoded frame inside | |
384 * @return VO_TRUE on success, VO_ERROR on failure | |
385 */ | |
27928 | 386 static uint32_t render_d3d_frame(mp_image_t *mpi) |
27921 | 387 { |
388 /* Uncomment when direct rendering is implemented. | |
389 * if (mpi->flags & MP_IMGFLAG_DIRECT) ... | |
390 */ | |
391 | |
28026 | 392 resize_d3d(); |
393 | |
27921 | 394 if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK) |
27967
ad71ce76c6ce
Move the StretchRect call from draw_slices to render_d3d_frame.
reimar
parents:
27966
diff
changeset
|
395 goto skip_upload; |
27921 | 396 |
27928 | 397 if (mpi->flags & MP_IMGFLAG_PLANAR) { /* Copy a planar frame. */ |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
398 draw_slice(mpi->planes, mpi->stride, mpi->w, mpi->h, 0, 0); |
27967
ad71ce76c6ce
Move the StretchRect call from draw_slices to render_d3d_frame.
reimar
parents:
27966
diff
changeset
|
399 goto skip_upload; |
27921 | 400 } |
401 | |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
402 /* If we're here, then we should lock the rect and copy a packed frame */ |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
403 if (!priv->locked_rect.pBits) { |
27970 | 404 if (FAILED(IDirect3DSurface9_LockRect(priv->d3d_surface, |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
405 &priv->locked_rect, NULL, 0))) { |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
406 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Surface lock failure\n"); |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
407 return VO_ERROR; |
27970 | 408 } |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
409 } |
27921 | 410 |
27968
1081658aa871
Move locked_rect from stack to priv struct in preparation for following patch.
reimar
parents:
27967
diff
changeset
|
411 memcpy_pic(priv->locked_rect.pBits, mpi->planes[0], mpi->stride[0], |
1081658aa871
Move locked_rect from stack to priv struct in preparation for following patch.
reimar
parents:
27967
diff
changeset
|
412 mpi->height, priv->locked_rect.Pitch, mpi->stride[0]); |
27921 | 413 |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
414 skip_upload: |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
415 /* This unlock is used for both slice_draw path and render_d3d_frame path. */ |
27928 | 416 if (FAILED(IDirect3DSurface9_UnlockRect(priv->d3d_surface))) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
417 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Surface unlock failure\n"); |
27921 | 418 return VO_ERROR; |
419 } | |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
420 priv->locked_rect.pBits = NULL; |
27921 | 421 |
27967
ad71ce76c6ce
Move the StretchRect call from draw_slices to render_d3d_frame.
reimar
parents:
27966
diff
changeset
|
422 if (FAILED(IDirect3DDevice9_BeginScene(priv->d3d_device))) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
423 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>BeginScene failed\n"); |
27970 | 424 return VO_ERROR; |
27967
ad71ce76c6ce
Move the StretchRect call from draw_slices to render_d3d_frame.
reimar
parents:
27966
diff
changeset
|
425 } |
ad71ce76c6ce
Move the StretchRect call from draw_slices to render_d3d_frame.
reimar
parents:
27966
diff
changeset
|
426 |
27984
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
427 if (priv->is_clear_needed) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
428 IDirect3DDevice9_Clear(priv->d3d_device, 0, NULL, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
429 D3DCLEAR_TARGET, 0, 0, 0); |
27984
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
430 priv->is_clear_needed = 0; |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
431 } |
21221fd6d994
Make sure the backbuffer is cleared when the border size might have changed.
reimar
parents:
27971
diff
changeset
|
432 |
27928 | 433 if (FAILED(IDirect3DDevice9_StretchRect(priv->d3d_device, |
434 priv->d3d_surface, | |
27937 | 435 &priv->fs_panscan_rect, |
27928 | 436 priv->d3d_backbuf, |
27937 | 437 &priv->fs_movie_rect, |
27928 | 438 D3DTEXF_LINEAR))) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
439 mp_msg(MSGT_VO, MSGL_ERR, |
27921 | 440 "<vo_direct3d>Unable to copy the frame to the back buffer\n"); |
441 return VO_ERROR; | |
442 } | |
443 | |
27928 | 444 if (FAILED(IDirect3DDevice9_EndScene(priv->d3d_device))) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
445 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>EndScene failed\n"); |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
446 return VO_ERROR; |
27921 | 447 } |
448 | |
449 return VO_TRUE; | |
450 } | |
451 | |
452 | |
453 /** @brief Query if movie colorspace is supported by the HW. | |
454 * @return 0 on failure, device capabilities (not probed | |
455 * currently) on success. | |
456 */ | |
27928 | 457 static int query_format(uint32_t movie_fmt) |
27921 | 458 { |
459 int i; | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
460 for (i = 0; i < DISPLAY_FORMAT_TABLE_ENTRIES; i++) { |
27928 | 461 if (fmt_table[i].mplayer_fmt == movie_fmt) { |
27921 | 462 /* Test conversion from Movie colorspace to |
463 * display's target colorspace. */ | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
464 if (FAILED(IDirect3D9_CheckDeviceFormatConversion(priv->d3d_handle, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
465 D3DADAPTER_DEFAULT, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
466 D3DDEVTYPE_HAL, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
467 fmt_table[i].fourcc, |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
468 priv->desktop_fmt))) { |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
469 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Rejected image format: %s\n", |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
470 vo_format_name(fmt_table[i].mplayer_fmt)); |
27928 | 471 return 0; |
472 } | |
27921 | 473 |
27928 | 474 priv->movie_src_fmt = fmt_table[i].fourcc; |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
475 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Accepted image format: %s\n", |
27928 | 476 vo_format_name(fmt_table[i].mplayer_fmt)); |
27921 | 477 return (VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW |
478 /*| VFCAP_OSD*/ | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN); | |
479 | |
480 } | |
481 } | |
482 | |
483 return 0; | |
484 } | |
485 | |
486 /**************************************************************************** | |
487 * * | |
488 * * | |
489 * * | |
490 * libvo Control / Callback functions * | |
491 * * | |
492 * * | |
493 * * | |
494 ****************************************************************************/ | |
495 | |
496 | |
497 | |
498 | |
499 /** @brief libvo Callback: Preinitialize the video card. | |
500 * Preinit the hardware just enough to be queried about | |
501 * supported formats. | |
502 * | |
503 * @return 0 on success, -1 on failure | |
504 */ | |
27928 | 505 |
27921 | 506 static int preinit(const char *arg) |
507 { | |
27928 | 508 D3DDISPLAYMODE disp_mode; |
509 | |
27921 | 510 /* Set to zero all global variables. */ |
28027 | 511 priv = calloc(1, sizeof(struct global_priv)); |
27928 | 512 if (!priv) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
513 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Not enough memory\r\n"); |
27928 | 514 return -1; |
515 } | |
27921 | 516 |
517 /* FIXME | |
518 > Please use subopt-helper.h for this, see vo_gl.c:preinit for | |
519 > an example of how to use it. | |
520 */ | |
521 | |
27928 | 522 priv->d3d_handle = Direct3DCreate9(D3D_SDK_VERSION); |
523 if (!priv->d3d_handle) { | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
524 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Unable to initialize Direct3D\n"); |
27921 | 525 return -1; |
526 } | |
527 | |
27928 | 528 if (FAILED(IDirect3D9_GetAdapterDisplayMode(priv->d3d_handle, |
529 D3DADAPTER_DEFAULT, | |
530 &disp_mode))) { | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
531 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Could not read display mode\n"); |
27921 | 532 return -1; |
533 } | |
534 | |
27928 | 535 /* Store in priv->desktop_fmt the user desktop's colorspace. Usually XRGB. */ |
536 priv->desktop_fmt = disp_mode.Format; | |
27921 | 537 |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
538 mp_msg(MSGT_VO, MSGL_V, "disp_mode.Width %d, disp_mode.Height %d\n", |
27928 | 539 disp_mode.Width, disp_mode.Height); |
27921 | 540 |
541 /* w32_common framework call. Configures window on the screen, gets | |
542 * fullscreen dimensions and does other useful stuff. | |
543 */ | |
27928 | 544 if (!vo_w32_init()) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
545 mp_msg(MSGT_VO, MSGL_V, "Unable to configure onscreen window\r\n"); |
27921 | 546 return -1; |
547 } | |
548 | |
549 return 0; | |
550 } | |
551 | |
552 | |
553 | |
554 /** @brief libvo Callback: Handle control requests. | |
555 * @return VO_TRUE on success, VO_NOTIMPL when not implemented | |
556 */ | |
557 static int control(uint32_t request, void *data, ...) | |
558 { | |
27928 | 559 switch (request) { |
27921 | 560 case VOCTRL_QUERY_FORMAT: |
27928 | 561 return query_format(*(uint32_t*) data); |
27921 | 562 case VOCTRL_GET_IMAGE: /* Direct Rendering. Not implemented yet. */ |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
563 mp_msg(MSGT_VO, MSGL_V, |
27921 | 564 "<vo_direct3d>Direct Rendering request. Not implemented yet\n"); |
565 return VO_NOTIMPL; | |
566 case VOCTRL_DRAW_IMAGE: | |
27928 | 567 return render_d3d_frame(data); |
27921 | 568 case VOCTRL_FULLSCREEN: |
569 vo_w32_fullscreen(); | |
28026 | 570 resize_d3d(); |
27921 | 571 return VO_TRUE; |
572 case VOCTRL_RESET: | |
573 return VO_NOTIMPL; | |
574 case VOCTRL_PAUSE: | |
27928 | 575 priv->is_paused = 1; |
27921 | 576 return VO_TRUE; |
577 case VOCTRL_RESUME: | |
27928 | 578 priv->is_paused = 0; |
27921 | 579 return VO_TRUE; |
580 case VOCTRL_GUISUPPORT: | |
581 return VO_NOTIMPL; | |
582 case VOCTRL_SET_EQUALIZER: | |
583 return VO_NOTIMPL; | |
584 case VOCTRL_GET_EQUALIZER: | |
585 return VO_NOTIMPL; | |
586 case VOCTRL_ONTOP: | |
587 vo_w32_ontop(); | |
588 return VO_TRUE; | |
589 case VOCTRL_BORDER: | |
590 vo_w32_border(); | |
28026 | 591 resize_d3d(); |
27921 | 592 return VO_TRUE; |
593 case VOCTRL_UPDATE_SCREENINFO: | |
594 w32_update_xinerama_info(); | |
595 return VO_TRUE; | |
596 case VOCTRL_SET_PANSCAN: | |
28027 | 597 calc_fs_rect(); |
27921 | 598 return VO_TRUE; |
599 case VOCTRL_GET_PANSCAN: | |
600 return VO_TRUE; | |
601 } | |
602 return VO_FALSE; | |
603 } | |
604 | |
605 /** @brief libvo Callback: Configre the Direct3D adapter. | |
606 * @param width Movie source width | |
607 * @param height Movie source height | |
608 * @param d_width Screen (destination) width | |
609 * @param d_height Screen (destination) height | |
610 * @param options Options bitmap | |
611 * @param title Window title | |
612 * @param format Movie colorspace format (using MPlayer's | |
613 * defines, e.g. IMGFMT_YUY2) | |
614 * @return 0 on success, VO_ERROR on failure | |
615 */ | |
616 static int config(uint32_t width, uint32_t height, uint32_t d_width, | |
617 uint32_t d_height, uint32_t options, char *title, | |
618 uint32_t format) | |
619 { | |
27928 | 620 |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
621 priv->src_width = width; |
27928 | 622 priv->src_height = height; |
27921 | 623 |
624 /* w32_common framework call. Creates window on the screen with | |
625 * the given coordinates. | |
626 */ | |
27928 | 627 if (!vo_w32_config(d_width, d_height, options)) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
628 mp_msg(MSGT_VO, MSGL_V, "Unable to create onscreen window\r\n"); |
27921 | 629 return VO_ERROR; |
630 } | |
631 | |
28026 | 632 /* "config" may be called several times, so if this is not the first |
633 * call, we should destroy Direct3D adapter and surfaces before | |
634 * calling configure_d3d, which will create them again. | |
635 */ | |
636 | |
637 destroy_d3d_surfaces(); | |
638 | |
639 /* Destroy the D3D Device */ | |
28028
62ccb6c80212
Consistency cosmetics: do not compare against NULL in ifs
reimar
parents:
28027
diff
changeset
|
640 if (priv->d3d_device) { |
28026 | 641 IDirect3DDevice9_Release(priv->d3d_device); |
642 priv->d3d_device = NULL; | |
643 } | |
644 | |
645 if (!configure_d3d()) | |
27966 | 646 return VO_ERROR; |
647 | |
27921 | 648 return 0; /* Success */ |
649 } | |
650 | |
651 /** @brief libvo Callback: Flip next already drawn frame on the | |
652 * screen. | |
653 * @return N/A | |
654 */ | |
655 static void flip_page(void) | |
656 { | |
27928 | 657 if (FAILED(IDirect3DDevice9_Present(priv->d3d_device, 0, 0, 0, 0))) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
658 mp_msg(MSGT_VO, MSGL_V, |
27921 | 659 "<vo_direct3d>Video adapter became uncooperative.\n"); |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
660 mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Trying to reinitialize it...\n"); |
27928 | 661 if (!reconfigure_d3d()) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
662 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Reinitialization Failed.\n"); |
27921 | 663 return; |
664 } | |
27928 | 665 if (FAILED(IDirect3DDevice9_Present(priv->d3d_device, 0, 0, 0, 0))) { |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
666 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Reinitialization Failed.\n"); |
27921 | 667 return; |
668 } | |
669 else | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
670 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Video adapter reinitialized.\n"); |
27921 | 671 |
672 } | |
673 } | |
674 | |
675 /** @brief libvo Callback: Draw OSD/Subtitles, | |
676 * @return N/A | |
677 */ | |
678 static void draw_osd(void) | |
679 { | |
680 } | |
681 | |
682 /** @brief libvo Callback: Uninitializes all pointers and closes | |
683 * all D3D related stuff, | |
684 * @return N/A | |
685 */ | |
686 static void uninit(void) | |
687 { | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
688 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Uninitialization\r\n"); |
27921 | 689 |
27928 | 690 uninit_d3d(); |
27921 | 691 vo_w32_uninit(); /* w32_common framework call */ |
28027 | 692 free(priv); |
27928 | 693 priv = NULL; |
27921 | 694 } |
695 | |
696 /** @brief libvo Callback: Handles video window events. | |
697 * @return N/A | |
698 */ | |
699 static void check_events(void) | |
700 { | |
701 int flags; | |
702 /* w32_common framework call. Handles video window events. | |
703 * Updates global libvo's vo_dwidth/vo_dheight upon resize | |
704 * with the new window width/height. | |
705 */ | |
706 flags = vo_w32_check_events(); | |
707 if (flags & VO_EVENT_RESIZE) | |
28026 | 708 resize_d3d(); |
27921 | 709 |
27928 | 710 if ((flags & VO_EVENT_EXPOSE) && priv->is_paused) |
27921 | 711 flip_page(); |
712 } | |
713 | |
714 /** @brief libvo Callback: Draw slice | |
715 * @return 0 on success | |
716 */ | |
717 static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y ) | |
718 { | |
27971 | 719 char *my_src; /**< Pointer to the source image */ |
720 char *dst; /**< Pointer to the destination image */ | |
721 int uv_stride; /**< Stride of the U/V planes */ | |
27921 | 722 |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
723 /* Lock the offscreen surface if it's not already locked. */ |
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
724 if (!priv->locked_rect.pBits) { |
27970 | 725 if (FAILED(IDirect3DSurface9_LockRect(priv->d3d_surface, |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
726 &priv->locked_rect, NULL, 0))) { |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
727 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Surface lock failure\n"); |
27970 | 728 return VO_FALSE; |
729 } | |
27969
7ddd69cf214f
Lock/unlock surface only once even when drawing many slices.
reimar
parents:
27968
diff
changeset
|
730 } |
27921 | 731 |
27971 | 732 uv_stride = priv->locked_rect.Pitch / 2; |
27921 | 733 |
734 /* Copy Y */ | |
27971 | 735 dst = priv->locked_rect.pBits; |
736 dst = dst + priv->locked_rect.Pitch * y + x; | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
737 my_src = src[0]; |
27971 | 738 memcpy_pic(dst, my_src, w, h, priv->locked_rect.Pitch, stride[0]); |
27921 | 739 |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
740 w /= 2; |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
741 h /= 2; |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
742 x /= 2; |
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
743 y /= 2; |
27921 | 744 |
745 /* Copy U */ | |
27971 | 746 dst = priv->locked_rect.pBits; |
747 dst = dst + priv->locked_rect.Pitch * priv->src_height | |
748 + uv_stride * y + x; | |
27928 | 749 if (priv->movie_src_fmt == MAKEFOURCC('Y','V','1','2')) |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
750 my_src = src[2]; |
27921 | 751 else |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
752 my_src = src[1]; |
27921 | 753 |
27971 | 754 memcpy_pic(dst, my_src, w, h, uv_stride, stride[1]); |
27921 | 755 |
756 /* Copy V */ | |
27971 | 757 dst = priv->locked_rect.pBits; |
758 dst = dst + priv->locked_rect.Pitch * priv->src_height | |
759 + uv_stride * (priv->src_height / 2) + uv_stride * y + x; | |
27928 | 760 if (priv->movie_src_fmt == MAKEFOURCC('Y','V','1','2')) |
27971 | 761 my_src=src[1]; |
27921 | 762 else |
27971 | 763 my_src=src[2]; |
27921 | 764 |
27971 | 765 memcpy_pic(dst, my_src, w, h, uv_stride, stride[2]); |
27921 | 766 |
767 return 0; /* Success */ | |
768 } | |
769 | |
770 /** @brief libvo Callback: Unused function | |
771 * @return N/A | |
772 */ | |
773 static int draw_frame(uint8_t *src[]) | |
774 { | |
28011
7f7ffa0eb45a
whitespace cosmetics: prettyprinting and indentation
diego
parents:
28007
diff
changeset
|
775 mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>draw_frame called\n"); |
27921 | 776 return VO_FALSE; |
777 } |