2009-02-08 03:27:30 +00:00
|
|
|
/*
|
|
|
|
* This file is part of MPlayer.
|
|
|
|
*
|
|
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* MPlayer 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 General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
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
|
|
|
|
|
|
|
#include "config.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "vo.h"
|
2008-11-23 20:17:46 +00:00
|
|
|
#include "aspect.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "video/csputils.h"
|
|
|
|
#include "video/mp_image.h"
|
|
|
|
#include "video/vfcap.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"
|
|
|
|
|
2003-12-27 19:45:54 +00:00
|
|
|
#ifdef HAVE_SHM
|
|
|
|
#include <sys/ipc.h>
|
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <X11/extensions/XShm.h>
|
|
|
|
#endif
|
|
|
|
|
2011-01-26 17:40:52 +00:00
|
|
|
#include "sub/sub.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"
|
2006-06-18 10:59:23 +00:00
|
|
|
#define MODE_RGB 0x1
|
|
|
|
#define MODE_BGR 0x2
|
2001-10-15 19:33:26 +00:00
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/mp_msg.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
|
|
|
extern int sws_flags;
|
2001-02-24 20:28:24 +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
|
|
|
int int_pause;
|
2003-08-31 22:27:10 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
int Flip_Flag;
|
|
|
|
int zoomFlag;
|
2001-11-18 14:09:56 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
uint32_t image_width;
|
|
|
|
uint32_t image_height;
|
|
|
|
uint32_t in_format;
|
|
|
|
uint32_t out_format;
|
|
|
|
int out_offset;
|
|
|
|
int srcW;
|
|
|
|
int srcH;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
int old_vo_dwidth;
|
|
|
|
int old_vo_dheight;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
struct SwsContext *swsContext;
|
|
|
|
int dst_width;
|
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 visible_buf;
|
|
|
|
int num_buffers;
|
|
|
|
int total_buffers;
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
int Shmem_Flag;
|
2013-01-02 12:20:38 +00:00
|
|
|
#ifdef 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
|
|
|
int gXErrorFlag;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
static void flip_page(struct vo *vo);
|
|
|
|
|
|
|
|
static void check_events(struct vo *vo)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
|
|
|
|
|
|
|
int ret = vo_x11_check_events(vo);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-11-23 20:49:05 +00:00
|
|
|
if (ret & VO_EVENT_RESIZE)
|
2012-08-06 20:13:24 +00:00
|
|
|
vo_x11_clearwindow(vo, vo->x11->window);
|
2008-11-23 20:49:05 +00:00
|
|
|
else if (ret & VO_EVENT_EXPOSE)
|
2013-01-02 12:20:38 +00:00
|
|
|
vo_x11_clearwindow_part(vo, vo->x11->window,
|
|
|
|
p->myximage[p->current_buf]->width,
|
|
|
|
p->myximage[p->current_buf]->height);
|
2012-08-06 20:13:24 +00:00
|
|
|
if (ret & VO_EVENT_EXPOSE && p->int_pause)
|
|
|
|
flip_page(vo);
|
2001-02-24 20:28: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. */
|
|
|
|
static int find_depth_from_visuals(Display * dpy, int screen,
|
|
|
|
Visual ** visual_return)
|
|
|
|
{
|
|
|
|
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++)
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"vo: X11 truecolor visual %#lx, depth %d, R:%lX G:%lX B:%lX\n",
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
static void 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;
|
2002-01-30 15:26:11 +00:00
|
|
|
#ifdef HAVE_SHM
|
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;
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
|
|
|
"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) {
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
|
|
|
"Shared memory error,disabling ( Ximage error )\n");
|
|
|
|
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]);
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "%s\n", strerror(errno));
|
|
|
|
//perror( strerror( errno ) );
|
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
|
|
|
"Shared memory error,disabling ( seg id error )\n");
|
|
|
|
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]);
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
|
|
|
"Shared memory error,disabling ( address error )\n");
|
|
|
|
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
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->gXErrorFlag) {
|
2013-01-02 12:20:38 +00:00
|
|
|
XDestroyImage(p->myximage[foo]);
|
|
|
|
shmdt(p->Shminfo[foo].shmaddr);
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_WARN, "Shared memory error,disabling.\n");
|
2012-08-06 20:13:24 +00:00
|
|
|
p->gXErrorFlag = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
goto shmemerror;
|
|
|
|
} else
|
2013-01-02 12:20:38 +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) {
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "Sharing memory.\n");
|
|
|
|
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);
|
2013-01-02 12:20:38 +00:00
|
|
|
p->ImageDataOrig[foo] =
|
|
|
|
malloc(p->myximage[foo]->bytes_per_line * p->image_height + 32);
|
|
|
|
p->myximage[foo]->data = p->ImageDataOrig[foo] + 16
|
|
|
|
- ((long)p->ImageDataOrig & 15);
|
|
|
|
memset(p->myximage[foo]->data, 0, p->myximage[foo]->bytes_per_line
|
|
|
|
* p->image_height);
|
|
|
|
p->ImageData[foo] = p->myximage[foo]->data;
|
2002-01-30 15:26:11 +00:00
|
|
|
#ifdef HAVE_SHM
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
2002-01-30 15:26:11 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
static void freeMyXImage(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;
|
2002-01-30 15:26:11 +00:00
|
|
|
#ifdef HAVE_SHM
|
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[] = {
|
2012-08-06 20:13:24 +00:00
|
|
|
{IMGFMT_RGB8, BO_NATIVE, 0x00000007, 0x00000038, 0x000000C0},
|
|
|
|
{IMGFMT_RGB8, BO_NONNATIVE, 0x00000007, 0x00000038, 0x000000C0},
|
|
|
|
{IMGFMT_BGR8, BO_NATIVE, 0x000000E0, 0x0000001C, 0x00000003},
|
|
|
|
{IMGFMT_BGR8, BO_NONNATIVE, 0x000000E0, 0x0000001C, 0x00000003},
|
|
|
|
{IMGFMT_RGB15, BO_NATIVE, 0x0000001F, 0x000003E0, 0x00007C00},
|
|
|
|
{IMGFMT_BGR15, BO_NATIVE, 0x00007C00, 0x000003E0, 0x0000001F},
|
|
|
|
{IMGFMT_RGB16, BO_NATIVE, 0x0000001F, 0x000007E0, 0x0000F800},
|
|
|
|
{IMGFMT_BGR16, 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},
|
|
|
|
{0}
|
2006-10-23 15:49:44 +00:00
|
|
|
};
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static int config(struct vo *vo, uint32_t width, uint32_t height,
|
|
|
|
uint32_t d_width, uint32_t d_height, uint32_t flags,
|
|
|
|
uint32_t format)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
|
|
|
|
2007-12-02 20:43:35 +00:00
|
|
|
const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
mp_image_unrefp(&p->original_image);
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
p->Flip_Flag = flags & VOFLAG_FLIPPING;
|
2012-11-15 14:03:40 +00:00
|
|
|
p->zoomFlag = 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
p->old_vo_dwidth = -1;
|
|
|
|
p->old_vo_dheight = -1;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
p->in_format = format;
|
|
|
|
p->srcW = width;
|
|
|
|
p->srcH = height;
|
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-01-26 21:37:47 +00:00
|
|
|
p->depth = find_depth_from_visuals(vo->x11->display, vo->x11->screen,
|
|
|
|
&visual);
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
|
|
|
if (!XMatchVisualInfo(vo->x11->display, vo->x11->screen, p->depth,
|
|
|
|
DirectColor, &p->vinfo)
|
|
|
|
|| (WinID > 0
|
|
|
|
&& p->vinfo.visualid != XVisualIDFromVisual(p->attribs.visual)))
|
|
|
|
{
|
|
|
|
XMatchVisualInfo(vo->x11->display, vo->x11->screen, p->depth, TrueColor,
|
|
|
|
&p->vinfo);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2001-08-29 15:09:19 +00:00
|
|
|
|
2009-07-06 23:26:13 +00:00
|
|
|
/* set image size (which is indeed neither the input nor output size),
|
2012-11-04 17:16:36 +00:00
|
|
|
if zoom is on it will be changed during draw_image anyway so we don't
|
2012-08-06 20:13:24 +00:00
|
|
|
duplicate the aspect code here
|
2004-06-14 04:53:03 +00:00
|
|
|
*/
|
2012-08-06 20:13:24 +00:00
|
|
|
p->image_width = (width + 7) & (~7);
|
|
|
|
p->image_height = height;
|
2002-02-11 13:45:26 +00:00
|
|
|
|
2013-01-27 11:01:08 +00:00
|
|
|
vo_x11_create_vo_window(vo, &p->vinfo, vo->dx, vo->dy, vo->dwidth,
|
|
|
|
vo->dheight, flags, "x11");
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (WinID > 0) {
|
|
|
|
unsigned depth, dummy_uint;
|
|
|
|
int dummy_int;
|
|
|
|
Window dummy_win;
|
|
|
|
XGetGeometry(vo->x11->display, vo->x11->window, &dummy_win, &dummy_int,
|
|
|
|
&dummy_int, &dummy_uint, &dummy_uint, &dummy_uint, &depth);
|
|
|
|
p->depth = depth;
|
|
|
|
}
|
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < p->total_buffers; i++)
|
|
|
|
freeMyXImage(p, i);
|
|
|
|
sws_freeContext(p->swsContext);
|
|
|
|
p->num_buffers = 2;
|
|
|
|
p->total_buffers = p->num_buffers;
|
|
|
|
for (i = 0; i < p->total_buffers; i++)
|
|
|
|
getMyXImage(p, i);
|
2001-02-24 20:28:24 +00:00
|
|
|
|
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) {
|
2012-08-06 20:13:24 +00:00
|
|
|
mp_msg(
|
|
|
|
MSGT_VO, MSGL_ERR,
|
|
|
|
"X server image format not supported, please contact the developers\n");
|
|
|
|
return -1;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2012-08-06 20:13:24 +00:00
|
|
|
p->out_format = fmte->mpfmt;
|
2013-01-02 12:20:38 +00:00
|
|
|
p->bpp = p->myximage[0]->bits_per_pixel;
|
2012-08-06 20:13:24 +00:00
|
|
|
p->out_offset = 0;
|
2012-02-07 21:56:45 +00:00
|
|
|
// We can easily "emulate" non-native RGB32 and BGR32
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->out_format == (IMGFMT_BGR32 | 128)
|
|
|
|
|| p->out_format == (IMGFMT_RGB32 | 128))
|
|
|
|
{
|
|
|
|
p->out_format &= ~128;
|
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
|
2012-08-06 20:13:24 +00:00
|
|
|
p->out_offset = 1;
|
2006-12-12 19:13:48 +00:00
|
|
|
#else
|
2012-08-06 20:13:24 +00:00
|
|
|
p->out_offset = -1;
|
2006-12-12 19:13:48 +00:00
|
|
|
#endif
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
/* always allocate swsContext as size could change between frames */
|
2012-08-06 20:13:24 +00:00
|
|
|
p->swsContext = sws_getContextFromCmdLine(width, height, p->in_format,
|
|
|
|
width, height, p->out_format);
|
|
|
|
if (!p->swsContext)
|
2004-06-14 04:53:03 +00:00
|
|
|
return -1;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
p->dst_width = width;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static void Display_Image(struct priv *p, XImage *myximage, uint8_t *ImageData)
|
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];
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
int x = (vo->dwidth - p->dst_width) / 2;
|
2013-01-02 12:20:38 +00:00
|
|
|
int y = (vo->dheight - x_image->height) / 2;
|
2008-11-23 20:39:15 +00:00
|
|
|
|
|
|
|
// do not draw if the image needs rescaling
|
2012-08-06 20:13:24 +00:00
|
|
|
if ((p->old_vo_dwidth != vo->dwidth ||
|
|
|
|
p->old_vo_dheight != vo->dheight) && p->zoomFlag)
|
|
|
|
return;
|
2008-11-23 20:39:15 +00:00
|
|
|
|
2008-11-15 22:48:41 +00:00
|
|
|
if (WinID == 0) {
|
2012-08-06 20:13:24 +00:00
|
|
|
x = vo->dx;
|
|
|
|
y = vo->dy;
|
2008-11-15 22:48:41 +00:00
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
x_image->data += p->out_offset;
|
2001-11-19 15:51:17 +00:00
|
|
|
#ifdef HAVE_SHM
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->Shmem_Flag) {
|
|
|
|
XShmPutImage(vo->x11->display, vo->x11->window, vo->x11->vo_gc,
|
2013-01-02 12:20:38 +00:00
|
|
|
x_image, 0, 0, x, y, p->dst_width, x_image->height,
|
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
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
XPutImage(vo->x11->display, vo->x11->window, vo->x11->vo_gc,
|
2013-01-02 12:20:38 +00:00
|
|
|
x_image, 0, 0, x, y, p->dst_width, x_image->height);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2013-01-02 12:20:38 +00:00
|
|
|
x_image->data -= p->out_offset;
|
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};
|
2012-11-10 01:02:24 +00:00
|
|
|
mp_image_set_size(&img, p->image_width, p->image_height);
|
2012-10-07 19:24:22 +00:00
|
|
|
mp_image_setfmt(&img, p->out_format);
|
|
|
|
|
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
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static void draw_osd(struct vo *vo, struct osd_state *osd)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
2012-10-07 19:24:22 +00:00
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
struct mp_image img = get_x_buffer(p, p->current_buf);
|
2012-10-07 19:24:22 +00:00
|
|
|
|
VO, sub: refactor
Remove VFCTRL_DRAW_OSD, VFCAP_EOSD_FILTER, VFCAP_EOSD_RGBA, VFCAP_EOSD,
VOCTRL_DRAW_EOSD, VOCTRL_GET_EOSD_RES, VOCTRL_QUERY_EOSD_FORMAT.
Remove draw_osd_with_eosd(), which rendered the OSD by calling
VOCTRL_DRAW_EOSD. Change VOs to call osd_draw() directly, which takes
a callback as argument. (This basically works like the old OSD API,
except multiple OSD bitmap formats are supported and caching is
possible.)
Remove all mentions of "eosd". It's simply "osd" now.
Make OSD size per-OSD-object, as they can be different when using
vf_sub. Include display_par/video_par in resolution change detection.
Fix the issue with margin borders in vo_corevideo.
2012-10-19 17:25:18 +00:00
|
|
|
struct mp_osd_res res = {
|
|
|
|
.w = img.w,
|
|
|
|
.h = img.h,
|
|
|
|
.display_par = vo->monitor_par,
|
|
|
|
.video_par = vo->aspdat.par,
|
2012-10-07 19:24:22 +00:00
|
|
|
};
|
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
osd_draw_on_image(osd, res, osd->vo_pts, 0, &img);
|
2001-03-03 21:46:39 +00:00
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2012-11-21 17:52:41 +00:00
|
|
|
static mp_image_t *get_screenshot(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct priv *p = vo->priv;
|
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
if (!p->original_image)
|
|
|
|
return NULL;
|
2012-11-21 17:52:41 +00:00
|
|
|
|
2012-12-22 16:50:15 +00:00
|
|
|
struct mp_image *res = mp_image_new_ref(p->original_image);
|
|
|
|
mp_image_set_display_size(res, vo->aspdat.prew, vo->aspdat.preh);
|
2012-11-21 17:52:41 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2013-01-02 11:55:52 +00:00
|
|
|
static void wait_for_completion(struct vo *vo, int max_outstanding)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_SHM
|
|
|
|
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) {
|
|
|
|
mp_msg(MSGT_VO, MSGL_WARN, "[VO_X11] X11 can't keep up! Waiting"
|
|
|
|
" for XShm completion events...\n");
|
|
|
|
ctx->Shm_Warned_Slow = 1;
|
|
|
|
}
|
|
|
|
usec_sleep(1000);
|
|
|
|
check_events(vo);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#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-01-02 12:20:38 +00:00
|
|
|
Display_Image(p, p->myximage[p->current_buf],
|
|
|
|
p->ImageData[p->current_buf]);
|
|
|
|
p->visible_buf = p->current_buf;
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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;
|
2009-03-29 14:37:21 +00:00
|
|
|
uint8_t *dst[MP_MAX_PLANES] = {NULL};
|
|
|
|
int dstStride[MP_MAX_PLANES] = {0};
|
2004-06-14 04:53:03 +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
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
if ((p->old_vo_dwidth != vo->dwidth || p->old_vo_dheight != vo->dheight)
|
|
|
|
/*&& y==0 */ && p->zoomFlag)
|
2002-02-05 19:54:38 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
int newW = vo->dwidth;
|
|
|
|
int newH = vo->dheight;
|
|
|
|
struct SwsContext *oldContext = p->swsContext;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
p->old_vo_dwidth = vo->dwidth;
|
|
|
|
p->old_vo_dheight = vo->dheight;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-11-23 20:17:46 +00:00
|
|
|
if (vo_fs)
|
2012-08-06 20:13:24 +00:00
|
|
|
aspect(vo, &newW, &newH, A_ZOOM);
|
2004-06-14 04:53:03 +00:00
|
|
|
if (sws_flags == 0)
|
|
|
|
newW &= (~31); // not needed but, if the user wants the FAST_BILINEAR SCALER, then its needed
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
p->swsContext
|
|
|
|
= sws_getContextFromCmdLine(p->srcW, p->srcH, p->in_format, newW,
|
|
|
|
newH, p->out_format);
|
|
|
|
if (p->swsContext) {
|
|
|
|
p->image_width = (newW + 7) & (~7);
|
|
|
|
p->image_height = newH;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-02 12:20:38 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < p->total_buffers; i++)
|
|
|
|
freeMyXImage(p, i);
|
2004-06-14 04:53:03 +00:00
|
|
|
sws_freeContext(oldContext);
|
2013-01-02 12:20:38 +00:00
|
|
|
for (i = 0; i < p->total_buffers; i++)
|
|
|
|
getMyXImage(p, i);
|
2004-06-14 04:53:03 +00:00
|
|
|
} else
|
2012-08-06 20:13:24 +00:00
|
|
|
p->swsContext = oldContext;
|
|
|
|
p->dst_width = newW;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2002-02-10 01:07:58 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
dstStride[0] = p->image_width * ((p->bpp + 7) / 8);
|
2013-01-02 12:20:38 +00:00
|
|
|
dst[0] = p->ImageData[p->current_buf];
|
2012-08-06 20:13:24 +00:00
|
|
|
if (p->Flip_Flag) {
|
|
|
|
dst[0] += dstStride[0] * (p->image_height - 1);
|
2007-05-12 09:06:07 +00:00
|
|
|
dstStride[0] = -dstStride[0];
|
2002-02-05 19:54:38 +00:00
|
|
|
}
|
2012-11-04 17:16:36 +00:00
|
|
|
sws_scale(p->swsContext, (const uint8_t **)mpi->planes, mpi->stride,
|
|
|
|
0, mpi->h, dst, dstStride);
|
2012-12-22 16:50:15 +00:00
|
|
|
|
|
|
|
mp_image_setrefp(&p->original_image, mpi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int redraw_frame(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct priv *p = vo->priv;
|
|
|
|
|
|
|
|
if (!p->original_image)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
draw_image(vo, p->original_image);
|
|
|
|
return true;
|
2012-11-04 14:56:04 +00:00
|
|
|
}
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static int query_format(struct vo *vo, uint32_t format)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
struct priv *p = vo->priv;
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_DBG2,
|
|
|
|
"vo_x11: 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++) {
|
|
|
|
if (fmt2Xfmt[n].mpfmt == format) {
|
2013-01-26 21:37:47 +00:00
|
|
|
if (IMGFMT_RGB_DEPTH(format) == p->ximage_depth) {
|
2012-12-24 00:10:57 +00:00
|
|
|
return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW |
|
|
|
|
VFCAP_OSD | VFCAP_FLIP;
|
|
|
|
} else {
|
|
|
|
return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_FLIP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-03-16 02:42:19 +00:00
|
|
|
}
|
2001-04-10 00:18:41 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
switch (format) {
|
video: decouple internal pixel formats from FourCCs
mplayer's video chain traditionally used FourCCs for pixel formats. For
example, it used IMGFMT_YV12 for 4:2:0 YUV, which was defined to the
string 'YV12' interpreted as unsigned int. Additionally, it used to
encode information into the numeric values of some formats. The RGB
formats had their bit depth and endian encoded into the least
significant byte. Extended planar formats (420P10 etc.) had chroma
shift, endian, and component bit depth encoded. (This has been removed
in recent commits.)
Replace the FourCC mess with a simple enum. Remove all the redundant
formats like YV12/I420/IYUV. Replace some image format names by
something more intuitive, most importantly IMGFMT_YV12 -> IMGFMT_420P.
Add img_fourcc.h, which contains the old IDs for code that actually uses
FourCCs. Change the way demuxers, that output raw video, identify the
video format: they set either MP_FOURCC_RAWVIDEO or MP_FOURCC_IMGFMT to
request the rawvideo decoder, and sh_video->imgfmt specifies the pixel
format. Like the previous hack, this is supposed to avoid the need for
a complete codecs.cfg entry per format, or other lookup tables. (Note
that the RGB raw video FourCCs mostly rely on ffmpeg's mappings for NUT
raw video, but this is still considered better than adding a raw video
decoder - even if trivial, it would be full of annoying lookup tables.)
The TV code has not been tested.
Some corrective changes regarding endian and other image format flags
creep in.
2012-12-23 19:03:30 +00:00
|
|
|
case IMGFMT_420P:
|
2012-12-12 22:55:41 +00:00
|
|
|
return VFCAP_CSP_SUPPORTED | VFCAP_OSD;
|
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;
|
|
|
|
|
|
|
|
depth = find_depth_from_visuals(x11->display, x11->screen, &visual);
|
|
|
|
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;
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"vo: X11 color mask: %X (R:%lX G:%lX B:%lX)\n", mask,
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo: X11 depth %d and %d bpp.\n", depth,
|
|
|
|
ximage_depth);
|
|
|
|
|
|
|
|
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);
|
2002-02-12 17:55:03 +00:00
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
sws_freeContext(p->swsContext);
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2012-08-06 20:13:24 +00:00
|
|
|
static int preinit(struct vo *vo, const char *arg)
|
2002-01-26 16:01:26 +00:00
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
|
|
|
p->vo = vo;
|
|
|
|
|
|
|
|
if (arg) {
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_ERR, "vo_x11: Unknown subdevice: %s\n", arg);
|
|
|
|
return ENOSYS;
|
2002-02-17 08:24:43 +00:00
|
|
|
}
|
2002-03-16 02:42:19 +00:00
|
|
|
|
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);
|
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
|
|
|
{
|
2012-08-06 20:13:24 +00:00
|
|
|
struct priv *p = vo->priv;
|
|
|
|
switch (request) {
|
|
|
|
case VOCTRL_PAUSE:
|
|
|
|
return p->int_pause = 1;
|
|
|
|
case VOCTRL_RESUME:
|
|
|
|
return p->int_pause = 0;
|
|
|
|
case VOCTRL_FULLSCREEN:
|
|
|
|
vo_x11_fullscreen(vo);
|
|
|
|
vo_x11_clearwindow(vo, vo->x11->window);
|
|
|
|
return VO_TRUE;
|
|
|
|
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;
|
|
|
|
return vo_x11_set_equalizer(vo, args->name, args->value);
|
|
|
|
}
|
|
|
|
case VOCTRL_GET_EQUALIZER:
|
|
|
|
{
|
|
|
|
struct voctrl_get_equalizer_args *args = data;
|
2013-01-26 21:37:47 +00:00
|
|
|
return vo_x11_get_equalizer(vo, args->name, args->valueptr);
|
2012-08-06 20:13:24 +00:00
|
|
|
}
|
|
|
|
case VOCTRL_ONTOP:
|
|
|
|
vo_x11_ontop(vo);
|
|
|
|
return VO_TRUE;
|
|
|
|
case VOCTRL_UPDATE_SCREENINFO:
|
2013-01-26 21:37:47 +00:00
|
|
|
vo_x11_update_screeninfo(vo);
|
2012-08-06 20:13:24 +00:00
|
|
|
return VO_TRUE;
|
2012-11-21 18:03:00 +00:00
|
|
|
case VOCTRL_REDRAW_FRAME:
|
|
|
|
return redraw_frame(vo);
|
2012-11-21 17:52:41 +00:00
|
|
|
case VOCTRL_SCREENSHOT: {
|
|
|
|
struct voctrl_screenshot_args *args = data;
|
|
|
|
args->out_image = get_screenshot(vo);
|
|
|
|
return true;
|
|
|
|
}
|
2003-08-31 22:27:10 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
return VO_NOTIMPL;
|
2002-01-26 16:01:26 +00:00
|
|
|
}
|
2012-08-06 20:13:24 +00:00
|
|
|
|
|
|
|
const struct vo_driver video_out_x11 = {
|
|
|
|
.info = &(const vo_info_t) {
|
|
|
|
"X11 ( XImage/Shm )",
|
|
|
|
"x11",
|
|
|
|
"Aaron Holtzman <aholtzma@ess.engr.uvic.ca>",
|
|
|
|
""
|
|
|
|
},
|
|
|
|
.priv_size = sizeof(struct priv),
|
|
|
|
.priv_defaults = &(const struct priv) {
|
|
|
|
.srcW = -1,
|
|
|
|
.srcH = -1,
|
|
|
|
.old_vo_dwidth = -1,
|
|
|
|
.old_vo_dheight = -1,
|
|
|
|
},
|
|
|
|
.preinit = preinit,
|
2012-11-04 15:24:18 +00:00
|
|
|
.query_format = query_format,
|
2012-08-06 20:13:24 +00:00
|
|
|
.config = config,
|
|
|
|
.control = control,
|
2012-11-04 14:56:04 +00:00
|
|
|
.draw_image = draw_image,
|
2012-08-06 20:13:24 +00:00
|
|
|
.draw_osd = draw_osd,
|
|
|
|
.flip_page = flip_page,
|
|
|
|
.check_events = check_events,
|
|
|
|
.uninit = uninit,
|
|
|
|
};
|