x11: cleanup, refactor

Move things that are used by vo_xv only into vo_xv, same for vo_x11.

Rename some functions exported by x11_common, like vo_init to
vo_x11_common. Make functions not used outsode of x11_common.c private
to that file. Eliminate all global variables defined by x11_common
(except error handler and colormap stuff).

There shouldn't be any functional changes, and only code is moved
around. There are some minor simplifications in the X11 init code, as
we completely remove the ability to initialize X11 and X11+VO
separately (see commit b4d9647 "mplayer: do not create X11 state in player frontend"),
and the respective functions are conflated into vo_x11_init() and
vo_x11_uninit().

1 files changed, 375 insertions, 33 deletions

diff --git a/video/out/vo_xv.c b/video/out/vo_xv.c
index 90cc112ad2..8d52db96fa 100644
--- a/video/out/vo_xv.c
+++ b/video/out/vo_xv.c
@@ -64,7 +64,21 @@ static const vo_info_t info = {
     ""
 };
 
+#define CK_METHOD_NONE       0 // no colorkey drawing
+#define CK_METHOD_BACKGROUND 1 // set colorkey as window background
+#define CK_METHOD_AUTOPAINT  2 // let xv draw the colorkey
+#define CK_METHOD_MANUALFILL 3 // manually draw the colorkey
+#define CK_SRC_USE           0 // use specified / default colorkey
+#define CK_SRC_SET           1 // use and set specified / default colorkey
+#define CK_SRC_CUR           2 // use current colorkey (get it from xv)
+
 struct xvctx {
+    struct xv_ck_info_s {
+        int method; // CK_METHOD_* constants
+        int source; // CK_SRC_* constants
+    } xv_ck_info;
+    unsigned long xv_colorkey;
+    unsigned int xv_port;
     XvAdaptorInfo *ai;
     XvImageFormatValues *fo;
     unsigned int formats, adaptors, xv_format;
@@ -116,14 +130,342 @@ static int find_xv_format(int imgfmt)
     return 0;
 }
 
