2009-02-08 03:27:30 +00:00
|
|
|
/*
|
2013-10-23 17:06:14 +00:00
|
|
|
* Original author: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
|
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* This file is part of mpv.
|
|
|
|
*
|
|
|
|
* mpv is free software; you can redistribute it and/or modify
|
2009-02-08 03:27:30 +00:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is distributed in the hope that it will be useful,
|
2009-02-08 03:27:30 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
2015-04-13 07:36:54 +00:00
|
|
|
* with mpv. If not, see <http://www.gnu.org/licenses/>.
|
2009-02-08 03:27:30 +00:00
|
|
|
*/
|
2001-02-24 20:28:24 +00:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2012-07-31 21:37:56 +00:00
|
|
|
#include <sys/types.h>
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2013-07-18 11:46:05 +00:00
|
|
|
#include <libswscale/swscale.h>
|
2013-03-14 14:49:32 +00:00
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
#include "config.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "vo.h"
|
|
|
|
#include "video/csputils.h"
|
|
|
|
#include "video/mp_image.h"
|
2013-09-29 22:37:44 +00:00
|
|
|
#include "video/filter/vf.h"
|
2001-02-24 20:28:24 +00:00
|
|
|
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xutil.h>
|
2002-01-07 17:33:59 +00:00
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
#include <errno.h>
|
|
|
|
|
2001-03-03 21:46:39 +00:00
|
|
|
#include "x11_common.h"
|
|
|
|
|
2013-07-16 11:28:28 +00:00
|
|
|
#if HAVE_SHM
|
2003-12-27 19:45:54 +00:00
|
|
|
#include <sys/ipc.h>
|
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <X11/extensions/XShm.h>
|
|
|
|
#endif
|
|
|
|
|
2013-11-24 11:58:06 +00:00
|
|
|
#include "sub/osd.h"
|
2012-11-21 18:03:00 +00:00
|
|
|
#include "sub/draw_bmp.h"
|
2001-04-11 12:47:45 +00:00
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "video/sws_utils.h"
|
2013-03-14 14:53:51 +00:00
|
|
|
#include "video/fmt-conversion.h"
|
2001-10-15 19:33:26 +00:00
|
|
|
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/msg.h"
|
2014-07-27 19:33:11 +00:00
|
|
|
#include "input/input.h"
|
2013-12-17 01:02:25 +00:00
|
|
|
#include "options/options.h"
|
2013-01-02 11:55:52 +00:00
|
|
|
#include "osdep/timer.h"
|
2002-02-17 02:01:45 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv {
|
|
|
|
struct vo *vo;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
struct mp_image *original_image;
|
2012-11-21 18:03:00 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
/* local data */
|
2013-01-02 12:20:38 +00:00
|
|
|
unsigned char *ImageData[2];
|
2012-08-06 20:13:24 +00:00
|
|
|
//! original unaligned pointer for free
|
2013-01-02 12:20:38 +00:00
|
|
|
unsigned char *ImageDataOrig[2];
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
/* X11 related variables */
|
2013-01-02 12:20:38 +00:00
|
|
|
XImage *myximage[2];
|
2012-08-06 20:13:24 +00:00
|
|
|
int depth, bpp;
|
|
|
|
XWindowAttributes attribs;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
uint32_t image_width;
|
|
|
|
uint32_t image_height;
|
2013-07-18 11:44:56 +00:00
|
|
|
struct mp_image_params in_format;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
struct mp_rect src;
|
|
|
|
struct mp_rect dst;
|
|
|
|
int src_w, src_h;
|
|
|
|
int dst_w, dst_h;
|
|
|
|
struct mp_osd_res osd;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-07-18 11:44:56 +00:00
|
|
|
struct mp_sws_context *sws;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
XVisualInfo vinfo;
|
2013-01-26 21:37:47 +00:00
|
|
|
int ximage_depth;
|
2012-08-06 20:13:24 +00:00
|
|
|
|
|
|
|
int firstTime;
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
int current_buf;
|
|
|
|
int num_buffers;
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
int Shmem_Flag;
|
2013-07-16 11:28:28 +00:00
|
|
|
#if HAVE_SHM
|
2013-01-02 11:55:52 +00:00
|
|
|
int Shm_Warned_Slow;
|
2012-08-06 20:13:24 +00:00
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
XShmSegmentInfo Shminfo[2];
|
2012-08-06 20:13:24 +00:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
static bool resize(struct vo *vo);
|
2012-08-06 20:13:24 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
/* Scan the available visuals on this Display/Screen. Try to find
|
|
|
|
* the 'best' available TrueColor visual that has a decent color
|
|
|
|
* depth (at least 15bit). If there are multiple visuals with depth
|
|
|
|
* >= 15bit, we prefer visuals with a smaller color depth. */
|
2013-08-23 17:52:25 +00:00
|
|
|
static int find_depth_from_visuals(struct vo *vo, Visual ** visual_return)
|
2013-01-26 21:37:47 +00:00
|
|
|
{
|
2013-08-23 17:52:25 +00:00
|
|
|
Display *dpy = vo->x11->display;
|
|
|
|
int screen = vo->x11->screen;
|
2013-01-26 21:37:47 +00:00
|
|
|
XVisualInfo visual_tmpl;
|
|
|
|
XVisualInfo *visuals;
|
|
|
|
int nvisuals, i;
|
|
|
|
int bestvisual = -1;
|
|
|
|
int bestvisual_depth = -1;
|
|
|
|
|
|
|
|
visual_tmpl.screen = screen;
|
|
|
|
visual_tmpl.class = TrueColor;
|
|
|
|
visuals = XGetVisualInfo(dpy,
|
|
|
|
VisualScreenMask | VisualClassMask,
|
|
|
|
&visual_tmpl, &nvisuals);
|
|
|
|
if (visuals != NULL)
|
|
|
|
{
|
|
|
|
for (i = 0; i < nvisuals; i++)
|
|
|
|
{
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_VERBOSE(vo,
|
|
|
|
"truecolor visual %#lx, depth %d, R:%lX G:%lX B:%lX\n",
|
2013-01-26 21:37:47 +00:00
|
|
|
visuals[i].visualid, visuals[i].depth,
|
|
|
|
visuals[i].red_mask, visuals[i].green_mask,
|
|
|
|
visuals[i].blue_mask);
|
|
|
|
/*
|
|
|
|
* Save the visual index and its depth, if this is the first
|
|
|
|
* truecolor visul, or a visual that is 'preferred' over the
|
|
|
|
* previous 'best' visual.
|
|
|
|
*/
|
|
|
|
if (bestvisual_depth == -1
|
|
|
|
|| (visuals[i].depth >= 15
|
|
|
|
&& (visuals[i].depth < bestvisual_depth
|
|
|
|
|| bestvisual_depth < 15)))
|
|
|
|
{
|
|
|
|
bestvisual = i;
|
|
|
|
bestvisual_depth = visuals[i].depth;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bestvisual != -1 && visual_return != NULL)
|
|
|
|
*visual_return = visuals[bestvisual].visual;
|
|
|
|
|
|
|
|
XFree(visuals);
|
|
|
|
}
|
|
|
|
return bestvisual_depth;
|
|
|
|
}
|
|
|
|
|
2014-12-14 21:00:21 +00:00
|
|
|
static bool getMyXImage(struct priv *p, int foo)
|
2002-01-30 15:26:11 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct vo *vo = p->vo;
|
2013-12-25 16:06:32 +00:00
|
|
|
#if HAVE_SHM && HAVE_XEXT
|
2013-01-02 11:55:52 +00:00
|
|
|
if (vo->x11->display_is_local && XShmQueryExtension(vo->x11->display)) {
|
2012-08-06 20:13:24 +00:00
|
|
|
p->Shmem_Flag = 1;
|
2013-01-02 11:55:52 +00:00
|
|
|
vo->x11->ShmCompletionEvent = XShmGetEventBase(vo->x11->display)
|
|
|
|
+ ShmCompletion;
|
|
|
|
} else {
|
2012-08-06 20:13:24 +00:00
|
|
|
p->Shmem_Flag = 0;
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_WARN(vo, "Shared memory not supported\nReverting to normal Xlib\n");
|
2002-01-30 15:26:11 +00:00
|
|
|
}
|
2012-08-06 20:13:24 +00:00
|
|
|
|
|
|
|
if (p->Shmem_Flag) {
|
2013-01-02 12:20:38 +00:00
|
|
|
p->myximage[foo] =
|
2012-08-06 20:13:24 +00:00
|
|
|
XShmCreateImage(vo->x11->display, p->vinfo.visual, p->depth,
|
2013-01-02 12:20:38 +00:00
|
|
|
ZPixmap, NULL, &p->Shminfo[foo], p->image_width,
|
2012-08-06 20:13:24 +00:00
|
|
|
p->image_height);
|
2013-01-02 12:20:38 +00:00
|
|
|
if (p->myximage[foo] == NULL) {
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_WARN(vo, "Shared memory error,disabling ( Ximage error )\n");
|
2004-06-14 04:53:03 +00:00
|
|
|
goto shmemerror;
|
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
p->Shminfo[foo].shmid = shmget(IPC_PRIVATE,
|
|
|
|
p->myximage[foo]->bytes_per_line *
|
|
|
|
p->myximage[foo]->height,
|
|
|
|
IPC_CREAT | 0777);
|
|
|
|
if (p->Shminfo[foo].shmid < 0) {
|
|
|
|
XDestroyImage(p->myximage[foo]);
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_WARN(vo, "Shared memory error,disabling ( seg id error )\n");
|
2004-06-14 04:53:03 +00:00
|
|
|
goto shmemerror;
|
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
p->Shminfo[foo].shmaddr = (char *) shmat(p->Shminfo[foo].shmid, 0, 0);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
if (p->Shminfo[foo].shmaddr == ((char *) -1)) {
|
|
|
|
XDestroyImage(p->myximage[foo]);
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_WARN(vo, "Shared memory error,disabling ( address error )\n");
|
2004-06-14 04:53:03 +00:00
|
|
|
goto shmemerror;
|
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
p->myximage[foo]->data = p->Shminfo[foo].shmaddr;
|
|
|
|
p->ImageData[foo] = (unsigned char *) p->myximage[foo]->data;
|
|
|
|
p->Shminfo[foo].readOnly = False;
|
|
|
|
XShmAttach(vo->x11->display, &p->Shminfo[foo]);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
XSync(vo->x11->display, False);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
shmctl(p->Shminfo[foo].shmid, IPC_RMID, 0);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
if (!p->firstTime) {
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_VERBOSE(vo, "Sharing memory.\n");
|
2012-08-06 20:13:24 +00:00
|
|
|
p->firstTime = 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2012-08-06 20:13:24 +00:00
|
|
|
} else {
|
|
|
|
shmemerror:
|
|
|
|
p->Shmem_Flag = 0;
|
2002-01-30 15:26:11 +00:00
|
|
|
#endif
|
2013-01-02 12:20:38 +00:00
|
|
|
p->myximage[foo] =
|
2012-08-06 20:13:24 +00:00
|
|
|
XCreateImage(vo->x11->display, p->vinfo.visual, p->depth, ZPixmap,
|
|
|
|
0, NULL, p->image_width, p->image_height, 8, 0);
|
2014-12-14 21:00:21 +00:00
|
|
|
if (!p->myximage[foo]) {
|
|
|
|
MP_WARN(vo, "could not allocate image");
|
|
|
|
return false;
|
|
|
|
}
|
2014-09-04 23:44:51 +00:00
|
|
|
size_t sz = p->myximage[foo]->bytes_per_line * p->image_height + 32;
|
|
|
|
p->ImageDataOrig[foo] = calloc(1, sz);
|
2013-01-02 12:20:38 +00:00
|
|
|
p->myximage[foo]->data = p->ImageDataOrig[foo] + 16
|
|
|
|
- ((long)p->ImageDataOrig & 15);
|
|
|
|
p->ImageData[foo] = p->myximage[foo]->data;
|
2013-12-25 16:06:32 +00:00
|
|
|
#if HAVE_SHM && HAVE_XEXT
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
2002-01-30 15:26:11 +00:00
|
|
|
#endif
|
2014-12-14 21:00:21 +00:00
|
|
|
return true;
|
2002-01-30 15:26:11 +00:00
|
|
|
}
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
static void freeMyXImage(struct priv *p, int foo)
|
2002-01-30 15:26:11 +00:00
|
|
|
{
|
2013-12-25 16:06:32 +00:00
|
|
|
#if HAVE_SHM && HAVE_XEXT
|
2014-05-22 01:27:18 +00:00
|
|
|
struct vo *vo = p->vo;
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->Shmem_Flag) {
|
2013-01-02 12:20:38 +00:00
|
|
|
XShmDetach(vo->x11->display, &p->Shminfo[foo]);
|
|
|
|
XDestroyImage(p->myximage[foo]);
|
|
|
|
shmdt(p->Shminfo[foo].shmaddr);
|
2004-06-14 04:53:03 +00:00
|
|
|
} else
|
2002-01-30 15:26:11 +00:00
|
|
|
#endif
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-01-02 12:20:38 +00:00
|
|
|
if (p->myximage[foo]) {
|
|
|
|
p->myximage[foo]->data = p->ImageDataOrig[foo];
|
|
|
|
XDestroyImage(p->myximage[foo]);
|
|
|
|
p->ImageDataOrig[foo] = NULL;
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
p->myximage[foo] = NULL;
|
|
|
|
p->ImageData[foo] = NULL;
|
2002-01-30 15:26:11 +00:00
|
|
|
}
|
2001-10-15 19:33:26 +00:00
|
|
|
|
Remove compile time/runtime CPU detection, and drop some platforms
mplayer had three ways of enabling CPU specific assembler routines:
a) Enable them at compile time; crash if the CPU can't handle it.
b) Enable them at compile time, but let the configure script detect
your CPU. Your binary will only crash if you try to run it on a
different system that has less features than yours.
This was the default, I think.
c) Runtime detection.
The implementation of b) and c) suck. a) is not really feasible (it
sucks for users). Remove all code related to this, and use libav's CPU
detection instead. Now the configure script will always enable CPU
specific features, and disable them at runtime if libav reports them
not as available.
One implication is that now the compiler is always expected to handle
SSE (etc.) inline assembly at runtime, unless it's explicitly disabled.
Only checks for x86 CPU specific features are kept, the rest is either
unused or barely used.
Get rid of all the dump -mpcu, -march etc. flags. Trust the compiler
to select decent settings.
Get rid of support for the following operating systems:
- BSD/OS (some ancient BSD fork)
- QNX (don't care)
- BeOS (dead, Haiku support is still welcome)
- AIX (don't care)
- HP-UX (don't care)
- OS/2 (dead, actual support has been removed a while ago)
Remove the configure code for detecting the endianness. Instead, use
the standard header <endian.h>, which can be used if _GNU_SOURCE or
_BSD_SOURCE is defined. (Maybe these changes should have been in a
separate commit.)
Since this is a quite violent code removal orgy, and I'm testing only
on x86 32 bit Linux, expect regressions.
2012-07-29 15:20:57 +00:00
|
|
|
#if BYTE_ORDER == BIG_ENDIAN
|
2006-10-23 15:49:44 +00:00
|
|
|
#define BO_NATIVE MSBFirst
|
|
|
|
#define BO_NONNATIVE LSBFirst
|
|
|
|
#else
|
|
|
|
#define BO_NATIVE LSBFirst
|
|
|
|
#define BO_NONNATIVE MSBFirst
|
|
|
|
#endif
|
2007-12-02 20:43:35 +00:00
|
|
|
const struct fmt2Xfmtentry_s {
|
2012-08-06 20:13:24 +00:00
|
|
|
uint32_t mpfmt;
|
|
|
|
int byte_order;
|
|
|
|
unsigned red_mask;
|
|
|
|
unsigned green_mask;
|
|
|
|
unsigned blue_mask;
|
2006-10-23 15:49:44 +00:00
|
|
|
} fmt2Xfmt[] = {
|
2014-06-14 08:03:04 +00:00
|
|
|
{IMGFMT_BGR8, BO_NATIVE, 0x00000007, 0x00000038, 0x000000C0},
|
|
|
|
{IMGFMT_BGR8, BO_NONNATIVE, 0x00000007, 0x00000038, 0x000000C0},
|
|
|
|
{IMGFMT_RGB8, BO_NATIVE, 0x000000E0, 0x0000001C, 0x00000003},
|
|
|
|
{IMGFMT_RGB8, BO_NONNATIVE, 0x000000E0, 0x0000001C, 0x00000003},
|
|
|
|
{IMGFMT_BGR555, BO_NATIVE, 0x0000001F, 0x000003E0, 0x00007C00},
|
|
|
|
{IMGFMT_BGR555, BO_NATIVE, 0x00007C00, 0x000003E0, 0x0000001F},
|
|
|
|
{IMGFMT_BGR565, BO_NATIVE, 0x0000001F, 0x000007E0, 0x0000F800},
|
|
|
|
{IMGFMT_RGB565, BO_NATIVE, 0x0000F800, 0x000007E0, 0x0000001F},
|
|
|
|
{IMGFMT_RGB24, MSBFirst, 0x00FF0000, 0x0000FF00, 0x000000FF},
|
|
|
|
{IMGFMT_RGB24, LSBFirst, 0x000000FF, 0x0000FF00, 0x00FF0000},
|
|
|
|
{IMGFMT_BGR24, MSBFirst, 0x000000FF, 0x0000FF00, 0x00FF0000},
|
|
|
|
{IMGFMT_BGR24, LSBFirst, 0x00FF0000, 0x0000FF00, 0x000000FF},
|
|
|
|
{IMGFMT_RGB32, BO_NATIVE, 0x000000FF, 0x0000FF00, 0x00FF0000},
|
|
|
|
{IMGFMT_RGB32, BO_NONNATIVE, 0xFF000000, 0x00FF0000, 0x0000FF00},
|
|
|
|
{IMGFMT_BGR32, BO_NATIVE, 0x00FF0000, 0x0000FF00, 0x000000FF},
|
|
|
|
{IMGFMT_BGR32, BO_NONNATIVE, 0x0000FF00, 0x00FF0000, 0xFF000000},
|
|
|
|
{IMGFMT_ARGB, MSBFirst, 0x00FF0000, 0x0000FF00, 0x000000FF},
|
|
|
|
{IMGFMT_ARGB, LSBFirst, 0x0000FF00, 0x00FF0000, 0xFF000000},
|
|
|
|
{IMGFMT_ABGR, MSBFirst, 0x000000FF, 0x0000FF00, 0x00FF0000},
|
|
|
|
{IMGFMT_ABGR, LSBFirst, 0xFF000000, 0x00FF0000, 0x0000FF00},
|
|
|
|
{IMGFMT_RGBA, MSBFirst, 0xFF000000, 0x00FF0000, 0x0000FF00},
|
|
|
|
{IMGFMT_RGBA, LSBFirst, 0x000000FF, 0x0000FF00, 0x00FF0000},
|
|
|
|
{IMGFMT_BGRA, MSBFirst, 0x0000FF00, 0x00FF0000, 0xFF000000},
|
|
|
|
{IMGFMT_BGRA, LSBFirst, 0x00FF0000, 0x0000FF00, 0x000000FF},
|
2012-08-06 20:13:24 +00:00
|
|
|
{0}
|
2006-10-23 15:49:44 +00:00
|
|
|
};
|
|
|
|
|
2013-07-18 11:44:56 +00:00
|
|
|
static int reconfig(struct vo *vo, struct mp_image_params *fmt, int flags)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
mp_image_unrefp(&p->original_image);
|
|
|
|
|
2013-07-18 11:44:56 +00:00
|
|
|
p->in_format = *fmt;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
XGetWindowAttributes(vo->x11->display, vo->x11->rootwin, &p->attribs);
|
|
|
|
p->depth = p->attribs.depth;
|
2001-08-29 15:09:19 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->depth != 15 && p->depth != 16 && p->depth != 24 && p->depth != 32) {
|
2004-06-14 04:53:03 +00:00
|
|
|
Visual *visual;
|
|
|
|
|
2013-08-23 17:52:25 +00:00
|
|
|
p->depth = find_depth_from_visuals(vo, &visual);
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
|
|
|
if (!XMatchVisualInfo(vo->x11->display, vo->x11->screen, p->depth,
|
2013-09-29 22:37:44 +00:00
|
|
|
TrueColor, &p->vinfo))
|
|
|
|
return -1;
|
2001-08-29 15:09:19 +00:00
|
|
|
|
2014-05-06 18:24:35 +00:00
|
|
|
vo_x11_config_vo_window(vo, &p->vinfo, flags, "x11");
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
if (!resize(vo))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool resize(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct priv *p = vo->priv;
|
2013-01-26 21:37:47 +00:00
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
for (int i = 0; i < p->num_buffers; i++)
|
|
|
|
freeMyXImage(p, i);
|
|
|
|
|
|
|
|
vo_get_src_dst_rects(vo, &p->src, &p->dst, &p->osd);
|
|
|
|
|
|
|
|
p->src_w = p->src.x1 - p->src.x0;
|
|
|
|
p->src_h = p->src.y1 - p->src.y0;
|
|
|
|
p->dst_w = p->dst.x1 - p->dst.x0;
|
|
|
|
p->dst_h = p->dst.y1 - p->dst.y0;
|
|
|
|
|
|
|
|
// p->osd contains the parameters assuming OSD rendering in window
|
|
|
|
// coordinates, but OSD can only be rendered in the intersection
|
|
|
|
// between window and video rectangle (i.e. not into panscan borders).
|
|
|
|
p->osd.w = p->dst_w;
|
|
|
|
p->osd.h = p->dst_h;
|
2014-07-28 19:48:43 +00:00
|
|
|
p->osd.mt = MPMIN(0, p->osd.mt);
|
|
|
|
p->osd.mb = MPMIN(0, p->osd.mb);
|
|
|
|
p->osd.mr = MPMIN(0, p->osd.mr);
|
|
|
|
p->osd.ml = MPMIN(0, p->osd.ml);
|
2013-03-14 14:49:32 +00:00
|
|
|
|
2014-07-27 19:33:11 +00:00
|
|
|
mp_input_set_mouse_transform(vo->input_ctx, &p->dst, NULL);
|
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
p->image_width = (p->dst_w + 7) & (~7);
|
|
|
|
p->image_height = p->dst_h;
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
p->num_buffers = 2;
|
2014-12-14 21:00:21 +00:00
|
|
|
for (int i = 0; i < p->num_buffers; i++) {
|
|
|
|
if (!getMyXImage(p, i))
|
|
|
|
return -1;
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
|
2006-10-23 15:49:44 +00:00
|
|
|
while (fmte->mpfmt) {
|
2012-08-06 20:13:24 +00:00
|
|
|
int depth = IMGFMT_RGB_DEPTH(fmte->mpfmt);
|
|
|
|
/* bits_per_pixel in X seems to be set to 16 for 15 bit formats
|
|
|
|
=> force depth to 16 so that only the color masks are used for the format check */
|
|
|
|
if (depth == 15)
|
|
|
|
depth = 16;
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
if (depth == p->myximage[0]->bits_per_pixel &&
|
|
|
|
fmte->byte_order == p->myximage[0]->byte_order &&
|
|
|
|
fmte->red_mask == p->myximage[0]->red_mask &&
|
|
|
|
fmte->green_mask == p->myximage[0]->green_mask &&
|
|
|
|
fmte->blue_mask == p->myximage[0]->blue_mask)
|
2012-08-06 20:13:24 +00:00
|
|
|
break;
|
|
|
|
fmte++;
|
2006-10-23 15:49:44 +00:00
|
|
|
}
|
|
|
|
if (!fmte->mpfmt) {
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_ERR(vo, "X server image format not supported,"
|
|
|
|
" please contact the developers\n");
|
2012-08-06 20:13:24 +00:00
|
|
|
return -1;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
p->bpp = p->myximage[0]->bits_per_pixel;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2014-06-10 20:41:14 +00:00
|
|
|
mp_sws_set_from_cmdline(p->sws, vo->opts->sws_opts);
|
2013-07-18 11:44:56 +00:00
|
|
|
p->sws->src = p->in_format;
|
|
|
|
p->sws->dst = (struct mp_image_params) {
|
|
|
|
.imgfmt = fmte->mpfmt,
|
|
|
|
.w = p->dst_w,
|
|
|
|
.h = p->dst_h,
|
|
|
|
.d_w = p->dst_w,
|
|
|
|
.d_h = p->dst_h,
|
|
|
|
};
|
2013-07-25 21:02:23 +00:00
|
|
|
mp_image_params_guess_csp(&p->sws->dst);
|
2013-07-18 11:44:56 +00:00
|
|
|
|
|
|
|
if (mp_sws_reinit(p->sws) < 0)
|
2013-03-14 14:49:32 +00:00
|
|
|
return false;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2013-03-17 22:01:33 +00:00
|
|
|
vo_x11_clear_background(vo, &p->dst);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
vo->want_redraw = true;
|
|
|
|
return true;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2013-03-14 14:49:32 +00:00
|
|
|
static void Display_Image(struct priv *p, XImage *myximage)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct vo *vo = p->vo;
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
XImage *x_image = p->myximage[p->current_buf];
|
|
|
|
|
2013-12-25 16:06:32 +00:00
|
|
|
#if HAVE_SHM && HAVE_XEXT
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->Shmem_Flag) {
|
2013-03-14 14:49:32 +00:00
|
|
|
XShmPutImage(vo->x11->display, vo->x11->window, vo->x11->vo_gc, x_image,
|
|
|
|
0, 0, p->dst.x0, p->dst.y0, p->dst_w, p->dst_h,
|
2012-08-06 20:13:24 +00:00
|
|
|
True);
|
2013-01-02 11:55:52 +00:00
|
|
|
vo->x11->ShmCompletionWaitCount++;
|
2004-06-14 04:53:03 +00:00
|
|
|
} else
|
2001-02-24 20:28:24 +00:00
|
|
|
#endif
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-03-14 14:49:32 +00:00
|
|
|
XPutImage(vo->x11->display, vo->x11->window, vo->x11->vo_gc, x_image,
|
|
|
|
0, 0, p->dst.x0, p->dst.y0, p->dst_w, p->dst_h);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
static struct mp_image get_x_buffer(struct priv *p, int buf_index)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2012-10-07 19:24:22 +00:00
|
|
|
struct mp_image img = {0};
|
2013-07-18 11:44:56 +00:00
|
|
|
mp_image_set_params(&img, &p->sws->dst);
|
2012-10-07 19:24:22 +00:00
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
img.planes[0] = p->ImageData[buf_index];
|
2012-10-07 19:24:22 +00:00
|
|
|
img.stride[0] = p->image_width * ((p->bpp + 7) / 8);
|
|
|
|
|
|
|
|
return img;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2001-08-13 11:08:18 +00:00
|
|
|
|
2013-01-02 11:55:52 +00:00
|
|
|
static void wait_for_completion(struct vo *vo, int max_outstanding)
|
|
|
|
{
|
2013-12-25 16:06:32 +00:00
|
|
|
#if HAVE_SHM && HAVE_XEXT
|
2013-01-02 11:55:52 +00:00
|
|
|
struct priv *ctx = vo->priv;
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
if (ctx->Shmem_Flag) {
|
|
|
|
while (x11->ShmCompletionWaitCount > max_outstanding) {
|
|
|
|
if (!ctx->Shm_Warned_Slow) {
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_WARN(vo, "can't keep up! Waiting"
|
|
|
|
" for XShm completion events...\n");
|
2013-01-02 11:55:52 +00:00
|
|
|
ctx->Shm_Warned_Slow = 1;
|
|
|
|
}
|
2013-05-25 17:56:52 +00:00
|
|
|
mp_sleep_us(1000);
|
2013-05-16 12:02:28 +00:00
|
|
|
vo_x11_check_events(vo);
|
2013-01-02 11:55:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static void flip_page(struct vo *vo)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
2013-03-14 14:49:32 +00:00
|
|
|
Display_Image(p, p->myximage[p->current_buf]);
|
2013-01-02 12:20:38 +00:00
|
|
|
p->current_buf = (p->current_buf + 1) % p->num_buffers;
|
|
|
|
|
|
|
|
if (!p->Shmem_Flag)
|
|
|
|
XSync(vo->x11->display, False);
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
|
|
|
|
2014-06-18 18:04:59 +00:00
|
|
|
// Note: REDRAW_FRAME can call this with NULL.
|
2012-11-04 17:16:36 +00:00
|
|
|
static void draw_image(struct vo *vo, mp_image_t *mpi)
|
2012-08-06 20:13:24 +00:00
|
|
|
{
|
|
|
|
struct priv *p = vo->priv;
|
2013-03-14 14:49:32 +00:00
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
wait_for_completion(vo, p->num_buffers - 1);
|
2013-01-02 11:55:52 +00:00
|
|
|
|
2013-07-18 11:44:56 +00:00
|
|
|
struct mp_image img = get_x_buffer(p, p->current_buf);
|
2013-10-06 21:03:30 +00:00
|
|
|
|
|
|
|
if (mpi) {
|
|
|
|
struct mp_image src = *mpi;
|
|
|
|
struct mp_rect src_rc = p->src;
|
|
|
|
src_rc.x0 = MP_ALIGN_DOWN(src_rc.x0, src.fmt.align_x);
|
|
|
|
src_rc.y0 = MP_ALIGN_DOWN(src_rc.y0, src.fmt.align_y);
|
|
|
|
mp_image_crop_rc(&src, src_rc);
|
|
|
|
|
|
|
|
mp_sws_scale(p->sws, &img, &src);
|
|
|
|
} else {
|
|
|
|
mp_image_clear(&img, 0, 0, img.w, img.h);
|
|
|
|
}
|
2012-12-22 16:50:15 +00:00
|
|
|
|
2014-06-15 18:46:57 +00:00
|
|
|
osd_draw_on_image(vo->osd, p->osd, mpi ? mpi->pts : 0, 0, &img);
|
|
|
|
|
2014-06-17 21:05:50 +00:00
|
|
|
if (mpi != p->original_image) {
|
|
|
|
talloc_free(p->original_image);
|
|
|
|
p->original_image = mpi;
|
|
|
|
}
|
2012-12-22 16:50:15 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 21:08:24 +00:00
|
|
|
static int query_format(struct vo *vo, int format)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_DBG(vo, "query_format was called: %x (%s)\n", format,
|
|
|
|
vo_format_name(format));
|
2012-12-24 00:10:57 +00:00
|
|
|
if (IMGFMT_IS_RGB(format)) {
|
|
|
|
for (int n = 0; fmt2Xfmt[n].mpfmt; n++) {
|
2015-01-21 21:08:24 +00:00
|
|
|
if (fmt2Xfmt[n].mpfmt == format)
|
|
|
|
return 1;
|
2012-12-24 00:10:57 +00:00
|
|
|
}
|
2002-03-16 02:42:19 +00:00
|
|
|
}
|
2001-04-10 00:18:41 +00:00
|
|
|
|
2013-03-14 14:53:51 +00:00
|
|
|
if (sws_isSupportedInput(imgfmt2pixfmt(format)))
|
2015-01-21 21:08:24 +00:00
|
|
|
return 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void find_x11_depth(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
struct priv *p = vo->priv;
|
|
|
|
XImage *mXImage = NULL;
|
|
|
|
int depth, bpp, ximage_depth;
|
|
|
|
unsigned int mask;
|
|
|
|
XWindowAttributes attribs;
|
|
|
|
|
|
|
|
// get color depth (from root window, or the best visual):
|
|
|
|
XGetWindowAttributes(x11->display, x11->rootwin, &attribs);
|
|
|
|
depth = attribs.depth;
|
|
|
|
|
|
|
|
if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
|
|
|
|
{
|
|
|
|
Visual *visual;
|
|
|
|
|
2013-08-23 17:52:25 +00:00
|
|
|
depth = find_depth_from_visuals(vo, &visual);
|
2013-01-26 21:37:47 +00:00
|
|
|
if (depth != -1)
|
|
|
|
mXImage = XCreateImage(x11->display, visual, depth, ZPixmap,
|
|
|
|
0, NULL, 1, 1, 8, 1);
|
|
|
|
} else
|
|
|
|
mXImage =
|
|
|
|
XGetImage(x11->display, x11->rootwin, 0, 0, 1, 1, AllPlanes, ZPixmap);
|
|
|
|
|
|
|
|
ximage_depth = depth; // display depth on screen
|
|
|
|
|
|
|
|
// get bits/pixel from XImage structure:
|
|
|
|
if (mXImage == NULL)
|
|
|
|
{
|
|
|
|
mask = 0;
|
|
|
|
} else
|
|
|
|
{
|
|
|
|
/* for the depth==24 case, the XImage structures might use
|
|
|
|
* 24 or 32 bits of data per pixel. */
|
|
|
|
bpp = mXImage->bits_per_pixel;
|
|
|
|
if ((ximage_depth + 7) / 8 != (bpp + 7) / 8)
|
|
|
|
ximage_depth = bpp; // by A'rpi
|
|
|
|
mask =
|
|
|
|
mXImage->red_mask | mXImage->green_mask | mXImage->blue_mask;
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_VERBOSE(vo, "color mask: %X (R:%lX G:%lX B:%lX)\n", mask,
|
2013-01-26 21:37:47 +00:00
|
|
|
mXImage->red_mask, mXImage->green_mask, mXImage->blue_mask);
|
|
|
|
XDestroyImage(mXImage);
|
|
|
|
}
|
|
|
|
if (((ximage_depth + 7) / 8) == 2)
|
|
|
|
{
|
|
|
|
if (mask == 0x7FFF)
|
|
|
|
ximage_depth = 15;
|
|
|
|
else if (mask == 0xFFFF)
|
|
|
|
ximage_depth = 16;
|
|
|
|
}
|
|
|
|
|
2013-08-23 17:52:25 +00:00
|
|
|
MP_VERBOSE(vo, "depth %d and %d bpp.\n", depth, ximage_depth);
|
2013-01-26 21:37:47 +00:00
|
|
|
|
|
|
|
p->ximage_depth = ximage_depth;
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static void uninit(struct vo *vo)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
2013-01-02 12:20:38 +00:00
|
|
|
if (p->myximage[0])
|
|
|
|
freeMyXImage(p, 0);
|
|
|
|
if (p->myximage[1])
|
|
|
|
freeMyXImage(p, 1);
|
2002-01-31 00:37:59 +00:00
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
talloc_free(p->original_image);
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
vo_x11_uninit(vo);
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2013-07-22 20:52:42 +00:00
|
|
|
static int preinit(struct vo *vo)
|
2002-01-26 16:01:26 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
|
|
|
p->vo = vo;
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (!vo_x11_init(vo))
|
2004-06-14 04:53:03 +00:00
|
|
|
return -1; // Can't open X11
|
2013-01-26 21:37:47 +00:00
|
|
|
find_x11_depth(vo);
|
2013-07-18 11:44:56 +00:00
|
|
|
p->sws = mp_sws_alloc(vo);
|
2002-02-17 08:24:43 +00:00
|
|
|
return 0;
|
2002-01-26 16:01:26 +00:00
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static int control(struct vo *vo, uint32_t request, void *data)
|
2002-01-26 16:01:26 +00:00
|
|
|
{
|
input: handle mouse movement differently
Before this commit, mouse movement events emitted a special command
("set_mouse_pos"), which was specially handled in command.c. This was
once special-cased to the dvdnav and menu code, and did nothing after
libmenu and dvdnav were removed.
Change it so that mouse movement triggers a pseudo-key ("MOUSE_MOVE"),
which then can be bound to an arbitrary command. The mouse position is
now managed in input.c. A command which actually needs the mouse
position can use either mp_input_get_mouse_pos() or mp_get_osd_mouse_pos()
to query it. The former returns raw window-space coordinates, while the
latter returns coordinates transformed to OSD- space. (Both are the same
for most VOs, except vo_xv and vo_x11, which can't render OSD in
window-space. These require extra code for mapping mouse position.)
As of this commit, there is still nothing that uses mouse movement, so
MOUSE_MOVE is mapped to "ignore" to silence warnings when moving the
mouse (much like MOUSE_BTN0).
Extend the concept of input sections. Allow multiple sections to be
active at once, and organize them as stack. Bindings from the top of
the stack are preferred to lower ones.
Each section has a mouse input section associated, inside which mouse
events are associated with the bindings. If the mouse pointer is
outside of a section's mouse area, mouse events will be dispatched to
an input section lower on the stack of active sections. This is intended
for scripting, which is to be added later. Two scripts could occupy
different areas of the screen without conflicting with each other. (If
it turns out that this mechanism is useless, we'll just remove it
again.)
2013-04-26 00:13:30 +00:00
|
|
|
struct priv *p = vo->priv;
|
2012-08-06 20:13:24 +00:00
|
|
|
switch (request) {
|
|
|
|
case VOCTRL_SET_EQUALIZER:
|
2003-08-31 22:27:10 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct voctrl_set_equalizer_args *args = data;
|
2013-09-29 22:37:44 +00:00
|
|
|
struct vf_seteq eq = {args->name, args->value};
|
|
|
|
if (mp_sws_set_vf_equalizer(p->sws, &eq) == 0)
|
|
|
|
break;
|
|
|
|
return true;
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
|
|
|
case VOCTRL_GET_EQUALIZER:
|
|
|
|
{
|
|
|
|
struct voctrl_get_equalizer_args *args = data;
|
2013-09-29 22:37:44 +00:00
|
|
|
struct vf_seteq eq = {args->name};
|
|
|
|
if (mp_sws_get_vf_equalizer(p->sws, &eq) == 0)
|
|
|
|
break;
|
|
|
|
*(int *)args->valueptr = eq.value;
|
|
|
|
return true;
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
2013-03-14 14:49:32 +00:00
|
|
|
case VOCTRL_GET_PANSCAN:
|
|
|
|
return VO_TRUE;
|
|
|
|
case VOCTRL_SET_PANSCAN:
|
2014-12-14 21:01:30 +00:00
|
|
|
if (vo->config_ok)
|
|
|
|
resize(vo);
|
2013-03-14 14:49:32 +00:00
|
|
|
return VO_TRUE;
|
2012-11-21 18:03:00 +00:00
|
|
|
case VOCTRL_REDRAW_FRAME:
|
2014-06-18 18:04:59 +00:00
|
|
|
draw_image(vo, p->original_image);
|
video/out: always support redrawing VO window at any point
Before, a VO could easily refuse to respond to VOCTRL_REDRAW_FRAME,
which means the VO wouldn't redraw OSD and window contents, and the
player would appear frozen to the user. This was a bit stupid, and makes
dealing with some corner cases much harder (think of --keep-open, which
was hard to implement, because the VO gets into this state if there are
no new video frames after a seek reset).
Change this, and require VOs to always react to VOCTRL_REDRAW_FRAME.
There are two aspects of this: First, behavior after a (successful)
vo_reconfig() call, but before any video frame has been displayed.
Second, behavior after a vo_seek_reset().
For the first issue, we define that sending VOCTRL_REDRAW_FRAME after
vo_reconfig() should clear the window with black. This requires minor
changes to some VOs. In particular vaapi makes this horribly
complicated, because OSD rendering is bound to a video surface. We
create a black dummy surface for this purpose.
The second issue is much simpler and works already with most VOs: they
simply redraw whatever has been uploaded previously. The exception is
vdpau, which has a complicated mechanism to track and filter video
frames. The state associated with this mechanism is completely cleared
with vo_seek_reset(), so implementing this to work as expected is not
trivial. For now, we just clear the window with black.
2013-10-01 21:35:51 +00:00
|
|
|
return true;
|
2012-11-21 17:52:41 +00:00
|
|
|
}
|
2013-05-16 12:02:28 +00:00
|
|
|
|
|
|
|
int events = 0;
|
|
|
|
int r = vo_x11_control(vo, &events, request, data);
|
2014-12-14 21:01:30 +00:00
|
|
|
if (vo->config_ok && (events & (VO_EVENT_EXPOSE | VO_EVENT_RESIZE)))
|
2013-05-16 12:02:28 +00:00
|
|
|
resize(vo);
|
2014-11-02 19:26:51 +00:00
|
|
|
vo_event(vo, events);
|
2013-05-16 12:02:28 +00:00
|
|
|
return r;
|
2002-01-26 16:01:26 +00:00
|
|
|
}
|
2012-08-06 20:13:24 +00:00
|
|
|
|
|
|
|
const struct vo_driver video_out_x11 = {
|
2013-10-23 17:06:14 +00:00
|
|
|
.description = "X11 ( XImage/Shm )",
|
|
|
|
.name = "x11",
|
2012-08-06 20:13:24 +00:00
|
|
|
.priv_size = sizeof(struct priv),
|
2013-03-14 14:49:32 +00:00
|
|
|
.options = (const struct m_option []){{0}},
|
2012-08-06 20:13:24 +00:00
|
|
|
.preinit = preinit,
|
2012-11-04 15:24:18 +00:00
|
|
|
.query_format = query_format,
|
2013-07-18 11:44:56 +00:00
|
|
|
.reconfig = reconfig,
|
2012-08-06 20:13:24 +00:00
|
|
|
.control = control,
|
2012-11-04 14:56:04 +00:00
|
|
|
.draw_image = draw_image,
|
2012-08-06 20:13:24 +00:00
|
|
|
.flip_page = flip_page,
|
|
|
|
.uninit = uninit,
|
|
|
|
};
|