mirror of
https://github.com/mpv-player/mpv
synced 2024-12-12 18:06:18 +00:00
a160405284
Another fix for the crazy and insane nvidia preemption behavior. This time, the situation is that we are using vo_opengl with vdpau interop, and that vdpau got preempted in the background while mpv was sitting idly. This can be e.g. reproduced by using: --force-window=immediate --idle --hwdec=vdpau and switching VTs. Then after switching back, load a video file. This will not let mp_vdpau_handle_preemption() perform preemption recovery, simply because it will do so only once vdp_decoder_create() has been called. There are some other API calls which trigger preemption, but many don't. Due to the way the libavcodec API works, vdp_decoder_create() is way too late. It does so when get_format returns. It notices creating the decoder fails, and continues calling get_format without the vdpau format. We could perhaps force it to reinit again (by adding a call to vdpau.c, that checks for preemption, and sets hwdec_request_reinit), but this seems too much of a mess. Solve it by calling API in mp_vdpau_handle_preemption() that empirically does trigger preemption: output_surface_put_bits_native(). This call is useless, and in fact should be doing nothing (empty update VdpRect). There's the slight chance that in theory it will slow down operation, but in practice it's bound to be harmless. It's the likely cheapest and simplest API call I've found that can trigger the fallback this way. (The driver is closed source, so it was up to trial & error.) Also, when initializing decoding, allow initial preemption recovery, which is needed to pass the test mention above.
102 lines
3.1 KiB
C
102 lines
3.1 KiB
C
#ifndef MPV_VDPAU_H
|
|
#define MPV_VDPAU_H
|
|
|
|
#include <stdbool.h>
|
|
#include <inttypes.h>
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <vdpau/vdpau.h>
|
|
#include <vdpau/vdpau_x11.h>
|
|
|
|
#include "common/msg.h"
|
|
#include "hwdec.h"
|
|
|
|
#define CHECK_VDP_ERROR_ST(ctx, message, statement) \
|
|
do { \
|
|
if (vdp_st != VDP_STATUS_OK) { \
|
|
MP_ERR(ctx, "%s: %s\n", message, vdp->get_error_string(vdp_st)); \
|
|
statement \
|
|
} \
|
|
} while (0)
|
|
|
|
#define CHECK_VDP_ERROR(ctx, message) \
|
|
CHECK_VDP_ERROR_ST(ctx, message, return -1;)
|
|
|
|
#define CHECK_VDP_WARNING(ctx, message) \
|
|
do { \
|
|
if (vdp_st != VDP_STATUS_OK) \
|
|
MP_WARN(ctx, "%s: %s\n", message, vdp->get_error_string(vdp_st)); \
|
|
} while (0)
|
|
|
|
struct vdp_functions {
|
|
#define VDP_FUNCTION(vdp_type, _, mp_name) vdp_type *mp_name;
|
|
#include "video/vdpau_functions.inc"
|
|
#undef VDP_FUNCTION
|
|
};
|
|
|
|
|
|
#define MAX_VIDEO_SURFACES 50
|
|
|
|
// Shared state. Objects created from different VdpDevices are often (always?)
|
|
// incompatible to each other, so all code must use a shared VdpDevice.
|
|
struct mp_vdpau_ctx {
|
|
struct mp_log *log;
|
|
Display *x11;
|
|
|
|
struct mp_hwdec_ctx hwctx;
|
|
|
|
// These are mostly immutable, except on preemption. We don't really care
|
|
// to synchronize the preemption case fully correctly, because it's an
|
|
// extremely obscure corner case, and basically a vdpau API design bug.
|
|
// What we do will sort-of work anyway (no memory errors are possible).
|
|
struct vdp_functions vdp;
|
|
VdpGetProcAddress *get_proc_address;
|
|
VdpDevice vdp_device;
|
|
|
|
pthread_mutex_t preempt_lock;
|
|
bool is_preempted; // set to true during unavailability
|
|
uint64_t preemption_counter; // incremented after _restoring_
|
|
bool preemption_user_notified;
|
|
double last_preemption_retry_fail;
|
|
VdpOutputSurface preemption_obj; // dummy for reliable preempt. check
|
|
|
|
// Surface pool
|
|
pthread_mutex_t pool_lock;
|
|
int64_t age_counter;
|
|
struct surface_entry {
|
|
VdpVideoSurface surface;
|
|
VdpOutputSurface osurface;
|
|
bool allocated;
|
|
int w, h;
|
|
VdpRGBAFormat rgb_format;
|
|
VdpChromaType chroma;
|
|
bool rgb;
|
|
bool in_use;
|
|
int64_t age;
|
|
} video_surfaces[MAX_VIDEO_SURFACES];
|
|
struct mp_vdpau_mixer *getimg_mixer;
|
|
VdpOutputSurface getimg_surface;
|
|
int getimg_w, getimg_h;
|
|
};
|
|
|
|
struct mp_vdpau_ctx *mp_vdpau_create_device_x11(struct mp_log *log, Display *x11,
|
|
bool probing);
|
|
void mp_vdpau_destroy(struct mp_vdpau_ctx *ctx);
|
|
|
|
int mp_vdpau_handle_preemption(struct mp_vdpau_ctx *ctx, uint64_t *counter);
|
|
|
|
struct mp_image *mp_vdpau_get_video_surface(struct mp_vdpau_ctx *ctx,
|
|
VdpChromaType chroma, int w, int h);
|
|
|
|
bool mp_vdpau_get_format(int imgfmt, VdpChromaType *out_chroma_type,
|
|
VdpYCbCrFormat *out_pixel_format);
|
|
bool mp_vdpau_get_rgb_format(int imgfmt, VdpRGBAFormat *out_rgba_format);
|
|
|
|
struct mp_image *mp_vdpau_upload_video_surface(struct mp_vdpau_ctx *ctx,
|
|
struct mp_image *mpi);
|
|
|
|
bool mp_vdpau_guess_if_emulated(struct mp_vdpau_ctx *ctx);
|
|
|
|
#endif
|