[vlc-commits] vout: directdraw: remove this display module
Steve Lhomme
git at videolan.org
Fri Mar 29 15:47:15 CET 2019
vlc | branch: master | Steve Lhomme <robux4 at ycbcr.xyz> | Fri Mar 22 10:14:24 2019 +0100| [729b1f96e69e492359f65422f5108bfa1ca3c94b] | committer: Steve Lhomme
vout: directdraw: remove this display module
For old windows version there's always the GDI fallback.
> http://git.videolan.org/gitweb.cgi/vlc.git/?a=commit;h=729b1f96e69e492359f65422f5108bfa1ca3c94b
---
configure.ac | 5 -
modules/MODULES_LIST | 1 -
modules/video_output/Makefile.am | 14 -
modules/video_output/win32/common.c | 58 --
modules/video_output/win32/common.h | 6 -
modules/video_output/win32/direct3d9.c | 5 +
modules/video_output/win32/directdraw.c | 1452 -------------------------------
modules/video_output/win32/events.c | 25 -
8 files changed, 5 insertions(+), 1561 deletions(-)
diff --git a/configure.ac b/configure.ac
index 1bd42678b8..737f26b5db 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3550,11 +3550,6 @@ AC_ARG_ENABLE([directx],
])
])
AS_IF([test "${enable_directx}" != "no"], [
- dnl DirectDraw
- AC_CHECK_HEADERS([ddraw.h], [
- VLC_ADD_PLUGIN([directdraw])
- ])
-
dnl OpenGL
AC_CHECK_HEADERS([GL/glew.h], [
AC_CHECK_HEADERS([GL/wglew.h], [
diff --git a/modules/MODULES_LIST b/modules/MODULES_LIST
index a06c8c7399..dc9c9fd1c6 100644
--- a/modules/MODULES_LIST
+++ b/modules/MODULES_LIST
@@ -111,7 +111,6 @@ $Id$
* direct3d11_filters: adjust|deinterlacer filter for Direct3D11 video decoding
* direct3d9: video output module using the Direct3D9 API
* direct3d9_filters: adjust|deinterlacer filter for Direct3D9 video decoding
- * directdraw: video output module using the DirectDraw API
* directory_demux: Ouput folder contents to playlist
* directsound: audio output module using the DirectSound API
* dmo: a DirectMediaObject decoder that uses DirectMedia to decode video (WMV3)
diff --git a/modules/video_output/Makefile.am b/modules/video_output/Makefile.am
index 7d12466b32..51a09a30d3 100644
--- a/modules/video_output/Makefile.am
+++ b/modules/video_output/Makefile.am
@@ -333,20 +333,6 @@ libdirect3d11_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(voutdir)'
vout_LTLIBRARIES += $(LTLIBdirect3d11)
EXTRA_LTLIBRARIES += libdirect3d11_plugin.la
-libdirectdraw_plugin_la_SOURCES = video_output/win32/directdraw.c \
- video_output/win32/common.c video_output/win32/common.h \
- video_output/win32/events.c video_output/win32/events.h \
- video_output/win32/sensors.cpp \
- video_output/win32/win32touch.c video_output/win32/win32touch.h
-libdirectdraw_plugin_la_CPPFLAGS = $(AM_CPPFLAGS) \
- -DMODULE_NAME_IS_directdraw
-libdirectdraw_plugin_la_LIBADD = libchroma_copy.la -luser32 -ldxguid -lgdi32 $(LIBCOM) -luuid
-libdirectdraw_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(voutdir)'
-if HAVE_WIN32_DESKTOP
-vout_LTLIBRARIES += $(LTLIBdirectdraw)
-EXTRA_LTLIBRARIES += libdirectdraw_plugin.la
-endif
-
libglwin32_plugin_la_SOURCES = $(OPENGL_COMMONSOURCES) \
video_output/win32/glwin32.c \
video_output/win32/common.c video_output/win32/common.h \
diff --git a/modules/video_output/win32/common.c b/modules/video_output/win32/common.c
index 2b2ab0f678..071156671b 100644
--- a/modules/video_output/win32/common.c
+++ b/modules/video_output/win32/common.c
@@ -111,9 +111,6 @@ int CommonInit(vout_display_t *vd, bool b_windowless, const vout_display_cfg_t *
#ifdef MODULE_NAME_IS_direct3d9
cfg.use_desktop = sys->use_desktop;
#endif
-#ifdef MODULE_NAME_IS_directdraw
- cfg.use_overlay = sys->use_overlay;
-#endif
cfg.x = var_InheritInteger(vd, "video-x");
cfg.y = var_InheritInteger(vd, "video-y");
cfg.width = vdcfg->display.width;
@@ -235,40 +232,11 @@ void UpdateRects(vout_display_t *vd, bool is_forced)
rect_dest.right = rect_dest.left + place.width;
rect_dest.top = point.y + place.y;
rect_dest.bottom = rect_dest.top + place.height;
-
-#ifdef MODULE_NAME_IS_directdraw
- /* Apply overlay hardware constraints */
- if (sys->use_overlay)
- AlignRect(&rect_dest, sys->i_align_dest_boundary, sys->i_align_dest_size);
-#endif
-
-#endif
-
-#if defined(MODULE_NAME_IS_directdraw)
- /* UpdateOverlay directdraw function doesn't automatically clip to the
- * display size so we need to do it otherwise it will fail */
-
- /* Clip the destination window */
- if (!IntersectRect(&rect_dest_clipped, &rect_dest,
- &sys->rect_display)) {
- SetRectEmpty(&rect_src_clipped);
- goto exit;
- }
-
-#ifndef NDEBUG
- msg_Dbg(vd, "DirectXUpdateRects image_dst_clipped coords:"
- " %li,%li,%li,%li",
- rect_dest_clipped.left, rect_dest_clipped.top,
- rect_dest_clipped.right, rect_dest_clipped.bottom);
#endif
-#else
-
/* AFAIK, there are no clipping constraints in Direct3D, OpenGL and GDI */
rect_dest_clipped = rect_dest;
-#endif
-
/* the 2 following lines are to fix a bug when clicking on the desktop */
if ((rect_dest_clipped.right - rect_dest_clipped.left) == 0 ||
(rect_dest_clipped.bottom - rect_dest_clipped.top) == 0) {
@@ -300,12 +268,6 @@ void UpdateRects(vout_display_t *vd, bool is_forced)
(rect_dest.bottom - rect_dest_clipped.bottom) *
source->i_visible_height / (rect_dest.bottom - rect_dest.top);
-#ifdef MODULE_NAME_IS_directdraw
- /* Apply overlay hardware constraints */
- if (sys->use_overlay)
- AlignRect(&rect_src_clipped, sys->i_align_src_boundary, sys->i_align_src_size);
-#endif
-
#ifndef NDEBUG
msg_Dbg(vd, "DirectXUpdateRects source"
" offset: %i,%i visible: %ix%i",
@@ -329,15 +291,6 @@ void UpdateRects(vout_display_t *vd, bool is_forced)
rect_dest_clipped.right, rect_dest_clipped.bottom);
#endif
-#ifdef MODULE_NAME_IS_directdraw
- /* The destination coordinates need to be relative to the current
- * directdraw primary surface (display) */
- rect_dest_clipped.left -= sys->rect_display.left;
- rect_dest_clipped.right -= sys->rect_display.left;
- rect_dest_clipped.top -= sys->rect_display.top;
- rect_dest_clipped.bottom -= sys->rect_display.top;
-#endif
-
CommonChangeThumbnailClip(vd, true);
exit:
@@ -392,9 +345,6 @@ void CommonManage(vout_display_t *vd)
* For most drivers(direct3d9, gdi, opengl), move is never
* an issue. The surface automatically gets moved together
* with the associated window (hvideownd)
- *
- * For directdraw, it is still important to call UpdateRects
- * on a move of the parent window, even if no resize occurred
*/
SetWindowPos(sys->hwnd, 0, 0, 0,
rect_parent.right - rect_parent.left,
@@ -434,14 +384,6 @@ void CommonDisplay(vout_display_t *vd)
}
#endif
-void AlignRect(RECT *r, int align_boundary, int align_size)
-{
- if (align_boundary)
- r->left = (r->left + align_boundary/2) & ~align_boundary;
- if (align_size)
- r->right = ((r->right - r->left + align_size/2) & ~align_size) + r->left;
-}
-
#if !VLC_WINSTORE_APP
/* */
static void CommonChangeThumbnailClip(vout_display_t *vd, bool show)
diff --git a/modules/video_output/win32/common.h b/modules/video_output/win32/common.h
index 36e47adb19..f575b04f10 100644
--- a/modules/video_output/win32/common.h
+++ b/modules/video_output/win32/common.h
@@ -74,11 +74,6 @@ typedef struct vout_display_sys_win32_t
bool use_desktop; /* show video on desktop window ? */
bool use_overlay; /* Are we using an overlay surface */
- /* Overlay alignment restrictions */
- int i_align_src_boundary;
- int i_align_src_size;
- int i_align_dest_boundary;
- int i_align_dest_size;
bool (*pf_GetRect)(const struct vout_display_sys_win32_t *p_sys, RECT *out);
unsigned int (*pf_GetPictureWidth) (const vout_display_t *);
@@ -96,7 +91,6 @@ int CommonControl(vout_display_t *, int , va_list );
void CommonDisplay(vout_display_t *);
void UpdateRects (vout_display_t *, bool is_forced);
-void AlignRect(RECT *, int align_boundary, int align_size);
/*****************************************************************************
* Constants
diff --git a/modules/video_output/win32/direct3d9.c b/modules/video_output/win32/direct3d9.c
index 89c36038bd..bd534b3628 100644
--- a/modules/video_output/win32/direct3d9.c
+++ b/modules/video_output/win32/direct3d9.c
@@ -73,6 +73,10 @@ static void GLConvClose(vlc_object_t *);
#define HW_BLENDING_TEXT N_("Use hardware blending support")
#define HW_BLENDING_LONGTEXT N_(\
"Try to use hardware acceleration for subtitle/OSD blending.")
+#define HW_YUV_TEXT N_("Use hardware YUV->RGB conversions")
+#define HW_YUV_LONGTEXT N_(\
+ "Try to use hardware acceleration for YUV->RGB conversions. " \
+ "This option doesn't have any effect when using overlays.")
#define PIXEL_SHADER_TEXT N_("Pixel Shader")
#define PIXEL_SHADER_LONGTEXT N_(\
@@ -94,6 +98,7 @@ vlc_module_begin ()
set_subcategory(SUBCAT_VIDEO_VOUT)
add_bool("direct3d9-hw-blending", true, HW_BLENDING_TEXT, HW_BLENDING_LONGTEXT, true)
+ add_bool("directx-hw-yuv", true, HW_YUV_TEXT, HW_YUV_LONGTEXT, true)
add_string("direct3d9-shader", "", PIXEL_SHADER_TEXT, PIXEL_SHADER_LONGTEXT, true)
change_string_cb(FindShadersCallback)
diff --git a/modules/video_output/win32/directdraw.c b/modules/video_output/win32/directdraw.c
deleted file mode 100644
index e436d26ca5..0000000000
--- a/modules/video_output/win32/directdraw.c
+++ /dev/null
@@ -1,1452 +0,0 @@
-/*****************************************************************************
- * directdraw.c: Windows DirectDraw video output
- *****************************************************************************
- * Copyright (C) 2001-2009 VLC authors and VideoLAN
- *
- * Authors: Gildas Bazin <gbazin at videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble:
- *
- * This plugin will use YUV overlay if supported, using overlay will result in
- * the best video quality (hardware interpolation when rescaling the picture)
- * and the fastest display as it requires less processing.
- *
- * If YUV overlay is not supported this plugin will use RGB offscreen video
- * surfaces that will be blitted onto the primary surface (display) to
- * effectively display the pictures. This fallback method also enables us to
- * display video in window mode.
- *
- *****************************************************************************/
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <assert.h>
-
-#include <vlc_common.h>
-#include <vlc_plugin.h>
-#include <vlc_vout_display.h>
-#include <vlc_charset.h> /* FromT */
-
-#include <windows.h>
-#include <ddraw.h>
-#include <commctrl.h> /* ListView_(Get|Set)* */
-
-#include "common.h"
-#include "../video_chroma/copy.h"
-
-/* Unicode function "DirectDrawEnumerateExW" has been desactivated
- since in some cases this function fails and the callbacks are not
- called. If the Unicode mode is restored, one should modify the
- prototype of the callbacks and call the FromT conversion function.
-*/
-#define DIRECTDRAWENUMERATEEX_NAME "DirectDrawEnumerateExA"
-
-/*****************************************************************************
- * Module descriptor
- *****************************************************************************/
-#define HW_YUV_TEXT N_("Use hardware YUV->RGB conversions")
-#define HW_YUV_LONGTEXT N_(\
- "Try to use hardware acceleration for YUV->RGB conversions. " \
- "This option doesn't have any effect when using overlays.")
-
-#define OVERLAY_TEXT N_("Overlay video output")
-#define OVERLAY_LONGTEXT N_(\
- "Overlay is the hardware acceleration capability of your video card " \
- "(ability to render video directly). VLC will try to use it by default.")
-
-#define SYSMEM_TEXT N_("Use video buffers in system memory")
-#define SYSMEM_LONGTEXT N_(\
- "Create video buffers in system memory instead of video memory. This " \
- "isn't recommended as usually using video memory allows benefiting from " \
- "more hardware acceleration (like rescaling or YUV->RGB conversions). " \
- "This option doesn't have any effect when using overlays.")
-
-#define TRIPLEBUF_TEXT N_("Use triple buffering for overlays")
-#define TRIPLEBUF_LONGTEXT N_(\
- "Try to use triple buffering when using YUV overlays. That results in " \
- "much better video quality (no flickering).")
-
-#define DEVICE_TEXT N_("Name of desired display device")
-#define DEVICE_LONGTEXT N_("In a multiple monitor configuration, you can " \
- "specify the Windows device name of the display that you want the video " \
- "window to open on. For example, \"\\\\.\\DISPLAY1\" or " \
- "\"\\\\.\\DISPLAY2\".")
-
-#define DX_HELP N_("Recommended video output for Windows XP. " \
- "Incompatible with Vista's Aero interface" )
-
-static int Open (vout_display_t *, const vout_display_cfg_t *,
- video_format_t *, vlc_video_context *);
-static void Close(vout_display_t *);
-
-static int FindDevicesCallback(const char *, char ***, char ***);
-
-vlc_module_begin()
- set_shortname("DirectDraw")
- set_description(N_("DirectX (DirectDraw) video output"))
- set_help(DX_HELP)
- set_category(CAT_VIDEO)
- set_subcategory(SUBCAT_VIDEO_VOUT)
- add_bool("directx-hw-yuv", true, HW_YUV_TEXT, HW_YUV_LONGTEXT,
- true)
- add_bool("directx-overlay", true, OVERLAY_TEXT, OVERLAY_LONGTEXT, false)
- add_bool("directx-use-sysmem", false, SYSMEM_TEXT, SYSMEM_LONGTEXT,
- true)
- add_bool("directx-3buffering", true, TRIPLEBUF_TEXT,
- TRIPLEBUF_LONGTEXT, true)
- add_string("directx-device", "", DEVICE_TEXT, DEVICE_LONGTEXT, true)
- change_string_cb(FindDevicesCallback)
-
- set_capability("vout display", 180)
- add_shortcut("directx", "directdraw")
- set_callbacks(Open, Close)
-vlc_module_end()
-
-/*****************************************************************************
- * Local prototypes.
- *****************************************************************************/
-
-struct vout_display_sys_t
-{
- vout_display_sys_win32_t sys;
- /* Multi-monitor support */
- HMONITOR hmonitor; /* handle of the current monitor */
- GUID *display_driver;
-
- bool use_wallpaper; /* show as desktop wallpaper ? */
-
- bool restore_overlay;
-
- /* DDraw capabilities */
- bool can_blit_fourcc;
-
- uint32_t i_rgb_colorkey; /* colorkey in RGB used by the overlay */
- uint32_t i_colorkey; /* colorkey used by the overlay */
-
- COLORREF color_bkg;
- COLORREF color_bkgtxt;
-
- LPDIRECTDRAW2 ddobject; /* DirectDraw object */
- LPDIRECTDRAWSURFACE2 display; /* Display device */
- LPDIRECTDRAWCLIPPER clipper; /* clipper used for blitting */
- HINSTANCE hddraw_dll; /* handle of the opened ddraw dll */
-
- LPDIRECTDRAWSURFACE2 surface;
- LPDIRECTDRAWSURFACE2 front_surface;
-
- /* It protects the following variables */
- vlc_mutex_t lock;
- bool ch_wallpaper;
- bool wallpaper_requested;
-};
-
-static picture_pool_t *Pool (vout_display_t *, unsigned);
-static void Display(vout_display_t *, picture_t *);
-static int Control(vout_display_t *, int, va_list);
-static void Manage (vout_display_t *);
-
-/* */
-static int WallpaperCallback(vlc_object_t *, char const *,
- vlc_value_t, vlc_value_t, void *);
-
-static int DirectXOpen(vout_display_t *, video_format_t *fmt);
-static void DirectXClose(vout_display_t *);
-
-static int DirectXLock(vout_display_sys_t *, picture_t *);
-static void DirectXUnlock(vout_display_sys_t *,picture_t *);
-
-static int DirectXUpdateOverlay(vout_display_t *, LPDIRECTDRAWSURFACE2 surface);
-
-static void WallpaperChange(vout_display_t *vd, bool use_wallpaper);
-
-static void Prepare(vout_display_t *vd, picture_t *pic, subpicture_t *subpic, vlc_tick_t date)
-{
- VLC_UNUSED(subpic);
- VLC_UNUSED(date);
- picture_t fake_pic = *pic;
- if (DirectXLock(vd->sys, &fake_pic) == VLC_SUCCESS)
- {
- picture_CopyPixels(&fake_pic, pic);
- DirectXUnlock(vd->sys, &fake_pic);
- }
-}
-
-/** This function allocates and initialize the DirectX vout display.
- */
-static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg,
- video_format_t *fmtp, vlc_video_context *context)
-{
- vout_display_sys_t *sys;
-
- /* Allocate structure */
- vd->sys = sys = calloc(1, sizeof(*sys));
- if (!sys)
- return VLC_ENOMEM;
-
- /* Load direct draw DLL */
- sys->hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
- if (!sys->hddraw_dll) {
- msg_Warn(vd, "DirectXInitDDraw failed loading ddraw.dll");
- free(sys);
- return VLC_EGENERIC;
- }
-
- /* */
- sys->use_wallpaper = var_CreateGetBool(vd, "video-wallpaper");
- /* FIXME */
- sys->sys.use_overlay = false;//var_CreateGetBool(vd, "overlay"); /* FIXME */
- sys->restore_overlay = false;
- var_Create(vd, "directx-device", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
-
- /* Initialisation */
- if (CommonInit(vd, false, cfg))
- goto error;
-
- /* */
- video_format_t fmt = *fmtp;
-
- if (DirectXOpen(vd, &fmt))
- goto error;
-
- /* Setup vout_display now that everything is fine */
- vd->info.is_slow = true;
- vd->info.has_double_click = true;
- vd->info.has_pictures_invalid = true;
-
- /* Interaction TODO support starting with wallpaper mode */
- vlc_mutex_init(&sys->lock);
- sys->ch_wallpaper = sys->use_wallpaper;
- sys->wallpaper_requested = sys->use_wallpaper;
- sys->use_wallpaper = false;
-
- var_Change(vd, "video-wallpaper", VLC_VAR_SETTEXT, _("Wallpaper"));
- var_AddCallback(vd, "video-wallpaper", WallpaperCallback, NULL);
-
- video_format_Clean(fmtp);
- video_format_Copy(fmtp, &fmt);
-
- vd->prepare = Prepare;
- vd->display = Display;
- vd->control = Control;
- return VLC_SUCCESS;
-
-error:
- DirectXClose(vd);
- CommonClean(vd);
- if (sys->hddraw_dll)
- FreeLibrary(sys->hddraw_dll);
- free(sys);
- return VLC_EGENERIC;
-}
-
-/** Terminate a vout display created by Open.
- */
-static void Close(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
-
- var_DelCallback(vd, "video-wallpaper", WallpaperCallback, NULL);
- vlc_mutex_destroy(&sys->lock);
-
- /* Make sure the wallpaper is restored */
- WallpaperChange(vd, false);
-
- DirectXClose(vd);
-
- CommonClean(vd);
-
- if (sys->hddraw_dll)
- FreeLibrary(sys->hddraw_dll);
- free(sys);
-}
-
-static void Display(vout_display_t *vd, picture_t *picture)
-{
- vout_display_sys_t *sys = vd->sys;
-
- assert(sys->display);
-
- /* Our surface can be lost so be sure to check this
- * and restore it if need be */
- if (IDirectDrawSurface2_IsLost(sys->display) == DDERR_SURFACELOST) {
- if (IDirectDrawSurface2_Restore(sys->display) == DD_OK) {
- if (sys->sys.use_overlay)
- DirectXUpdateOverlay(vd, NULL);
- }
- }
- if (sys->restore_overlay)
- DirectXUpdateOverlay(vd, NULL);
-
- /* */
- if (sys->sys.use_overlay) {
- /* Flip the overlay buffers if we are using back buffers */
- if (sys->surface != sys->front_surface) {
- HRESULT hr = IDirectDrawSurface2_Flip(sys->front_surface,
- NULL, DDFLIP_WAIT);
- if (hr != DD_OK)
- msg_Warn(vd, "could not flip overlay (error %li)", hr);
- }
- } else {
- /* Blit video surface to display with the NOTEARING option */
- DDBLTFX ddbltfx;
- ZeroMemory(&ddbltfx, sizeof(ddbltfx));
- ddbltfx.dwSize = sizeof(ddbltfx);
- ddbltfx.dwDDFX = DDBLTFX_NOTEARING;
-
- HRESULT hr = IDirectDrawSurface2_Blt(sys->display,
- &sys->sys.rect_dest_clipped,
- sys->surface,
- &sys->sys.rect_src_clipped,
- DDBLT_ASYNC, &ddbltfx);
- if (hr != DD_OK)
- msg_Warn(vd, "could not blit surface (error %li)", hr);
- }
-
- if (sys->sys.is_first_display) {
- IDirectDraw_WaitForVerticalBlank(sys->ddobject,
- DDWAITVB_BLOCKBEGIN, NULL);
- if (sys->sys.use_overlay) {
- HBRUSH brush = CreateSolidBrush(sys->i_rgb_colorkey);
- /* set the colorkey as the backgound brush for the video window */
- SetClassLongPtr(sys->sys.hvideownd, GCLP_HBRBACKGROUND, (LONG_PTR)brush);
- }
- }
- CommonDisplay(vd);
-
- Manage(vd);
-}
-static int Control(vout_display_t *vd, int query, va_list args)
-{
- vout_display_sys_t *sys = vd->sys;
-
- switch (query) {
- case VOUT_DISPLAY_RESET_PICTURES:
- {
- const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
- video_format_t *fmt = va_arg(args, video_format_t *);
- DirectXClose(vd);
- /* Make sure the wallpaper is restored */
- if (sys->use_wallpaper) {
-
- vlc_mutex_lock(&sys->lock);
- if (!sys->ch_wallpaper) {
- sys->ch_wallpaper = true;
- sys->wallpaper_requested = true;
- }
- vlc_mutex_unlock(&sys->lock);
-
- WallpaperChange(vd, false);
- }
- (void) cfg;
- return DirectXOpen(vd, fmt);
- }
- default:
- return CommonControl(vd, query, args);
- }
-}
-static void Manage(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
-
- CommonManage(vd);
-
- if (sys->sys.changes & DX_POSITION_CHANGE) {
- /* Update overlay */
- if (sys->sys.use_overlay)
- DirectXUpdateOverlay(vd, NULL);
-
- /* Check if we are still on the same monitor */
- HMONITOR hmon = MonitorFromWindow(sys->sys.hwnd, MONITOR_DEFAULTTONEAREST);
- if (sys->hmonitor != hmon) {
- vout_display_SendEventPicturesInvalid(vd);
- }
- /* */
- sys->sys.changes &= ~DX_POSITION_CHANGE;
- }
-
- /* Wallpaper mode change */
- vlc_mutex_lock(&sys->lock);
- const bool ch_wallpaper = sys->ch_wallpaper;
- const bool wallpaper_requested = sys->wallpaper_requested;
- sys->ch_wallpaper = false;
- vlc_mutex_unlock(&sys->lock);
-
- if (ch_wallpaper)
- WallpaperChange(vd, wallpaper_requested);
-
- /* */
- if (sys->restore_overlay)
- DirectXUpdateOverlay(vd, NULL);
-}
-
-/* */
-static int DirectXOpenDDraw(vout_display_t *);
-static void DirectXCloseDDraw(vout_display_t *);
-
-static int DirectXOpenDisplay(vout_display_t *vd);
-static void DirectXCloseDisplay(vout_display_t *vd);
-
-static int DirectXCreatePictureResource(vout_display_t *,
- bool *use_overlay,
- video_format_t *fmt);
-static void DirectXDestroyPictureResource(vout_display_t *);
-
-static int DirectXOpen(vout_display_t *vd, video_format_t *fmt)
-{
- vout_display_sys_t *sys = vd->sys;
-
- assert(!sys->ddobject);
- assert(!sys->display);
- assert(!sys->clipper);
-
- /* Initialise DirectDraw */
- if (DirectXOpenDDraw(vd)) {
- msg_Err(vd, "cannot initialize DirectX DirectDraw");
- return VLC_EGENERIC;
- }
-
- /* Create the directx display */
- if (DirectXOpenDisplay(vd)) {
- msg_Err(vd, "cannot initialize DirectX DirectDraw");
- return VLC_EGENERIC;
- }
- UpdateRects(vd, true);
-
- if (DirectXCreatePictureResource(vd, &sys->sys.use_overlay, fmt))
- return VLC_EGENERIC;
-
- /* */
- if (sys->sys.use_overlay)
- DirectXUpdateOverlay(vd, NULL);
- if (!sys->sys.b_windowless)
- {
- EventThreadUseOverlay(sys->sys.event, sys->sys.use_overlay);
-
- /* Change the window title bar text */
- const char *fallback;
- if (sys->sys.use_overlay)
- fallback = VOUT_TITLE " (hardware YUV overlay DirectX output)";
- else if (vlc_fourcc_IsYUV(fmt->i_chroma))
- fallback = VOUT_TITLE " (hardware YUV DirectX output)";
- else
- fallback = VOUT_TITLE " (software RGB DirectX output)";
- EventThreadUpdateTitle(sys->sys.event, fallback);
- }
-
- return VLC_SUCCESS;
-}
-static void DirectXClose(vout_display_t *vd)
-{
- DirectXDestroyPictureResource(vd);
- DirectXCloseDisplay(vd);
- DirectXCloseDDraw(vd);
-}
-
-/* */
-static BOOL WINAPI DirectXOpenDDrawCallback(GUID *guid, LPSTR desc,
- LPSTR drivername, VOID *context,
- HMONITOR hmon)
-{
- vout_display_t *vd = context;
- vout_display_sys_t *sys = vd->sys;
-
- /* This callback function is called by DirectDraw once for each
- * available DirectDraw device.
- *
- * Returning TRUE keeps enumerating.
- */
- if (!hmon)
- return TRUE;
-
- char *psz_drivername = drivername;
- char *psz_desc = desc;
-
- msg_Dbg(vd, "DirectXEnumCallback: %s, %s", psz_desc, psz_drivername);
-
- char *device = var_GetString(vd, "directx-device");
-
- /* Check for forced device */
- if (device && *device && !strcmp(psz_drivername, device)) {
- MONITORINFO monitor_info;
- monitor_info.cbSize = sizeof(MONITORINFO);
-
- if (GetMonitorInfoA(hmon, &monitor_info)) {
- RECT rect;
-
- /* Move window to the right screen */
- GetWindowRect(sys->sys.hwnd, &rect);
- if (!IntersectRect(&rect, &rect, &monitor_info.rcWork)) {
- rect.left = monitor_info.rcWork.left;
- rect.top = monitor_info.rcWork.top;
- msg_Dbg(vd, "DirectXEnumCallback: setting window "
- "position to %ld,%ld", rect.left, rect.top);
- SetWindowPos(sys->sys.hwnd, NULL,
- rect.left, rect.top, 0, 0,
- SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
- }
- }
- sys->hmonitor = hmon;
- }
- free(device);
-
- if (hmon == sys->hmonitor) {
- msg_Dbg(vd, "selecting %s, %s", psz_desc, psz_drivername);
-
- free(sys->display_driver);
- sys->display_driver = malloc(sizeof(*guid));
- if (sys->display_driver)
- *sys->display_driver = *guid;
- }
-
- return TRUE;
-}
-/**
- * Probe the capabilities of the hardware
- *
- * It is nice to know which features are supported by the hardware so we can
- * find ways to optimize our rendering.
- */
-static void DirectXGetDDrawCaps(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
-
- /* This is just an indication of whether or not we'll support overlay,
- * but with this test we don't know if we support YUV overlay */
- DDCAPS ddcaps;
- ZeroMemory(&ddcaps, sizeof(ddcaps));
- ddcaps.dwSize = sizeof(ddcaps);
- HRESULT hr = IDirectDraw2_GetCaps(sys->ddobject, &ddcaps, NULL);
- if (hr != DD_OK) {
- msg_Warn(vd, "cannot get caps");
- return;
- }
-
- /* Determine if the hardware supports overlay surfaces */
- const bool has_overlay = ddcaps.dwCaps & DDCAPS_OVERLAY;
- /* Determine if the hardware supports overlay surfaces */
- const bool has_overlay_fourcc = ddcaps.dwCaps & DDCAPS_OVERLAYFOURCC;
- /* Determine if the hardware supports overlay deinterlacing */
- const bool can_deinterlace = ddcaps.dwCaps & DDCAPS2_CANFLIPODDEVEN;
- /* Determine if the hardware supports colorkeying */
- const bool has_color_key = ddcaps.dwCaps & DDCAPS_COLORKEY;
- /* Determine if the hardware supports scaling of the overlay surface */
- const bool can_stretch = ddcaps.dwCaps & DDCAPS_OVERLAYSTRETCH;
- /* Determine if the hardware supports color conversion during a blit */
- sys->can_blit_fourcc = ddcaps.dwCaps & DDCAPS_BLTFOURCC;
- /* Determine overlay source boundary alignment */
- const bool align_boundary_src = ddcaps.dwCaps & DDCAPS_ALIGNBOUNDARYSRC;
- /* Determine overlay destination boundary alignment */
- const bool align_boundary_dest = ddcaps.dwCaps & DDCAPS_ALIGNBOUNDARYDEST;
- /* Determine overlay destination size alignment */
- const bool align_size_src = ddcaps.dwCaps & DDCAPS_ALIGNSIZESRC;
- /* Determine overlay destination size alignment */
- const bool align_size_dest = ddcaps.dwCaps & DDCAPS_ALIGNSIZEDEST;
-
- msg_Dbg(vd, "DirectDraw Capabilities: overlay=%i yuvoverlay=%i "
- "can_deinterlace_overlay=%i colorkey=%i stretch=%i "
- "bltfourcc=%i",
- has_overlay, has_overlay_fourcc, can_deinterlace,
- has_color_key, can_stretch, sys->can_blit_fourcc);
-
- if (align_boundary_src || align_boundary_dest || align_size_src || align_size_dest) {
- if (align_boundary_src)
- vd->sys->sys.i_align_src_boundary = ddcaps.dwAlignBoundarySrc;
- if (align_boundary_dest)
- vd->sys->sys.i_align_dest_boundary = ddcaps.dwAlignBoundaryDest;
- if (align_size_src)
- vd->sys->sys.i_align_src_size = ddcaps.dwAlignSizeSrc;
- if (align_size_dest)
- vd->sys->sys.i_align_dest_size = ddcaps.dwAlignSizeDest;
-
- msg_Dbg(vd,
- "align_boundary_src=%i,%i align_boundary_dest=%i,%i "
- "align_size_src=%i,%i align_size_dest=%i,%i",
- align_boundary_src, vd->sys->sys.i_align_src_boundary,
- align_boundary_dest, vd->sys->sys.i_align_dest_boundary,
- align_size_src, vd->sys->sys.i_align_src_size,
- align_size_dest, vd->sys->sys.i_align_dest_size);
- }
-}
-
-
-
-/* */
-static int DirectXOpenDDraw(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
- HRESULT hr;
-
- /* */
- HRESULT (WINAPI *OurDirectDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *);
- OurDirectDrawCreate =
- (void *)GetProcAddress(sys->hddraw_dll, "DirectDrawCreate");
- if (!OurDirectDrawCreate) {
- msg_Err(vd, "DirectXInitDDraw failed GetProcAddress");
- return VLC_EGENERIC;
- }
-
- /* */
- HRESULT (WINAPI *OurDirectDrawEnumerateEx)(LPDDENUMCALLBACKEXA, LPVOID, DWORD);
- OurDirectDrawEnumerateEx =
- (void *)GetProcAddress(sys->hddraw_dll, DIRECTDRAWENUMERATEEX_NAME);
-
- if (OurDirectDrawEnumerateEx) {
- char *device = var_GetString(vd, "directx-device");
- if (device) {
- msg_Dbg(vd, "directx-device: %s", device);
- free(device);
- }
-
- sys->hmonitor = MonitorFromWindow(sys->sys.hwnd, MONITOR_DEFAULTTONEAREST);
-
- /* Enumerate displays */
- OurDirectDrawEnumerateEx(DirectXOpenDDrawCallback,
- vd, DDENUM_ATTACHEDSECONDARYDEVICES);
- }
-
- /* Initialize DirectDraw now */
- LPDIRECTDRAW ddobject;
- hr = OurDirectDrawCreate(sys->display_driver, &ddobject, NULL);
- if (hr != DD_OK) {
- msg_Err(vd, "DirectXInitDDraw cannot initialize DDraw");
- return VLC_EGENERIC;
- }
-
- /* Get the IDirectDraw2 interface */
- void *ptr;
- hr = IDirectDraw_QueryInterface(ddobject, &IID_IDirectDraw2,
- &ptr);
- /* Release the unused interface */
- IDirectDraw_Release(ddobject);
-
- if (hr != DD_OK) {
- msg_Err(vd, "cannot get IDirectDraw2 interface");
- sys->ddobject = NULL;
- return VLC_EGENERIC;
- }
- sys->ddobject = ptr;
-
- /* Set DirectDraw Cooperative level, ie what control we want over Windows
- * display */
- hr = IDirectDraw2_SetCooperativeLevel(sys->ddobject, NULL, DDSCL_NORMAL);
- if (hr != DD_OK) {
- msg_Err(vd, "cannot set direct draw cooperative level");
- return VLC_EGENERIC;
- }
-
- /* Get the size of the current display device */
- if (sys->hmonitor) {
- MONITORINFO monitor_info;
- monitor_info.cbSize = sizeof(MONITORINFO);
- GetMonitorInfoA(vd->sys->hmonitor, &monitor_info);
- sys->sys.rect_display = monitor_info.rcMonitor;
- } else {
- sys->sys.rect_display.left = 0;
- sys->sys.rect_display.top = 0;
- sys->sys.rect_display.right = GetSystemMetrics(SM_CXSCREEN);
- sys->sys.rect_display.bottom = GetSystemMetrics(SM_CYSCREEN);
- }
-
- msg_Dbg(vd, "screen dimensions (%lix%li,%lix%li)",
- sys->sys.rect_display.left,
- sys->sys.rect_display.top,
- sys->sys.rect_display.right,
- sys->sys.rect_display.bottom);
-
- /* Probe the capabilities of the hardware */
- DirectXGetDDrawCaps(vd);
-
- return VLC_SUCCESS;
-}
-
-static void DirectXCloseDDraw(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
- if (sys->ddobject)
- IDirectDraw2_Release(sys->ddobject);
-
- sys->ddobject = NULL;
-
- free(sys->display_driver);
- sys->display_driver = NULL;
-
- sys->hmonitor = NULL;
-}
-
-/**
- * Create a clipper that will be used when blitting the RGB surface to the main display.
- *
- * This clipper prevents us to modify by mistake anything on the screen
- * which doesn't belong to our window. For example when a part of our video
- * window is hidden by another window.
- */
-static void DirectXCreateClipper(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
- HRESULT hr;
-
- /* Create the clipper */
- hr = IDirectDraw2_CreateClipper(sys->ddobject, 0, &sys->clipper, NULL);
- if (hr != DD_OK) {
- msg_Warn(vd, "cannot create clipper (error %li)", hr);
- goto error;
- }
-
- /* Associate the clipper to the window */
- hr = IDirectDrawClipper_SetHWnd(sys->clipper, 0, sys->sys.hvideownd);
- if (hr != DD_OK) {
- msg_Warn(vd, "cannot attach clipper to window (error %li)", hr);
- goto error;
- }
-
- /* associate the clipper with the surface */
- hr = IDirectDrawSurface_SetClipper(sys->display, sys->clipper);
- if (hr != DD_OK)
- {
- msg_Warn(vd, "cannot attach clipper to surface (error %li)", hr);
- goto error;
- }
-
- return;
-
-error:
- if (sys->clipper)
- IDirectDrawClipper_Release(sys->clipper);
- sys->clipper = NULL;
-}
-
-/**
- * It finds out the 32bits RGB pixel value of the colorkey.
- */
-static uint32_t DirectXFindColorkey(vout_display_t *vd, uint32_t *color)
-{
- vout_display_sys_t *sys = vd->sys;
- HRESULT hr;
-
- /* */
- DDSURFACEDESC ddsd;
- ddsd.dwSize = sizeof(ddsd);
- hr = IDirectDrawSurface2_Lock(sys->display, NULL, &ddsd, DDLOCK_WAIT, NULL);
- if (hr != DD_OK)
- return 0;
-
- uint32_t backup = *(uint32_t *)ddsd.lpSurface;
-
- switch (ddsd.ddpfPixelFormat.dwRGBBitCount) {
- case 4:
- *(uint8_t *)ddsd.lpSurface = *color | (*color << 4);
- break;
- case 8:
- *(uint8_t *)ddsd.lpSurface = *color;
- break;
- case 15:
- case 16:
- *(uint16_t *)ddsd.lpSurface = *color;
- break;
- case 24:
- /* Seems to be problematic so we'll just put black as the colorkey */
- *color = 0;
- default:
- *(uint32_t *)ddsd.lpSurface = *color;
- break;
- }
- IDirectDrawSurface2_Unlock(sys->display, NULL);
-
- /* */
- HDC hdc;
- COLORREF rgb;
- if (IDirectDrawSurface2_GetDC(sys->display, &hdc) == DD_OK) {
- rgb = GetPixel(hdc, 0, 0);
- IDirectDrawSurface2_ReleaseDC(sys->display, hdc);
- } else {
- rgb = 0;
- }
-
- /* Restore the pixel value */
- ddsd.dwSize = sizeof(ddsd);
- if (IDirectDrawSurface2_Lock(sys->display, NULL, &ddsd, DDLOCK_WAIT, NULL) == DD_OK) {
- *(uint32_t *)ddsd.lpSurface = backup;
- IDirectDrawSurface2_Unlock(sys->display, NULL);
- }
-
- return rgb;
-}
-
-/**
- * Create and initialize display according to preferences specified in the vout
- * thread fields.
- */
-static int DirectXOpenDisplay(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
- HRESULT hr;
-
- /* Now get the primary surface. This surface is what you actually see
- * on your screen */
- DDSURFACEDESC ddsd;
- ZeroMemory(&ddsd, sizeof(ddsd));
- ddsd.dwSize = sizeof(ddsd);
- ddsd.dwFlags = DDSD_CAPS;
- ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
-
- LPDIRECTDRAWSURFACE display;
- hr = IDirectDraw2_CreateSurface(sys->ddobject, &ddsd, &display, NULL);
- if (hr != DD_OK) {
- msg_Err(vd, "cannot get primary surface (error %li)", hr);
- return VLC_EGENERIC;
- }
-
- void *ptr;
- hr = IDirectDrawSurface_QueryInterface(display, &IID_IDirectDrawSurface2,
- &ptr);
- /* Release the old interface */
- IDirectDrawSurface_Release(display);
-
- if (hr != DD_OK) {
- msg_Err(vd, "cannot query IDirectDrawSurface2 interface (error %li)", hr);
- sys->display = NULL;
- return VLC_EGENERIC;
- }
- sys->display = ptr;
-
- /* The clipper will be used only in non-overlay mode */
- DirectXCreateClipper(vd);
-
- /* Make sure the colorkey will be painted */
- sys->i_colorkey = 1;
- sys->i_rgb_colorkey = DirectXFindColorkey(vd, &sys->i_colorkey);
-
- return VLC_SUCCESS;
-}
-static void DirectXCloseDisplay(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
-
- if (sys->clipper != NULL)
- IDirectDrawClipper_Release(sys->clipper);
-
- if (sys->display != NULL)
- IDirectDrawSurface2_Release(sys->display);
-
- sys->clipper = NULL;
- sys->display = NULL;
-}
-
-/**
- * Create an YUV overlay or RGB surface for the video.
- *
- * The best method of display is with an YUV overlay because the YUV->RGB
- * conversion is done in hardware.
- * You can also create a plain RGB surface.
- * (Maybe we could also try an RGB overlay surface, which could have hardware
- * scaling and which would also be faster in window mode because you don't
- * need to do any blitting to the main display...)
- */
-static int DirectXCreateSurface(vout_display_t *vd,
- LPDIRECTDRAWSURFACE2 *surface,
- const video_format_t *fmt,
- DWORD fourcc,
- bool use_overlay,
- bool use_sysmem,
- int backbuffer_count)
-{
- vout_display_sys_t *sys = vd->sys;
-
- DDSURFACEDESC ddsd;
-
- ZeroMemory(&ddsd, sizeof(ddsd));
- ddsd.dwSize = sizeof(ddsd);
- ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
- ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
- ddsd.dwWidth = fmt->i_width;
- ddsd.dwHeight = fmt->i_height;
- if (fourcc) {
- ddsd.dwFlags |= DDSD_PIXELFORMAT;
- ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
- ddsd.ddpfPixelFormat.dwFourCC = fourcc;
- }
- ddsd.dwFlags |= DDSD_CAPS;
- if (use_overlay) {
- ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
- if (backbuffer_count > 0) {
- ddsd.ddsCaps.dwCaps |= DDSCAPS_COMPLEX | DDSCAPS_FLIP;
- ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT;
- ddsd.dwBackBufferCount = backbuffer_count;
- }
- } else {
- ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
- if (use_sysmem)
- ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
- else
- ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
- }
-
- /* Create the video surface */
- LPDIRECTDRAWSURFACE surface_v1;
- HRESULT hr = IDirectDraw2_CreateSurface(sys->ddobject, &ddsd, &surface_v1, NULL);
- if (hr == DDERR_INVALIDCAPS)
- {
- msg_Dbg(vd, "failed to create a DirectDrawSurface with invalid caps %lx", ddsd.ddsCaps.dwCaps);
- return VLC_EGENERIC;
- }
- if (hr != DD_OK)
- {
- msg_Dbg(vd, "failed to create a DirectDrawSurface (error %li)", hr);
- return VLC_EGENERIC;
- }
-
- /* Now that the surface is created, try to get a newer DirectX interface */
- hr = IDirectDrawSurface_QueryInterface(surface_v1,
- &IID_IDirectDrawSurface2,
- (LPVOID *)surface);
- IDirectDrawSurface_Release(surface_v1);
- if (hr != DD_OK) {
- msg_Err(vd, "cannot query IDirectDrawSurface2 interface (error %li)", hr);
- return VLC_EGENERIC;
- }
-
- if (use_overlay) {
- /* Check the overlay is useable as some graphics cards allow creating
- * several overlays but only one can be used at one time. */
- if (DirectXUpdateOverlay(vd, *surface)) {
- IDirectDrawSurface2_Release(*surface);
- msg_Err(vd, "overlay unuseable (might already be in use)");
- return VLC_EGENERIC;
- }
- }
-
- return VLC_SUCCESS;
-}
-
-static void DirectXDestroySurface(LPDIRECTDRAWSURFACE2 surface)
-{
- IDirectDrawSurface2_Release(surface);
-}
-/**
- * This function locks a surface and get the surface descriptor.
- */
-static int DirectXLockSurface(LPDIRECTDRAWSURFACE2 front_surface,
- LPDIRECTDRAWSURFACE2 surface,
- DDSURFACEDESC *ddsd)
-{
- HRESULT hr;
-
- DDSURFACEDESC ddsd_dummy;
- if (!ddsd)
- ddsd = &ddsd_dummy;
-
- ZeroMemory(ddsd, sizeof(*ddsd));
- ddsd->dwSize = sizeof(*ddsd);
- hr = IDirectDrawSurface2_Lock(surface, NULL, ddsd, DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL);
- if (hr != DD_OK) {
- if (hr == DDERR_INVALIDPARAMS) {
- /* DirectX 3 doesn't support the DDLOCK_NOSYSLOCK flag, resulting
- * in an invalid params error */
- hr = IDirectDrawSurface2_Lock(surface, NULL, ddsd, DDLOCK_WAIT, NULL);
- }
- if (hr == DDERR_SURFACELOST) {
- /* Your surface can be lost so be sure
- * to check this and restore it if needed */
-
- /* When using overlays with back-buffers, we need to restore
- * the front buffer so the back-buffers get restored as well. */
- if (front_surface != surface)
- IDirectDrawSurface2_Restore(front_surface);
- else
- IDirectDrawSurface2_Restore(surface);
-
- hr = IDirectDrawSurface2_Lock(surface, NULL, ddsd, DDLOCK_WAIT, NULL);
- }
- if (hr != DD_OK)
- return VLC_EGENERIC;
- }
- return VLC_SUCCESS;
-}
-static void DirectXUnlockSurface(LPDIRECTDRAWSURFACE2 front_surface,
- LPDIRECTDRAWSURFACE2 surface)
-{
- VLC_UNUSED(front_surface);
- IDirectDrawSurface2_Unlock(surface, NULL);
-}
-static int DirectXCheckLockingSurface(LPDIRECTDRAWSURFACE2 front_surface,
- LPDIRECTDRAWSURFACE2 surface)
-{
- if (DirectXLockSurface(front_surface, surface, NULL))
- return VLC_EGENERIC;
-
- DirectXUnlockSurface(front_surface, surface);
- return VLC_SUCCESS;
-}
-
-
-
-typedef struct {
- vlc_fourcc_t codec;
- DWORD fourcc;
-} dx_format_t;
-
-static DWORD DirectXGetFourcc(vlc_fourcc_t codec)
-{
- static const dx_format_t dx_formats[] = {
- { VLC_CODEC_YUYV, MAKEFOURCC('Y','U','Y','2') },
- { VLC_CODEC_UYVY, MAKEFOURCC('U','Y','V','Y') },
- { VLC_CODEC_YVYU, MAKEFOURCC('Y','V','Y','U') },
- { VLC_CODEC_YV12, MAKEFOURCC('Y','V','1','2') },
- { VLC_CODEC_I420, MAKEFOURCC('Y','V','1','2') },
- { VLC_CODEC_J420, MAKEFOURCC('Y','V','1','2') },
- { 0, 0 }
- };
-
- for (unsigned i = 0; dx_formats[i].codec != 0; i++) {
- if (dx_formats[i].codec == codec)
- return dx_formats[i].fourcc;
- }
- return 0;
-}
-
-static int DirectXCreatePictureResourceYuvOverlay(vout_display_t *vd,
- const video_format_t *fmt,
- DWORD fourcc)
-{
- vout_display_sys_t *sys = vd->sys;
-
- bool allow_3buf = var_InheritBool(vd, "directx-3buffering");
-
- /* The overlay surface that we create won't be used to decode directly
- * into it because accessing video memory directly is way to slow (remember
- * that pictures are decoded macroblock per macroblock). Instead the video
- * will be decoded in picture buffers in system memory which will then be
- * memcpy() to the overlay surface. */
- LPDIRECTDRAWSURFACE2 front_surface;
- int ret = VLC_EGENERIC;
- if (allow_3buf) {
- /* Triple buffering rocks! it doesn't have any processing overhead
- * (you don't have to wait for the vsync) and provides for a very nice
- * video quality (no tearing). */
- ret = DirectXCreateSurface(vd, &front_surface, fmt, fourcc, true, false, 2);
- }
- if (ret)
- ret = DirectXCreateSurface(vd, &front_surface, fmt, fourcc, true, false, 0);
- if (ret)
- return VLC_EGENERIC;
- msg_Dbg(vd, "YUV overlay surface (%4.4s) created successfully", (const char *)&fourcc);
-
- /* Get the back buffer */
- LPDIRECTDRAWSURFACE2 surface;
- DDSCAPS dds_caps;
- ZeroMemory(&dds_caps, sizeof(dds_caps));
- dds_caps.dwCaps = DDSCAPS_BACKBUFFER;
- if (IDirectDrawSurface2_GetAttachedSurface(front_surface, &dds_caps, &surface) != DD_OK) {
- msg_Warn(vd, "Failed to get surface back buffer");
- /* front buffer is the same as back buffer */
- surface = front_surface;
- }
-
- if (DirectXCheckLockingSurface(front_surface, surface)) {
- DirectXDestroySurface(front_surface);
- return VLC_EGENERIC;
- }
-
- /* */
- sys->front_surface = front_surface;
- sys->surface = surface;
- return VLC_SUCCESS;
-}
-static int DirectXCreatePictureResourceYuv(vout_display_t *vd,
- const video_format_t *fmt,
- DWORD fourcc)
-{
- vout_display_sys_t *sys = vd->sys;
-
- bool allow_sysmem = var_InheritBool(vd, "directx-use-sysmem");
-
- /* As we can't have an overlay, we'll try to create a plain offscreen
- * surface. This surface will reside in video memory because there's a
- * better chance then that we'll be able to use some kind of hardware
- * acceleration like rescaling, blitting or YUV->RGB conversions.
- * We then only need to blit this surface onto the main display when we
- * want to display it */
-
- /* Check if the chroma is supported first. This is required
- * because a few buggy drivers don't mind creating the surface
- * even if they don't know about the chroma. */
- DWORD count;
- if (IDirectDraw2_GetFourCCCodes(sys->ddobject, &count, NULL) != DD_OK)
- return VLC_EGENERIC;
-
- DWORD *list = calloc(count, sizeof(*list));
- if (!list)
- return VLC_ENOMEM;
- if (IDirectDraw2_GetFourCCCodes(sys->ddobject, &count, list) != DD_OK) {
- free(list);
- return VLC_EGENERIC;
- }
- unsigned index;
- for (index = 0; index < count; index++) {
- if (list[index] == fourcc)
- break;
- }
- free(list);
- if (index >= count)
- return VLC_EGENERIC;
-
- /* */
- LPDIRECTDRAWSURFACE2 surface;
- if (DirectXCreateSurface(vd, &surface, fmt, fourcc, false, allow_sysmem, 0))
- return VLC_EGENERIC;
- msg_Dbg(vd, "YUV plain surface (%4.4s) created successfully", (const char *)&fourcc);
-
- if (DirectXCheckLockingSurface(surface, surface)) {
- DirectXDestroySurface(surface);
- return VLC_EGENERIC;
- }
-
- /* */
- sys->front_surface = surface;
- sys->surface = surface;
- return VLC_SUCCESS;
-}
-static int DirectXCreatePictureResourceRgb(vout_display_t *vd,
- video_format_t *fmt)
-{
- vout_display_sys_t *sys = vd->sys;
- bool allow_sysmem = var_InheritBool(vd, "directx-use-sysmem");
-
- /* Our last choice is to use a plain RGB surface */
- DDPIXELFORMAT ddpfPixelFormat;
- ZeroMemory(&ddpfPixelFormat, sizeof(ddpfPixelFormat));
- ddpfPixelFormat.dwSize = sizeof(ddpfPixelFormat);
-
- IDirectDrawSurface2_GetPixelFormat(sys->display, &ddpfPixelFormat);
- if ((ddpfPixelFormat.dwFlags & DDPF_RGB) == 0)
- return VLC_EGENERIC;
-
- switch (ddpfPixelFormat.dwRGBBitCount) {
- case 8:
- fmt->i_chroma = VLC_CODEC_RGB8;
- break;
- case 15:
- fmt->i_chroma = VLC_CODEC_RGB15;
- break;
- case 16:
- fmt->i_chroma = VLC_CODEC_RGB16;
- break;
- case 24:
- fmt->i_chroma = VLC_CODEC_RGB24;
- break;
- case 32:
- fmt->i_chroma = VLC_CODEC_RGB32;
- break;
- default:
- msg_Err(vd, "unknown screen depth");
- return VLC_EGENERIC;
- }
- fmt->i_rmask = ddpfPixelFormat.dwRBitMask;
- fmt->i_gmask = ddpfPixelFormat.dwGBitMask;
- fmt->i_bmask = ddpfPixelFormat.dwBBitMask;
-
- /* */
- LPDIRECTDRAWSURFACE2 surface;
- int ret = DirectXCreateSurface(vd, &surface, fmt, 0, false, allow_sysmem, 0);
- if (ret && !allow_sysmem)
- ret = DirectXCreateSurface(vd, &surface, fmt, 0, false, true, 0);
- if (ret)
- return VLC_EGENERIC;
- msg_Dbg(vd, "RGB plain surface (%4.4s) created successfully", (const char *)&fmt->i_chroma);
-
- if (DirectXCheckLockingSurface(surface, surface)) {
- DirectXDestroySurface(surface);
- return VLC_EGENERIC;
- }
-
- /* */
- sys->front_surface = surface;
- sys->surface = surface;
- return VLC_SUCCESS;
-}
-
-static int DirectXCreatePictureResource(vout_display_t *vd,
- bool *use_overlay,
- video_format_t *fmt)
-{
- vout_display_sys_t *sys = vd->sys;
-
- /* */
- bool allow_hw_yuv = sys->can_blit_fourcc &&
- vlc_fourcc_IsYUV(fmt->i_chroma) &&
- var_InheritBool(vd, "directx-hw-yuv");
- bool allow_overlay = var_InheritBool(vd, "directx-overlay");
-
- /* Try to use an yuv surface */
- if (allow_hw_yuv) {
- const vlc_fourcc_t *list = vlc_fourcc_GetYUVFallback(fmt->i_chroma);
- /* Try with overlay first */
- for (unsigned pass = allow_overlay ? 0 : 1; pass < 2; pass++) {
- for (unsigned i = 0; list[i] != 0; i++) {
- const DWORD fourcc = DirectXGetFourcc(list[i]);
- if (!fourcc)
- continue;
-
- if (pass == 0) {
- if (DirectXCreatePictureResourceYuvOverlay(vd, fmt, fourcc))
- {
-#ifndef NDEBUG
- msg_Dbg(vd, "Failed to create YUV overlay surface %4.4s", (const char*)&fourcc);
-#endif
- continue;
- }
- } else {
- if (DirectXCreatePictureResourceYuv(vd, fmt, fourcc))
- {
-#ifndef NDEBUG
- msg_Dbg(vd, "Failed to create YUV surface %4.4s", (const char*)&fourcc);
-#endif
- continue;
- }
- }
- /* */
- *use_overlay = pass == 0;
- fmt->i_chroma = list[i];
- return VLC_SUCCESS;
- }
- }
- }
-
- /* Try plain RGB */
- return DirectXCreatePictureResourceRgb(vd, fmt);
-}
-static void DirectXDestroyPictureResource(vout_display_t *vd)
-{
- vout_display_sys_t *sys = vd->sys;
-
- if (sys->front_surface != sys->surface)
- DirectXDestroySurface(sys->surface);
- DirectXDestroySurface(sys->front_surface);
-}
-
-static int DirectXLock(vout_display_sys_t *sys, picture_t *picture)
-{
- DDSURFACEDESC ddsd;
- if (DirectXLockSurface(sys->front_surface,
- sys->surface, &ddsd))
- return VLC_EGENERIC;
-
- picture_UpdatePlanes(picture, ddsd.lpSurface, ddsd.lPitch);
- return VLC_SUCCESS;
-}
-static void DirectXUnlock(vout_display_sys_t *sys, picture_t *picture)
-{
- DirectXUnlockSurface(sys->front_surface, sys->surface);
-}
-
-/**
- * Move or resize overlay surface on video display.
- *
- * This function is used to move or resize an overlay surface on the screen.
- * Ususally the overlay is moved by the user and thus, by a move or resize
- * event.
- */
-static int DirectXUpdateOverlay(vout_display_t *vd, LPDIRECTDRAWSURFACE2 surface)
-{
- vout_display_sys_t *sys = vd->sys;
-
- RECT src = sys->sys.rect_src_clipped;
- RECT dst = sys->sys.rect_dest_clipped;
-
- if (sys->use_wallpaper) {
- src.left = vd->source.i_x_offset;
- src.top = vd->source.i_y_offset;
- src.right = vd->source.i_x_offset + vd->source.i_visible_width;
- src.bottom = vd->source.i_y_offset + vd->source.i_visible_height;
- AlignRect(&src, sys->sys.i_align_src_boundary, sys->sys.i_align_src_size);
-
- vout_display_cfg_t cfg = sys->sys.vdcfg;
- cfg.display.width = sys->sys.rect_display.right;
- cfg.display.height = sys->sys.rect_display.bottom;
-
- vout_display_place_t place;
- vout_display_PlacePicture(&place, &vd->source, &cfg);
-
- if (place.x < 0) {
- place.width += -place.x;
- place.x = 0;
- }
- if (place.y < 0) {
- place.height += -place.y;
- place.y = 0;
- }
- if (place.width > cfg.display.width)
- place.width = cfg.display.width;
- if (place.height > cfg.display.height)
- place.height = cfg.display.height;
-
- dst.left = sys->sys.rect_display.left + place.x;
- dst.top = sys->sys.rect_display.top + place.y;
- dst.right = dst.left + place.width;
- dst.bottom = dst.top + place.height;
- AlignRect(&dst, sys->sys.i_align_dest_boundary, sys->sys.i_align_dest_size);
- }
-
- if (!surface) {
- surface = sys->front_surface;
- }
-
- /* The new window dimensions should already have been computed by the
- * caller of this function */
-
- /* Position and show the overlay */
- DDOVERLAYFX ddofx;
- ZeroMemory(&ddofx, sizeof(ddofx));
- ddofx.dwSize = sizeof(ddofx);
- ddofx.dckDestColorkey.dwColorSpaceLowValue = sys->i_colorkey;
- ddofx.dckDestColorkey.dwColorSpaceHighValue = sys->i_colorkey;
-
- HRESULT hr = IDirectDrawSurface2_UpdateOverlay(surface,
- &src, sys->display, &dst,
- DDOVER_SHOW | DDOVER_KEYDESTOVERRIDE | DDOVER_DDFX,
- &ddofx);
- sys->restore_overlay = hr != DD_OK;
-
- if (hr != DD_OK) {
- msg_Warn(vd, "DirectDrawUpdateOverlay cannot move/resize overlay. (hr=0x%lX)", hr);
- return VLC_EGENERIC;
- }
- return VLC_SUCCESS;
-}
-
-/* */
-static void WallpaperChange(vout_display_t *vd, bool use_wallpaper)
-{
- vout_display_sys_t *sys = vd->sys;
-
- if (!sys->use_wallpaper == !use_wallpaper)
- return;
-
- HWND hwnd = FindWindow(_T("Progman"), NULL);
- if (hwnd)
- hwnd = FindWindowEx(hwnd, NULL, _T("SHELLDLL_DefView"), NULL);
- if (hwnd)
- hwnd = FindWindowEx(hwnd, NULL, _T("SysListView32"), NULL);
- if (!hwnd) {
- msg_Warn(vd, "couldn't find \"SysListView32\" window, "
- "wallpaper mode not supported");
- return;
- }
-
- msg_Dbg(vd, "wallpaper mode %s", use_wallpaper ? "enabled" : "disabled");
- sys->use_wallpaper = use_wallpaper;
-
- if (sys->use_wallpaper) {
- sys->color_bkg = ListView_GetBkColor(hwnd);
- sys->color_bkgtxt = ListView_GetTextBkColor(hwnd);
-
- ListView_SetBkColor(hwnd, sys->i_rgb_colorkey);
- ListView_SetTextBkColor(hwnd, sys->i_rgb_colorkey);
- } else {
- ListView_SetBkColor(hwnd, sys->color_bkg);
- ListView_SetTextBkColor(hwnd, sys->color_bkgtxt);
- }
-
- /* Update desktop */
- InvalidateRect(hwnd, NULL, TRUE);
- UpdateWindow(hwnd);
-
- if (sys->sys.use_overlay)
- DirectXUpdateOverlay(vd, NULL);
-}
-
-/* */
-static int WallpaperCallback(vlc_object_t *object, char const *cmd,
- vlc_value_t oldval, vlc_value_t newval, void *data)
-{
- vout_display_t *vd = (vout_display_t *)object;
- vout_display_sys_t *sys = vd->sys;
- VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(data);
-
- vlc_mutex_lock(&sys->lock);
- const bool ch_wallpaper = !sys->wallpaper_requested != !newval.b_bool;
- sys->ch_wallpaper |= ch_wallpaper;
- sys->wallpaper_requested = newval.b_bool;
- vlc_mutex_unlock(&sys->lock);
- return VLC_SUCCESS;
-}
-
-typedef struct
-{
- char **values;
- char **descs;
- size_t count;
-} enum_context_t;
-
-/*****************************************************************************
- * config variable callback
- *****************************************************************************/
-static BOOL WINAPI DirectXEnumCallback2(GUID *guid, LPSTR desc,
- LPSTR drivername, VOID *data,
- HMONITOR hmon)
-{
- enum_context_t *ctx = data;
-
- VLC_UNUSED(guid); VLC_UNUSED(desc); VLC_UNUSED(hmon);
-
- char *psz_drivername = drivername;
- ctx->values = xrealloc(ctx->values, (ctx->count + 1) * sizeof(char *));
- ctx->descs = xrealloc(ctx->descs, (ctx->count + 1) * sizeof(char *));
-
- ctx->values[ctx->count] = strdup(psz_drivername);
- ctx->descs[ctx->count] = strdup(psz_drivername);
- ctx->count++;
-
- return TRUE; /* Keep enumerating */
-}
-
-static int FindDevicesCallback(const char *name, char ***values, char ***descs)
-{
- enum_context_t ctx;
-
- ctx.values = xmalloc(sizeof(char *));
- ctx.descs = xmalloc(sizeof(char *));
- ctx.values[0] = strdup("");
- ctx.descs[0] = strdup(_("Default"));
- ctx.count = 1;
-
- /* Load direct draw DLL */
- HINSTANCE hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
- if (hddraw_dll != NULL)
- {
- /* Enumerate displays */
- HRESULT (WINAPI *OurDirectDrawEnumerateEx)(LPDDENUMCALLBACKEXA,
- LPVOID, DWORD) =
- (void *)GetProcAddress(hddraw_dll, DIRECTDRAWENUMERATEEX_NAME);
- if (OurDirectDrawEnumerateEx != NULL)
- OurDirectDrawEnumerateEx(DirectXEnumCallback2, &ctx,
- DDENUM_ATTACHEDSECONDARYDEVICES);
- FreeLibrary(hddraw_dll);
- }
-
- VLC_UNUSED(name);
-
- *values = ctx.values;
- *descs = ctx.descs;
- return ctx.count;
-}
-
-
diff --git a/modules/video_output/win32/events.c b/modules/video_output/win32/events.c
index 74c33dca05..c918071d4f 100644
--- a/modules/video_output/win32/events.c
+++ b/modules/video_output/win32/events.c
@@ -956,32 +956,8 @@ static long FAR PASCAL WinVoutEventProc( HWND hwnd, UINT message,
if( hwnd == p_event->hvideownd )
{
-#ifdef MODULE_NAME_IS_directdraw
- vlc_mutex_lock( &p_event->lock );
- const bool use_overlay = p_event->use_overlay;
- vlc_mutex_unlock( &p_event->lock );
-#endif
-
switch( message )
{
-#ifdef MODULE_NAME_IS_directdraw
- case WM_ERASEBKGND:
- /* For overlay, we need to erase background */
- return !use_overlay ? 1 : DefWindowProc(hwnd, message, wParam, lParam);
- case WM_PAINT:
- /*
- ** For overlay, DefWindowProc() will erase dirty regions
- ** with colorkey.
- ** For non-overlay, vout will paint the whole window at
- ** regular interval, therefore dirty regions can be ignored
- ** to minimize repaint.
- */
- if( !use_overlay )
- {
- ValidateRect(hwnd, NULL);
- }
- // fall through to default
-#else
/*
** For OpenGL and Direct3D, vout will update the whole
** window at regular interval, therefore dirty region
@@ -994,7 +970,6 @@ static long FAR PASCAL WinVoutEventProc( HWND hwnd, UINT message,
/* nothing to repaint */
ValidateRect(hwnd, NULL);
// fall through
-#endif
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
More information about the vlc-commits
mailing list