RepoMirrors/mpv
1
0
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2025-01-12 01:49:33 +00:00
Code Issues Releases Wiki Activity

vo_xv: Reformat code

Browse Source 
Reformat vo_xv.c completely to K & R style and remove a couple of
outdated comments.
This commit is contained in:
Uoti Urpala 2008-12-01 16:15:17 +02:00
parent 6fec7ec734
commit 95f35c4d20
1 changed files with 219 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

485
libvo/vo_xv.c
View File

@ -95,11 +95,9 @@ struct xvctx {
#endif
};
// FIXME: dynamically allocate this stuff
static void allocate_xvimage(struct vo *, int);
static void draw_alpha_yv12(void *p, int x0, int y0, int w, int h,
unsigned char *src, unsigned char *srca,
int stride)
@ -154,21 +152,22 @@ static void draw_alpha_null(void *p, int x0, int y0, int w, int h,
static void deallocate_xvimage(struct vo *vo, int foo);
static void calc_drwXY(struct vo *vo, uint32_t *drwX, uint32_t *drwY) {
static void calc_drwXY(struct vo *vo, uint32_t *drwX, uint32_t *drwY)
{
struct MPOpts *opts = vo->opts;
*drwX = *drwY = 0;
if (vo_fs) {
aspect(vo, &vo->dwidth, &vo->dheight, A_ZOOM);
vo->dwidth = FFMIN(vo->dwidth, opts->vo_screenwidth);
vo->dheight = FFMIN(vo->dheight, opts->vo_screenheight);
*drwX = (opts->vo_screenwidth - vo->dwidth) / 2;
*drwY = (opts->vo_screenheight - vo->dheight) / 2;
mp_msg(MSGT_VO, MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n",
*drwX, *drwY, vo->dwidth, vo->dheight);
} else if (WinID == 0) {
*drwX = vo->dx;
*drwY = vo->dy;
}
*drwX = *drwY = 0;
if (vo_fs) {
aspect(vo, &vo->dwidth, &vo->dheight, A_ZOOM);
vo->dwidth = FFMIN(vo->dwidth, opts->vo_screenwidth);
vo->dheight = FFMIN(vo->dheight, opts->vo_screenheight);
*drwX = (opts->vo_screenwidth - vo->dwidth) / 2;
*drwY = (opts->vo_screenheight - vo->dheight) / 2;
mp_msg(MSGT_VO, MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n", *drwX,
*drwY, vo->dwidth, vo->dheight);
} else if (WinID == 0) {
*drwX = vo->dx;
*drwY = vo->dy;
}
}
/*
@ -193,11 +192,12 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
ctx->image_width = width;
ctx->image_format = format;
if ((ctx->max_width != 0 && ctx->max_height != 0) &&
(ctx->image_width > ctx->max_width || ctx->image_height > ctx->max_height))
{
mp_msg( MSGT_VO, MSGL_ERR, MSGTR_VO_XV_ImagedimTooHigh,
ctx->image_width, ctx->image_height, ctx->max_width, ctx->max_height);
if ((ctx->max_width != 0 && ctx->max_height != 0)
&& (ctx->image_width > ctx->max_width
|| ctx->image_height > ctx->max_height)) {
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_VO_XV_ImagedimTooHigh,
ctx->image_width, ctx->image_height, ctx->max_width,
ctx->max_height);
return -1;
}
@ -207,9 +207,8 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
/* check image formats */
ctx->xv_format = 0;
for (i = 0; i < ctx->formats; i++) {
mp_msg(MSGT_VO, MSGL_V,
"Xvideo image format: 0x%x (%4.4s) %s\n", ctx->fo[i].id,
(char *) &ctx->fo[i].id,
mp_msg(MSGT_VO, MSGL_V, "Xvideo image format: 0x%x (%4.4s) %s\n",
ctx->fo[i].id, (char *) &ctx->fo[i].id,
(ctx->fo[i].format == XvPacked) ? "packed" : "planar");
if (ctx->fo[i].id == format)
ctx->xv_format = ctx->fo[i].id;
@ -225,8 +224,7 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
{
#ifdef CONFIG_XF86VM
int vm = flags & VOFLAG_MODESWITCHING;
if (vm)
{
if (vm) {
vo_vm_switch(vo);
ctx->mode_switched = 1;
}
@ -240,25 +238,23 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
xswa.background_pixel = 0;
if (x11->xv_ck_info.method == CK_METHOD_BACKGROUND)
{
xswa.background_pixel = x11->xv_colorkey;
}
xswa.background_pixel = x11->xv_colorkey;
xswa.border_pixel = 0;
xswamask = CWBackPixel | CWBorderPixel;
vo_x11_create_vo_window(vo, &vinfo, vo->dx, vo->dy, vo->dwidth, vo->dheight,
flags, CopyFromParent, "xv", title);
XChangeWindowAttributes(x11->display, x11->window, xswamask, &xswa);
vo_x11_create_vo_window(vo, &vinfo, vo->dx, vo->dy, vo->dwidth,
vo->dheight, flags, CopyFromParent, "xv",
title);
XChangeWindowAttributes(x11->display, x11->window, xswamask, &xswa);
#ifdef CONFIG_XF86VM
if (vm)
{
if (vm) {
/* Grab the mouse pointer in our window */
if (vo_grabpointer)
XGrabPointer(x11->display, x11->window, True, 0,
GrabModeAsync, GrabModeAsync,
x11->window, None, CurrentTime);
XSetInputFocus(x11->display, x11->window, RevertToNone, CurrentTime);
XGrabPointer(x11->display, x11->window, True, 0, GrabModeAsync,
GrabModeAsync, x11->window, None, CurrentTime);
XSetInputFocus(x11->display, x11->window, RevertToNone,
CurrentTime);
}
#endif
}
@ -266,22 +262,21 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
mp_msg(MSGT_VO, MSGL_V, "using Xvideo port %d for hw scaling\n",
x11->xv_port);
switch (ctx->xv_format)
{
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
ctx->draw_alpha_fnc = draw_alpha_yv12;
break;
case IMGFMT_YUY2:
case IMGFMT_YVYU:
ctx->draw_alpha_fnc = draw_alpha_yuy2;
break;
case IMGFMT_UYVY:
ctx->draw_alpha_fnc = draw_alpha_uyvy;
break;
default:
ctx->draw_alpha_fnc = draw_alpha_null;
switch (ctx->xv_format) {
case IMGFMT_YV12:
case IMGFMT_I420:
case IMGFMT_IYUV:
ctx->draw_alpha_fnc = draw_alpha_yv12;
break;
case IMGFMT_YUY2:
case IMGFMT_YVYU:
ctx->draw_alpha_fnc = draw_alpha_yuy2;
break;
case IMGFMT_UYVY:
ctx->draw_alpha_fnc = draw_alpha_uyvy;
break;
default:
ctx->draw_alpha_fnc = draw_alpha_null;
}
// In case config has been called before
@ -297,11 +292,12 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
ctx->current_buf = 0;
ctx->current_ip_buf = 0;
if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0) vo_fs = 1;
if ((flags & VOFLAG_FULLSCREEN) && WinID <= 0)
vo_fs = 1;
calc_drwXY(vo, &ctx->drwX, &ctx->drwY);
panscan_calc(vo);
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
@ -324,22 +320,22 @@ static void allocate_xvimage(struct vo *vo, int foo)
#ifdef HAVE_SHM
if (x11->display_is_local && XShmQueryExtension(x11->display))
ctx->Shmem_Flag = 1;
else
{
else {
ctx->Shmem_Flag = 0;
mp_msg(MSGT_VO, MSGL_INFO,
MSGTR_LIBVO_XV_SharedMemoryNotSupported);
mp_msg(MSGT_VO, MSGL_INFO, MSGTR_LIBVO_XV_SharedMemoryNotSupported);
}
if (ctx->Shmem_Flag)
{
if (ctx->Shmem_Flag) {
ctx->xvimage[foo] =
(XvImage *) XvShmCreateImage(x11->display, x11->xv_port, ctx->xv_format,
NULL, ctx->image_width, ctx->image_height,
(XvImage *) XvShmCreateImage(x11->display, x11->xv_port,
ctx->xv_format, NULL,
ctx->image_width, ctx->image_height,
&ctx->Shminfo[foo]);
ctx->Shminfo[foo].shmid =
shmget(IPC_PRIVATE, ctx->xvimage[foo]->data_size, IPC_CREAT | 0777);
ctx->Shminfo[foo].shmaddr = (char *) shmat(ctx->Shminfo[foo].shmid, 0, 0);
ctx->Shminfo[foo].shmid = shmget(IPC_PRIVATE,
ctx->xvimage[foo]->data_size,
IPC_CREAT | 0777);
ctx->Shminfo[foo].shmaddr = (char *) shmat(ctx->Shminfo[foo].shmid, 0,
0);
ctx->Shminfo[foo].readOnly = False;
ctx->xvimage[foo]->data = ctx->Shminfo[foo].shmaddr;
@ -350,8 +346,9 @@ static void allocate_xvimage(struct vo *vo, int foo)
#endif
{
ctx->xvimage[foo] =
(XvImage *) XvCreateImage(x11->display, x11->xv_port, ctx->xv_format, NULL,
ctx->image_width, ctx->image_height);
(XvImage *) XvCreateImage(x11->display, x11->xv_port,
ctx->xv_format, NULL, ctx->image_width,
ctx->image_height);
ctx->xvimage[foo]->data = malloc(ctx->xvimage[foo]->data_size);
XSync(x11->display, False);
}
@ -363,8 +360,7 @@ static void deallocate_xvimage(struct vo *vo, int foo)
{
struct xvctx *ctx = vo->priv;
#ifdef HAVE_SHM
if (ctx->Shmem_Flag)
{
if (ctx->Shmem_Flag) {
XShmDetach(vo->x11->display, &ctx->Shminfo[foo]);
shmdt(ctx->Shminfo[foo].shmaddr);
} else
@ -383,22 +379,21 @@ static inline void put_xvimage(struct vo *vo, XvImage *xvi)
struct xvctx *ctx = vo->priv;
struct vo_x11_state *x11 = vo->x11;
#ifdef HAVE_SHM
if (ctx->Shmem_Flag)
{
XvShmPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc,
xvi, 0, 0, ctx->image_width,
ctx->image_height, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1), vo->dwidth + vo->panscan_x,
vo->dheight + vo->panscan_y,
if (ctx->Shmem_Flag) {
XvShmPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc, xvi,
0, 0, ctx->image_width, ctx->image_height,
ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x, vo->dheight + vo->panscan_y,
False);
} else
#endif
{
XvPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc,
xvi, 0, 0, ctx->image_width, ctx->image_height,
ctx->drwX - (vo->panscan_x >> 1), ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x,
vo->dheight + vo->panscan_y);
XvPutImage(x11->display, x11->xv_port, x11->window, x11->vo_gc, xvi, 0,
0, ctx->image_width, ctx->image_height,
ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x, vo->dheight + vo->panscan_y);
}
}
@ -411,21 +406,18 @@ static void check_events(struct vo *vo)
if (e & VO_EVENT_RESIZE)
calc_drwXY(vo, &ctx->drwX, &ctx->drwY);
if (e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE)
{
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
if (e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) {
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
}
if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && ctx->is_paused)
{
if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && ctx->is_paused) {
/* did we already draw a buffer */
if ( ctx->visible_buf != -1 )
{
/* redraw the last visible buffer */
put_xvimage(vo, ctx->xvimage[ctx->visible_buf]);
if (ctx->visible_buf != -1) {
/* redraw the last visible buffer */
put_xvimage(vo, ctx->xvimage[ctx->visible_buf]);
}
}
}
@ -434,8 +426,10 @@ static void draw_osd(struct vo *vo, struct osd_state *osd)
{
struct xvctx *ctx = vo->priv;
osd_draw_text(osd, ctx->image_width -
ctx->image_width * vo->panscan_x / (vo->dwidth + vo->panscan_x),
osd_draw_text(osd,
ctx->image_width -
ctx->image_width * vo->panscan_x / (vo->dwidth +
vo->panscan_x),
ctx->image_height, ctx->draw_alpha_fnc, vo);
}
@ -447,77 +441,68 @@ static void flip_page(struct vo *vo)
/* remember the currently visible buffer */
ctx->visible_buf = ctx->current_buf;
if (ctx->num_buffers > 1)
{
ctx->current_buf =
vo_directrendering ? 0 : ((ctx->current_buf + 1) % ctx->num_buffers);
if (ctx->num_buffers > 1) {
ctx->current_buf = vo_directrendering ? 0 : ((ctx->current_buf + 1) %
ctx->num_buffers);
XFlush(vo->x11->display);
} else
XSync(vo->x11->display, False);
return;
}
static int draw_slice(struct vo *vo, uint8_t * image[], int stride[], int w,
static int draw_slice(struct vo *vo, uint8_t *image[], int stride[], int w,
int h, int x, int y)
{
struct xvctx *ctx = vo->priv;
uint8_t *dst;
XvImage *current_image = ctx->xvimage[ctx->current_buf];
dst = current_image->data + current_image->offsets[0] +
current_image->pitches[0] * y + x;
memcpy_pic(dst, image[0], w, h, current_image->pitches[0],
stride[0]);
dst = current_image->data + current_image->offsets[0]
+ current_image->pitches[0] * y + x;
memcpy_pic(dst, image[0], w, h, current_image->pitches[0], stride[0]);
x /= 2;
y /= 2;
w /= 2;
h /= 2;
dst = current_image->data + current_image->offsets[1] +
current_image->pitches[1] * y + x;
dst = current_image->data + current_image->offsets[1]
+ current_image->pitches[1] * y + x;
if (ctx->image_format != IMGFMT_YV12)
memcpy_pic(dst, image[1], w, h, current_image->pitches[1],
stride[1]);
memcpy_pic(dst, image[1], w, h, current_image->pitches[1], stride[1]);
else
memcpy_pic(dst, image[2], w, h, current_image->pitches[1],
stride[2]);
memcpy_pic(dst, image[2], w, h, current_image->pitches[1], stride[2]);
dst = current_image->data + current_image->offsets[2] +
current_image->pitches[2] * y + x;
dst = current_image->data + current_image->offsets[2]
+ current_image->pitches[2] * y + x;
if (ctx->image_format == IMGFMT_YV12)
memcpy_pic(dst, image[1], w, h, current_image->pitches[1],
stride[1]);
memcpy_pic(dst, image[1], w, h, current_image->pitches[1], stride[1]);
else
memcpy_pic(dst, image[2], w, h, current_image->pitches[1],
stride[2]);
memcpy_pic(dst, image[2], w, h, current_image->pitches[1], stride[2]);
return 0;
}
static int draw_frame(struct vo *vo, uint8_t * src[])
static int draw_frame(struct vo *vo, uint8_t *src[])
{
return VO_ERROR;
}
static uint32_t draw_image(struct vo *vo, mp_image_t * mpi)
static uint32_t draw_image(struct vo *vo, mp_image_t *mpi)
{
struct xvctx *ctx = vo->priv;
if (mpi->flags & MP_IMGFLAG_DIRECT)
{
if (mpi->flags & MP_IMGFLAG_DIRECT) {
// direct rendering:
ctx->current_buf = (int) (mpi->priv); // hack!
return VO_TRUE;
}
if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
return VO_TRUE; // done
if (mpi->flags & MP_IMGFLAG_PLANAR)
{
if (mpi->flags & MP_IMGFLAG_PLANAR) {
draw_slice(vo, mpi->planes, mpi->stride, mpi->w, mpi->h, 0, 0);
return VO_TRUE;
}
if (mpi->flags & MP_IMGFLAG_YUV)
{
if (mpi->flags & MP_IMGFLAG_YUV) {
// packed YUV:
memcpy_pic(ctx->xvimage[ctx->current_buf]->data +
ctx->xvimage[ctx->current_buf]->offsets[0], mpi->planes[0],
@ -528,18 +513,17 @@ static uint32_t draw_image(struct vo *vo, mp_image_t * mpi)
return VO_FALSE; // not (yet) supported
}
static uint32_t get_image(struct xvctx *ctx, mp_image_t * mpi)
static uint32_t get_image(struct xvctx *ctx, mp_image_t *mpi)
{
int buf = ctx->current_buf; // we shouldn't change current_buf unless we do DR!
// we shouldn't change current_buf unless we do DR!
int buf = ctx->current_buf;
if (mpi->type == MP_IMGTYPE_STATIC && ctx->num_buffers > 1)
return VO_FALSE; // it is not static
if (mpi->imgfmt != ctx->image_format)
return VO_FALSE; // needs conversion :(
// if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE; // slow video ram
if (mpi->flags & MP_IMGFLAG_READABLE &&
(mpi->type == MP_IMGTYPE_IPB || mpi->type == MP_IMGTYPE_IP))
{
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 (ctx->num_buffers < 2)
return VO_FALSE; // not enough
@ -557,42 +541,33 @@ static uint32_t get_image(struct xvctx *ctx, mp_image_t * mpi)
if (mpi->width * (mpi->bpp / 8) > ctx->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) == ctx->xvimage[buf]->pitches[0]))
{
|| (mpi->width * (mpi->bpp / 8) == ctx->xvimage[buf]->pitches[0])) {
ctx->current_buf = buf;
XvImage *current_image = ctx->xvimage[ctx->current_buf];
mpi->planes[0] = current_image->data + current_image->offsets[0];
mpi->stride[0] = current_image->pitches[0];
mpi->width = mpi->stride[0] / (mpi->bpp / 8);
if (mpi->flags & MP_IMGFLAG_PLANAR)
{
if (mpi->flags & MP_IMGFLAG_SWAPPED)
{
if (mpi->flags & MP_IMGFLAG_PLANAR) {
if (mpi->flags & MP_IMGFLAG_SWAPPED) {
// I420
mpi->planes[1] =
current_image->data +
current_image->offsets[1];
mpi->planes[2] =
current_image->data +
current_image->offsets[2];
mpi->planes[1] = current_image->data
+ current_image->offsets[1];
mpi->planes[2] = current_image->data
+ current_image->offsets[2];
mpi->stride[1] = current_image->pitches[1];
mpi->stride[2] = current_image->pitches[2];
} else
{
} else {
// YV12
mpi->planes[1] =
current_image->data +
current_image->offsets[2];
mpi->planes[2] =
current_image->data +
current_image->offsets[1];
mpi->planes[1] = current_image->data
+ current_image->offsets[2];
mpi->planes[2] = current_image->data
+ current_image->offsets[1];
mpi->stride[1] = current_image->pitches[2];
mpi->stride[2] = current_image->pitches[1];
}
}
mpi->flags |= MP_IMGFLAG_DIRECT;
mpi->priv = (void *) ctx->current_buf;
// printf("mga: get_image() SUCCESS -> Direct Rendering ENABLED\n");
return VO_TRUE;
}
return VO_FALSE;
@ -604,8 +579,7 @@ static int query_format(struct xvctx *ctx, uint32_t format)
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 < ctx->formats; i++)
{
for (i = 0; i < ctx->formats; i++) {
if (ctx->fo[i].id == format)
return flag; //xv_format = fo[i].id;
}
@ -656,22 +630,20 @@ static int preinit(struct vo *vo, const char *arg)
struct vo_x11_state *x11 = vo->x11;
int xv_adaptor = -1;
opt_t subopts[] =
{
/* name arg type arg var test */
{ "port", OPT_ARG_INT, &x11->xv_port, (opt_test_f)int_pos },
{ "adaptor", OPT_ARG_INT, &xv_adaptor, (opt_test_f)int_non_neg },
{ "ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck },
{ "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm },
{ NULL }
opt_t subopts[] = {
/* name arg type arg var test */
{"port", OPT_ARG_INT, &x11->xv_port, (opt_test_f) int_pos},
{"adaptor", OPT_ARG_INT, &xv_adaptor, (opt_test_f) int_non_neg},
{"ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck},
{"ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm},
{NULL}
};
x11->xv_port = 0;
/* parse suboptions */
if ( subopt_parse( arg, subopts ) != 0 )
{
return -1;
if (subopt_parse(arg, subopts) != 0) {
return -1;
}
/* modify colorkey settings according to the given options */
@ -682,105 +654,90 @@ static int preinit(struct vo *vo, const char *arg)
/* check for Xvideo extension */
unsigned int ver, rel, req, ev, err;
if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err))
{
mp_msg(MSGT_VO, MSGL_ERR,
MSGTR_LIBVO_XV_XvNotSupportedByX11);
if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) {
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_XvNotSupportedByX11);
goto error;
}
/* check for Xvideo support */
if (Success !=
XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display), &ctx->adaptors,
&ctx->ai))
{
XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display),
&ctx->adaptors, &ctx->ai)) {
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_XvQueryAdaptorsFailed);
goto error;
}
/* check adaptors */
if (x11->xv_port)
{
if (x11->xv_port) {
int port_found;
for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++)
{
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask))
{
for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) {
if ((ctx->ai[i].type & XvInputMask)
&& (ctx->ai[i].type & XvImageMask)) {
for (xv_p = ctx->ai[i].base_id;
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p)
{
if (xv_p == x11->xv_port)
{
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports;
++xv_p) {
if (xv_p == x11->xv_port) {
port_found = 1;
break;
}
}
}
}
if (port_found)
{
if (port_found) {
if (XvGrabPort(x11->display, x11->xv_port, CurrentTime))
x11->xv_port = 0;
} else
{
mp_msg(MSGT_VO, MSGL_WARN,
MSGTR_LIBVO_XV_InvalidPortParameter);
} else {
mp_msg(MSGT_VO, MSGL_WARN, MSGTR_LIBVO_XV_InvalidPortParameter);
x11->xv_port = 0;
}
}
for (i = 0; i < ctx->adaptors && x11->xv_port == 0; i++)
{
for (i = 0; i < ctx->adaptors && x11->xv_port == 0; i++) {
/* check if adaptor number has been specified */
if (xv_adaptor != -1 && xv_adaptor != i)
continue;
continue;
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask))
{
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) {
for (xv_p = ctx->ai[i].base_id;
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p)
if (!XvGrabPort(x11->display, xv_p, CurrentTime))
{
if (!XvGrabPort(x11->display, xv_p, CurrentTime)) {
x11->xv_port = xv_p;
mp_msg(MSGT_VO, MSGL_V,
"[VO_XV] Using Xv Adapter #%d (%s)\n",
i, ctx->ai[i].name);
break;
} else
{
mp_msg(MSGT_VO, MSGL_WARN,
MSGTR_LIBVO_XV_CouldNotGrabPort, (int) xv_p);
} else {
mp_msg(MSGT_VO, MSGL_WARN, MSGTR_LIBVO_XV_CouldNotGrabPort,
(int) xv_p);
++busy_ports;
}
}
}
if (!x11->xv_port)
{
if (!x11->xv_port) {
if (busy_ports)
mp_msg(MSGT_VO, MSGL_ERR,
MSGTR_LIBVO_XV_CouldNotFindFreePort);
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_CouldNotFindFreePort);
else
mp_msg(MSGT_VO, MSGL_ERR,
MSGTR_LIBVO_XV_NoXvideoSupport);
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_NoXvideoSupport);
goto error;
}
if (!vo_xv_init_colorkey(vo)) {
goto error; // bail out, colorkey setup failed
goto error; // bail out, colorkey setup failed
}
vo_xv_enable_vsync(vo);
vo_xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height);
ctx->fo = XvListImageFormats(x11->display, x11->xv_port, (int *) &ctx->formats);
ctx->fo = XvListImageFormats(x11->display, x11->xv_port,
(int *) &ctx->formats);
mp_input_add_key_fd(vo->input_ctx, ConnectionNumber(x11->display), 1,
x11_fd_callback, NULL, vo);
ctx->event_fd_registered = 1;
return 0;
error:
uninit(vo); // free resources
error:
uninit(vo); // free resources
return -1;
}
@ -788,65 +745,61 @@ static int control(struct vo *vo, uint32_t request, void *data)
{
struct xvctx *ctx = vo->priv;
struct vo_x11_state *x11 = vo->x11;
switch (request)
{
case VOCTRL_PAUSE:
return (ctx->is_paused = 1);
case VOCTRL_RESUME:
return (ctx->is_paused = 0);
case VOCTRL_QUERY_FORMAT:
return query_format(ctx, *((uint32_t *) data));
case VOCTRL_GET_IMAGE:
return get_image(ctx, data);
case VOCTRL_DRAW_IMAGE:
return draw_image(vo, data);
case VOCTRL_GUISUPPORT:
return VO_TRUE;
case VOCTRL_GET_PANSCAN:
if (!vo->config_ok || !vo_fs)
return VO_FALSE;
return VO_TRUE;
case VOCTRL_FULLSCREEN:
vo_x11_fullscreen(vo);
/* 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;
switch (request) {
case VOCTRL_PAUSE:
return (ctx->is_paused = 1);
case VOCTRL_RESUME:
return (ctx->is_paused = 0);
case VOCTRL_QUERY_FORMAT:
return query_format(ctx, *((uint32_t *) data));
case VOCTRL_GET_IMAGE:
return get_image(ctx, data);
case VOCTRL_DRAW_IMAGE:
return draw_image(vo, data);
case VOCTRL_GUISUPPORT:
return VO_TRUE;
case VOCTRL_GET_PANSCAN:
if (!vo->config_ok || !vo_fs)
return VO_FALSE;
return VO_TRUE;
case VOCTRL_FULLSCREEN:
vo_x11_fullscreen(vo);
/* 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(vo);
panscan_calc(vo);
if (old_y != vo->panscan_y)
{
vo_x11_clearwindow_part(vo, x11->window,
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1,
1);
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
flip_page(vo);
}
if (old_y != vo->panscan_y) {
vo_x11_clearwindow_part(vo, x11->window,
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1, 1);
vo_xv_draw_colorkey(vo, ctx->drwX - (vo->panscan_x >> 1),
ctx->drwY - (vo->panscan_y >> 1),
vo->dwidth + vo->panscan_x - 1,
vo->dheight + vo->panscan_y - 1);
flip_page(vo);
}
return VO_TRUE;
case VOCTRL_SET_EQUALIZER:
{
struct voctrl_set_equalizer_args *args = data;
return vo_xv_set_eq(vo, x11->xv_port, args->name, args->value);
}
case VOCTRL_GET_EQUALIZER:
{
struct voctrl_get_equalizer_args *args = data;
return vo_xv_get_eq(vo, x11->xv_port, args->name, args->valueptr);
}
case VOCTRL_ONTOP:
vo_x11_ontop(vo);
return VO_TRUE;
case VOCTRL_UPDATE_SCREENINFO:
update_xinerama_info(vo);
return VO_TRUE;
}
return VO_TRUE;
case VOCTRL_SET_EQUALIZER:
{
struct voctrl_set_equalizer_args *args = data;
return vo_xv_set_eq(vo, x11->xv_port, args->name, args->value);
}
case VOCTRL_GET_EQUALIZER:
{
struct voctrl_get_equalizer_args *args = data;
return vo_xv_get_eq(vo, x11->xv_port, args->name, args->valueptr);
}
case VOCTRL_ONTOP:
vo_x11_ontop(vo);
return VO_TRUE;
case VOCTRL_UPDATE_SCREENINFO:
update_xinerama_info(vo);
return VO_TRUE;
}
return VO_NOTIMPL;
}