diff options
Diffstat (limited to 'video/out/gpu_next/context.c')
| -rw-r--r-- | video/out/gpu_next/context.c | 237 |
1 files changed, 237 insertions, 0 deletions
diff --git a/video/out/gpu_next/context.c b/video/out/gpu_next/context.c new file mode 100644 index 0000000000..2c7c9fa21e --- /dev/null +++ b/video/out/gpu_next/context.c @@ -0,0 +1,237 @@ +/* + * 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 <https://www.gnu.org/licenses/>. + */ + +#include <libplacebo/config.h> + +#ifdef PL_HAVE_D3D11 +#include <libplacebo/d3d11.h> +#endif + +#ifdef PL_HAVE_OPENGL +#include <libplacebo/opengl.h> +#endif + +#include "context.h" +#include "config.h" +#include "common/common.h" +#include "options/m_config.h" +#include "video/out/placebo/utils.h" +#include "video/out/gpu/video.h" + +#if HAVE_D3D11 +#include "osdep/windows_utils.h" +#include "video/out/d3d11/ra_d3d11.h" +#include "video/out/d3d11/context.h" +#endif + +#if HAVE_GL +#include "video/out/opengl/context.h" +#include "video/out/opengl/ra_gl.h" +# if HAVE_EGL +#include <EGL/egl.h> +# endif +#endif + +#if HAVE_VULKAN +#include "video/out/vulkan/context.h" +#endif + +#if HAVE_D3D11 +static bool d3d11_pl_init(struct vo *vo, struct gpu_ctx *ctx, + struct ra_ctx_opts *ctx_opts) +{ +#if !defined(PL_HAVE_D3D11) + MP_MSG(ctx, vo->probing ? MSGL_V : MSGL_ERR, + "libplacebo was built without D3D11 support.\n"); + return false; +#else // defined(PL_HAVE_D3D11) + bool success = false; + + ID3D11Device *device = ra_d3d11_get_device(ctx->ra_ctx->ra); + IDXGISwapChain *swapchain = ra_d3d11_ctx_get_swapchain(ctx->ra_ctx); + if (!device || !swapchain) { + mp_err(ctx->log, + "Failed to receive required components from the mpv d3d11 " + "context! (device: %s, swap chain: %s)\n", + device ? "OK" : "failed", + swapchain ? "OK" : "failed"); + goto err_out; + } + + pl_d3d11 d3d11 = pl_d3d11_create(ctx->pllog, + pl_d3d11_params( + .device = device, + ) + ); + if (!d3d11) { + mp_err(ctx->log, "Failed to acquire a d3d11 libplacebo context!\n"); + goto err_out; + } + ctx->gpu = d3d11->gpu; + + mppl_log_set_probing(ctx->pllog, false); + + ctx->swapchain = pl_d3d11_create_swapchain(d3d11, + pl_d3d11_swapchain_params( + .swapchain = swapchain, + .disable_10bit_sdr = ra_d3d11_ctx_prefer_8bit_output_format(ctx->ra_ctx), + ) + ); + if (!ctx->swapchain) { + mp_err(ctx->log, "Failed to acquire a d3d11 libplacebo swap chain!\n"); + goto err_out; + } + + success = true; + +err_out: + SAFE_RELEASE(swapchain); + SAFE_RELEASE(device); + + return success; +#endif // defined(PL_HAVE_D3D11) +} +#endif // HAVE_D3D11 + +struct gpu_ctx *gpu_ctx_create(struct vo *vo, struct ra_ctx_opts *ctx_opts) +{ + struct gpu_ctx *ctx = talloc_zero(NULL, struct gpu_ctx); + ctx->log = vo->log; + ctx->ra_ctx = ra_ctx_create(vo, *ctx_opts); + if (!ctx->ra_ctx) + goto err_out; + +#if HAVE_VULKAN + struct mpvk_ctx *vkctx = ra_vk_ctx_get(ctx->ra_ctx); + if (vkctx) { + ctx->pllog = vkctx->pllog; + ctx->gpu = vkctx->gpu; + ctx->swapchain = vkctx->swapchain; + return ctx; + } +#endif + + ctx->pllog = mppl_log_create(ctx, ctx->log); + if (!ctx->pllog) + goto err_out; + + mppl_log_set_probing(ctx->pllog, vo->probing); + +#if HAVE_D3D11 + if (ra_is_d3d11(ctx->ra_ctx->ra)) { + if (!d3d11_pl_init(vo, ctx, ctx_opts)) + goto err_out; + + return ctx; + } +#endif + +#if HAVE_GL && defined(PL_HAVE_OPENGL) + if (ra_is_gl(ctx->ra_ctx->ra)) { + struct GL *gl = ra_gl_get(ctx->ra_ctx->ra); + struct pl_opengl_params params = *pl_opengl_params( + .debug = ctx_opts->debug, + .allow_software = ctx_opts->allow_sw, + .get_proc_addr_ex = (void *) gl->get_fn, + .proc_ctx = gl->fn_ctx, + ); +# if HAVE_EGL + params.egl_display = eglGetCurrentDisplay(); + params.egl_context = eglGetCurrentContext(); +# endif + pl_opengl opengl = pl_opengl_create(ctx->pllog, ¶ms); + if (!opengl) + goto err_out; + ctx->gpu = opengl->gpu; + + mppl_log_set_probing(ctx->pllog, false); + + ctx->swapchain = pl_opengl_create_swapchain(opengl, pl_opengl_swapchain_params( + .max_swapchain_depth = vo->opts->swapchain_depth, + .framebuffer.flipped = gl->flipped, + )); + if (!ctx->swapchain) + goto err_out; + + return ctx; + } +#elif HAVE_GL + if (ra_is_gl(ctx->ra_ctx->ra)) { + MP_MSG(ctx, vo->probing ? MSGL_V : MSGL_ERR, + "libplacebo was built without OpenGL support.\n"); + } +#endif + +err_out: + gpu_ctx_destroy(&ctx); + return NULL; +} + +bool gpu_ctx_resize(struct gpu_ctx *ctx, int w, int h) +{ +#if HAVE_VULKAN + if (ra_vk_ctx_get(ctx->ra_ctx)) + // vulkan RA handles this by itself + return true; +#endif + + return pl_swapchain_resize(ctx->swapchain, &w, &h); +} + +void gpu_ctx_destroy(struct gpu_ctx **ctxp) +{ + struct gpu_ctx *ctx = *ctxp; + if (!ctx) + return; + if (!ctx->ra_ctx) + goto skip_common_pl_cleanup; + +#if HAVE_VULKAN + if (ra_vk_ctx_get(ctx->ra_ctx)) + // vulkan RA context handles pl cleanup by itself, + // skip common local clean-up. + goto skip_common_pl_cleanup; +#endif + + if (ctx->swapchain) + pl_swapchain_destroy(&ctx->swapchain); + + if (ctx->gpu) { +#if HAVE_GL && defined(PL_HAVE_OPENGL) + if (ra_is_gl(ctx->ra_ctx->ra)) { + pl_opengl opengl = pl_opengl_get(ctx->gpu); + pl_opengl_destroy(&opengl); + } +#endif + +#if HAVE_D3D11 && defined(PL_HAVE_D3D11) + if (ra_is_d3d11(ctx->ra_ctx->ra)) { + pl_d3d11 d3d11 = pl_d3d11_get(ctx->gpu); + pl_d3d11_destroy(&d3d11); + } +#endif + } + + if (ctx->pllog) + pl_log_destroy(&ctx->pllog); + +skip_common_pl_cleanup: + ra_ctx_destroy(&ctx->ra_ctx); + + talloc_free(ctx); + *ctxp = NULL; +} |