RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity
mpv/video/out/vo_libmpv.c

751 lines
22 KiB
C
Raw Blame History

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpv_talloc.h"
#include "common/common.h"
#include "misc/bstr.h"
#include "misc/dispatch.h"
#include "common/msg.h"
#include "options/m_config.h"
#include "options/options.h"
#include "aspect.h"
#include "dr_helper.h"
#include "vo.h"
#include "video/mp_image.h"
#include "sub/osd.h"
#include "osdep/threads.h"
#include "osdep/timer.h"
#include "common/global.h"
#include "player/client.h"
#include "libmpv.h"
/*
* mpv_render_context is managed by the host application - the host application
* can access it any time, even if the VO is destroyed (or not created yet).
*
* - the libmpv user can mix render API and normal API; thus render API
* functions can wait on the core, but not the reverse
* - the core does blocking calls into the VO thread, thus the VO functions
* can't wait on the user calling the API functions
* - to make video timing work like it should, the VO thread waits on the
* render API user anyway, and the (unlikely) deadlock is avoided with
* a timeout
*
* Locking: mpv core > VO > mpv_render_context.lock > mp_client_api.lock
* > mpv_render_context.update_lock
* And: render thread > VO (wait for present)
* VO > render thread (wait for present done, via timeout)
*
* Locking gets more complex with advanced_control enabled. Use
* mpv_render_context.dispatch with care; synchronous calls can add lock
* dependencies.
*/
struct vo_priv {
struct mpv_render_context *ctx; // immutable after init
};
struct mpv_render_context {
struct mp_log *log;
struct mpv_global *global;
struct mp_client_api *client_api;
atomic_bool in_use;
// --- Immutable after init
struct mp_dispatch_queue *dispatch;
bool advanced_control;
struct dr_helper *dr; // NULL if advanced_control disabled
mp_mutex control_lock;
// --- Protected by control_lock
mp_render_cb_control_fn control_cb;
void *control_cb_ctx;
mp_mutex update_lock;
mp_cond update_cond; // paired with update_lock
// --- Protected by update_lock
mpv_render_update_fn update_cb;
void *update_cb_ctx;
mp_mutex lock;
mp_cond video_wait; // paired with lock
// --- Protected by lock
struct vo_frame *next_frame; // next frame to draw
int64_t present_count; // incremented when next frame can be shown
int64_t expected_flip_count; // next vsync event for next_frame
bool redrawing; // next_frame was a redraw request
int64_t flip_count;
struct vo_frame *cur_frame;
struct mp_image_params img_params;
int vp_w, vp_h;
bool flip;
bool imgfmt_supported[IMGFMT_END - IMGFMT_START];
bool need_reconfig;
bool need_resize;
bool need_reset;
bool need_update_external;
struct vo *vo;
// --- Mostly immutable after init.
struct mp_hwdec_devices *hwdec_devs;
// --- All of these can only be accessed from mpv_render_*() API, for
// which the user makes sure they're called synchronized.
struct render_backend *renderer;
struct m_config_cache *vo_opts_cache;
struct mp_vo_opts *vo_opts;
};
const struct render_backend_fns *render_backends[] = {
&render_backend_gpu,
&render_backend_sw,
NULL
};
static void update(struct mpv_render_context *ctx)
{
mp_mutex_lock(&ctx->update_lock);
if (ctx->update_cb)
ctx->update_cb(ctx->update_cb_ctx);
mp_cond_broadcast(&ctx->update_cond);
mp_mutex_unlock(&ctx->update_lock);
}
void *get_mpv_render_param(mpv_render_param *params, mpv_render_param_type type,
void *def)
{
for (int n = 0; params && params[n].type; n++) {
if (params[n].type == type)
return params[n].data;
}
return def;
}
static void forget_frames(struct mpv_render_context *ctx, bool all)
{
mp_cond_broadcast(&ctx->video_wait);
if (all) {
talloc_free(ctx->cur_frame);
ctx->cur_frame = NULL;
}
}
static void dispatch_wakeup(void *ptr)
{
struct mpv_render_context *ctx = ptr;
update(ctx);
}
static struct mp_image *render_get_image(void *ptr, int imgfmt, int w, int h,
int stride_align, int flags)
{
struct mpv_render_context *ctx = ptr;
return ctx->renderer->fns->get_image(ctx->renderer, imgfmt, w, h, stride_align, flags);
}
int mpv_render_context_create(mpv_render_context **res, mpv_handle *mpv,
mpv_render_param *params)
{
mpv_render_context *ctx = talloc_zero(NULL, mpv_render_context);
mp_mutex_init(&ctx->control_lock);
mp_mutex_init(&ctx->lock);
mp_mutex_init(&ctx->update_lock);
mp_cond_init(&ctx->update_cond);
mp_cond_init(&ctx->video_wait);
ctx->global = mp_client_get_global(mpv);
ctx->client_api = ctx->global->client_api;
ctx->log = mp_log_new(ctx, ctx->global->log, "libmpv_render");
ctx->vo_opts_cache = m_config_cache_alloc(ctx, ctx->global, &vo_sub_opts);
ctx->vo_opts = ctx->vo_opts_cache->opts;
ctx->dispatch = mp_dispatch_create(ctx);
mp_dispatch_set_wakeup_fn(ctx->dispatch, dispatch_wakeup, ctx);
if (GET_MPV_RENDER_PARAM(params, MPV_RENDER_PARAM_ADVANCED_CONTROL, int, 0))
ctx->advanced_control = true;
int err = MPV_ERROR_NOT_IMPLEMENTED;
for (int n = 0; render_backends[n]; n++) {
ctx->renderer = talloc_zero(NULL, struct render_backend);
*ctx->renderer = (struct render_backend){
.global = ctx->global,
.log = ctx->log,
.fns = render_backends[n],
};
err = ctx->renderer->fns->init(ctx->renderer, params);
if (err >= 0)
break;
ctx->renderer->fns->destroy(ctx->renderer);
talloc_free(ctx->renderer->priv);
TA_FREEP(&ctx->renderer);
if (err != MPV_ERROR_NOT_IMPLEMENTED)
break;
}
if (err < 0) {
mpv_render_context_free(ctx);
return err;
}
ctx->hwdec_devs = ctx->renderer->hwdec_devs;
for (int n = IMGFMT_START; n < IMGFMT_END; n++) {
ctx->imgfmt_supported[n - IMGFMT_START] =
ctx->renderer->fns->check_format(ctx->renderer, n);
}
if (ctx->renderer->fns->get_image && ctx->advanced_control)
ctx->dr = dr_helper_create(ctx->dispatch, render_get_image, ctx);
if (!mp_set_main_render_context(ctx->client_api, ctx, true)) {
MP_ERR(ctx, "There is already a mpv_render_context set.\n");
mpv_render_context_free(ctx);
return MPV_ERROR_GENERIC;
}
*res = ctx;
return 0;
}
void mpv_render_context_set_update_callback(mpv_render_context *ctx,
mpv_render_update_fn callback,
void *callback_ctx)
{
mp_mutex_lock(&ctx->update_lock);
ctx->update_cb = callback;
ctx->update_cb_ctx = callback_ctx;
if (ctx->update_cb)
ctx->update_cb(ctx->update_cb_ctx);
mp_mutex_unlock(&ctx->update_lock);
}
void mp_render_context_set_control_callback(mpv_render_context *ctx,
mp_render_cb_control_fn callback,
void *callback_ctx)
{
mp_mutex_lock(&ctx->control_lock);
ctx->control_cb = callback;
ctx->control_cb_ctx = callback_ctx;
mp_mutex_unlock(&ctx->control_lock);
}
void mpv_render_context_free(mpv_render_context *ctx)
{
if (!ctx)
return;
// From here on, ctx becomes invisible and cannot be newly acquired. Only
// a VO could still hold a reference.
mp_set_main_render_context(ctx->client_api, ctx, false);
if (atomic_load(&ctx->in_use)) {
// Start destroy the VO, and also bring down the decoder etc., which
// still might be using the hwdec context or use DR images. The above
// mp_set_main_render_context() call guarantees it can't come back (so
// ctx->vo can't change to non-NULL).
// In theory, this races with vo_libmpv exiting and another VO being
// used, which is a harmless grotesque corner case.
kill_video_async(ctx->client_api);
while (atomic_load(&ctx->in_use)) {
// As a nasty detail, we need to wait until the VO is released, but
// also need to react to update() calls during it (the update calls
// are supposed to trigger processing ctx->dispatch). We solve this
// by making the VO uninit function call mp_dispatch_interrupt().
//
// Other than that, processing ctx->dispatch is needed to serve the
// video decoder, which might still not be fully destroyed, and e.g.
// performs calls to release DR images (or, as a grotesque corner
// case may even try to allocate new ones).
//
// Once the VO is released, ctx->dispatch becomes truly inactive.
// (The libmpv API user could call mpv_render_context_update() while
// mpv_render_context_free() is being called, but of course this is
// invalid.)
mp_dispatch_queue_process(ctx->dispatch, INFINITY);
}
}
mp_mutex_lock(&ctx->lock);
// Barrier - guarantee uninit() has left the lock region. It will access ctx
// until the lock has been released, so we must not proceed with destruction
// before we can acquire the lock. (The opposite, uninit() acquiring the
// lock, can not happen anymore at this point - we've waited for VO uninit,
// and prevented that new VOs can be created.)
mp_mutex_unlock(&ctx->lock);
assert(!atomic_load(&ctx->in_use));
assert(!ctx->vo);
// With the dispatch queue not being served anymore, allow frame free
// requests from this thread to be served directly.
if (ctx->dr)
dr_helper_acquire_thread(ctx->dr);
// Possibly remaining outstanding work.
mp_dispatch_queue_process(ctx->dispatch, 0);
forget_frames(ctx, true);
if (ctx->renderer) {
ctx->renderer->fns->destroy(ctx->renderer);
talloc_free(ctx->renderer->priv);
talloc_free(ctx->renderer);
}
talloc_free(ctx->dr);
talloc_free(ctx->dispatch);
mp_cond_destroy(&ctx->update_cond);
mp_cond_destroy(&ctx->video_wait);
mp_mutex_destroy(&ctx->update_lock);
mp_mutex_destroy(&ctx->lock);
mp_mutex_destroy(&ctx->control_lock);
talloc_free(ctx);
}
// Try to mark the context as "in exclusive use" (e.g. by a VO).
// Note: the function must not acquire any locks, because it's called with an
// external leaf lock held.
bool mp_render_context_acquire(mpv_render_context *ctx)
{
bool prev = false;
return atomic_compare_exchange_strong(&ctx->in_use, &prev, true);
}
int mpv_render_context_render(mpv_render_context *ctx, mpv_render_param *params)
{
mp_mutex_lock(&ctx->lock);
int do_render =
!GET_MPV_RENDER_PARAM(params, MPV_RENDER_PARAM_SKIP_RENDERING, int, 0);
if (do_render) {
int vp_w, vp_h;
int err = ctx->renderer->fns->get_target_size(ctx->renderer, params,
&vp_w, &vp_h);
if (err < 0) {
mp_mutex_unlock(&ctx->lock);
return err;
}
if (ctx->vo && (ctx->vp_w != vp_w || ctx->vp_h != vp_h ||
ctx->need_resize))
{
ctx->vp_w = vp_w;
ctx->vp_h = vp_h;
m_config_cache_update(ctx->vo_opts_cache);
struct mp_rect src, dst;
struct mp_osd_res osd;
mp_get_src_dst_rects(ctx->log, ctx->vo_opts, ctx->vo->driver->caps,
&ctx->img_params, vp_w, abs(vp_h),
1.0, &src, &dst, &osd);
ctx->renderer->fns->resize(ctx->renderer, &src, &dst, &osd);
}
ctx->need_resize = false;
}
if (ctx->need_reconfig)
ctx->renderer->fns->reconfig(ctx->renderer, &ctx->img_params);
ctx->need_reconfig = false;
if (ctx->need_update_external)
ctx->renderer->fns->update_external(ctx->renderer, ctx->vo);
ctx->need_update_external = false;
if (ctx->need_reset) {
ctx->renderer->fns->reset(ctx->renderer);
if (ctx->cur_frame)
ctx->cur_frame->still = true;
}
ctx->need_reset = false;
struct vo_frame *frame = ctx->next_frame;
int64_t wait_present_count = ctx->present_count;
if (frame) {
ctx->next_frame = NULL;
if (!(frame->redraw || !frame->current))
wait_present_count += 1;
mp_cond_broadcast(&ctx->video_wait);
talloc_free(ctx->cur_frame);
ctx->cur_frame = vo_frame_ref(frame);
} else {
frame = vo_frame_ref(ctx->cur_frame);
if (frame)
frame->redraw = true;
MP_STATS(ctx, "glcb-noframe");
}
struct vo_frame dummy = {0};
if (!frame)
frame = &dummy;
mp_mutex_unlock(&ctx->lock);
MP_STATS(ctx, "glcb-render");
int err = 0;
if (do_render)
err = ctx->renderer->fns->render(ctx->renderer, params, frame);
if (frame != &dummy)
talloc_free(frame);
if (GET_MPV_RENDER_PARAM(params, MPV_RENDER_PARAM_BLOCK_FOR_TARGET_TIME,
int, 1))
{
mp_mutex_lock(&ctx->lock);
while (wait_present_count > ctx->present_count)
mp_cond_wait(&ctx->video_wait, &ctx->lock);
mp_mutex_unlock(&ctx->lock);
}
return err;
}
void mpv_render_context_report_swap(mpv_render_context *ctx)
{
MP_STATS(ctx, "glcb-reportflip");
mp_mutex_lock(&ctx->lock);
ctx->flip_count += 1;
mp_cond_broadcast(&ctx->video_wait);
mp_mutex_unlock(&ctx->lock);
}
uint64_t mpv_render_context_update(mpv_render_context *ctx)
{
uint64_t res = 0;
mp_dispatch_queue_process(ctx->dispatch, 0);
mp_mutex_lock(&ctx->lock);
if (ctx->next_frame)
res |= MPV_RENDER_UPDATE_FRAME;
mp_mutex_unlock(&ctx->lock);
return res;
}
int mpv_render_context_set_parameter(mpv_render_context *ctx,
mpv_render_param param)
{
return ctx->renderer->fns->set_parameter(ctx->renderer, param);
}
int mpv_render_context_get_info(mpv_render_context *ctx,
mpv_render_param param)
{
int res = MPV_ERROR_NOT_IMPLEMENTED;
mp_mutex_lock(&ctx->lock);
switch (param.type) {
case MPV_RENDER_PARAM_NEXT_FRAME_INFO: {
mpv_render_frame_info *info = param.data;
*info = (mpv_render_frame_info){0};
struct vo_frame *frame = ctx->next_frame;
if (frame) {
info->flags =
MPV_RENDER_FRAME_INFO_PRESENT |
(frame->redraw ? MPV_RENDER_FRAME_INFO_REDRAW : 0) |
(frame->repeat ? MPV_RENDER_FRAME_INFO_REPEAT : 0) |
(frame->display_synced && !frame->redraw ?
MPV_RENDER_FRAME_INFO_BLOCK_VSYNC : 0);
info->target_time = frame->pts;
}
res = 0;
break;
}
default:;
}
mp_mutex_unlock(&ctx->lock);
return res;
}
static void draw_frame(struct vo *vo, struct vo_frame *frame)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
mp_mutex_lock(&ctx->lock);
assert(!ctx->next_frame);
ctx->next_frame = vo_frame_ref(frame);
ctx->expected_flip_count = ctx->flip_count + 1;
ctx->redrawing = frame->redraw || !frame->current;
mp_mutex_unlock(&ctx->lock);
update(ctx);
}
static void flip_page(struct vo *vo)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
int64_t until = mp_time_ns() + MP_TIME_MS_TO_NS(200);
mp_mutex_lock(&ctx->lock);
// Wait until frame was rendered
while (ctx->next_frame) {
if (mp_cond_timedwait_until(&ctx->video_wait, &ctx->lock, until)) {
if (ctx->next_frame) {
MP_VERBOSE(vo, "mpv_render_context_render() not being called "
"or stuck.\n");
goto done;
}
}
}
// Unblock mpv_render_context_render().
ctx->present_count += 1;
mp_cond_broadcast(&ctx->video_wait);
if (ctx->redrawing)
goto done; // do not block for redrawing
// Wait until frame was presented
while (ctx->expected_flip_count > ctx->flip_count) {
// mpv_render_report_swap() is declared as optional API.
// Assume the user calls it consistently _if_ it's called at all.
if (!ctx->flip_count)
break;
if (mp_cond_timedwait_until(&ctx->video_wait, &ctx->lock, until)) {
MP_VERBOSE(vo, "mpv_render_report_swap() not being called.\n");
goto done;
}
}
done:
// Cleanup after the API user is not reacting, or is being unusually slow.
if (ctx->next_frame) {
talloc_free(ctx->cur_frame);
ctx->cur_frame = ctx->next_frame;
ctx->next_frame = NULL;
ctx->present_count += 2;
mp_cond_signal(&ctx->video_wait);
vo_increment_drop_count(vo, 1);
}
mp_mutex_unlock(&ctx->lock);
}
static int query_format(struct vo *vo, int format)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
bool ok = false;
mp_mutex_lock(&ctx->lock);
if (format >= IMGFMT_START && format < IMGFMT_END)
ok = ctx->imgfmt_supported[format - IMGFMT_START];
mp_mutex_unlock(&ctx->lock);
return ok;
}
static void run_control_on_render_thread(void *p)
{
void **args = p;
struct mpv_render_context *ctx = args[0];
int request = (intptr_t)args[1];
void *data = args[2];
int ret = VO_NOTIMPL;
switch (request) {
case VOCTRL_SCREENSHOT: {
mp_mutex_lock(&ctx->lock);
struct vo_frame *frame = vo_frame_ref(ctx->cur_frame);
mp_mutex_unlock(&ctx->lock);
if (frame && ctx->renderer->fns->screenshot)
ctx->renderer->fns->screenshot(ctx->renderer, frame, data);
talloc_free(frame);
break;
}
case VOCTRL_PERFORMANCE_DATA: {
if (ctx->renderer->fns->perfdata) {
ctx->renderer->fns->perfdata(ctx->renderer, data);
ret = VO_TRUE;
}
break;
}
}
*(int *)args[3] = ret;
}
static int control(struct vo *vo, uint32_t request, void *data)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
switch (request) {
case VOCTRL_RESET:
mp_mutex_lock(&ctx->lock);
forget_frames(ctx, false);
ctx->need_reset = true;
mp_mutex_unlock(&ctx->lock);
vo->want_redraw = true;
return VO_TRUE;
case VOCTRL_PAUSE:
vo->want_redraw = true;
return VO_TRUE;
case VOCTRL_SET_PANSCAN:
mp_mutex_lock(&ctx->lock);
ctx->need_resize = true;
mp_mutex_unlock(&ctx->lock);
vo->want_redraw = true;
return VO_TRUE;
case VOCTRL_UPDATE_RENDER_OPTS:
mp_mutex_lock(&ctx->lock);
ctx->need_update_external = true;
mp_mutex_unlock(&ctx->lock);
vo->want_redraw = true;
return VO_TRUE;
}
// VOCTRLs to be run on the renderer thread (if possible at all).
if (ctx->advanced_control) {
switch (request) {
case VOCTRL_SCREENSHOT:
case VOCTRL_PERFORMANCE_DATA: {
int ret;
void *args[] = {ctx, (void *)(intptr_t)request, data, &ret};
mp_dispatch_run(ctx->dispatch, run_control_on_render_thread, args);
return ret;
}
}
}
int r = VO_NOTIMPL;
mp_mutex_lock(&ctx->control_lock);
if (ctx->control_cb) {
int events = 0;
r = p->ctx->control_cb(vo, p->ctx->control_cb_ctx,
&events, request, data);
vo_event(vo, events);
}
mp_mutex_unlock(&ctx->control_lock);
return r;
}
static struct mp_image *get_image(struct vo *vo, int imgfmt, int w, int h,
int stride_align, int flags)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
if (ctx->dr)
return dr_helper_get_image(ctx->dr, imgfmt, w, h, stride_align, flags);
return NULL;
}
static int reconfig(struct vo *vo, struct mp_image_params *params)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
mp_mutex_lock(&ctx->lock);
forget_frames(ctx, true);
ctx->img_params = *params;
ctx->need_reconfig = true;
ctx->need_resize = true;
mp_mutex_unlock(&ctx->lock);
control(vo, VOCTRL_RECONFIG, NULL);
return 0;
}
static void uninit(struct vo *vo)
{
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx = p->ctx;
control(vo, VOCTRL_UNINIT, NULL);
mp_mutex_lock(&ctx->lock);
forget_frames(ctx, true);
ctx->img_params = (struct mp_image_params){0};
ctx->need_reconfig = true;
ctx->need_resize = true;
ctx->need_update_external = true;
ctx->need_reset = true;
ctx->vo = NULL;
// The following do not normally need ctx->lock, however, ctx itself may
// become invalid once we release ctx->lock.
bool prev_in_use = atomic_exchange(&ctx->in_use, false);
assert(prev_in_use); // obviously must have been set
mp_dispatch_interrupt(ctx->dispatch);
mp_mutex_unlock(&ctx->lock);
}
static int preinit(struct vo *vo)
{
#if !HAVE_MACOS_COCOA_CB
if (vo->probing)
return -1;
#endif
struct vo_priv *p = vo->priv;
struct mpv_render_context *ctx =
mp_client_api_acquire_render_context(vo->global->client_api);
p->ctx = ctx;
if (!ctx) {
if (!vo->probing)
MP_FATAL(vo, "No render context set.\n");
return -1;
}
mp_mutex_lock(&ctx->lock);
ctx->vo = vo;
ctx->need_resize = true;
ctx->need_update_external = true;
mp_mutex_unlock(&ctx->lock);
vo->hwdec_devs = ctx->hwdec_devs;
control(vo, VOCTRL_PREINIT, NULL);
return 0;
}
const struct vo_driver video_out_libmpv = {
.description = "render API for libmpv",
.name = "libmpv",
.caps = VO_CAP_ROTATE90,
.preinit = preinit,
.query_format = query_format,
.reconfig = reconfig,
.control = control,
.get_image_ts = get_image,
.draw_frame = draw_frame,
.flip_page = flip_page,
.uninit = uninit,
.priv_size = sizeof(struct vo_priv),
};
Reference in New Issue View Git Blame Copy Permalink