Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610/* * This file is part of mpv. * * mpv 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. * * mpv 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 mpv. If not, see <http://www.gnu.org/licenses/>. */
#include "common/msg.h"#include "options/m_config.h"#include "osdep/timer.h"#include "osdep/windows_utils.h"
#include "video/out/gpu/context.h"#include "video/out/gpu/d3d11_helpers.h"#include "video/out/gpu/spirv.h"#include "video/out/w32_common.h"#include "context.h"#include "ra_d3d11.h"
struct d3d11_opts { int feature_level; int warp; bool flip; int sync_interval; char *adapter_name; int output_format; int color_space; bool exclusive_fs;};
#define OPT_BASE_STRUCT struct d3d11_optsconst struct m_sub_options d3d11_conf = { .opts = (const struct m_option[]) { {"d3d11-warp", OPT_CHOICE(warp, {"auto", -1}, {"no", 0}, {"yes", 1}), .flags = UPDATE_VO, }, {"d3d11-feature-level", OPT_CHOICE(feature_level, {"12_1", D3D_FEATURE_LEVEL_12_1}, {"12_0", D3D_FEATURE_LEVEL_12_0}, {"11_1", D3D_FEATURE_LEVEL_11_1}, {"11_0", D3D_FEATURE_LEVEL_11_0}, {"10_1", D3D_FEATURE_LEVEL_10_1}, {"10_0", D3D_FEATURE_LEVEL_10_0}, {"9_3", D3D_FEATURE_LEVEL_9_3}, {"9_2", D3D_FEATURE_LEVEL_9_2}, {"9_1", D3D_FEATURE_LEVEL_9_1}), .flags = UPDATE_VO, }, {"d3d11-flip", OPT_BOOL(flip), .flags = UPDATE_VO}, {"d3d11-sync-interval", OPT_INT(sync_interval), M_RANGE(0, 4)}, {"d3d11-adapter", OPT_STRING_VALIDATE(adapter_name, mp_dxgi_validate_adapter), .flags = UPDATE_VO, }, {"d3d11-output-format", OPT_CHOICE(output_format, {"auto", DXGI_FORMAT_UNKNOWN}, {"rgba8", DXGI_FORMAT_R8G8B8A8_UNORM}, {"bgra8", DXGI_FORMAT_B8G8R8A8_UNORM}, {"rgb10_a2", DXGI_FORMAT_R10G10B10A2_UNORM}, {"rgba16f", DXGI_FORMAT_R16G16B16A16_FLOAT}), .flags = UPDATE_VO, }, {"d3d11-output-csp", OPT_CHOICE(color_space, {"auto", -1}, {"srgb", DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709}, {"linear", DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709}, {"pq", DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020}, {"bt.2020", DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020}), .flags = UPDATE_VO, }, {"d3d11-exclusive-fs", OPT_BOOL(exclusive_fs)}, {0} }, .defaults = &(const struct d3d11_opts) { .feature_level = D3D_FEATURE_LEVEL_12_1, .warp = -1, .flip = true, .sync_interval = 1, .adapter_name = NULL, .output_format = DXGI_FORMAT_UNKNOWN, .color_space = -1, }, .size = sizeof(struct d3d11_opts)};
struct priv { struct d3d11_opts *opts; struct m_config_cache *opts_cache;
struct mp_vo_opts *vo_opts; struct m_config_cache *vo_opts_cache;
struct ra_tex *backbuffer; ID3D11Device *device; IDXGISwapChain *swapchain; struct pl_color_space swapchain_csp;
int64_t perf_freq; unsigned last_sync_refresh_count; int64_t last_sync_qpc_time; int64_t vsync_duration_qpc; int64_t last_submit_qpc;};
static struct ra_tex *get_backbuffer(struct ra_ctx *ctx){ struct priv *p = ctx->priv; ID3D11Texture2D *backbuffer = NULL; struct ra_tex *tex = NULL; HRESULT hr;
hr = IDXGISwapChain_GetBuffer(p->swapchain, 0, &IID_ID3D11Texture2D, (void**)&backbuffer); if (FAILED(hr)) { MP_ERR(ctx, "Couldn't get swapchain image\n"); goto done; }
tex = ra_d3d11_wrap_tex(ctx->ra, (ID3D11Resource *)backbuffer);done: SAFE_RELEASE(backbuffer); return tex;}
static bool resize(struct ra_ctx *ctx){ struct priv *p = ctx->priv; HRESULT hr;
if (p->backbuffer) { MP_ERR(ctx, "Attempt at resizing while a frame was in progress!\n"); return false; }
hr = IDXGISwapChain_ResizeBuffers(p->swapchain, 0, ctx->vo->dwidth, ctx->vo->dheight, DXGI_FORMAT_UNKNOWN, 0); if (FAILED(hr)) { MP_FATAL(ctx, "Couldn't resize swapchain: %s\n", mp_HRESULT_to_str(hr)); return false; }
return true;}
static bool d3d11_reconfig(struct ra_ctx *ctx){ vo_w32_config(ctx->vo); return resize(ctx);}
static int d3d11_color_depth(struct ra_swapchain *sw){ struct priv *p = sw->priv;
DXGI_OUTPUT_DESC1 desc1; if (!mp_get_dxgi_output_desc(p->swapchain, &desc1)) desc1.BitsPerColor = 0;
DXGI_SWAP_CHAIN_DESC desc;
HRESULT hr = IDXGISwapChain_GetDesc(p->swapchain, &desc); if (FAILED(hr)) { MP_ERR(sw->ctx, "Failed to query swap chain description: %s!\n", mp_HRESULT_to_str(hr)); return desc1.BitsPerColor; }
const struct ra_format *ra_fmt = ra_d3d11_get_ra_format(sw->ctx->ra, desc.BufferDesc.Format); if (!ra_fmt || !ra_fmt->component_depth[0]) return desc1.BitsPerColor;
if (!desc1.BitsPerColor) return ra_fmt->component_depth[0];
return MPMIN(ra_fmt->component_depth[0], desc1.BitsPerColor);}
static struct pl_color_space d3d11_target_color_space(struct ra_swapchain *sw){ struct priv *p = sw->priv;
struct pl_color_space ret = {0}; DXGI_OUTPUT_DESC1 desc1; if (!mp_get_dxgi_output_desc(p->swapchain, &desc1)) return ret;
ret.hdr.max_luma = desc1.MaxLuminance; ret.hdr.min_luma = desc1.MinLuminance; ret.hdr.prim.blue.x = desc1.BluePrimary[0]; ret.hdr.prim.blue.y = desc1.BluePrimary[1]; ret.hdr.prim.green.x = desc1.GreenPrimary[0]; ret.hdr.prim.green.y = desc1.GreenPrimary[1]; ret.hdr.prim.red.x = desc1.RedPrimary[0]; ret.hdr.prim.red.y = desc1.RedPrimary[1];
switch (desc1.ColorSpace) { case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709: ret.primaries = PL_COLOR_PRIM_BT_709; ret.transfer = PL_COLOR_TRC_SRGB; break; case DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709: ret.primaries = PL_COLOR_PRIM_BT_709; ret.transfer = PL_COLOR_TRC_LINEAR; break; case DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020: ret.primaries = PL_COLOR_PRIM_BT_2020; ret.transfer = PL_COLOR_TRC_PQ; break; case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020: ret.primaries = PL_COLOR_PRIM_BT_2020; ret.transfer = PL_COLOR_TRC_SRGB; break; default: ret.primaries = PL_COLOR_PRIM_UNKNOWN; ret.transfer = PL_COLOR_TRC_UNKNOWN; break; }
return ret;}
static bool d3d11_start_frame(struct ra_swapchain *sw, struct ra_fbo *out_fbo){ struct priv *p = sw->priv;
if (!out_fbo) return true;
assert(!p->backbuffer);
p->backbuffer = get_backbuffer(sw->ctx); if (!p->backbuffer) return false;
*out_fbo = (struct ra_fbo) { .tex = p->backbuffer, .flip = false, .color_space = p->swapchain_csp }; return true;}
static bool d3d11_submit_frame(struct ra_swapchain *sw, const struct vo_frame *frame){ struct priv *p = sw->priv;
ra_d3d11_flush(sw->ctx->ra); ra_tex_free(sw->ctx->ra, &p->backbuffer); return true;}
static int64_t qpc_to_ns(struct ra_swapchain *sw, int64_t qpc){ struct priv *p = sw->priv;
// Convert QPC units (1/perf_freq seconds) to nanoseconds. This will work // without overflow because the QPC value is guaranteed not to roll-over // within 100 years, so perf_freq must be less than 2.9*10^9. return qpc / p->perf_freq * INT64_C(1000000000) + qpc % p->perf_freq * INT64_C(1000000000) / p->perf_freq;}
static int64_t qpc_ns_now(struct ra_swapchain *sw){ LARGE_INTEGER perf_count; QueryPerformanceCounter(&perf_count); return qpc_to_ns(sw, perf_count.QuadPart);}
static void d3d11_swap_buffers(struct ra_swapchain *sw){ struct priv *p = sw->priv;
m_config_cache_update(p->opts_cache);
LARGE_INTEGER perf_count; QueryPerformanceCounter(&perf_count); p->last_submit_qpc = perf_count.QuadPart;
IDXGISwapChain_Present(p->swapchain, p->opts->sync_interval, 0);}
static void d3d11_get_vsync(struct ra_swapchain *sw, struct vo_vsync_info *info){ struct priv *p = sw->priv; HRESULT hr;
m_config_cache_update(p->opts_cache);
// The calculations below are only valid if mpv presents on every vsync if (p->opts->sync_interval != 1) return;
// They're also only valid for flip model swapchains DXGI_SWAP_CHAIN_DESC desc; hr = IDXGISwapChain_GetDesc(p->swapchain, &desc); if (FAILED(hr) || (desc.SwapEffect != DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL && desc.SwapEffect != DXGI_SWAP_EFFECT_FLIP_DISCARD)) { return; }
// GetLastPresentCount returns a sequential ID for the frame submitted by // the last call to IDXGISwapChain::Present() UINT submit_count; hr = IDXGISwapChain_GetLastPresentCount(p->swapchain, &submit_count); if (FAILED(hr)) return;
// GetFrameStatistics returns two pairs. The first is (PresentCount, // PresentRefreshCount) which relates a present ID (on the same timeline as // GetLastPresentCount) to the physical vsync it was displayed on. The // second is (SyncRefreshCount, SyncQPCTime), which relates a physical vsync // to a timestamp on the same clock as QueryPerformanceCounter. DXGI_FRAME_STATISTICS stats; hr = IDXGISwapChain_GetFrameStatistics(p->swapchain, &stats); if (hr == DXGI_ERROR_FRAME_STATISTICS_DISJOINT) { p->last_sync_refresh_count = 0; p->last_sync_qpc_time = 0; } if (FAILED(hr)) return;
// Detecting skipped vsyncs is possible but not supported yet info->skipped_vsyncs = -1;
// Get the number of physical vsyncs that have passed since the last call. // Check for 0 here, since sometimes GetFrameStatistics returns S_OK but // with 0s in some (all?) members of DXGI_FRAME_STATISTICS. unsigned src_passed = 0; if (stats.SyncRefreshCount && p->last_sync_refresh_count) src_passed = stats.SyncRefreshCount - p->last_sync_refresh_count; p->last_sync_refresh_count = stats.SyncRefreshCount;
// Get the elapsed time passed between the above vsyncs unsigned sqt_passed = 0; if (stats.SyncQPCTime.QuadPart && p->last_sync_qpc_time) sqt_passed = stats.SyncQPCTime.QuadPart - p->last_sync_qpc_time; p->last_sync_qpc_time = stats.SyncQPCTime.QuadPart;
// If any vsyncs have passed, estimate the physical frame rate if (src_passed && sqt_passed) p->vsync_duration_qpc = sqt_passed / src_passed; if (p->vsync_duration_qpc) info->vsync_duration = qpc_to_ns(sw, p->vsync_duration_qpc);
// If the physical frame rate is known and the other members of // DXGI_FRAME_STATISTICS are non-0, estimate the timing of the next frame if (p->vsync_duration_qpc && stats.PresentCount && stats.PresentRefreshCount && stats.SyncRefreshCount && stats.SyncQPCTime.QuadPart) { // It's not clear if PresentRefreshCount and SyncRefreshCount can refer // to different frames, but in case they can, assuming mpv presents on // every frame, guess the present count that relates to SyncRefreshCount. unsigned expected_sync_pc = stats.PresentCount + (stats.SyncRefreshCount - stats.PresentRefreshCount);
// Now guess the timestamp of the last submitted frame based on the // timestamp of the frame at SyncRefreshCount and the frame rate int queued_frames = submit_count - expected_sync_pc; int64_t last_queue_display_time_qpc = stats.SyncQPCTime.QuadPart + queued_frames * p->vsync_duration_qpc;
// Only set the estimated display time if it's after the last submission // time. It could be before if mpv skips a lot of frames. if (last_queue_display_time_qpc >= p->last_submit_qpc) { info->last_queue_display_time = mp_time_ns() + (qpc_to_ns(sw, last_queue_display_time_qpc) - qpc_ns_now(sw)); } }}
static bool d3d11_set_fullscreen(struct ra_ctx *ctx){ struct priv *p = ctx->priv; HRESULT hr;
m_config_cache_update(p->opts_cache);
if (!p->swapchain) { MP_ERR(ctx, "Full screen configuration was requested before D3D11 " "swap chain was ready!"); return false; }
// we only want exclusive FS if we are entering FS and // exclusive FS is enabled. Otherwise disable exclusive FS. bool enable_exclusive_fs = p->vo_opts->fullscreen && p->opts->exclusive_fs;
MP_VERBOSE(ctx, "%s full-screen exclusive mode while %s fullscreen\n", enable_exclusive_fs ? "Enabling" : "Disabling", ctx->vo->opts->fullscreen ? "entering" : "leaving");
hr = IDXGISwapChain_SetFullscreenState(p->swapchain, enable_exclusive_fs, NULL); if (FAILED(hr)) return false;
if (!resize(ctx)) return false;
return true;}
static int d3d11_control(struct ra_ctx *ctx, int *events, int request, void *arg){ struct priv *p = ctx->priv; int ret = -1; bool fullscreen_switch_needed = false;
switch (request) { case VOCTRL_VO_OPTS_CHANGED: { void *changed_option;
while (m_config_cache_get_next_changed(p->vo_opts_cache, &changed_option)) { struct mp_vo_opts *vo_opts = p->vo_opts_cache->opts;
if (changed_option == &vo_opts->fullscreen) { fullscreen_switch_needed = true; } }
break; } default: break; }
// if leaving full screen, handle d3d11 stuff first, then general // windowing if (fullscreen_switch_needed && !p->vo_opts->fullscreen) { if (!d3d11_set_fullscreen(ctx)) return VO_FALSE;
fullscreen_switch_needed = false; }
ret = vo_w32_control(ctx->vo, events, request, arg);
// if entering full screen, handle d3d11 after general windowing stuff if (fullscreen_switch_needed && p->vo_opts->fullscreen) { if (!d3d11_set_fullscreen(ctx)) return VO_FALSE;
fullscreen_switch_needed = false; }
if (*events & VO_EVENT_RESIZE) { if (!resize(ctx)) return VO_ERROR; } return ret;}
static void d3d11_uninit(struct ra_ctx *ctx){ struct priv *p = ctx->priv;
if (p->swapchain) IDXGISwapChain_SetFullscreenState(p->swapchain, FALSE, NULL);
if (ctx->ra) ra_tex_free(ctx->ra, &p->backbuffer); SAFE_RELEASE(p->swapchain); vo_w32_uninit(ctx->vo); SAFE_RELEASE(p->device);
// Destroy the RA last to prevent objects we hold from showing up in D3D's // leak checker if (ctx->ra) ctx->ra->fns->destroy(ctx->ra);}
static const struct ra_swapchain_fns d3d11_swapchain = { .color_depth = d3d11_color_depth, .target_csp = d3d11_target_color_space, .start_frame = d3d11_start_frame, .submit_frame = d3d11_submit_frame, .swap_buffers = d3d11_swap_buffers, .get_vsync = d3d11_get_vsync,};
static bool d3d11_init(struct ra_ctx *ctx){ struct priv *p = ctx->priv = talloc_zero(ctx, struct priv); p->opts_cache = m_config_cache_alloc(ctx, ctx->global, &d3d11_conf); p->opts = p->opts_cache->opts;
p->vo_opts_cache = m_config_cache_alloc(ctx, ctx->vo->global, &vo_sub_opts); p->vo_opts = p->vo_opts_cache->opts;
LARGE_INTEGER perf_freq; QueryPerformanceFrequency(&perf_freq); p->perf_freq = perf_freq.QuadPart;
struct ra_swapchain *sw = ctx->swapchain = talloc_zero(ctx, struct ra_swapchain); sw->priv = p; sw->ctx = ctx; sw->fns = &d3d11_swapchain;
struct d3d11_device_opts dopts = { .debug = ctx->opts.debug, .allow_warp = p->opts->warp != 0, .force_warp = p->opts->warp == 1, .max_feature_level = p->opts->feature_level, .max_frame_latency = ctx->vo->opts->swapchain_depth, .adapter_name = p->opts->adapter_name, }; if (!mp_d3d11_create_present_device(ctx->log, &dopts, &p->device)) goto error;
if (!spirv_compiler_init(ctx)) goto error; ctx->ra = ra_d3d11_create(p->device, ctx->log, ctx->spirv); if (!ctx->ra) goto error;
if (!vo_w32_init(ctx->vo)) goto error;
if (ctx->opts.want_alpha) vo_w32_set_transparency(ctx->vo, ctx->opts.want_alpha);
UINT usage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT; if (ID3D11Device_GetFeatureLevel(p->device) >= D3D_FEATURE_LEVEL_11_0 && p->opts->output_format != DXGI_FORMAT_B8G8R8A8_UNORM) { usage |= DXGI_USAGE_UNORDERED_ACCESS; }
struct d3d11_swapchain_opts scopts = { .window = vo_w32_hwnd(ctx->vo), .width = ctx->vo->dwidth, .height = ctx->vo->dheight, .format = p->opts->output_format, .color_space = p->opts->color_space, .configured_csp = &p->swapchain_csp, .flip = p->opts->flip, // Add one frame for the backbuffer and one frame of "slack" to reduce // contention with the window manager when acquiring the backbuffer .length = ctx->vo->opts->swapchain_depth + 2, .usage = usage, }; if (!mp_d3d11_create_swapchain(p->device, ctx->log, &scopts, &p->swapchain)) goto error;
return true;
error: d3d11_uninit(ctx); return false;}
static void d3d11_update_render_opts(struct ra_ctx *ctx){ vo_w32_set_transparency(ctx->vo, ctx->opts.want_alpha);}
IDXGISwapChain *ra_d3d11_ctx_get_swapchain(struct ra_ctx *ra){ if (ra->swapchain->fns != &d3d11_swapchain) return NULL;
struct priv *p = ra->priv;
IDXGISwapChain_AddRef(p->swapchain);
return p->swapchain;}
bool ra_d3d11_ctx_prefer_8bit_output_format(struct ra_ctx *ra){ if (ra->swapchain->fns != &d3d11_swapchain) return false;
struct priv *p = ra->priv;
return p->opts->output_format == DXGI_FORMAT_R8G8B8A8_UNORM;}
const struct ra_ctx_fns ra_ctx_d3d11 = { .type = "d3d11", .name = "d3d11", .description = "Direct3D 11", .reconfig = d3d11_reconfig, .control = d3d11_control, .update_render_opts = d3d11_update_render_opts, .init = d3d11_init, .uninit = d3d11_uninit,};