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)
|
|
|
|
#define NUM_BUFFERS 2
|
2001-05-01 01:32:59 +00:00
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
/*
|
|
|
|
* vo_xv.c, X11 Xv interface
|
2001-02-24 20:28:24 +00:00
|
|
|
*
|
2001-03-21 19:10:55 +00:00
|
|
|
* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved.
|
2001-02-24 20:28:24 +00:00
|
|
|
*
|
|
|
|
* Hacked into mpeg2dec by
|
|
|
|
*
|
2001-03-21 19:10:55 +00:00
|
|
|
* Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
|
2001-02-24 20:28:24 +00:00
|
|
|
*
|
|
|
|
* Xv image suuport by Gerd Knorr <kraxel@goldbach.in-berlin.de>
|
2001-07-03 23:22:29 +00:00
|
|
|
* fullscreen support by Pontscho
|
|
|
|
* double buffering support by A'rpi
|
2001-02-24 20:28:24 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "video_out.h"
|
|
|
|
#include "video_out_internal.h"
|
|
|
|
|
|
|
|
LIBVO_EXTERN(xv)
|
|
|
|
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xutil.h>
|
|
|
|
#include <X11/extensions/XShm.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
|
|
|
|
2002-02-10 01:43:35 +00:00
|
|
|
#include "../postproc/rgb2rgb.h"
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static vo_info_t vo_info =
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2001-03-21 19:10:55 +00:00
|
|
|
"X11/Xv",
|
|
|
|
"xv",
|
|
|
|
"Gerd Knorr <kraxel@goldbach.in-berlin.de>",
|
|
|
|
""
|
2001-02-24 20:28:24 +00:00
|
|
|
};
|
|
|
|
|
2002-01-21 18:55:51 +00:00
|
|
|
extern int verbose;
|
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
/* since it doesn't seem to be defined on some platforms */
|
|
|
|
int XShmGetEventBase(Display*);
|
|
|
|
|
|
|
|
/* local data */
|
|
|
|
static unsigned char *ImageData;
|
|
|
|
|
|
|
|
/* X11 related variables */
|
2001-05-31 22:32:58 +00:00
|
|
|
//static Display *mydisplay;
|
2001-02-24 20:28:24 +00:00
|
|
|
static Window mywindow;
|
|
|
|
static GC mygc;
|
|
|
|
static XImage *myximage;
|
|
|
|
static int depth, bpp, mode;
|
|
|
|
static XWindowAttributes attribs;
|
|
|
|
|
|
|
|
#include <X11/extensions/Xv.h>
|
|
|
|
#include <X11/extensions/Xvlib.h>
|
|
|
|
// FIXME: dynamically allocate this stuff
|
|
|
|
static void allocate_xvimage(int);
|
|
|
|
static unsigned int ver,rel,req,ev,err;
|
|
|
|
static unsigned int formats, adaptors,i,xv_port,xv_format;
|
|
|
|
static XvAdaptorInfo *ai;
|
|
|
|
static XvImageFormatValues *fo;
|
2001-05-01 01:32:59 +00:00
|
|
|
|
|
|
|
static int current_buf=0;
|
2001-07-03 23:22:29 +00:00
|
|
|
static int num_buffers=1; // default
|
2001-05-01 01:32:59 +00:00
|
|
|
static XvImage* xvimage[NUM_BUFFERS];
|
2001-02-24 20:28:24 +00:00
|
|
|
|
|
|
|
#include <sys/ipc.h>
|
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <X11/extensions/XShm.h>
|
|
|
|
|
|
|
|
static int Shmem_Flag;
|
|
|
|
static int Quiet_Flag;
|
2001-05-01 01:32:59 +00:00
|
|
|
static XShmSegmentInfo Shminfo[NUM_BUFFERS];
|
2001-02-24 20:28:24 +00:00
|
|
|
static int gXErrorFlag;
|
|
|
|
static int CompletionType = -1;
|
|
|
|
|
|
|
|
static uint32_t image_width;
|
|
|
|
static uint32_t image_height;
|
|
|
|
static uint32_t image_format;
|
2002-02-10 01:43:35 +00:00
|
|
|
static int flip_flag;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static Window mRoot;
|
|
|
|
static uint32_t drwX,drwY,drwWidth,drwHeight,drwBorderWidth,drwDepth;
|
|
|
|
static uint32_t drwcX,drwcY,dwidth,dheight,mFullscreen;
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2001-08-30 16:05:04 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
2001-05-08 12:17:03 +00:00
|
|
|
static uint32_t mdwidth,mdheight;
|
|
|
|
#endif
|
|
|
|
|
2001-08-23 11:04:23 +00:00
|
|
|
static void (*draw_alpha_fnc)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride);
|
|
|
|
|
|
|
|
static void draw_alpha_yv12(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
|
|
|
|
vo_draw_alpha_yv12(w,h,src,srca,stride,xvimage[current_buf]->data+image_width*y0+x0,image_width);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void draw_alpha_yuy2(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
|
|
|
|
vo_draw_alpha_yuy2(w,h,src,srca,stride,xvimage[current_buf]->data+2*(image_width*y0+x0),2*image_width);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void draw_alpha_uyvy(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
|
|
|
|
vo_draw_alpha_yuy2(w,h,src,srca,stride,xvimage[current_buf]->data+2*(image_width*y0+x0)+1,2*image_width);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void draw_alpha_null(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
|
|
|
|
}
|
|
|
|
|
2002-01-28 08:37:58 +00:00
|
|
|
static int __xv_set_video_eq( const vidix_video_eq_t *info,int use_reset)
|
2002-01-21 18:55:51 +00:00
|
|
|
{
|
|
|
|
XvAttribute *attributes;
|
2002-01-22 18:19:02 +00:00
|
|
|
int howmany, xv_min,xv_max,xv_atomka;
|
|
|
|
static int was_reset = 0;
|
|
|
|
/* get available attributes */
|
2002-01-21 18:55:51 +00:00
|
|
|
attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany);
|
2002-01-22 18:19:02 +00:00
|
|
|
/* first pass try reset */
|
2002-01-28 08:37:58 +00:00
|
|
|
if(use_reset)
|
2002-01-22 18:19:02 +00:00
|
|
|
{
|
2002-01-28 08:37:58 +00:00
|
|
|
for (i = 0; i < howmany && attributes; i++)
|
|
|
|
{
|
2002-01-22 18:19:02 +00:00
|
|
|
if (attributes[i].flags & XvSettable && !strcmp(attributes[i].name,"XV_SET_DEFAULTS"
|
|
|
|
))
|
|
|
|
{
|
|
|
|
was_reset = 1;
|
|
|
|
if(verbose > 1) printf("vo_xv: reset gamma correction\n");
|
|
|
|
xv_atomka = XInternAtom(mDisplay, attributes[i].name, True);
|
|
|
|
XvSetPortAttribute(mDisplay, xv_port, xv_atomka, attributes[i].max_value);
|
|
|
|
}
|
2002-01-28 08:37:58 +00:00
|
|
|
}
|
|
|
|
/* for safety purposes */
|
|
|
|
if(!was_reset) return ENOSYS;
|
2002-01-22 18:19:02 +00:00
|
|
|
}
|
2002-01-21 18:55:51 +00:00
|
|
|
for (i = 0; i < howmany && attributes; i++)
|
|
|
|
{
|
|
|
|
if (attributes[i].flags & XvSettable)
|
|
|
|
{
|
|
|
|
xv_min = attributes[i].min_value;
|
|
|
|
xv_max = attributes[i].max_value;
|
|
|
|
xv_atomka = XInternAtom(mDisplay, attributes[i].name, True);
|
2002-01-22 18:19:02 +00:00
|
|
|
/* since we have SET_DEFAULTS first in our list, we can check if it's available
|
|
|
|
then trigger it if it's ok so that the other values are at default upon query */
|
2002-01-21 18:55:51 +00:00
|
|
|
if (xv_atomka != None)
|
|
|
|
{
|
|
|
|
int port_value,port_min,port_max,port_mid;
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_BRIGHTNESS") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_BRIGHTNESS))
|
|
|
|
port_value = info->brightness;
|
2002-01-21 18:55:51 +00:00
|
|
|
else
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_SATURATION") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_SATURATION))
|
|
|
|
port_value = info->saturation;
|
2002-01-21 18:55:51 +00:00
|
|
|
else
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_CONTRAST") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_CONTRAST))
|
|
|
|
port_value = info->contrast;
|
2002-01-21 18:55:51 +00:00
|
|
|
else
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_HUE") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_HUE))
|
|
|
|
port_value = info->hue;
|
2002-01-23 17:03:15 +00:00
|
|
|
else
|
|
|
|
/* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_RED_INTENSITY") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_RGB_INTENSITY))
|
|
|
|
port_value = info->red_intensity;
|
2002-01-23 17:03:15 +00:00
|
|
|
else
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_GREEN_INTENSITY") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_RGB_INTENSITY))
|
|
|
|
port_value = info->green_intensity;
|
2002-01-23 17:03:15 +00:00
|
|
|
else
|
2002-01-28 08:37:58 +00:00
|
|
|
if(strcmp(attributes[i].name,"XV_BLUE_INTENSITY") == 0
|
|
|
|
&& (info->cap & VEQ_CAP_RGB_INTENSITY))
|
|
|
|
port_value = info->blue_intensity;
|
2002-01-21 18:55:51 +00:00
|
|
|
else continue;
|
2002-01-23 17:03:15 +00:00
|
|
|
/* means that user has untouched this parameter since
|
|
|
|
NVidia driver has default == min for XV_HUE but not mid */
|
2002-01-29 10:07:05 +00:00
|
|
|
if(!port_value && use_reset) continue;
|
2002-01-21 18:55:51 +00:00
|
|
|
port_min = xv_min;
|
|
|
|
port_max = xv_max;
|
|
|
|
port_mid = (port_min + port_max) / 2;
|
|
|
|
port_value = port_mid + (port_value * (port_max - port_min)) / 2000;
|
|
|
|
if(verbose > 1)
|
|
|
|
printf("vo_xv: set gamma %s to %i (min %i max %i mid %i)\n",attributes[i].name,port_value,port_min,port_max,port_mid);
|
|
|
|
XvSetPortAttribute(mDisplay, xv_port, xv_atomka, port_value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-01-28 08:37:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int xv_set_video_eq( const vidix_video_eq_t *info)
|
|
|
|
{
|
|
|
|
return __xv_set_video_eq(info,0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int xv_get_video_eq( vidix_video_eq_t *info)
|
|
|
|
{
|
|
|
|
XvAttribute *attributes;
|
|
|
|
int howmany, xv_min,xv_max,xv_atomka;
|
|
|
|
/* get available attributes */
|
|
|
|
memset(info,0,sizeof(vidix_video_eq_t));
|
|
|
|
attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany);
|
|
|
|
for (i = 0; i < howmany && attributes; i++)
|
|
|
|
{
|
|
|
|
if (attributes[i].flags & XvGettable)
|
|
|
|
{
|
|
|
|
xv_min = attributes[i].min_value;
|
|
|
|
xv_max = attributes[i].max_value;
|
|
|
|
xv_atomka = XInternAtom(mDisplay, attributes[i].name, True);
|
|
|
|
/* since we have SET_DEFAULTS first in our list, we can check if it's available
|
|
|
|
then trigger it if it's ok so that the other values are at default upon query */
|
|
|
|
if (xv_atomka != None)
|
|
|
|
{
|
|
|
|
int port_value,port_min,port_max,port_mid;
|
|
|
|
XvGetPortAttribute(mDisplay, xv_port, xv_atomka, &port_value);
|
|
|
|
if(verbose>1) printf("vo_xv: get: %s = %i\n",attributes[i].name,port_value);
|
|
|
|
|
|
|
|
port_min = xv_min;
|
|
|
|
port_max = xv_max;
|
|
|
|
port_mid = (port_min + port_max) / 2;
|
|
|
|
port_value = ((port_value - port_mid)*2000)/(port_max-port_min);
|
|
|
|
|
|
|
|
if(verbose>1) printf("vo_xv: assume: %s = %i\n",attributes[i].name,port_value);
|
|
|
|
|
|
|
|
if(strcmp(attributes[i].name,"XV_BRIGHTNESS") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_BRIGHTNESS;
|
|
|
|
info->brightness = port_value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if(strcmp(attributes[i].name,"XV_SATURATION") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_SATURATION;
|
|
|
|
info->saturation = port_value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if(strcmp(attributes[i].name,"XV_CONTRAST") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_CONTRAST;
|
|
|
|
info->contrast = port_value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if(strcmp(attributes[i].name,"XV_HUE") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_HUE;
|
|
|
|
info->hue = port_value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */
|
|
|
|
if(strcmp(attributes[i].name,"XV_RED_INTENSITY") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_RGB_INTENSITY;
|
|
|
|
info->red_intensity = port_value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if(strcmp(attributes[i].name,"XV_GREEN_INTENSITY") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_RGB_INTENSITY;
|
|
|
|
info->green_intensity = port_value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
if(strcmp(attributes[i].name,"XV_BLUE_INTENSITY") == 0)
|
|
|
|
{
|
|
|
|
info->cap |= VEQ_CAP_RGB_INTENSITY;
|
|
|
|
info->blue_intensity = port_value;
|
|
|
|
}
|
|
|
|
else continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern int vo_gamma_brightness;
|
|
|
|
extern int vo_gamma_saturation;
|
|
|
|
extern int vo_gamma_contrast;
|
|
|
|
extern int vo_gamma_hue;
|
|
|
|
extern int vo_gamma_red_intensity;
|
|
|
|
extern int vo_gamma_green_intensity;
|
|
|
|
extern int vo_gamma_blue_intensity;
|
|
|
|
|
|
|
|
static void set_gamma_correction( void )
|
|
|
|
{
|
|
|
|
vidix_video_eq_t info;
|
|
|
|
/* try all */
|
|
|
|
info.cap = VEQ_CAP_BRIGHTNESS | VEQ_CAP_CONTRAST | VEQ_CAP_SATURATION |
|
|
|
|
VEQ_CAP_HUE | VEQ_CAP_RGB_INTENSITY;
|
|
|
|
info.flags = 0; /* doesn't matter for xv */
|
|
|
|
info.brightness = vo_gamma_brightness;
|
|
|
|
info.contrast = vo_gamma_contrast;
|
|
|
|
info.saturation = vo_gamma_saturation;
|
|
|
|
info.hue = vo_gamma_hue;
|
|
|
|
info.red_intensity = vo_gamma_red_intensity;
|
|
|
|
info.green_intensity = vo_gamma_green_intensity;
|
|
|
|
info.blue_intensity = vo_gamma_blue_intensity;
|
|
|
|
/* reset with XV_SET_DEFAULTS only once */
|
|
|
|
__xv_set_video_eq(&info,1);
|
2002-01-21 18:55:51 +00:00
|
|
|
}
|
2001-08-23 11:04:23 +00:00
|
|
|
|
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
|
|
|
|
*/
|
2002-01-31 09:57:13 +00:00
|
|
|
static uint32_t config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format,const vo_tune_info_t *info)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2001-05-31 22:32:58 +00:00
|
|
|
// int screen;
|
2001-03-21 19:10:55 +00:00
|
|
|
char *hello = (title == NULL) ? "Xv render" : title;
|
2001-05-31 22:32:58 +00:00
|
|
|
// char *name = ":0.0";
|
2001-03-21 19:10:55 +00:00
|
|
|
XSizeHints hint;
|
|
|
|
XVisualInfo vinfo;
|
|
|
|
XEvent xev;
|
2001-06-21 22:36:02 +00:00
|
|
|
XvPortID xv_p;
|
2001-03-21 19:10:55 +00:00
|
|
|
|
|
|
|
XGCValues xgcv;
|
|
|
|
XSetWindowAttributes xswa;
|
|
|
|
unsigned long xswamask;
|
2002-01-31 00:37:59 +00:00
|
|
|
#ifdef HAVE_XF86VM
|
|
|
|
int vm=0;
|
|
|
|
unsigned int modeline_width, modeline_height;
|
|
|
|
static uint32_t vm_width;
|
|
|
|
static uint32_t vm_height;
|
|
|
|
#endif
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2001-10-18 02:42:20 +00:00
|
|
|
aspect_save_orig(width,height);
|
|
|
|
aspect_save_prescale(d_width,d_height);
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
image_height = height;
|
|
|
|
image_width = width;
|
|
|
|
image_format=format;
|
|
|
|
|
2001-08-30 16:05:04 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
|
|
|
mdwidth=width;
|
|
|
|
mdheight=height;
|
|
|
|
#endif
|
|
|
|
|
2001-05-20 21:49:45 +00:00
|
|
|
mFullscreen=flags&1;
|
2002-01-31 00:37:59 +00:00
|
|
|
if( flags&0x02 ) vm = 1;
|
2002-02-10 01:43:35 +00:00
|
|
|
flip_flag=flags&8;
|
2001-07-03 23:22:29 +00:00
|
|
|
num_buffers=vo_doublebuffering?NUM_BUFFERS:1;
|
2001-05-31 22:32:58 +00:00
|
|
|
|
|
|
|
if (!vo_init()) return -1;
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2001-10-18 02:42:20 +00:00
|
|
|
aspect_save_screenres(vo_screenwidth,vo_screenheight);
|
|
|
|
|
2001-08-30 16:05:04 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
2001-05-08 12:17:03 +00:00
|
|
|
if ( vo_window == None )
|
2001-03-21 19:10:55 +00:00
|
|
|
{
|
2001-05-08 12:17:03 +00:00
|
|
|
#endif
|
|
|
|
hint.x = 0;
|
|
|
|
hint.y = 0;
|
|
|
|
hint.width = d_width;
|
|
|
|
hint.height = d_height;
|
2001-10-18 02:42:20 +00:00
|
|
|
aspect(&d_width,&d_height,A_NOZOOM);
|
2002-01-31 00:37:59 +00:00
|
|
|
#ifdef HAVE_XF86VM
|
|
|
|
if ( vm )
|
|
|
|
{
|
|
|
|
if ((d_width==0) && (d_height==0))
|
|
|
|
{ vm_width=image_width; vm_height=image_height; }
|
|
|
|
else
|
|
|
|
{ vm_width=d_width; vm_height=d_height; }
|
|
|
|
vo_vm_switch(vm_width, vm_height,&modeline_width, &modeline_height);
|
|
|
|
hint.x=(vo_screenwidth-modeline_width)/2;
|
|
|
|
hint.y=(vo_screenheight-modeline_height)/2;
|
|
|
|
hint.width=modeline_width;
|
|
|
|
hint.height=modeline_height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
2001-05-20 21:49:45 +00:00
|
|
|
if ( mFullscreen )
|
2001-05-08 12:17:03 +00:00
|
|
|
{
|
|
|
|
hint.width=vo_screenwidth;
|
|
|
|
hint.height=vo_screenheight;
|
2001-10-03 14:53:15 +00:00
|
|
|
#ifdef X11_FULLSCREEN
|
2001-10-01 15:58:31 +00:00
|
|
|
/* this code replaces X11_FULLSCREEN hack in mplayer.c
|
2001-10-03 14:53:15 +00:00
|
|
|
* aspect() is available through aspect.h for all vos.
|
2001-10-01 15:58:31 +00:00
|
|
|
* besides zooming should only be done with -zoom,
|
|
|
|
* but I leave the old -fs behaviour so users don't get
|
|
|
|
* irritated for now (and send lots o' mails ;) ::atmos
|
|
|
|
*/
|
|
|
|
|
2001-10-18 02:42:20 +00:00
|
|
|
aspect(&d_width,&d_height,A_ZOOM);
|
2001-10-01 15:58:31 +00:00
|
|
|
#endif
|
|
|
|
|
2001-05-08 12:17:03 +00:00
|
|
|
}
|
2001-10-18 02:42:20 +00:00
|
|
|
dwidth=d_width; dheight=d_height; //XXX: what are the copy vars used for?
|
2001-05-08 12:17:03 +00:00
|
|
|
hint.flags = PPosition | PSize;
|
2001-05-31 22:32:58 +00:00
|
|
|
XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &attribs);
|
2001-05-08 12:17:03 +00:00
|
|
|
depth=attribs.depth;
|
|
|
|
if (depth != 15 && depth != 16 && depth != 24 && depth != 32) depth = 24;
|
2001-05-31 22:32:58 +00:00
|
|
|
XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
|
2001-05-08 12:17:03 +00:00
|
|
|
|
|
|
|
xswa.background_pixel = 0;
|
|
|
|
xswa.border_pixel = 0;
|
|
|
|
xswamask = CWBackPixel | CWBorderPixel;
|
|
|
|
|
2001-12-28 13:24:27 +00:00
|
|
|
if ( WinID>=0 ){
|
|
|
|
mywindow = WinID ? ((Window)WinID) : RootWindow(mDisplay,mScreen);
|
|
|
|
XUnmapWindow( mDisplay,mywindow );
|
|
|
|
XChangeWindowAttributes( mDisplay,mywindow,xswamask,&xswa );
|
|
|
|
} else
|
|
|
|
|
2001-05-31 22:32:58 +00:00
|
|
|
mywindow = XCreateWindow(mDisplay, RootWindow(mDisplay,mScreen),
|
2001-12-28 13:24:27 +00:00
|
|
|
hint.x, hint.y, hint.width, hint.height,
|
|
|
|
0, depth,CopyFromParent,vinfo.visual,xswamask,&xswa);
|
|
|
|
|
2001-06-17 01:22:09 +00:00
|
|
|
vo_x11_classhint( mDisplay,mywindow,"xv" );
|
2001-05-31 22:32:58 +00:00
|
|
|
vo_hidecursor(mDisplay,mywindow);
|
|
|
|
|
2002-02-11 11:44:50 +00:00
|
|
|
XSelectInput(mDisplay, mywindow, StructureNotifyMask | KeyPressMask
|
|
|
|
#ifdef HAVE_NEW_INPUT
|
|
|
|
| ButtonPressMask | ButtonReleaseMask
|
|
|
|
#endif
|
|
|
|
);
|
2001-05-31 22:32:58 +00:00
|
|
|
XSetStandardProperties(mDisplay, mywindow, hello, hello, None, NULL, 0, &hint);
|
|
|
|
if ( mFullscreen ) vo_x11_decoration( mDisplay,mywindow,0 );
|
|
|
|
XMapWindow(mDisplay, mywindow);
|
2002-01-05 08:49:46 +00:00
|
|
|
#ifdef HAVE_XINERAMA
|
|
|
|
vo_x11_xinerama_move(mDisplay,mywindow);
|
|
|
|
#endif
|
2001-08-30 16:05:04 +00:00
|
|
|
mygc = XCreateGC(mDisplay, mywindow, 0L, &xgcv);
|
2001-05-31 22:32:58 +00:00
|
|
|
XFlush(mDisplay);
|
|
|
|
XSync(mDisplay, False);
|
2002-01-31 00:37:59 +00:00
|
|
|
#ifdef HAVE_XF86VM
|
|
|
|
if ( vm )
|
|
|
|
{
|
|
|
|
/* Grab the mouse pointer in our window */
|
|
|
|
XGrabPointer(mDisplay, mywindow, True, 0,
|
|
|
|
GrabModeAsync, GrabModeAsync,
|
|
|
|
mywindow, None, CurrentTime);
|
|
|
|
XSetInputFocus(mDisplay, mywindow, RevertToNone, CurrentTime);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-08-30 16:05:04 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
2001-03-21 19:10:55 +00:00
|
|
|
}
|
2001-05-08 12:17:03 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
mywindow=vo_window;
|
|
|
|
mygc=vo_gc;
|
|
|
|
}
|
|
|
|
#endif
|
2001-03-21 19:10:55 +00:00
|
|
|
|
|
|
|
xv_port = 0;
|
2001-05-31 22:32:58 +00:00
|
|
|
if (Success == XvQueryExtension(mDisplay,&ver,&rel,&req,&ev,&err))
|
2001-03-21 19:10:55 +00:00
|
|
|
{
|
|
|
|
/* check for Xvideo support */
|
2001-05-31 22:32:58 +00:00
|
|
|
if (Success != XvQueryAdaptors(mDisplay,DefaultRootWindow(mDisplay), &adaptors,&ai))
|
2001-03-21 19:10:55 +00:00
|
|
|
{
|
2001-04-24 11:30:57 +00:00
|
|
|
printf("Xv: XvQueryAdaptors failed");
|
2001-03-21 19:10:55 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* check adaptors */
|
2001-06-21 22:36:02 +00:00
|
|
|
for (i = 0; i < adaptors && xv_port == 0; i++)
|
2001-03-21 19:10:55 +00:00
|
|
|
{
|
2001-06-21 22:36:02 +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;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
printf("Xv: could not grab port %i\n", (int)xv_p);
|
|
|
|
}
|
2001-03-21 19:10:55 +00:00
|
|
|
}
|
|
|
|
/* check image formats */
|
|
|
|
if (xv_port != 0)
|
|
|
|
{
|
2001-05-31 22:32:58 +00:00
|
|
|
fo = XvListImageFormats(mDisplay, xv_port, (int*)&formats);
|
2001-03-21 19:10:55 +00:00
|
|
|
xv_format=0;
|
2002-02-10 01:43:35 +00:00
|
|
|
if(format==IMGFMT_BGR24) format=IMGFMT_YV12;
|
|
|
|
for(i = 0; i < formats; i++){
|
2001-04-24 11:30:57 +00:00
|
|
|
printf("Xvideo image format: 0x%x (%4.4s) %s\n", fo[i].id,(char*)&fo[i].id, (fo[i].format == XvPacked) ? "packed" : "planar");
|
2002-02-10 01:43:35 +00:00
|
|
|
if (fo[i].id == format) xv_format = fo[i].id;
|
|
|
|
}
|
2001-03-21 19:10:55 +00:00
|
|
|
if (!xv_format) xv_port = 0;
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
if (xv_port != 0)
|
|
|
|
{
|
2001-04-24 11:30:57 +00:00
|
|
|
printf( "using Xvideo port %d for hw scaling\n",xv_port );
|
2001-08-23 11:04:23 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2001-08-23 11:04:23 +00:00
|
|
|
for(current_buf=0;current_buf<num_buffers;++current_buf)
|
2001-05-01 01:32:59 +00:00
|
|
|
allocate_xvimage(current_buf);
|
|
|
|
|
|
|
|
current_buf=0;
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2002-01-28 08:37:58 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
2001-09-01 08:54:37 +00:00
|
|
|
if ( vo_window != None )
|
|
|
|
{
|
|
|
|
mFullscreen=0;
|
|
|
|
dwidth=mdwidth; dheight=mdheight;
|
|
|
|
if ( ( vo_dwidth == vo_screenwidth )&&( vo_dheight == vo_screenheight ) )
|
|
|
|
{
|
|
|
|
mFullscreen=1;
|
|
|
|
dwidth=vo_screenwidth;
|
|
|
|
dheight=vo_screenwidth * mdheight / mdwidth;
|
|
|
|
}
|
|
|
|
}
|
2002-01-28 08:37:58 +00:00
|
|
|
#endif
|
|
|
|
set_gamma_correction();
|
2001-09-01 08:54:37 +00:00
|
|
|
|
2001-05-31 22:32:58 +00:00
|
|
|
XGetGeometry( mDisplay,mywindow,&mRoot,&drwX,&drwY,&drwWidth,&drwHeight,&drwBorderWidth,&drwDepth );
|
2001-03-21 19:10:55 +00:00
|
|
|
drwX=0; drwY=0;
|
2001-05-31 22:32:58 +00:00
|
|
|
XTranslateCoordinates( mDisplay,mywindow,mRoot,0,0,&drwcX,&drwcY,&mRoot );
|
2001-04-24 11:30:57 +00:00
|
|
|
printf( "[xv] dcx: %d dcy: %d dx: %d dy: %d dw: %d dh: %d\n",drwcX,drwcY,drwX,drwY,drwWidth,drwHeight );
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2001-12-17 14:19:37 +00:00
|
|
|
aspect(&dwidth,&dheight,A_NOZOOM);
|
2001-03-21 19:10:55 +00:00
|
|
|
if ( mFullscreen )
|
|
|
|
{
|
2001-12-17 14:19:37 +00:00
|
|
|
aspect(&dwidth,&dheight,A_ZOOM);
|
2001-10-03 15:31:51 +00:00
|
|
|
drwX=( vo_screenwidth - (dwidth > vo_screenwidth?vo_screenwidth:dwidth) ) / 2;
|
2001-03-21 19:10:55 +00:00
|
|
|
drwcX+=drwX;
|
2001-10-03 15:31:51 +00:00
|
|
|
drwY=( vo_screenheight - (dheight > vo_screenheight?vo_screenheight:dheight) ) / 2;
|
2001-03-21 19:10:55 +00:00
|
|
|
drwcY+=drwY;
|
2001-10-03 15:31:51 +00:00
|
|
|
drwWidth=(dwidth > vo_screenwidth?vo_screenwidth:dwidth);
|
|
|
|
drwHeight=(dheight > vo_screenheight?vo_screenheight:dheight);
|
2001-04-24 11:30:57 +00:00
|
|
|
printf( "[xv-fs] dcx: %d dcy: %d dx: %d dy: %d dw: %d dh: %d\n",drwcX,drwcY,drwX,drwY,drwWidth,drwHeight );
|
2001-03-21 19:10:55 +00:00
|
|
|
}
|
2002-01-23 15:16:20 +00:00
|
|
|
saver_off(mDisplay); // turning off screen saver
|
2001-03-21 19:10:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
printf("Sorry, Xv not supported by this X11 version/driver\n");
|
|
|
|
printf("******** Try with -vo x11 or -vo sdl *********\n");
|
|
|
|
return 1;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static const vo_info_t * get_info(void)
|
|
|
|
{ return &vo_info; }
|
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
|
|
|
{
|
2001-03-21 19:10:55 +00:00
|
|
|
/*
|
|
|
|
* allocate XvImages. FIXME: no error checking, without
|
|
|
|
* mit-shm this will bomb...
|
|
|
|
*/
|
2001-05-31 22:32:58 +00:00
|
|
|
xvimage[foo] = XvShmCreateImage(mDisplay, xv_port, xv_format, 0, image_width, image_height, &Shminfo[foo]);
|
2001-03-21 19:10:55 +00:00
|
|
|
|
|
|
|
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;
|
2001-05-31 22:32:58 +00:00
|
|
|
XShmAttach(mDisplay, &Shminfo[foo]);
|
|
|
|
XSync(mDisplay, False);
|
2001-03-21 19:10:55 +00:00
|
|
|
shmctl(Shminfo[foo].shmid, IPC_RMID, 0);
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
XShmDetach( mDisplay,&Shminfo[foo] );
|
|
|
|
shmdt( Shminfo[foo].shmaddr );
|
|
|
|
XFlush( mDisplay );
|
|
|
|
XSync(mDisplay, False);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2001-03-03 21:46:39 +00:00
|
|
|
static void check_events(void)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2001-05-31 22:32:58 +00:00
|
|
|
int e=vo_x11_check_events(mDisplay);
|
2001-03-21 19:10:55 +00:00
|
|
|
if(e&VO_EVENT_RESIZE)
|
|
|
|
{
|
2001-05-31 22:32:58 +00:00
|
|
|
XGetGeometry( mDisplay,mywindow,&mRoot,&drwX,&drwY,&drwWidth,&drwHeight,&drwBorderWidth,&drwDepth );
|
2001-03-21 19:10:55 +00:00
|
|
|
drwX=0; drwY=0;
|
2001-05-31 22:32:58 +00:00
|
|
|
XTranslateCoordinates( mDisplay,mywindow,mRoot,0,0,&drwcX,&drwcY,&mRoot );
|
2001-04-24 11:30:57 +00:00
|
|
|
printf( "[xv] dcx: %d dcy: %d dx: %d dy: %d dw: %d dh: %d\n",drwcX,drwcY,drwX,drwY,drwWidth,drwHeight );
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2001-08-30 16:05:04 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
2001-05-08 12:17:03 +00:00
|
|
|
if ( vo_window != None )
|
|
|
|
{
|
|
|
|
mFullscreen=0;
|
|
|
|
dwidth=mdwidth; dheight=mdheight;
|
2001-09-01 08:54:37 +00:00
|
|
|
if ( ( vo_dwidth == vo_screenwidth )&&( vo_dheight == vo_screenheight ) )
|
2001-05-08 12:17:03 +00:00
|
|
|
{
|
|
|
|
mFullscreen=1;
|
|
|
|
dwidth=vo_screenwidth;
|
|
|
|
dheight=vo_screenwidth * mdheight / mdwidth;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-12-17 14:19:37 +00:00
|
|
|
aspect(&dwidth,&dheight,A_NOZOOM);
|
2001-03-21 19:10:55 +00:00
|
|
|
if ( mFullscreen )
|
|
|
|
{
|
2001-12-17 14:19:37 +00:00
|
|
|
aspect(&dwidth,&dheight,A_ZOOM);
|
2001-03-21 19:10:55 +00:00
|
|
|
drwX=( vo_screenwidth - (dwidth > vo_screenwidth?vo_screenwidth:dwidth) ) / 2;
|
|
|
|
drwcX+=drwX;
|
|
|
|
drwY=( vo_screenheight - (dheight > vo_screenheight?vo_screenheight:dheight) ) / 2;
|
|
|
|
drwcY+=drwY;
|
|
|
|
drwWidth=(dwidth > vo_screenwidth?vo_screenwidth:dwidth);
|
|
|
|
drwHeight=(dheight > vo_screenheight?vo_screenheight:dheight);
|
2001-04-24 11:30:57 +00:00
|
|
|
printf( "[xv-fs] dcx: %d dcy: %d dx: %d dy: %d dw: %d dh: %d\n",drwcX,drwcY,drwX,drwY,drwWidth,drwHeight );
|
2001-03-21 19:10:55 +00:00
|
|
|
}
|
|
|
|
}
|
2001-09-05 18:17:22 +00:00
|
|
|
if ( e & VO_EVENT_EXPOSE )
|
|
|
|
{
|
|
|
|
XvShmPutImage(mDisplay, xv_port, mywindow, mygc, xvimage[current_buf], 0, 0, image_width, image_height, drwX, drwY, 1, 1, False);
|
|
|
|
XvShmPutImage(mDisplay, xv_port, mywindow, mygc, xvimage[current_buf], 0, 0, image_width, image_height, drwX,drwY,drwWidth,(mFullscreen?drwHeight - 1:drwHeight), False);
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-08-13 11:08:18 +00:00
|
|
|
static void draw_osd(void)
|
2001-08-23 11:04:23 +00:00
|
|
|
{ vo_draw_text(image_width,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
|
|
|
{
|
2001-05-31 22:32:58 +00:00
|
|
|
XvShmPutImage(mDisplay, xv_port, mywindow, mygc, xvimage[current_buf],
|
2001-03-21 19:10:55 +00:00
|
|
|
0, 0, image_width, image_height,
|
|
|
|
drwX,drwY,drwWidth,(mFullscreen?drwHeight - 1:drwHeight),
|
|
|
|
False);
|
2001-08-13 11:08:18 +00:00
|
|
|
if (num_buffers>1){
|
|
|
|
current_buf=(current_buf+1)%num_buffers;
|
|
|
|
XFlush(mDisplay);
|
|
|
|
} else
|
|
|
|
XSync(mDisplay, False);
|
2001-03-21 19:10:55 +00:00
|
|
|
return;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-03-29 15:32:42 +00:00
|
|
|
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static uint32_t draw_slice(uint8_t *image[], int stride[], int w,int h,int x,int y)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2001-03-21 19:10:55 +00:00
|
|
|
uint8_t *src;
|
|
|
|
uint8_t *dst;
|
|
|
|
int i;
|
|
|
|
|
2001-05-01 01:32:59 +00:00
|
|
|
dst = xvimage[current_buf]->data + image_width * y + x;
|
2001-03-21 19:10:55 +00:00
|
|
|
src = image[0];
|
|
|
|
if(w==stride[0] && w==image_width) memcpy(dst,src,w*h);
|
|
|
|
else
|
|
|
|
for(i=0;i<h;i++)
|
|
|
|
{
|
|
|
|
memcpy(dst,src,w);
|
|
|
|
src+=stride[0];
|
|
|
|
dst+=image_width;
|
|
|
|
}
|
|
|
|
|
|
|
|
x/=2;y/=2;w/=2;h/=2;
|
|
|
|
|
2001-05-01 01:32:59 +00:00
|
|
|
dst = xvimage[current_buf]->data + image_width * image_height + image_width/2 * y + x;
|
2001-03-21 19:10:55 +00:00
|
|
|
src = image[2];
|
|
|
|
if(w==stride[2] && w==image_width/2) memcpy(dst,src,w*h);
|
|
|
|
else
|
|
|
|
for(i=0;i<h;i++)
|
|
|
|
{
|
|
|
|
memcpy(dst,src,w);
|
|
|
|
src+=stride[2];
|
|
|
|
dst+=image_width/2;
|
|
|
|
}
|
2001-05-01 01:32:59 +00:00
|
|
|
dst = xvimage[current_buf]->data + image_width * image_height * 5 / 4 + image_width/2 * y + x;
|
2001-03-21 19:10:55 +00:00
|
|
|
src = image[1];
|
|
|
|
if(w==stride[1] && w==image_width/2) memcpy(dst,src,w*h);
|
|
|
|
else
|
|
|
|
for(i=0;i<h;i++)
|
|
|
|
{
|
|
|
|
memcpy(dst,src,w);
|
|
|
|
src+=stride[1];
|
|
|
|
dst+=image_width/2;
|
|
|
|
}
|
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static uint32_t draw_frame(uint8_t *src[])
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
|
|
|
|
2002-02-10 01:43:35 +00:00
|
|
|
switch (image_format) {
|
2001-04-14 17:55:20 +00:00
|
|
|
case IMGFMT_YUY2:
|
|
|
|
case IMGFMT_UYVY:
|
|
|
|
case IMGFMT_YVYU:
|
|
|
|
|
|
|
|
// YUY2 packed, flipped
|
2001-02-24 20:28:24 +00:00
|
|
|
#if 0
|
2001-04-14 17:55:20 +00:00
|
|
|
int i;
|
|
|
|
unsigned short *s=(unsigned short *)src[0];
|
2001-05-01 01:32:59 +00:00
|
|
|
unsigned short *d=(unsigned short *)xvimage[current_buf]->data;
|
2001-04-14 17:55:20 +00:00
|
|
|
s+=image_width*image_height;
|
|
|
|
for(i=0;i<image_height;i++) {
|
|
|
|
s-=image_width;
|
|
|
|
memcpy(d,s,image_width*2);
|
|
|
|
d+=image_width;
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
#else
|
2001-05-01 01:32:59 +00:00
|
|
|
memcpy(xvimage[current_buf]->data,src[0],image_width*image_height*2);
|
2001-02-24 20:28:24 +00:00
|
|
|
#endif
|
2001-04-14 17:55:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IMGFMT_YV12:
|
|
|
|
case IMGFMT_I420:
|
|
|
|
case IMGFMT_IYUV:
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
// YV12 planar
|
2001-05-01 01:32:59 +00:00
|
|
|
memcpy(xvimage[current_buf]->data,src[0],image_width*image_height);
|
2002-01-26 15:46:58 +00:00
|
|
|
if (xv_format == IMGFMT_YV12)
|
|
|
|
{
|
|
|
|
memcpy(xvimage[current_buf]->data+image_width*image_height,src[2],image_width*image_height/4);
|
|
|
|
memcpy(xvimage[current_buf]->data+image_width*image_height*5/4,src[1],image_width*image_height/4);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy(xvimage[current_buf]->data+image_width*image_height,src[1],image_width*image_height/4);
|
|
|
|
memcpy(xvimage[current_buf]->data+image_width*image_height*5/4,src[2],image_width*image_height/4);
|
|
|
|
}
|
2001-04-14 17:55:20 +00:00
|
|
|
break;
|
2002-02-10 01:43:35 +00:00
|
|
|
|
|
|
|
case IMGFMT_BGR24:
|
|
|
|
|
|
|
|
if(flip_flag) // tricky, using negative src stride:
|
|
|
|
rgb24toyv12(src[0]+3*image_width*(image_height-1),
|
|
|
|
xvimage[current_buf]->data,
|
|
|
|
xvimage[current_buf]->data+image_width*image_height*5/4,
|
|
|
|
xvimage[current_buf]->data+image_width*image_height,
|
|
|
|
image_width,image_height,
|
|
|
|
image_width,image_width/2,-3*image_width);
|
|
|
|
else
|
|
|
|
rgb24toyv12(src[0],
|
|
|
|
xvimage[current_buf]->data,
|
|
|
|
xvimage[current_buf]->data+image_width*image_height*5/4,
|
|
|
|
xvimage[current_buf]->data+image_width*image_height,
|
|
|
|
image_width,image_height,
|
|
|
|
image_width,image_width/2,3*image_width);
|
|
|
|
break;
|
|
|
|
|
2001-04-14 17:55:20 +00:00
|
|
|
}
|
2001-03-21 19:10:55 +00:00
|
|
|
|
|
|
|
return 0;
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-03-21 19:10:55 +00:00
|
|
|
static uint32_t query_format(uint32_t format)
|
2001-02-24 20:28:24 +00:00
|
|
|
{
|
2001-04-14 17:55:20 +00:00
|
|
|
|
2002-02-10 01:43:35 +00:00
|
|
|
switch(format){
|
|
|
|
case IMGFMT_YUY2:
|
|
|
|
case IMGFMT_UYVY:
|
|
|
|
case IMGFMT_YVYU:
|
|
|
|
|
|
|
|
case IMGFMT_YV12:
|
|
|
|
case IMGFMT_I420:
|
|
|
|
case IMGFMT_IYUV:
|
|
|
|
|
|
|
|
case IMGFMT_BGR24:
|
|
|
|
|
2001-04-14 17:55:20 +00:00
|
|
|
// umm, this is a kludge, we need to ask the server.. (see init function above)
|
|
|
|
return 1;
|
2002-02-10 01:43:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2001-02-24 20:28:24 +00:00
|
|
|
}
|
|
|
|
|
2001-09-04 15:21:00 +00:00
|
|
|
static void uninit(void)
|
|
|
|
{
|
|
|
|
int i;
|
2002-01-23 15:16:20 +00:00
|
|
|
saver_on(mDisplay); // screen saver back on
|
2001-08-31 10:06:32 +00:00
|
|
|
#ifdef HAVE_NEW_GUI
|
2001-09-04 15:21:00 +00:00
|
|
|
if ( vo_window == None )
|
2001-08-31 10:06:32 +00:00
|
|
|
#endif
|
2001-09-20 10:26:22 +00:00
|
|
|
{
|
|
|
|
XDestroyWindow( mDisplay,mywindow );
|
|
|
|
}
|
2001-09-04 15:21:00 +00:00
|
|
|
for( i=0;i<num_buffers;i++ ) deallocate_xvimage( i );
|
2002-01-31 00:37:59 +00:00
|
|
|
#ifdef HAVE_XF86VM
|
|
|
|
vo_vm_close(mDisplay);
|
|
|
|
#endif
|
|
|
|
|
2001-04-09 22:27:27 +00:00
|
|
|
}
|
2001-03-21 19:10:55 +00:00
|
|
|
|
2002-01-26 16:01:26 +00:00
|
|
|
static uint32_t preinit(const char *arg)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2001-02-24 20:28:24 +00:00
|
|
|
|
2002-01-26 16:01:26 +00:00
|
|
|
static void query_vaa(vo_vaa_t *vaa)
|
|
|
|
{
|
|
|
|
memset(vaa,0,sizeof(vo_vaa_t));
|
2002-01-28 08:37:58 +00:00
|
|
|
vaa->get_video_eq = xv_get_video_eq;
|
|
|
|
vaa->set_video_eq = xv_set_video_eq;
|
2002-01-26 16:01:26 +00:00
|
|
|
}
|
2002-02-09 00:47:26 +00:00
|
|
|
|
2002-02-09 01:21:48 +00:00
|
|
|
static uint32_t control(uint32_t request, void *data, ...)
|
2002-02-09 00:47:26 +00:00
|
|
|
{
|
|
|
|
switch (request) {
|
|
|
|
case VOCTRL_QUERY_VAA:
|
|
|
|
query_vaa((vo_vaa_t*)data);
|
|
|
|
return VO_TRUE;
|
|
|
|
case VOCTRL_QUERY_FORMAT:
|
|
|
|
return query_format(*((uint32_t*)data));
|
|
|
|
}
|
|
|
|
return VO_NOTIMPL;
|
|
|
|
}
|