-static void read_xv_csp(struct vo *vo)
+static int xv_find_atom(struct vo *vo, uint32_t xv_port, const char *name,
+                        bool get, int *min, int *max)
+{
+    Atom atom = None;
+    int howmany = 0;
+    XvAttribute *attributes = XvQueryPortAttributes(vo->x11->display, xv_port,
+                                                    &howmany);
+    for (int i = 0; i < howmany && attributes; i++) {
+        int flag = get ? XvGettable : XvSettable;
+        if (attributes[i].flags & flag) {
+            atom = XInternAtom(vo->x11->display, attributes[i].name, True);
+            *min = attributes[i].min_value;
+            *max = attributes[i].max_value;
+/* since we have SET_DEFAULTS first in our list, we can check if it's available
+   then trigger it if it's ok so that the other values are at default upon query */
+            if (atom != None) {
+                if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") &&
+                    (!strcasecmp(name, "brightness")))
+                    break;
+                else if (!strcmp(attributes[i].name, "XV_CONTRAST") &&
+                         (!strcasecmp(name, "contrast")))
+                    break;
+                else if (!strcmp(attributes[i].name, "XV_SATURATION") &&
+                         (!strcasecmp(name, "saturation")))
+                    break;
+                else if (!strcmp(attributes[i].name, "XV_HUE") &&
+                         (!strcasecmp(name, "hue")))
+                    break;
+                if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") &&
+                    (!strcasecmp(name, "red_intensity")))
+                    break;
+                else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY")
+                         && (!strcasecmp(name, "green_intensity")))
+                    break;
+                else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY")
+                         && (!strcasecmp(name, "blue_intensity")))
+                    break;
+                else if ((!strcmp(attributes[i].name, "XV_ITURBT_709") //NVIDIA
+                          || !strcmp(attributes[i].name, "XV_COLORSPACE")) //ATI
+                         && (!strcasecmp(name, "bt_709")))
+                    break;
+                atom = None;
+                continue;
+            }
+        }
+    }
+    XFree(attributes);
+    return atom;
+}
+
+static int xv_set_eq(struct vo *vo, uint32_t xv_port, const char *name,
+                     int value)
+{
+    mp_dbg(MSGT_VO, MSGL_V, "xv_set_eq called! (%s, %d)\n", name, value);
+
+    int min, max;
+    int atom = xv_find_atom(vo, xv_port, name, false, &min, &max);
+    if (atom != None) {
+        // -100 -> min
+        //   0  -> (max+min)/2
+        // +100 -> max
+        int port_value = (value + 100) * (max - min) / 200 + min;
+        XvSetPortAttribute(vo->x11->display, xv_port, atom, port_value);
+        return VO_TRUE;
+    }
+    return VO_FALSE;
+}
+
+static int xv_get_eq(struct vo *vo, uint32_t xv_port, const char *name,
+                     int *value)
+{
+    int min, max;
+    int atom = xv_find_atom(vo, xv_port, name, true, &min, &max);
+    if (atom != None) {
+        int port_value = 0;
+        XvGetPortAttribute(vo->x11->display, xv_port, atom, &port_value);
+
+        *value = (port_value - min) * 200 / (max - min) - 100;
+        mp_dbg(MSGT_VO, MSGL_V, "xv_get_eq called! (%s, %d)\n",
+               name, *value);
+        return VO_TRUE;
+    }
+    return VO_FALSE;
+}
+
+static Atom xv_intern_atom_if_exists(struct vo *vo, char const *atom_name)
+{
+    struct xvctx *ctx = vo->priv;
+    XvAttribute *attributes;
+    int attrib_count, i;
+    Atom xv_atom = None;
+
+    attributes = XvQueryPortAttributes(vo->x11->display, ctx->xv_port,
+                                       &attrib_count);
+    if (attributes != NULL) {
+        for (i = 0; i < attrib_count; ++i) {
+            if (strcmp(attributes[i].name, atom_name) == 0) {
+                xv_atom = XInternAtom(vo->x11->display, atom_name, False);
+                break;
+            }
+        }
+        XFree(attributes);
+    }
+
+    return xv_atom;
+}
+
+// Try to enable vsync for xv.
+// Returns -1 if not available, 0 on failure and 1 on success.
+static int xv_enable_vsync(struct vo *vo)
+{
+    struct xvctx *ctx = vo->priv;
+    Atom xv_atom = xv_intern_atom_if_exists(vo, "XV_SYNC_TO_VBLANK");
+    if (xv_atom == None)
+        return -1;
+    return XvSetPortAttribute(vo->x11->display, ctx->xv_port, xv_atom, 1)
+           == Success;
+}
+
+// Get maximum supported source image dimensions.
+// If querying the dimensions fails, don't change *width and *height.
+static void xv_get_max_img_dim(struct vo *vo, uint32_t *width, uint32_t *height)
+{
+    struct xvctx *ctx = vo->priv;
+    XvEncodingInfo *encodings;
+    unsigned int num_encodings, idx;
+
+    XvQueryEncodings(vo->x11->display, ctx->xv_port, &num_encodings, &encodings);
+
+    if (encodings) {
+        for (idx = 0; idx < num_encodings; ++idx) {
+            if (strcmp(encodings[idx].name, "XV_IMAGE") == 0) {
+                *width  = encodings[idx].width;
+                *height = encodings[idx].height;
+                break;
+            }
+        }
+    }
+
+    mp_msg(MSGT_VO, MSGL_V,
+           "[xv] Maximum source image dimensions: %ux%u\n",
+           *width, *height);
+
+    XvFreeEncodingInfo(encodings);
+}
+
+static void xv_print_ck_info(struct xvctx *xv)
+{
+    mp_msg(MSGT_VO, MSGL_V, "[xv] ");
+
+    switch (xv->xv_ck_info.method) {
+    case CK_METHOD_NONE:
+        mp_msg(MSGT_VO, MSGL_V, "Drawing no colorkey.\n");
+        return;
+    case CK_METHOD_AUTOPAINT:
+        mp_msg(MSGT_VO, MSGL_V, "Colorkey is drawn by Xv.");
+        break;
+    case CK_METHOD_MANUALFILL:
+        mp_msg(MSGT_VO, MSGL_V, "Drawing colorkey manually.");
+        break;
+    case CK_METHOD_BACKGROUND:
+        mp_msg(MSGT_VO, MSGL_V, "Colorkey is drawn as window background.");
+        break;
+    }
+
+    mp_msg(MSGT_VO, MSGL_V, "\n[xv] ");
+
+    switch (xv->xv_ck_info.source) {
+    case CK_SRC_CUR:
+        mp_msg(MSGT_VO, MSGL_V, "Using colorkey from Xv (0x%06lx).\n",
+               xv->xv_colorkey);
+        break;
+    case CK_SRC_USE:
+        if (xv->xv_ck_info.method == CK_METHOD_AUTOPAINT) {
+            mp_msg(MSGT_VO, MSGL_V, "Ignoring colorkey from mpv (0x%06lx).\n",
+                   xv->xv_colorkey);
+        } else {
+            mp_msg(MSGT_VO, MSGL_V,
+                   "Using colorkey from mpv (0x%06lx). Use -colorkey to change.\n",
+                   xv->xv_colorkey);
+        }
+        break;
+    case CK_SRC_SET:
+        mp_msg(MSGT_VO, MSGL_V, "Setting and using colorkey from mpv (0x%06lx)."
+               " Use -colorkey to change.\n", xv->xv_colorkey);
+        break;
+    }
+}
+
+/* NOTE: If vo_colorkey has bits set after the first 3 low order bytes
+ *       we don't draw anything as this means it was forced to off. */
+static int xv_init_colorkey(struct vo *vo)
+{
+    struct xvctx *ctx = vo->priv;
+    Display *display = vo->x11->display;
+    Atom xv_atom;
+    int rez;
+
+    /* check if colorkeying is needed */
+    xv_atom = xv_intern_atom_if_exists(vo, "XV_COLORKEY");
+    if (xv_atom != None && !(vo_colorkey & 0xFF000000)) {
+        if (ctx->xv_ck_info.source == CK_SRC_CUR) {
+            int colorkey_ret;
+
+            rez = XvGetPortAttribute(display, ctx->xv_port, xv_atom,
+                                     &colorkey_ret);
+            if (rez == Success)
+                ctx->xv_colorkey = colorkey_ret;
+            else {
+                mp_msg(MSGT_VO, MSGL_FATAL, "[xv] Couldn't get colorkey!"
+                       "Maybe the selected Xv port has no overlay.\n");
+                return 0; // error getting colorkey
+            }
+        } else {
+            ctx->xv_colorkey = vo_colorkey;
+
+            /* check if we have to set the colorkey too */
+            if (ctx->xv_ck_info.source == CK_SRC_SET) {
+                xv_atom = XInternAtom(display, "XV_COLORKEY", False);
+
+                rez = XvSetPortAttribute(display, ctx->xv_port, xv_atom,
+                                         vo_colorkey);
+                if (rez != Success) {
+                    mp_msg(MSGT_VO, MSGL_FATAL, "[xv] Couldn't set colorkey!\n");
+                    return 0; // error setting colorkey
+                }
+            }
+        }
+
+        xv_atom = xv_intern_atom_if_exists(vo, "XV_AUTOPAINT_COLORKEY");
+
+        /* should we draw the colorkey ourselves or activate autopainting? */
+        if (ctx->xv_ck_info.method == CK_METHOD_AUTOPAINT) {
+            rez = !Success;
+
+            if (xv_atom != None) // autopaint is supported
+                rez = XvSetPortAttribute(display, ctx->xv_port, xv_atom, 1);
+
+            if (rez != Success)
+                ctx->xv_ck_info.method = CK_METHOD_MANUALFILL;
+        } else {
+            // disable colorkey autopainting if supported
+            if (xv_atom != None)
+                XvSetPortAttribute(display, ctx->xv_port, xv_atom, 0);
+        }
+    } else // do no colorkey drawing at all
+        ctx->xv_ck_info.method = CK_METHOD_NONE;
+
+    xv_print_ck_info(ctx);
+
+    return 1;
+}
+
+/* Draw the colorkey on the video window.
+ *
+ * Draws the colorkey depending on the set method ( colorkey_handling ).
+ *
+ * Also draws the black bars ( when the video doesn't fit the display in
+ * fullscreen ) separately, so they don't overlap with the video area. */
+static void xv_draw_colorkey(struct vo *vo, int32_t x, int32_t y,
+                             int32_t w, int32_t h)
 {
     struct xvctx *ctx = vo->priv;
     struct vo_x11_state *x11 = vo->x11;
+    if (ctx->xv_ck_info.method == CK_METHOD_MANUALFILL ||
+        ctx->xv_ck_info.method == CK_METHOD_BACKGROUND)
+    {
+        //less tearing than XClearWindow()
+        XSetForeground(x11->display, x11->vo_gc, ctx->xv_colorkey);
+        XFillRectangle(x11->display, x11->window, x11->vo_gc, x, y, w, h);
+    }
+}
+
+// Tests if a valid argument for the ck suboption was given.
+static int xv_test_ck(void *arg)
+{
+    strarg_t *strarg = (strarg_t *)arg;
+
+    if (strargcmp(strarg, "use") == 0 ||
+        strargcmp(strarg, "set") == 0 ||
+        strargcmp(strarg, "cur") == 0)
+        return 1;
+
+    return 0;
+}
+
+// Tests if a valid arguments for the ck-method suboption was given.
+static int xv_test_ckm(void *arg)
+{
+    strarg_t *strarg = (strarg_t *)arg;
+
+    if (strargcmp(strarg, "bg") == 0 ||
+        strargcmp(strarg, "man") == 0 ||
+        strargcmp(strarg, "auto") == 0)
+        return 1;
+
+    return 0;
+}
+
+/* Modify the colorkey_handling var according to str
+ *
+ * Checks if a valid pointer ( not NULL ) to the string
+ * was given. And in that case modifies the colorkey_handling
+ * var to reflect the requested behaviour.
+ * If nothing happens the content of colorkey_handling stays
+ * the same.
+ */
+static void xv_setup_colorkeyhandling(struct xvctx *ctx,
+                                      const char *ck_method_str,
+                                      const char *ck_str)
+{
+    /* check if a valid pointer to the string was passed */
+    if (ck_str) {
+        if (strncmp(ck_str, "use", 3) == 0)
+            ctx->xv_ck_info.source = CK_SRC_USE;
+        else if (strncmp(ck_str, "set", 3) == 0)
+            ctx->xv_ck_info.source = CK_SRC_SET;
+    }
+    /* check if a valid pointer to the string was passed */
+    if (ck_method_str) {
+        if (strncmp(ck_method_str, "bg", 2) == 0)
+            ctx->xv_ck_info.method = CK_METHOD_BACKGROUND;
+        else if (strncmp(ck_method_str, "man", 3) == 0)
+            ctx->xv_ck_info.method = CK_METHOD_MANUALFILL;
+        else if (strncmp(ck_method_str, "auto", 4) == 0)
+            ctx->xv_ck_info.method = CK_METHOD_AUTOPAINT;
+    }
+}
+
+static void read_xv_csp(struct vo *vo)
+{
+    struct xvctx *ctx = vo->priv;
     struct mp_csp_details *cspc = &ctx->cached_csp;
     *cspc = (struct mp_csp_details) MP_CSP_DETAILS_DEFAULTS;
     int bt709_enabled;
-    if (vo_xv_get_eq(vo, x11->xv_port, "bt_709", &bt709_enabled))
+    if (xv_get_eq(vo, ctx->xv_port, "bt_709", &bt709_enabled))
         cspc->format = bt709_enabled == 100 ? MP_CSP_BT_709 : MP_CSP_BT_601;
 }
 
