2009-02-08 03:27:30 +00:00
|
|
|
/*
|
|
|
|
* X11 Xv interface
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
2001-07-03 23:22:29 +00:00
|
|
|
// Number of buffers _FOR_DOUBLEBUFFERING_MODE_
|
|
|
|
// Use option -double to enable double buffering! (default: single buffer)
|
2002-07-20 15:49:38 +00:00
|
|
|
#define NUM_BUFFERS 3
|
|
|
|
|
|
|
|
/*
|
|
|
|
Buffer allocation:
|
|
|
|
|
|
|
|
-nodr:
|
|
|
|
1: TEMP
|
|
|
|
2: 2*TEMP
|
|
|
|
|
|
|
|
-dr:
|
|
|
|
1: TEMP
|
|
|
|
3: 2*STATIC+TEMP
|
|
|
|
*/
|
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "config.h"
|
2002-05-02 10:49:55 +00:00
|
|
|
#include "mp_msg.h"
|
2005-11-10 02:39:31 +00:00
|
|
|
#include "help_mp.h"
|
2001-02-24 20:28:24 +00:00
|
|
|
#include "video_out.h"
|
|
|
|
#include "video_out_internal.h"
|
|
|
|
|
|
|
|
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xutil.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
2001-03-03 21:46:39 +00:00
|
|
|
#include "x11_common.h"
|
|
|
|
|
2001-04-11 19:41:38 +00:00
|
|
|
#include "fastmemcpy.h"
|
2001-04-24 11:42:04 +00:00
|
|
|
#include "sub.h"
|
2001-10-03 14:53:15 +00:00
|
|
|
#include "aspect.h"
|
2001-04-11 12:47:45 +00:00
|
|
|
|
2005-02-20 22:43:25 +00:00
|
|
|
#include "subopt-helper.h"
|
|
|
|
|
2007-08-25 04:28:17 +00:00
|
|
|
#include "input/input.h"
|
|
|
|
|
2008-07-30 13:44:59 +00:00
|
|
|
#ifdef CONFIG_GUI
|
2007-04-23 07:42:42 +00:00
|
|
|
#include "gui/interface.h"
|
2002-05-03 20:57:13 +00:00
|
|
|
#endif
|
|
|
|
|
2008-02-14 14:39:49 +00:00
|
|
|
#include "libavutil/common.h"
|
2007-03-06 15:34:54 +00:00
|
|
|
|
2007-12-02 14:06:03 +00:00
|
|
|
static const vo_info_t info = {
|
2004-06-14 04:53:03 +00:00
|
|
|
"X11/Xv",
|
|
|
|
"xv",
|
|
|
|
"Gerd Knorr <kraxel@goldbach.in-berlin.de> and others",
|
|
|
|
""
|
2001-02-24 20:28:24 +00:00
|
|
|
};
|
|
|
|
|
2007-12-02 14:39:15 +00:00
|
|
|
const LIBVO_EXTERN(xv)
|
2003-09-12 15:50:35 +00:00
|
|
|
#ifdef HAVE_SHM
|
|
|
|
#include <sys/ipc.h>
|
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <X11/extensions/XShm.h>
|
|
|
|
|
|
|
|
static XShmSegmentInfo Shminfo[NUM_BUFFERS];
|
|
|
|
static int Shmem_Flag;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Note: depends on the inclusion of X11/extensions/XShm.h
|
2001-02-24 20:28:24 +00:00
|
|
|
#include <X11/extensions/Xv.h>
|
|
|
|
#include <X11/extensions/Xvlib.h>
|
2003-09-12 15:50:35 +00:00
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
// FIXME: dynamically allocate this stuff
|
|
|
|
static void allocate_xvimage(int);
|
2004-06-14 04:53:03 +00:00
|
|
|
static unsigned int ver, rel, req, ev, err;
|
2005-02-20 22:43:25 +00:00
|
|
|
static unsigned int formats, adaptors, xv_format;
|
2004-06-14 04:53:03 +00:00
|
|
|
static XvAdaptorInfo *ai = NULL;
|
2004-11-15 14:56:18 +00:00
|
|
|
static XvImageFormatValues *fo=NULL;
|
2001-05-01 01:32:59 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static int current_buf = 0;
|
|
|
|
static int current_ip_buf = 0;
|
|
|
|
static int num_buffers = 1; // default
|
2005-02-23 12:23:44 +00:00
|
|
|
static int visible_buf = -1; // -1 means: no buffer was drawn yet
|
2004-06-14 04:53:03 +00:00
|
|
|
static XvImage *xvimage[NUM_BUFFERS];
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2002-06-13 14:23:03 +00:00
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
static uint32_t image_width;
|
|
|
|
static uint32_t image_height;
|
|
|
|
static uint32_t image_format;
|
|
|
|
|
2003-08-31 22:27:10 +00:00
|
|
|
static int int_pause;
|
|
|
|
|
2009-02-12 17:40:53 +00:00
|
|
|
static struct vo_rect src_rect;
|
|
|
|
static struct vo_rect dst_rect;
|
2005-11-10 02:39:31 +00:00
|
|
|
static uint32_t max_width = 0, max_height = 0; // zero means: not set
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static void (*draw_alpha_fnc) (int x0, int y0, int w, int h,
|
|
|
|
unsigned char *src, unsigned char *srca,
|
|
|
|
int stride);
|
2001-08-23 11:04:23 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static void draw_alpha_yv12(int x0, int y0, int w, int h,
|
|
|
|
unsigned char *src, unsigned char *srca,
|
|
|
|
int stride)
|
|
|
|
{
|
|
|
|
x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
|
|
|
|
vo_draw_alpha_yv12(w, h, src, srca, stride,
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[0] +
|
|
|
|
xvimage[current_buf]->pitches[0] * y0 + x0,
|
|
|
|
xvimage[current_buf]->pitches[0]);
|
2001-08-23 11:04:23 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static void draw_alpha_yuy2(int x0, int y0, int w, int h,
|
|
|
|
unsigned char *src, unsigned char *srca,
|
|
|
|
int stride)
|
|
|
|
{
|
|
|
|
x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
|
|
|
|
vo_draw_alpha_yuy2(w, h, src, srca, stride,
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[0] +
|
|
|
|
xvimage[current_buf]->pitches[0] * y0 + 2 * x0,
|
|
|
|
xvimage[current_buf]->pitches[0]);
|
2001-08-23 11:04:23 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static void draw_alpha_uyvy(int x0, int y0, int w, int h,
|
|
|
|
unsigned char *src, unsigned char *srca,
|
|
|
|
int stride)
|
|
|
|
{
|
|
|
|
x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
|
|
|
|
vo_draw_alpha_yuy2(w, h, src, srca, stride,
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[0] +
|
|
|
|
xvimage[current_buf]->pitches[0] * y0 + 2 * x0 + 1,
|
|
|
|
xvimage[current_buf]->pitches[0]);
|
2001-08-23 11:04:23 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static void draw_alpha_null(int x0, int y0, int w, int h,
|
|
|
|
unsigned char *src, unsigned char *srca,
|
|
|
|
int stride)
|
|
|
|
{
|
2001-08-23 11:04:23 +00:00
|
|
|
}
|
|
|
|
|
2002-07-25 13:12:23 +00:00
|
|
|
|
2002-10-16 19:31:07 +00:00
|
|
|
static void deallocate_xvimage(int foo);
|
|
|
|
|
2009-02-12 17:40:53 +00:00
|
|
|
static void resize(void)
|
|
|
|
{
|
2009-02-17 11:59:49 +00:00
|
|
|
calc_src_dst_rects(image_width, image_height, &src_rect, &dst_rect, NULL, NULL);
|
2009-02-12 17:40:53 +00:00
|
|
|
vo_x11_clearwindow_part(mDisplay, vo_window, dst_rect.width, dst_rect.height, 1);
|
|
|
|
vo_xv_draw_colorkey(dst_rect.left, dst_rect.top, dst_rect.width, dst_rect.height);
|
|
|
|
}
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
/*
|
|
|
|
* connect to server, create and map window,
|
2001-02-24 20:28:24 +00:00
|
|
|
* allocate colors and (shared) memory
|
|
|
|
*/
|
2005-08-05 01:24:37 +00:00
|
|
|
static int config(uint32_t width, uint32_t height, uint32_t d_width,
|
2004-06-14 04:53:03 +00:00
|
|
|
uint32_t d_height, uint32_t flags, char *title,
|
|
|
|
uint32_t format)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
XVisualInfo vinfo;
|
|
|
|
XSetWindowAttributes xswa;
|
|
|
|
XWindowAttributes attribs;
|
|
|
|
unsigned long xswamask;
|
|
|
|
int depth;
|
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2008-11-23 12:30:39 +00:00
|
|
|
int vm = flags & VOFLAG_MODESWITCHING;
|
2002-01-31 00:37:59 +00:00
|
|
|
#endif
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
image_height = height;
|
|
|
|
image_width = width;
|
|
|
|
image_format = format;
|
2001-10-18 02:42:20 +00:00
|
|
|
|
2005-11-10 02:39:31 +00:00
|
|
|
if ((max_width != 0 && max_height != 0) &&
|
|
|
|
(image_width > max_width || image_height > max_height))
|
|
|
|
{
|
2006-11-08 14:55:37 +00:00
|
|
|
mp_msg( MSGT_VO, MSGL_ERR, MSGTR_VO_XV_ImagedimTooHigh,
|
2005-11-10 02:39:31 +00:00
|
|
|
image_width, image_height, max_width, max_height);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
int_pause = 0;
|
2005-02-23 12:23:44 +00:00
|
|
|
visible_buf = -1;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
num_buffers =
|
|
|
|
vo_doublebuffering ? (vo_directrendering ? NUM_BUFFERS : 2) : 1;
|
|
|
|
|
|
|
|
/* check image formats */
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
xv_format = 0;
|
|
|
|
for (i = 0; i < formats; i++)
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"Xvideo image format: 0x%x (%4.4s) %s\n", fo[i].id,
|
|
|
|
(char *) &fo[i].id,
|
|
|
|
(fo[i].format == XvPacked) ? "packed" : "planar");
|
|
|
|
if (fo[i].id == format)
|
|
|
|
xv_format = fo[i].id;
|
|
|
|
}
|
|
|
|
if (!xv_format)
|
|
|
|
return -1;
|
|
|
|
}
|
2001-10-18 02:42:20 +00:00
|
|
|
|
2008-07-30 13:44:59 +00:00
|
|
|
#ifdef CONFIG_GUI
|
2004-06-14 04:53:03 +00:00
|
|
|
if (use_gui)
|
2008-11-15 14:21:02 +00:00
|
|
|
guiGetEvent(guiSetShVideo, 0); // the GUI will set up / resize the window
|
2002-01-31 00:37:59 +00:00
|
|
|
else
|
|
|
|
#endif
|
2001-05-08 12:17:03 +00:00
|
|
|
{
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2004-06-14 04:53:03 +00:00
|
|
|
if (vm)
|
|
|
|
{
|
2008-11-15 18:56:25 +00:00
|
|
|
vo_vm_switch();
|
2008-11-15 19:14:09 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
#endif
|
|
|
|
XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay),
|
|
|
|
&attribs);
|
|
|
|
depth = attribs.depth;
|
|
|
|
if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
|
|
|
|
depth = 24;
|
|
|
|
XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
|
|
|
|
|
|
|
|
xswa.background_pixel = 0;
|
2005-02-20 22:43:25 +00:00
|
|
|
if (xv_ck_info.method == CK_METHOD_BACKGROUND)
|
|
|
|
{
|
|
|
|
xswa.background_pixel = xv_colorkey;
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
xswa.border_pixel = 0;
|
|
|
|
xswamask = CWBackPixel | CWBorderPixel;
|
|
|
|
|
2008-11-15 18:58:14 +00:00
|
|
|
vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, vo_dwidth, vo_dheight,
|
2007-06-27 10:26:13 +00:00
|
|
|
flags, CopyFromParent, "xv", title);
|
|
|
|
XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2004-06-14 04:53:03 +00:00
|
|
|
if (vm)
|
|
|
|
{
|
|
|
|
/* Grab the mouse pointer in our window */
|
|
|
|
if (vo_grabpointer)
|
|
|
|
XGrabPointer(mDisplay, vo_window, True, 0,
|
|
|
|
GrabModeAsync, GrabModeAsync,
|
|
|
|
vo_window, None, CurrentTime);
|
|
|
|
XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
|
|
|
|
}
|
2002-01-31 00:37:59 +00:00
|
|
|
#endif
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "using Xvideo port %d for hw scaling\n",
|
|
|
|
xv_port);
|
|
|
|
|
|
|
|
switch (xv_format)
|
|
|
|
{
|
|
|
|
case IMGFMT_YV12:
|
|
|
|
case IMGFMT_I420:
|
|
|
|
case IMGFMT_IYUV:
|
|
|
|
draw_alpha_fnc = draw_alpha_yv12;
|
|
|
|
break;
|
|
|
|
case IMGFMT_YUY2:
|
|
|
|
case IMGFMT_YVYU:
|
|
|
|
draw_alpha_fnc = draw_alpha_yuy2;
|
|
|
|
break;
|
|
|
|
case IMGFMT_UYVY:
|
|
|
|
draw_alpha_fnc = draw_alpha_uyvy;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
draw_alpha_fnc = draw_alpha_null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vo_config_count)
|
|
|
|
for (current_buf = 0; current_buf < num_buffers; ++current_buf)
|
|
|
|
deallocate_xvimage(current_buf);
|
|
|
|
|
|
|
|
for (current_buf = 0; current_buf < num_buffers; ++current_buf)
|
|
|
|
allocate_xvimage(current_buf);
|
|
|
|
|
|
|
|
current_buf = 0;
|
|
|
|
current_ip_buf = 0;
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2009-02-12 17:40:53 +00:00
|
|
|
resize();
|
2003-11-30 16:36:10 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static void allocate_xvimage(int foo)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
/*
|
|
|
|
* allocate XvImages. FIXME: no error checking, without
|
|
|
|
* mit-shm this will bomb... trzing to fix ::atmos
|
|
|
|
*/
|
2002-06-13 14:23:03 +00:00
|
|
|
#ifdef HAVE_SHM
|
2004-06-14 04:53:03 +00:00
|
|
|
if (mLocalDisplay && XShmQueryExtension(mDisplay))
|
|
|
|
Shmem_Flag = 1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Shmem_Flag = 0;
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
2006-11-08 14:55:37 +00:00
|
|
|
MSGTR_LIBVO_XV_SharedMemoryNotSupported);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
if (Shmem_Flag)
|
|
|
|
{
|
|
|
|
xvimage[foo] =
|
|
|
|
(XvImage *) XvShmCreateImage(mDisplay, xv_port, xv_format,
|
|
|
|
NULL, image_width, image_height,
|
|
|
|
&Shminfo[foo]);
|
|
|
|
|
|
|
|
Shminfo[foo].shmid =
|
|
|
|
shmget(IPC_PRIVATE, xvimage[foo]->data_size, IPC_CREAT | 0777);
|
|
|
|
Shminfo[foo].shmaddr = (char *) shmat(Shminfo[foo].shmid, 0, 0);
|
|
|
|
Shminfo[foo].readOnly = False;
|
|
|
|
|
|
|
|
xvimage[foo]->data = Shminfo[foo].shmaddr;
|
|
|
|
XShmAttach(mDisplay, &Shminfo[foo]);
|
|
|
|
XSync(mDisplay, False);
|
|
|
|
shmctl(Shminfo[foo].shmid, IPC_RMID, 0);
|
|
|
|
} else
|
2002-06-13 14:23:03 +00:00
|
|
|
#endif
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
xvimage[foo] =
|
|
|
|
(XvImage *) XvCreateImage(mDisplay, xv_port, xv_format, NULL,
|
|
|
|
image_width, image_height);
|
|
|
|
xvimage[foo]->data = malloc(xvimage[foo]->data_size);
|
|
|
|
XSync(mDisplay, False);
|
|
|
|
}
|
|
|
|
memset(xvimage[foo]->data, 128, xvimage[foo]->data_size);
|
|
|
|
return;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-08-31 10:06:32 +00:00
|
|
|
static void deallocate_xvimage(int foo)
|
|
|
|
{
|
2002-06-13 14:23:03 +00:00
|
|
|
#ifdef HAVE_SHM
|
2004-06-14 04:53:03 +00:00
|
|
|
if (Shmem_Flag)
|
|
|
|
{
|
|
|
|
XShmDetach(mDisplay, &Shminfo[foo]);
|
|
|
|
shmdt(Shminfo[foo].shmaddr);
|
|
|
|
} else
|
2002-06-13 14:23:03 +00:00
|
|
|
#endif
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
free(xvimage[foo]->data);
|
|
|
|
}
|
|
|
|
XFree(xvimage[foo]);
|
|
|
|
|
|
|
|
XSync(mDisplay, False);
|
|
|
|
return;
|
2001-08-31 10:06:32 +00:00
|
|
|
}
|
|
|
|
|
2005-02-23 12:23:44 +00:00
|
|
|
static inline void put_xvimage( XvImage * xvi )
|
|
|
|
{
|
|
|
|
#ifdef HAVE_SHM
|
|
|
|
if (Shmem_Flag)
|
|
|
|
{
|
|
|
|
XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
|
2009-02-12 17:40:53 +00:00
|
|
|
xvi,
|
|
|
|
src_rect.left, src_rect.top, src_rect.width, src_rect.height,
|
|
|
|
dst_rect.left, dst_rect.top, dst_rect.width, dst_rect.height,
|
2005-02-23 12:23:44 +00:00
|
|
|
False);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
|
2009-02-12 17:40:53 +00:00
|
|
|
xvi,
|
|
|
|
src_rect.left, src_rect.top, src_rect.width, src_rect.height,
|
|
|
|
dst_rect.left, dst_rect.top, dst_rect.width, dst_rect.height);
|
2005-02-23 12:23:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-03-03 21:46:39 +00:00
|
|
|
static void check_events(void)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
int e = vo_x11_check_events(mDisplay);
|
2003-08-31 22:27:10 +00:00
|
|
|
|
2005-02-20 22:43:25 +00:00
|
|
|
if (e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE)
|
|
|
|
{
|
2009-02-12 17:40:53 +00:00
|
|
|
resize();
|
2005-02-20 22:43:25 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && int_pause)
|
2005-02-23 12:23:44 +00:00
|
|
|
{
|
|
|
|
/* did we already draw a buffer */
|
|
|
|
if ( visible_buf != -1 )
|
|
|
|
{
|
|
|
|
/* redraw the last visible buffer */
|
|
|
|
put_xvimage( xvimage[visible_buf] );
|
|
|
|
}
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-08-13 11:08:18 +00:00
|
|
|
static void draw_osd(void)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
vo_draw_text(image_width -
|
|
|
|
image_width * vo_panscan_x / (vo_dwidth + vo_panscan_x),
|
|
|
|
image_height, draw_alpha_fnc);
|
|
|
|
}
|
2001-08-13 11:08:18 +00:00
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static void flip_page(void)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2005-02-23 12:23:44 +00:00
|
|
|
put_xvimage( xvimage[current_buf] );
|
|
|
|
|
|
|
|
/* remember the currently visible buffer */
|
|
|
|
visible_buf = current_buf;
|
2002-06-04 20:17:07 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
if (num_buffers > 1)
|
|
|
|
{
|
|
|
|
current_buf =
|
|
|
|
vo_directrendering ? 0 : ((current_buf + 1) % num_buffers);
|
|
|
|
XFlush(mDisplay);
|
|
|
|
} else
|
|
|
|
XSync(mDisplay, False);
|
|
|
|
return;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 01:24:37 +00:00
|
|
|
static int draw_slice(uint8_t * image[], int stride[], int w, int h,
|
2004-06-14 04:53:03 +00:00
|
|
|
int x, int y)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
uint8_t *dst;
|
|
|
|
|
|
|
|
dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[0] +
|
|
|
|
xvimage[current_buf]->pitches[0] * y + x;
|
|
|
|
memcpy_pic(dst, image[0], w, h, xvimage[current_buf]->pitches[0],
|
|
|
|
stride[0]);
|
|
|
|
|
|
|
|
x /= 2;
|
|
|
|
y /= 2;
|
|
|
|
w /= 2;
|
|
|
|
h /= 2;
|
|
|
|
|
|
|
|
dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[1] +
|
|
|
|
xvimage[current_buf]->pitches[1] * y + x;
|
|
|
|
if (image_format != IMGFMT_YV12)
|
|
|
|
memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1],
|
|
|
|
stride[1]);
|
|
|
|
else
|
|
|
|
memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1],
|
|
|
|
stride[2]);
|
|
|
|
|
|
|
|
dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[2] +
|
|
|
|
xvimage[current_buf]->pitches[2] * y + x;
|
|
|
|
if (image_format == IMGFMT_YV12)
|
|
|
|
memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1],
|
|
|
|
stride[1]);
|
|
|
|
else
|
|
|
|
memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1],
|
|
|
|
stride[2]);
|
2002-05-30 00:08:47 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 01:24:37 +00:00
|
|
|
static int draw_frame(uint8_t * src[])
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-11-15 16:40:48 +00:00
|
|
|
return VO_ERROR;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static uint32_t draw_image(mp_image_t * mpi)
|
|
|
|
{
|
|
|
|
if (mpi->flags & MP_IMGFLAG_DIRECT)
|
|
|
|
{
|
|
|
|
// direct rendering:
|
|
|
|
current_buf = (int) (mpi->priv); // hack!
|
|
|
|
return VO_TRUE;
|
2002-07-20 16:27:17 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
|
|
|
|
return VO_TRUE; // done
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR)
|
|
|
|
{
|
|
|
|
draw_slice(mpi->planes, mpi->stride, mpi->w, mpi->h, 0, 0);
|
|
|
|
return VO_TRUE;
|
2002-10-09 21:26:16 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
if (mpi->flags & MP_IMGFLAG_YUV)
|
|
|
|
{
|
|
|
|
// packed YUV:
|
|
|
|
memcpy_pic(xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[0], mpi->planes[0],
|
|
|
|
mpi->w * (mpi->bpp / 8), mpi->h,
|
|
|
|
xvimage[current_buf]->pitches[0], mpi->stride[0]);
|
|
|
|
return VO_TRUE;
|
2002-10-09 21:26:16 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
return VO_FALSE; // not (yet) supported
|
2002-07-20 16:27:17 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static uint32_t get_image(mp_image_t * mpi)
|
|
|
|
{
|
|
|
|
int buf = current_buf; // we shouldn't change current_buf unless we do DR!
|
|
|
|
|
|
|
|
if (mpi->type == MP_IMGTYPE_STATIC && num_buffers > 1)
|
|
|
|
return VO_FALSE; // it is not static
|
|
|
|
if (mpi->imgfmt != image_format)
|
|
|
|
return VO_FALSE; // needs conversion :(
|
2002-03-07 16:57:40 +00:00
|
|
|
// if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE; // slow video ram
|
2004-06-14 04:53:03 +00:00
|
|
|
if (mpi->flags & MP_IMGFLAG_READABLE &&
|
|
|
|
(mpi->type == MP_IMGTYPE_IPB || mpi->type == MP_IMGTYPE_IP))
|
|
|
|
{
|
|
|
|
// reference (I/P) frame of IP or IPB:
|
|
|
|
if (num_buffers < 2)
|
|
|
|
return VO_FALSE; // not enough
|
|
|
|
current_ip_buf ^= 1;
|
|
|
|
// for IPB with 2 buffers we can DR only one of the 2 P frames:
|
|
|
|
if (mpi->type == MP_IMGTYPE_IPB && num_buffers < 3
|
|
|
|
&& current_ip_buf)
|
|
|
|
return VO_FALSE;
|
|
|
|
buf = current_ip_buf;
|
|
|
|
if (mpi->type == MP_IMGTYPE_IPB)
|
|
|
|
++buf; // preserve space for B
|
2002-07-20 15:49:38 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
if (mpi->height > xvimage[buf]->height)
|
|
|
|
return VO_FALSE; //buffer to small
|
|
|
|
if (mpi->width * (mpi->bpp / 8) > xvimage[buf]->pitches[0])
|
|
|
|
return VO_FALSE; //buffer to small
|
|
|
|
if ((mpi->flags & (MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_ACCEPT_WIDTH))
|
|
|
|
|| (mpi->width * (mpi->bpp / 8) == xvimage[buf]->pitches[0]))
|
|
|
|
{
|
|
|
|
current_buf = buf;
|
|
|
|
mpi->planes[0] =
|
|
|
|
xvimage[current_buf]->data + xvimage[current_buf]->offsets[0];
|
|
|
|
mpi->stride[0] = xvimage[current_buf]->pitches[0];
|
|
|
|
mpi->width = mpi->stride[0] / (mpi->bpp / 8);
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PLANAR)
|
|
|
|
{
|
|
|
|
if (mpi->flags & MP_IMGFLAG_SWAPPED)
|
|
|
|
{
|
|
|
|
// I420
|
|
|
|
mpi->planes[1] =
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[1];
|
|
|
|
mpi->planes[2] =
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[2];
|
|
|
|
mpi->stride[1] = xvimage[current_buf]->pitches[1];
|
|
|
|
mpi->stride[2] = xvimage[current_buf]->pitches[2];
|
|
|
|
} else
|
|
|
|
{
|
|
|
|
// YV12
|
|
|
|
mpi->planes[1] =
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[2];
|
|
|
|
mpi->planes[2] =
|
|
|
|
xvimage[current_buf]->data +
|
|
|
|
xvimage[current_buf]->offsets[1];
|
|
|
|
mpi->stride[1] = xvimage[current_buf]->pitches[2];
|
|
|
|
mpi->stride[2] = xvimage[current_buf]->pitches[1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mpi->flags |= MP_IMGFLAG_DIRECT;
|
|
|
|
mpi->priv = (void *) current_buf;
|
|
|
|
// printf("mga: get_image() SUCCESS -> Direct Rendering ENABLED\n");
|
|
|
|
return VO_TRUE;
|
2002-03-07 16:57:40 +00:00
|
|
|
}
|
|
|
|
return VO_FALSE;
|
|
|
|
}
|
|
|
|
|
2005-08-05 01:24:37 +00:00
|
|
|
static int query_format(uint32_t format)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2003-09-12 15:50:35 +00:00
|
|
|
uint32_t i;
|
2004-06-14 04:53:03 +00:00
|
|
|
int flag = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_OSD | VFCAP_ACCEPT_STRIDE; // FIXME! check for DOWN
|
|
|
|
|
|
|
|
/* check image formats */
|
|
|
|
for (i = 0; i < formats; i++)
|
|
|
|
{
|
|
|
|
if (fo[i].id == format)
|
|
|
|
return flag; //xv_format = fo[i].id;
|
|
|
|
}
|
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static void uninit(void)
|
2001-09-04 15:21:00 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!vo_config_count)
|
|
|
|
return;
|
2005-02-23 12:23:44 +00:00
|
|
|
visible_buf = -1;
|
2004-06-14 04:53:03 +00:00
|
|
|
XvFreeAdaptorInfo(ai);
|
|
|
|
ai = NULL;
|
2004-11-15 14:56:18 +00:00
|
|
|
if(fo){
|
|
|
|
XFree(fo);
|
|
|
|
fo=NULL;
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
for (i = 0; i < num_buffers; i++)
|
|
|
|
deallocate_xvimage(i);
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2008-11-15 18:56:25 +00:00
|
|
|
vo_vm_close();
|
2002-05-08 20:24:35 +00:00
|
|
|
#endif
|
2007-08-25 04:28:17 +00:00
|
|
|
mp_input_rm_event_fd(ConnectionNumber(mDisplay));
|
2004-06-14 04:53:03 +00:00
|
|
|
vo_x11_uninit();
|
2001-04-09 22:27:27 +00:00
|
|
|
}
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2005-08-05 01:24:37 +00:00
|
|
|
static int preinit(const char *arg)
|
2002-01-26 16:01:26 +00:00
|
|
|
{
|
2002-04-07 02:10:39 +00:00
|
|
|
XvPortID xv_p;
|
2004-06-14 04:53:03 +00:00
|
|
|
int busy_ports = 0;
|
2003-09-12 15:50:35 +00:00
|
|
|
unsigned int i;
|
2005-02-20 22:43:25 +00:00
|
|
|
strarg_t ck_src_arg = { 0, NULL };
|
|
|
|
strarg_t ck_method_arg = { 0, NULL };
|
2008-05-13 17:52:25 +00:00
|
|
|
int xv_adaptor = -1;
|
2005-02-20 22:43:25 +00:00
|
|
|
|
2009-03-07 08:51:40 +00:00
|
|
|
const opt_t subopts[] =
|
2005-02-20 22:43:25 +00:00
|
|
|
{
|
|
|
|
/* name arg type arg var test */
|
|
|
|
{ "port", OPT_ARG_INT, &xv_port, (opt_test_f)int_pos },
|
2008-05-13 17:52:25 +00:00
|
|
|
{ "adaptor", OPT_ARG_INT, &xv_adaptor, (opt_test_f)int_non_neg },
|
2005-02-20 22:43:25 +00:00
|
|
|
{ "ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck },
|
|
|
|
{ "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm },
|
|
|
|
{ NULL }
|
|
|
|
};
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2003-09-06 13:40:00 +00:00
|
|
|
xv_port = 0;
|
|
|
|
|
2005-02-20 22:43:25 +00:00
|
|
|
/* parse suboptions */
|
|
|
|
if ( subopt_parse( arg, subopts ) != 0 )
|
2002-02-17 08:24:43 +00:00
|
|
|
{
|
2005-02-20 22:43:25 +00:00
|
|
|
return -1;
|
2002-02-17 08:24:43 +00:00
|
|
|
}
|
2005-02-20 22:43:25 +00:00
|
|
|
|
|
|
|
/* modify colorkey settings according to the given options */
|
|
|
|
xv_setup_colorkeyhandling( ck_method_arg.str, ck_src_arg.str );
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
if (!vo_init())
|
|
|
|
return -1;
|
2002-04-07 02:10:39 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
/* check for Xvideo extension */
|
|
|
|
if (Success != XvQueryExtension(mDisplay, &ver, &rel, &req, &ev, &err))
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
2006-11-08 14:55:37 +00:00
|
|
|
MSGTR_LIBVO_XV_XvNotSupportedByX11);
|
2004-06-14 04:53:03 +00:00
|
|
|
return -1;
|
2002-04-07 02:10:39 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
/* check for Xvideo support */
|
|
|
|
if (Success !=
|
|
|
|
XvQueryAdaptors(mDisplay, DefaultRootWindow(mDisplay), &adaptors,
|
|
|
|
&ai))
|
|
|
|
{
|
2006-11-08 14:55:37 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_XvQueryAdaptorsFailed);
|
2004-06-14 04:53:03 +00:00
|
|
|
return -1;
|
2002-04-07 02:10:39 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
/* check adaptors */
|
|
|
|
if (xv_port)
|
|
|
|
{
|
2003-09-07 18:58:56 +00:00
|
|
|
int port_found;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
for (port_found = 0, i = 0; !port_found && i < adaptors; i++)
|
|
|
|
{
|
|
|
|
if ((ai[i].type & XvInputMask) && (ai[i].type & XvImageMask))
|
|
|
|
{
|
|
|
|
for (xv_p = ai[i].base_id;
|
|
|
|
xv_p < ai[i].base_id + ai[i].num_ports; ++xv_p)
|
|
|
|
{
|
|
|
|
if (xv_p == xv_port)
|
|
|
|
{
|
2003-09-07 18:58:56 +00:00
|
|
|
port_found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
if (port_found)
|
|
|
|
{
|
2003-09-07 18:58:56 +00:00
|
|
|
if (XvGrabPort(mDisplay, xv_port, CurrentTime))
|
|
|
|
xv_port = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
} else
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
2006-11-08 14:55:37 +00:00
|
|
|
MSGTR_LIBVO_XV_InvalidPortParameter);
|
2003-09-07 18:58:56 +00:00
|
|
|
xv_port = 0;
|
|
|
|
}
|
2003-09-06 13:40:00 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
for (i = 0; i < adaptors && xv_port == 0; i++)
|
|
|
|
{
|
2008-05-13 17:52:25 +00:00
|
|
|
/* check if adaptor number has been specified */
|
|
|
|
if (xv_adaptor != -1 && xv_adaptor != i)
|
|
|
|
continue;
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
if ((ai[i].type & XvInputMask) && (ai[i].type & XvImageMask))
|
|
|
|
{
|
|
|
|
for (xv_p = ai[i].base_id;
|
|
|
|
xv_p < ai[i].base_id + ai[i].num_ports; ++xv_p)
|
|
|
|
if (!XvGrabPort(mDisplay, xv_p, CurrentTime))
|
|
|
|
{
|
|
|
|
xv_port = xv_p;
|
2008-06-15 12:13:29 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"[VO_XV] Using Xv Adapter #%d (%s)\n",
|
|
|
|
i, ai[i].name);
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
|
|
|
} else
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
2006-11-08 14:55:37 +00:00
|
|
|
MSGTR_LIBVO_XV_CouldNotGrabPort, (int) xv_p);
|
2004-06-14 04:53:03 +00:00
|
|
|
++busy_ports;
|
|
|
|
}
|
|
|
|
}
|
2002-04-07 02:10:39 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
if (!xv_port)
|
|
|
|
{
|
|
|
|
if (busy_ports)
|
|
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
2006-11-08 14:55:37 +00:00
|
|
|
MSGTR_LIBVO_XV_CouldNotFindFreePort);
|
2004-06-14 04:53:03 +00:00
|
|
|
else
|
|
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
2006-11-08 14:55:37 +00:00
|
|
|
MSGTR_LIBVO_XV_NoXvideoSupport);
|
2004-06-14 04:53:03 +00:00
|
|
|
return -1;
|
2002-04-07 02:10:39 +00:00
|
|
|
}
|
|
|
|
|
2005-02-20 22:43:25 +00:00
|
|
|
if ( !vo_xv_init_colorkey() )
|
2002-10-23 00:36:55 +00:00
|
|
|
{
|
2005-02-20 22:43:25 +00:00
|
|
|
return -1; // bail out, colorkey setup failed
|
2002-10-23 00:36:55 +00:00
|
|
|
}
|
2005-06-27 10:05:39 +00:00
|
|
|
vo_xv_enable_vsync();
|
2005-11-10 02:39:31 +00:00
|
|
|
vo_xv_get_max_img_dim( &max_width, &max_height );
|
2002-10-23 00:36:55 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
fo = XvListImageFormats(mDisplay, xv_port, (int *) &formats);
|
2002-04-11 21:07:00 +00:00
|
|
|
|
2007-08-25 04:28:17 +00:00
|
|
|
mp_input_add_event_fd(ConnectionNumber(mDisplay), check_events);
|
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
|
|
|
|
2005-08-05 01:24:37 +00:00
|
|
|
static int control(uint32_t request, void *data, ...)
|
2002-02-09 00:47:26 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
switch (request)
|
|
|
|
{
|
|
|
|
case VOCTRL_PAUSE:
|
2008-05-16 08:33:27 +00:00
|
|
|
return int_pause = 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
case VOCTRL_RESUME:
|
2008-05-16 08:33:27 +00:00
|
|
|
return int_pause = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
case VOCTRL_QUERY_FORMAT:
|
|
|
|
return query_format(*((uint32_t *) data));
|
|
|
|
case VOCTRL_GET_IMAGE:
|
|
|
|
return get_image(data);
|
|
|
|
case VOCTRL_DRAW_IMAGE:
|
|
|
|
return draw_image(data);
|
|
|
|
case VOCTRL_GUISUPPORT:
|
|
|
|
return VO_TRUE;
|
|
|
|
case VOCTRL_GET_PANSCAN:
|
|
|
|
if (!vo_config_count || !vo_fs)
|
|
|
|
return VO_FALSE;
|
|
|
|
return VO_TRUE;
|
|
|
|
case VOCTRL_FULLSCREEN:
|
|
|
|
vo_x11_fullscreen();
|
|
|
|
/* indended, fallthrough to update panscan on fullscreen/windowed switch */
|
|
|
|
case VOCTRL_SET_PANSCAN:
|
|
|
|
if ((vo_fs && (vo_panscan != vo_panscan_amount))
|
|
|
|
|| (!vo_fs && vo_panscan_amount))
|
|
|
|
{
|
|
|
|
int old_y = vo_panscan_y;
|
|
|
|
|
|
|
|
panscan_calc();
|
|
|
|
|
|
|
|
if (old_y != vo_panscan_y)
|
|
|
|
{
|
2009-02-12 17:40:53 +00:00
|
|
|
resize();
|
2004-06-14 04:53:03 +00:00
|
|
|
flip_page();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return VO_TRUE;
|
|
|
|
case VOCTRL_SET_EQUALIZER:
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int value;
|
|
|
|
|
|
|
|
va_start(ap, data);
|
|
|
|
value = va_arg(ap, int);
|
|
|
|
|
|
|
|
va_end(ap);
|
|
|
|
|
2008-05-16 08:33:27 +00:00
|
|
|
return vo_xv_set_eq(xv_port, data, value);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
case VOCTRL_GET_EQUALIZER:
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int *value;
|
|
|
|
|
|
|
|
va_start(ap, data);
|
|
|
|
value = va_arg(ap, int *);
|
|
|
|
|
|
|
|
va_end(ap);
|
|
|
|
|
2008-05-16 08:33:27 +00:00
|
|
|
return vo_xv_get_eq(xv_port, data, value);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
case VOCTRL_ONTOP:
|
|
|
|
vo_x11_ontop();
|
|
|
|
return VO_TRUE;
|
2007-02-17 20:58:55 +00:00
|
|
|
case VOCTRL_UPDATE_SCREENINFO:
|
|
|
|
update_xinerama_info();
|
|
|
|
return VO_TRUE;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
return VO_NOTIMPL;
|
2002-02-09 00:47:26 +00:00
|
|
|
}
|