diff options
Diffstat (limited to 'libvo/vo_direct3d.c')
| -rw-r--r-- | libvo/vo_direct3d.c | 2157 |
1 files changed, 1651 insertions, 506 deletions
diff --git a/libvo/vo_direct3d.c b/libvo/vo_direct3d.c index 2fb40d0398..fb2f58f5cc 100644 --- a/libvo/vo_direct3d.c +++ b/libvo/vo_direct3d.c @@ -21,10 +21,20 @@ #include <windows.h> #include <errno.h> #include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <stdbool.h> +#include <assert.h> #include <d3d9.h> #include "config.h" +#include "options.h" +#include "subopt-helper.h" +#include "talloc.h" #include "video_out.h" -#include "video_out_internal.h" +#include "libmpcodecs/vfcap.h" +#include "csputils.h" +#include "libmpcodecs/mp_image.h" +#include "libmpcodecs/img_format.h" #include "fastmemcpy.h" #include "mp_msg.h" #include "aspect.h" @@ -32,28 +42,100 @@ #include "libavutil/common.h" #include "sub/font_load.h" #include "sub/sub.h" +#include "eosd_packer.h" -static const vo_info_t info = -{ - "Direct3D 9 Renderer", - "direct3d", - "Georgi Petrov (gogothebee) <gogothebee@gmail.com>", - "" -}; +// shaders generated by fxc.exe from d3d_shader_yuv.hlsl +#include "d3d_shader_yuv.h" +#include "d3d_shader_yuv_2ch.h" -/* - * Link essential libvo functions: preinit, config, control, draw_frame, - * draw_slice, draw_osd, flip_page, check_events, uninit and - * the structure info. - */ -const LIBVO_EXTERN(direct3d) +// TODO: beg someone to add this (there is already IMGFMT_Y8) +// equals MAKEFOURCC('Y', '1', '6', ' ') +#define IMGFMT_Y16 0x20363159 +#define IMGFMT_A8Y8 MAKEFOURCC('A', '8', 'Y', '8') + +#define IMGFMT_IS_Y(x) ((x) == IMGFMT_Y8 || (x) == IMGFMT_Y16 || (x) == IMGFMT_A8Y8) +#define IMGFMT_Y_DEPTH(x) ((x) == IMGFMT_Y8 ? 8 : 16) + +#define DEVTYPE D3DDEVTYPE_HAL +//#define DEVTYPE D3DDEVTYPE_REF + + +#define D3DFVF_OSD_VERTEX (D3DFVF_XYZ | D3DFVF_TEX1) + +typedef struct { + float x, y, z; /* Position of vertex in 3D space */ + float tu, tv; /* Texture coordinates */ +} vertex_osd; + +#define D3DFVF_EOSD_VERTEX (D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_DIFFUSE) + +typedef struct { + float x, y, z; + D3DCOLOR color; + float tu, tv; +} vertex_eosd; + +#define D3DFVF_VIDEO_VERTEX (D3DFVF_XYZ | D3DFVF_TEX3) + +typedef struct { + float x, y, z; + // pairs of texture coordinates for up to 3 planes + float t[3][2]; +} vertex_video; + + +struct d3dtex { + // user-requested size + int w, h; + // allocated texture size + int tex_w, tex_h; + // D3DPOOL_SYSTEMMEM (or others) texture: + // - can be locked in order to write (and even read) data + // - can _not_ (probably) be used as texture for rendering + // This is always non-NULL if d3dtex_allocate succeeds. + IDirect3DTexture9 *system; + // D3DPOOL_DEFAULT texture: + // - can't be locked (Probably.) + // - must be used for rendering + // This will be NULL on systems with device_texture_sys != 0. + IDirect3DTexture9 *device; +}; + +struct texplane { + int bytes_per_pixel; + int bits_per_pixel; + // chroma shifts + // e.g. get the plane's width in pixels with (priv->src_width >> shift_x) + int shift_x, shift_y; + D3DFORMAT d3d_format; + struct d3dtex texture; + // temporary locking during uploading the frame (e.g. for draw_slice) + D3DLOCKED_RECT locked_rect; + // value used to clear the image with memset (YUV chroma planes do not use + // the value 0 for this) + uint8_t clearval; +}; /* Global variables "priv" structure. I try to keep their count low. */ -static struct global_priv { - int is_paused; /**< 1 = Movie is paused, - 0 = Movie is not paused */ +typedef struct d3d_priv { + int opt_prefer_stretchrect; + int opt_disable_textures; + int opt_disable_stretchrect; + int opt_disable_shaders; + int opt_only_8bit; + int opt_disable_eosd; + int opt_disable_texture_align; + // debugging + int opt_force_power_of_2; + int opt_texture_memory; + int opt_swap_discard; + int opt_exact_backbuffer; + int opt_16bit_textures; + + struct vo *vo; + int is_clear_needed; /**< 1 = Clear the backbuffer before StretchRect 0 = (default) Don't clear it */ D3DLOCKED_RECT locked_rect; /**< The locked offscreen surface */ @@ -63,8 +145,22 @@ static struct global_priv { fullscreen */ int src_width; /**< Source (movie) width */ int src_height; /**< Source (movie) heigth */ + int src_d_width; /**< Source (movie) aspect corrected width */ + int src_d_height; /**< Source (movie) aspect corrected heigth */ int border_x; /**< horizontal border value for OSD */ int border_y; /**< vertical border value for OSD */ + int image_format; /**< mplayer image format */ + bool use_textures; /**< use 3D texture rendering, instead of + StretchRect */ + bool use_shaders; /**< use shader for YUV color conversion + (or possibly for RGB video equalizers) */ + bool use_2ch_hack; /**< 2 byte YUV formats use 2 channel hack */ + + int plane_count; + struct texplane planes[3]; + + IDirect3DPixelShader9 *pixel_shader; + const BYTE *pixel_shader_data; D3DFORMAT movie_src_fmt; /**< Movie colorspace format (depends on the movie's codec) */ @@ -76,14 +172,14 @@ static struct global_priv { LPDIRECT3D9 d3d_handle; /**< Direct3D Handle */ LPDIRECT3DDEVICE9 d3d_device; /**< The Direct3D Adapter */ + bool d3d_in_scene; /**< BeginScene was called, EndScene not */ IDirect3DSurface9 *d3d_surface; /**< Offscreen Direct3D Surface. MPlayer renders inside it. Uses colorspace priv->movie_src_fmt */ - IDirect3DTexture9 *d3d_texture_osd; /**< Direct3D Texture. Uses RGBA */ - IDirect3DTexture9 *d3d_texture_system; /**< Direct3D Texture. System memory - cannot lock a normal texture. Uses RGBA */ + struct d3dtex texture_osd; /**< RGBA */ IDirect3DSurface9 *d3d_backbuf; /**< Video card's back buffer (used to display next frame) */ + struct d3dtex texture_eosd; /**< A8 */ int cur_backbuf_width; /**< Current backbuffer width */ int cur_backbuf_height; /**< Current backbuffer height */ int is_osd_populated; /**< 1 = OSD texture has something to display, @@ -96,48 +192,82 @@ static struct global_priv { 0 = device requires shadow */ int max_texture_width; /**< from the device capabilities */ int max_texture_height; /**< from the device capabilities */ - int osd_width; /**< current width of the OSD */ - int osd_height; /**< current height of the OSD */ - int osd_texture_width; /**< current width of the OSD texture */ - int osd_texture_height; /**< current height of the OSD texture */ -} *priv; -typedef struct { + D3DMATRIX d3d_colormatrix; + float d3d_depth_vector[4]; + struct mp_csp_details colorspace; + struct mp_csp_equalizer video_eq; + + struct eosd_packer *eosd; /**< EOSD packer (image positions etc.) */ + vertex_eosd *eosd_vb; /**< temporary memory for D3D when rendering EOSD */ +} d3d_priv; + +struct fmt_entry { const unsigned int mplayer_fmt; /**< Given by MPlayer */ const D3DFORMAT fourcc; /**< Required by D3D's test function */ -} struct_fmt_table; +}; /* Map table from reported MPlayer format to the required fourcc. This is needed to perform the format query. */ -static const struct_fmt_table fmt_table[] = { +static const struct fmt_entry fmt_table[] = { + // planar YUV {IMGFMT_YV12, MAKEFOURCC('Y','V','1','2')}, {IMGFMT_I420, MAKEFOURCC('I','4','2','0')}, {IMGFMT_IYUV, MAKEFOURCC('I','Y','U','V')}, {IMGFMT_YVU9, MAKEFOURCC('Y','V','U','9')}, + // packed YUV {IMGFMT_YUY2, D3DFMT_YUY2}, {IMGFMT_UYVY, D3DFMT_UYVY}, + // packed RGB {IMGFMT_BGR32, D3DFMT_X8R8G8B8}, {IMGFMT_RGB32, D3DFMT_X8B8G8R8}, {IMGFMT_BGR24, D3DFMT_R8G8B8}, //untested {IMGFMT_BGR16, D3DFMT_R5G6B5}, {IMGFMT_BGR15, D3DFMT_X1R5G5B5}, {IMGFMT_BGR8 , D3DFMT_R3G3B2}, //untested + // grayscale (can be considered both packed and planar) + {IMGFMT_Y8, D3DFMT_L8}, + {IMGFMT_Y16, D3DFMT_L16}, + {IMGFMT_A8Y8, D3DFMT_A8L8}, + {0}, }; -#define DISPLAY_FORMAT_TABLE_ENTRIES (sizeof(fmt_table) / sizeof(fmt_table[0])) -#define D3DFVF_MY_VERTEX (D3DFVF_XYZ | D3DFVF_TEX1) +static void generate_eosd(d3d_priv *priv, mp_eosd_images_t *); +static void draw_eosd(d3d_priv *priv); +static void update_colorspace(d3d_priv *priv); +static void d3d_clear_video_textures(d3d_priv *priv); +static bool resize_d3d(d3d_priv *priv); +static uint32_t d3d_draw_frame(d3d_priv *priv); +static int draw_slice(struct vo *vo, uint8_t *src[], int stride[], int w, int h, + int x, int y); +static void uninit(struct vo *vo); +static void draw_osd(struct vo *vo, struct osd_state *osd); +static void flip_page(struct vo *vo); +static mp_image_t *get_screenshot(d3d_priv *priv); +static mp_image_t *get_window_screenshot(d3d_priv *priv); -typedef struct { - float x, y, z; /* Position of vertex in 3D space */ - float tu, tv; /* Texture coordinates */ -} struct_vertex; -typedef enum back_buffer_action { - BACKBUFFER_CREATE, - BACKBUFFER_RESET -} back_buffer_action_e; +static void d3d_matrix_identity(D3DMATRIX *m) +{ + memset(m, 0, sizeof(D3DMATRIX)); + m->_11 = m->_22 = m->_33 = m->_44 = 1.0f; +} + +static void d3d_matrix_ortho(D3DMATRIX *m, float left, float right, + float bottom, float top) +{ + d3d_matrix_identity(m); + m->_11 = 2.0f / (right - left); + m->_22 = 2.0f / (top - bottom); + m->_33 = 1.0f; + m->_41 = -(right + left) / (right - left); + m->_42 = -(top + bottom) / (top - bottom); + m->_43 = 0; + m->_44 = 1.0f; +} + /**************************************************************************** * * * * @@ -148,15 +278,28 @@ typedef enum back_buffer_action { * * ****************************************************************************/ +static bool d3d_begin_scene(d3d_priv *priv) +{ + if (!priv->d3d_in_scene) { + if (FAILED(IDirect3DDevice9_BeginScene(priv->d3d_device))) { + mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>BeginScene failed.\n"); + return false; + } + priv->d3d_in_scene = true; + } + return true; +} + /** @brief Calculate scaled fullscreen movie rectangle with * preserved aspect ratio. */ -static void calc_fs_rect(void) +static void calc_fs_rect(d3d_priv *priv) { struct vo_rect src_rect; struct vo_rect dst_rect; struct vo_rect borders; - calc_src_dst_rects(priv->src_width, priv->src_height, &src_rect, &dst_rect, &borders, NULL); + calc_src_dst_rects(priv->vo, priv->src_width, priv->src_height, &src_rect, + &dst_rect, &borders, NULL); priv->fs_movie_rect.left = dst_rect.left; priv->fs_movie_rect.right = dst_rect.right; @@ -170,7 +313,7 @@ static void calc_fs_rect(void) priv->border_y = borders.top; mp_msg(MSGT_VO, MSGL_V, - "<vo_direct3d>Fullscreen movie rectangle: t: %ld, l: %ld, r: %ld, b:%ld\n", + "<vo_direct3d>Video rectangle: t: %ld, l: %ld, r: %ld, b:%ld\n", priv->fs_movie_rect.top, priv->fs_movie_rect.left, priv->fs_movie_rect.right, priv->fs_movie_rect.bottom); @@ -181,54 +324,285 @@ static void calc_fs_rect(void) priv->is_clear_needed = 1; } -/** @brief Destroy D3D Offscreen and Backbuffer surfaces. - */ -static void destroy_d3d_surfaces(void) +// Adjust the texture size *width/*height to fit the requirements of the D3D +// device. The texture size is only increased. +static void d3d_fix_texture_size(d3d_priv *priv, int *width, int *height) { - mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>destroy_d3d_surfaces called.\n"); - /* Let's destroy the old (if any) D3D Surfaces */ + int tex_width = *width; + int tex_height = *height; + + // avoid nasty special cases with 0-sized textures and texture sizes + tex_width = FFMAX(tex_width, 1); + tex_height = FFMAX(tex_height, 1); + + if (priv->device_caps_power2_only) { + tex_width = 1; + tex_height = 1; + while (tex_width < *width) tex_width <<= 1; + while (tex_height < *height) tex_height <<= 1; + } + if (priv->device_caps_square_only) + /* device only supports square textures */ + tex_width = tex_height = FFMAX(tex_width, tex_height); + // better round up to a multiple of 16 + if (!priv->opt_disable_texture_align) { + tex_width = (tex_width + 15) & ~15; + tex_height = (tex_height + 15) & ~15; + } + + *width = tex_width; + *height = tex_height; +} + +static void d3dtex_release(d3d_priv *priv, struct d3dtex *tex) +{ + if (tex->system) + IDirect3DTexture9_Release(tex->system); + tex->system = NULL; + + if (tex->device) + IDirect3DTexture9_Release(tex->device); + tex->device = NULL; + + tex->tex_w = tex->tex_h = 0; +} + +static bool d3dtex_allocate(d3d_priv *priv, struct d3dtex *tex, D3DFORMAT fmt, + int w, int h) +{ + d3dtex_release(priv, tex); + + tex->w = w; + tex->h = h; + + int tw = w, th = h; + d3d_fix_texture_size(priv, &tw, &th); + + int memtype = D3DPOOL_SYSTEMMEM; + switch (priv->opt_texture_memory) { + case 1: memtype = D3DPOOL_MANAGED; break; + case 2: memtype = D3DPOOL_DEFAULT; break; + } + + if (FAILED(IDirect3DDevice9_CreateTexture(priv->d3d_device, tw, th, 1, + D3DUSAGE_DYNAMIC, fmt, memtype, &tex->system, NULL))) + { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Allocating %dx%d texture in system RAM failed.\n", + w, h); + goto error_exit; + } + + if (!priv->device_texture_sys && !priv->opt_texture_memory) { + if (FAILED(IDirect3DDevice9_CreateTexture(priv->d3d_device, tw, th, 1, + D3DUSAGE_DYNAMIC, fmt, D3DPOOL_DEFAULT, &tex->device, NULL))) + { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Allocating %dx%d texture in video RAM failed.\n", + w, h); + goto error_exit; + } + } + + tex->tex_w = tw; + tex->tex_h = th; + + return true; + +error_exit: + d3dtex_release(priv, tex); + return false; +} - if (priv->locked_rect.pBits) - IDirect3DSurface9_UnlockRect(priv->d3d_surface); +static IDirect3DBaseTexture9 *d3dtex_get_render_texture(d3d_priv *priv, + struct d3dtex *tex) +{ + return (IDirect3DBaseTexture9 *)(tex->device ? tex->device : tex->system); +} + +// Copy system texture contents to device texture. +static bool d3dtex_update(d3d_priv *priv, struct d3dtex *tex) +{ + if (!tex->device) + return true; + return !FAILED(IDirect3DDevice9_UpdateTexture(priv->d3d_device, + (IDirect3DBaseTexture9 *)tex->system, + (IDirect3DBaseTexture9 *)tex->device)); +} + +static void d3d_unlock_video_objects(d3d_priv *priv) +{ + bool any_failed = false; + + if (priv->locked_rect.pBits) { + if (FAILED(IDirect3DSurface9_UnlockRect(priv->d3d_surface))) + any_failed = true; + } priv->locked_rect.pBits = NULL; + for (int n = 0; n < priv->plane_count; n++) { + struct texplane *plane = &priv->planes[n]; + if (plane->locked_rect.pBits) { + if (FAILED(IDirect3DTexture9_UnlockRect(plane->texture.system, 0))) + any_failed = true; + } + plane->locked_rect.pBits = NULL; + } + + if (any_failed) { + mp_msg(MSGT_VO, MSGL_V, + "<vo_direct3d>Unlocking video objects failed.\n"); + } +} + +// Free video surface/textures, shaders, etc. +static void d3d_destroy_video_objects(d3d_priv *priv) +{ + d3d_unlock_video_objects(priv); + if (priv->d3d_surface) IDirect3DSurface9_Release(priv->d3d_surface); priv->d3d_surface = NULL; - /* kill the OSD texture and its shadow copy */ - if (priv->d3d_texture_osd) - IDirect3DTexture9_Release(priv->d3d_texture_osd); - priv->d3d_texture_osd = NULL; + for (int n = 0; n < priv->plane_count; n++) { + d3dtex_release(priv, &priv->planes[n].texture); + } - if (priv->d3d_texture_system) - IDirect3DTexture9_Release(priv->d3d_texture_system); - priv->d3d_texture_system = NULL; + if (priv->pixel_shader) + IDirect3DPixelShader9_Release(priv->pixel_shader); + priv->pixel_shader = NULL; +} + +/** @brief Destroy D3D Offscreen and Backbuffer surfaces. + */ +static void destroy_d3d_surfaces(d3d_priv *priv) +{ + mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>destroy_d3d_surfaces called.\n"); + + d3d_destroy_video_objects(priv); + + d3dtex_release(priv, &priv->texture_osd); if (priv->d3d_backbuf) IDirect3DSurface9_Release(priv->d3d_backbuf); priv->d3d_backbuf = NULL; + + d3dtex_release(priv, &priv->texture_eosd); + + if (priv->eosd) + eosd_packer_reinit(priv->eosd, 0, 0); + + priv->d3d_in_scene = false; } -/** @brief Create D3D Offscreen and Backbuffer surfaces. Each - * surface is created only if it's not already present. - * @return 1 on success, 0 on failure - */ -static int create_d3d_surfaces(void) +// Allocate video surface or textures, and create shaders if needed. +static bool d3d_configure_video_objects(d3d_priv *priv) { - int osd_width = vo_dwidth, osd_height = vo_dheight; - int tex_width = osd_width, tex_height = osd_height; - mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>create_d3d_surfaces called.\n"); + int n; + bool need_clear = false; + + assert(priv->image_format != 0); + + if (priv->use_textures) { + for (n = 0; n < priv->plane_count; n++) { + struct texplane *plane = &priv->planes[n]; + + if (!plane->texture.system) { + if (!d3dtex_allocate(priv, + &plane->texture, + plane->d3d_format, + priv->src_width >> plane->shift_x, + priv->src_height >> plane->shift_y)) + { + mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Allocating plane %d" + " failed.\n", n); + return false; + } + + mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Allocated plane %d:" + " %d bit, shift=%d/%d size=%d/%d (%d/%d).\n", n, + plane->bits_per_pixel, + plane->shift_x, plane->shift_y, + plane->texture.w, plane->texture.h, + plane->texture.tex_w, plane->texture.tex_h); + + need_clear = true; + } + } - if (!priv->d3d_surface && - FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface( - priv->d3d_device, priv->src_width, priv->src_height, - priv->movie_src_fmt, D3DPOOL_DEFAULT, &priv->d3d_surface, NULL))) { - mp_msg(MSGT_VO, MSGL_ERR, - "<vo_direct3d>Allocating offscreen surface failed.\n"); - return 0; + if (need_clear) + d3d_clear_video_textures(priv); + + if (priv->pixel_shader_data) { + if (!priv->pixel_shader && + FAILED(IDirect3DDevice9_CreatePixelShader(priv->d3d_device, + (DWORD *)priv->pixel_shader_data, &priv->pixel_shader))) + { + mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Failed to create " + "YUV conversion pixel shader.\n"); + return false; + } + } + + } else { + + if (!priv->d3d_surface && + FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface( + priv->d3d_device, priv->src_width, priv->src_height, + priv->movie_src_fmt, D3DPOOL_DEFAULT, &priv->d3d_surface, NULL))) + { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Allocating offscreen surface failed.\n"); + return false; + } } + return true; +} + +static bool d3d_lock_video_textures(d3d_priv *priv) +{ + for (int n = 0; n < priv->plane_count; n++) { + struct texplane *plane = &priv->planes[n]; + + if (!plane->locked_rect.pBits) { + if (FAILED(IDirect3DTexture9_LockRect(plane->texture.system, 0, + &plane->locked_rect, NULL, 0))) + { + mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Texture lock failure.\n"); + d3d_unlock_video_objects(priv); + return false; + } + } + } + + return true; +} + +static void d3d_clear_video_textures(d3d_priv *priv) +{ + if (!d3d_lock_video_textures(priv)) + return; + + for (int n = 0; n < priv->plane_count; n++) { + struct texplane *plane = &priv->planes[n]; + memset(plane->locked_rect.pBits, plane->clearval, + plane->locked_rect.Pitch * plane->texture.tex_h); + } + + d3d_unlock_video_objects(priv); +} + +// Recreate and initialize D3D objects if necessary. The amount of work that +// needs to be done can be quite different: it could be that full initialization +// is required, or that some objects need to be created, or that nothing is +// done. +static bool create_d3d_surfaces(d3d_priv *priv) +{ + int osd_width = priv->vo->dwidth, osd_height = priv->vo->dheight; + int tex_width = osd_width, tex_height = osd_height; + mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>create_d3d_surfaces called.\n"); + if (!priv->d3d_backbuf && FAILED(IDirect3DDevice9_GetBackBuffer(priv->d3d_device, 0, 0, D3DBACKBUFFER_TYPE_MONO, @@ -237,92 +611,150 @@ static int create_d3d_surfaces(void) return 0; } - /* calculate the best size for the OSD depending on the factors from the device */ - if (priv->device_caps_power2_only) { - tex_width = 1; - tex_height = 1; - while (tex_width < osd_width ) tex_width <<= 1; - while (tex_height < osd_height) tex_height <<= 1; - } - if (priv->device_caps_square_only) - /* device only supports square textures */ - tex_width = tex_height = tex_width > tex_height ? tex_width : tex_height; - // better round up to a multiple of 16 - tex_width = (tex_width + 15) & ~15; - tex_height = (tex_height + 15) & ~15; + if (!d3d_configure_video_objects(priv)) + return 0; + + /* create OSD */ + + d3d_fix_texture_size(priv, &tex_width, &tex_height); - // make sure we respect the size limits without breaking aspect or pow2-requirements - while (tex_width > priv->max_texture_width || tex_height > priv->max_texture_height) { + while (tex_width > priv->max_texture_width + || tex_height > priv->max_texture_height) + { osd_width >>= 1; osd_height >>= 1; tex_width >>= 1; tex_height >>= 1; } - priv->osd_width = osd_width; - priv->osd_height = osd_height; - priv->osd_texture_width = tex_width; - priv->osd_texture_height = tex_height; + if (priv->texture_osd.tex_w < tex_width + || priv->texture_osd.tex_h < tex_height) + { + d3dtex_release(priv, &priv->texture_osd); - mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>OSD texture size (%dx%d), requested (%dx%d).\n", - vo_dwidth, vo_dheight, priv->osd_texture_width, priv->osd_texture_height); + mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>OSD texture size (%dx%d)," + " requested (%dx%d).\n", osd_width, osd_height, tex_width, + tex_height); - /* create OSD */ - if (!priv->d3d_texture_system && - FAILED(IDirect3DDevice9_CreateTexture(priv->d3d_device, - priv->osd_texture_width, - priv->osd_texture_height, - 1, - D3DUSAGE_DYNAMIC, - D3DFMT_A8L8, - D3DPOOL_SYSTEMMEM, - &priv->d3d_texture_system, - NULL))) { - mp_msg(MSGT_VO,MSGL_ERR, - "<vo_direct3d>Allocating OSD texture in system RAM failed.\n"); - return 0; - } - - if (!priv->device_texture_sys) { - /* only create if we need a shadow version on the external device */ - if (!priv->d3d_texture_osd && - FAILED(IDirect3DDevice9_CreateTexture(priv->d3d_device, - priv->osd_texture_width, - priv->osd_texture_height, - 1, - D3DUSAGE_DYNAMIC, - D3DFMT_A8L8, - D3DPOOL_DEFAULT, - &priv->d3d_texture_osd, - NULL))) { - mp_msg(MSGT_VO,MSGL_ERR, - "<vo_direct3d>Allocating OSD texture in video RAM failed.\n"); + if (!d3dtex_allocate(priv, &priv->texture_osd, D3DFMT_A8L8, tex_width, + tex_height)) + { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Allocating OSD texture failed.\n"); return 0; } } + priv->texture_osd.w = osd_width; + priv->texture_osd.h = osd_height; + /* setup default renderstate */ - IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_SRCBLEND, D3DBLEND_ONE); - IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); - IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHAFUNC, D3DCMP_GREATER); - IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHAREF, (DWORD)0x0); - IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_LIGHTING, FALSE); - IDirect3DDevice9_SetSamplerState(priv->d3d_device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); - IDirect3DDevice9_SetSamplerState(priv->d3d_device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); + IDirect3DDevice9_SetRenderState(priv->d3d_device, + D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); + IDirect3DDevice9_SetRenderState(priv->d3d_device, + D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); + IDirect3DDevice9_SetRenderState(priv->d3d_device, + D3DRS_ALPHAFUNC, D3DCMP_GREATER); + IDirect3DDevice9_SetRenderState(priv->d3d_device, + D3DRS_ALPHAREF, (DWORD)0x0); + IDirect3DDevice9_SetRenderState(priv->d3d_device, + D3DRS_LIGHTING, FALSE); + + // we use up to 3 samplers for up to 3 YUV planes + for (int n = 0; n < 3; n++) { + IDirect3DDevice9_SetSamplerState(priv->d3d_device, n, D3DSAMP_MINFILTER, + D3DTEXF_LINEAR); + IDirect3DDevice9_SetSamplerState(priv->d3d_device, n, D3DSAMP_MAGFILTER, + D3DTEXF_LINEAR); + IDirect3DDevice9_SetSamplerState(priv->d3d_device, n, D3DSAMP_ADDRESSU, + D3DTADDRESS_CLAMP); + IDirect3DDevice9_SetSamplerState(priv->d3d_device, n, D3DSAMP_ADDRESSV, + D3DTADDRESS_CLAMP); + } + + if (priv->eosd && !priv->texture_eosd.system) + eosd_packer_reinit(priv->eosd, priv->max_texture_width, + priv->max_texture_height); return 1; } +static bool init_d3d(d3d_priv *priv) +{ + D3DDISPLAYMODE disp_mode; + D3DCAPS9 disp_caps; + DWORD texture_caps; + DWORD dev_caps; + + priv->d3d_handle = priv->pDirect3DCreate9(D3D_SDK_VERSION); + if (!priv->d3d_handle) { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Initializing Direct3D failed.\n"); + return false; + } + + if (FAILED(IDirect3D9_GetAdapterDisplayMode(priv->d3d_handle, + D3DADAPTER_DEFAULT, + &disp_mode))) { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Reading display mode failed.\n"); + return false; + } + + priv->desktop_fmt = disp_mode.Format; + priv->cur_backbuf_width = disp_mode.Width; + priv->cur_backbuf_height = disp_mode.Height; + + mp_msg(MSGT_VO, MSGL_V, + "<vo_direct3d>Setting backbuffer dimensions to (%dx%d).\n", + disp_mode.Width, disp_mode.Height); + + if (FAILED(IDirect3D9_GetDeviceCaps(priv->d3d_handle, + D3DADAPTER_DEFAULT, + DEVTYPE, + &disp_caps))) + { + mp_msg(MSGT_VO, MSGL_ERR, + "<vo_direct3d>Reading display capabilities failed.\n"); + return false; + } + + /* Store relevant information reguarding caps of device */ + texture_caps = disp_caps.TextureCaps; + dev_caps = disp_caps.DevCaps; + priv->device_caps_power2_only = (texture_caps & D3DPTEXTURECAPS_POW2) && + !(texture_caps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL); + priv->device_caps_square_only = texture_caps & D3DPTEXTURECAPS_SQUAREONLY; + priv->device_texture_sys = dev_caps & D3DDEVCAPS_TEXTURESYSTEMMEMORY; + priv->max_texture_width = disp_caps.MaxTextureWidth; + priv->max_texture_height = disp_caps.MaxTextureHeight; + + if (priv->opt_force_power_of_2) + priv->device_caps_power2_only = 1; + + mp_msg(MSGT_VO, MSGL_V, + "<vo_direct3d>device_caps_power2_only %d, device_caps_square_only %d\n" + "<vo_direct3d>device_texture_sys %d\n" + "<vo_direct3d>max_texture_width %d, max_texture_height %d\n", + priv->device_caps_power2_only, priv->device_caps_square_only, + priv->device_texture_sys, priv->max_texture_width, + priv->max_texture_height); + + return true; +} + /** @brief Fill D3D Presentation parameters */ -static void fill_d3d_presentparams(D3DPRESENT_PARAMETERS *present_params) +static void fill_d3d_presentparams(d3d_priv *priv, + D3DPRESENT_PARAMETERS *present_params) { /* Prepare Direct3D initialization parameters. */ memset(present_params, 0, sizeof(D3DPRESENT_PARAMETERS)); present_params->Windowed = TRUE; - present_params->SwapEffect = D3DSWAPEFFECT_COPY; + present_params->SwapEffect = + priv->opt_swap_discard ? D3DSWAPEFFECT_DISCARD : D3DSWAPEFFECT_COPY; present_params->Flags = D3DPRESENTFLAG_VIDEO; - present_params->hDeviceWindow = vo_w32_window; /* w32_common var */ + present_params->hDeviceWindow = priv->vo->w32->window; present_params->BackBufferWidth = priv->cur_backbuf_width; present_params->BackBufferHeight = priv->cur_backbuf_height; present_params->MultiSampleType = D3DMULTISAMPLE_NONE; @@ -333,177 +765,133 @@ static void fill_d3d_presentparams(D3DPRESENT_PARAMETERS *present_params) } -/** @brief Create a new backbuffer. Create or Reset the D3D - * device. - * @return 1 on success, 0 on failure - */ -static int change_d3d_backbuffer(back_buffer_action_e action) +// Create a new backbuffer. Create or Reset the D3D device. +static bool change_d3d_backbuffer(d3d_priv *priv) { D3DPRESENT_PARAMETERS present_params; - destroy_d3d_surfaces(); + int window_w = priv->vo->dwidth; + int window_h = priv->vo->dheight; /* Grow the backbuffer in the required dimension. */ - if (vo_dwidth > priv->cur_backbuf_width) - priv->cur_backbuf_width = vo_dwidth; + if (window_w > priv->cur_backbuf_width) + priv->cur_backbuf_width = window_w; + + if (window_h > priv->cur_backbuf_height) + priv->cur_backbuf_height = window_h; - if (vo_dheight > priv->cur_backbuf_height) - priv->cur_backbuf_height = vo_dheight; + if (priv->opt_exact_backbuffer) { + priv->cur_backbuf_width = window_w; + priv->cur_backbuf_height = window_h; + } /* The grown backbuffer dimensions are ready and fill_d3d_presentparams * will use them, so we can reset the device. */ - fill_d3d_presentparams(&present_params); - - /* vo_w32_window is w32_common variable. It's a handle to the window. */ - if (action == BACKBUFFER_CREATE && - FAILED(IDirect3D9_CreateDevice(priv->d3d_handle, - D3DADAPTER_DEFAULT, - D3DDEVTYPE_HAL, vo_w32_window, - D3DCREATE_SOFTWARE_VERTEXPROCESSING, - &present_params, &priv->d3d_device))) { + fill_d3d_presentparams(priv, &present_params); + + if (!priv->d3d_device) { + if (FAILED(IDirect3D9_CreateDevice(priv->d3d_handle, + D3DADAPTER_DEFAULT, + DEVTYPE, priv->vo->w32->window, + D3DCREATE_SOFTWARE_VERTEXPROCESSING + | D3DCREATE_FPU_PRESERVE, + &present_params, &priv->d3d_device))) + { mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>Creating Direct3D device failed.\n"); - return 0; - } - - if (action == BACKBUFFER_RESET && - FAILED(IDirect3DDevice9_Reset(priv->d3d_device, &present_params))) { + return 0; + } + } else { + if (FAILED(IDirect3DDevice9_Reset(priv->d3d_device, &present_params))) { mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Reseting Direct3D device failed.\n"); - return 0; + return 0; + } } mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>New backbuffer (%dx%d), VO (%dx%d)\n", present_params.BackBufferWidth, present_params.BackBufferHeight, - vo_dwidth, vo_dheight); - - return 1; -} - -/** @brief Configure initial Direct3D context. The first - * function called to initialize the D3D context. - * @return 1 on success, 0 on failure - */ -static int configure_d3d(void) -{ - D3DDISPLAYMODE disp_mode; - D3DVIEWPORT9 vp = {0, 0, vo_dwidth, vo_dheight, 0, 1}; - - mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>configure_d3d called |