@@ -140,7 +482,7 @@ static void resize(struct vo *vo)
     struct mp_rect *dst = &ctx->dst_rect;
     int dw = dst->x1 - dst->x0, dh = dst->y1 - dst->y0;
     vo_x11_clearwindow_part(vo, vo->x11->window, dw, dh);
-    vo_xv_draw_colorkey(vo, dst->x0, dst->y0, dw, dh);
+    xv_draw_colorkey(vo, dst->x0, dst->y0, dw, dh);
     read_xv_csp(vo);
 }
 
@@ -204,8 +546,8 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
 
         xswa.border_pixel = 0;
         xswamask = CWBorderPixel;
-        if (x11->xv_ck_info.method == CK_METHOD_BACKGROUND) {
-            xswa.background_pixel = x11->xv_colorkey;
+        if (ctx->xv_ck_info.method == CK_METHOD_BACKGROUND) {
+            xswa.background_pixel = ctx->xv_colorkey;
             xswamask |= CWBackPixel;
         }
 
@@ -226,7 +568,7 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
     }
 
     mp_msg(MSGT_VO, MSGL_V, "using Xvideo port %d for hw scaling\n",
-           x11->xv_port);
+           ctx->xv_port);
 
     // In case config has been called before
     for (i = 0; i < ctx->total_buffers; i++)
@@ -264,7 +606,7 @@ static void allocate_xvimage(struct vo *vo, int foo)
     }
     if (ctx->Shmem_Flag) {
         ctx->xvimage[foo] =
-            (XvImage *) XvShmCreateImage(x11->display, x11->xv_port,
+            (XvImage *) XvShmCreateImage(x11->display, ctx->xv_port,
                                          ctx->xv_format, NULL,
                                          aligned_w, ctx->image_height,
                                          &ctx->Shminfo[foo]);
@@ -284,7 +626,7 @@ static void allocate_xvimage(struct vo *vo, int foo)
 #endif
     {
         ctx->xvimage[foo] =
-            (XvImage *) XvCreateImage(x11->display, x11->xv_port,
+            (XvImage *) XvCreateImage(x11->display, ctx->xv_port,
                                       ctx->xv_format, NULL, aligned_w,
                                       ctx->image_height);
         ctx->xvimage[foo]->data = av_malloc(ctx->xvimage[foo]->data_size);
@@ -323,7 +665,7 @@ static inline void put_xvimage(struct vo *vo, XvImage *xvi)
     int sw = src->x1 - src->x0, sh = src->y1 - src->y0;
 #ifdef HAVE_SHM
     if (ctx->Shmem_Flag) {
-        XvShmPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc, xvi,
+        XvShmPutImage(x11->display, ctx->xv_port, x11->window, x11->vo_gc, xvi,
                       src->x0, src->y0, sw, sh,
                       dst->x0, dst->y0, dw, dh,
                       True);
@@ -331,7 +673,7 @@ static inline void put_xvimage(struct vo *vo, XvImage *xvi)
     } else
 #endif
     {
-        XvPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc, xvi,
+        XvPutImage(x11->display, ctx->xv_port, x11->window, x11->vo_gc, xvi,
                    src->x0, src->y0, sw, sh,
                    dst->x0, dst->y0, dw, dh);
     }
@@ -504,11 +846,14 @@ static int preinit(struct vo *vo, const char *arg)
     unsigned int i;
     strarg_t ck_src_arg = { 0, NULL };
     strarg_t ck_method_arg = { 0, NULL };
-    struct xvctx *ctx = talloc_zero(vo, struct xvctx);
+    struct xvctx *ctx = talloc_ptrtype(vo, ctx);
+    *ctx = (struct xvctx) {
+        .xv_ck_info = { CK_METHOD_MANUALFILL, CK_SRC_CUR },
+    };
     vo->priv = ctx;
     int xv_adaptor = -1;
 
-    if (!vo_init(vo))
+    if (!vo_x11_init(vo))
         return -1;
 
     struct vo_x11_state *x11 = vo->x11;
@@ -516,22 +861,20 @@ static int preinit(struct vo *vo, const char *arg)
     const opt_t subopts[] =
     {
       /* name         arg type     arg var         test */
-      {  "port",      OPT_ARG_INT, &x11->xv_port,  int_pos },
+      {  "port",      OPT_ARG_INT, &ctx->xv_port,  int_pos },
       {  "adaptor",   OPT_ARG_INT, &xv_adaptor,    int_non_neg },
       {  "ck",        OPT_ARG_STR, &ck_src_arg,    xv_test_ck },
       {  "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm },
       {  NULL }
     };
 
-    x11->xv_port = 0;
-
     /* parse suboptions */
     if (subopt_parse(arg, subopts) != 0) {
         return -1;
     }
 
     /* modify colorkey settings according to the given options */
-    xv_setup_colorkeyhandling(vo, ck_method_arg.str, ck_src_arg.str);
+    xv_setup_colorkeyhandling(ctx, ck_method_arg.str, ck_src_arg.str);
 
     /* check for Xvideo extension */
     unsigned int ver, rel, req, ev, err;
@@ -549,7 +892,7 @@ static int preinit(struct vo *vo, const char *arg)
     }
 
     /* check adaptors */
-    if (x11->xv_port) {
+    if (ctx->xv_port) {
         int port_found;
 
         for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) {
@@ -558,7 +901,7 @@ static int preinit(struct vo *vo, const char *arg)
                 for (xv_p = ctx->ai[i].base_id;
                      xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports;
                      ++xv_p) {
-                    if (xv_p == x11->xv_port) {
+                    if (xv_p == ctx->xv_port) {
                         port_found = 1;
                         break;
                     }
@@ -566,15 +909,15 @@ static int preinit(struct vo *vo, const char *arg)
             }
         }
         if (port_found) {
-            if (XvGrabPort(x11->display, x11->xv_port, CurrentTime))
-                x11->xv_port = 0;
+            if (XvGrabPort(x11->display, ctx->xv_port, CurrentTime))
+                ctx->xv_port = 0;
         } else {
             mp_tmsg(MSGT_VO, MSGL_WARN, "[VO_XV] Invalid port parameter, overriding with port 0.\n");
-            x11->xv_port = 0;
+            ctx->xv_port = 0;
         }
     }
 
-    for (i = 0; i < ctx->adaptors && x11->xv_port == 0; i++) {
+    for (i = 0; i < ctx->adaptors && ctx->xv_port == 0; i++) {
         /* check if adaptor number has been specified */
         if (xv_adaptor != -1 && xv_adaptor != i)
             continue;
@@ -583,7 +926,7 @@ static int preinit(struct vo *vo, const char *arg)
             for (xv_p = ctx->ai[i].base_id;
                  xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p)
                 if (!XvGrabPort(x11->display, xv_p, CurrentTime)) {
-                    x11->xv_port = xv_p;
+                    ctx->xv_port = xv_p;
                     mp_msg(MSGT_VO, MSGL_V,
                            "[VO_XV] Using Xv Adapter #%d (%s)\n",
                            i, ctx->ai[i].name);
@@ -595,7 +938,7 @@ static int preinit(struct vo *vo, const char *arg)
                 }
         }
     }
-    if (!x11->xv_port) {
+    if (!ctx->xv_port) {
         if (busy_ports)
             mp_tmsg(MSGT_VO, MSGL_ERR,
                 "[VO_XV] Could not find free Xvideo port - maybe another process is already\n"\
@@ -611,13 +954,13 @@ static int preinit(struct vo *vo, const char *arg)
         goto error;
     }
 
-    if (!vo_xv_init_colorkey(vo)) {
+    if (!xv_init_colorkey(vo)) {
         goto error;             // bail out, colorkey setup failed
     }
-    vo_xv_enable_vsync(vo);
-    vo_xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height);
+    xv_enable_vsync(vo);
+    xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height);
 
-    ctx->fo = XvListImageFormats(x11->display, x11->xv_port,
+    ctx->fo = XvListImageFormats(x11->display, ctx->xv_port,
                                  (int *) &ctx->formats);
 
     return 0;
@@ -630,7 +973,6 @@ static int preinit(struct vo *vo, const char *arg)
 static int control(struct vo *vo, uint32_t request, void *data)
 {
     struct xvctx *ctx = vo->priv;
-    struct vo_x11_state *x11 = vo->x11;
     switch (request) {
     case VOCTRL_PAUSE:
         return (ctx->is_paused = 1);
@@ -647,16 +989,16 @@ static int control(struct vo *vo, uint32_t request, void *data)
     case VOCTRL_SET_EQUALIZER: {
         vo->want_redraw = true;
         struct voctrl_set_equalizer_args *args = data;
-        return vo_xv_set_eq(vo, x11->xv_port, args->name, args->value);
+        return xv_set_eq(vo, ctx->xv_port, args->name, args->value);
     }
     case VOCTRL_GET_EQUALIZER: {
         struct voctrl_get_equalizer_args *args = data;
-        return vo_xv_get_eq(vo, x11->xv_port, args->name, args->valueptr);
+        return xv_get_eq(vo, ctx->xv_port, args->name, args->valueptr);
     }
     case VOCTRL_SET_YUV_COLORSPACE:;
         struct mp_csp_details* given_cspc = data;
         int is_709 = given_cspc->format == MP_CSP_BT_709;
-        vo_xv_set_eq(vo, x11->xv_port, "bt_709", is_709 * 200 - 100);
+        xv_set_eq(vo, ctx->xv_port, "bt_709", is_709 * 200 - 100);
         read_xv_csp(vo);
         vo->want_redraw = true;
         return true;
@@ -669,7 +1011,7 @@ static int control(struct vo *vo, uint32_t request, void *data)
         vo_x11_ontop(vo);
         return VO_TRUE;
     case VOCTRL_UPDATE_SCREENINFO:
-        update_xinerama_info(vo);
+        vo_x11_update_screeninfo(vo);
         return VO_TRUE;
     case VOCTRL_REDRAW_FRAME:
         return redraw_frame(vo);