diff options
| -rw-r--r-- | xine_sxfe_frontend.c | 460 |
1 files changed, 453 insertions, 7 deletions
diff --git a/xine_sxfe_frontend.c b/xine_sxfe_frontend.c index 7256f77b..ee056b15 100644 --- a/xine_sxfe_frontend.c +++ b/xine_sxfe_frontend.c @@ -4,7 +4,7 @@ * See the main source file 'xineliboutput.c' for copyright information and * how to reach the author. * - * $Id: xine_sxfe_frontend.c,v 1.33 2008-03-31 21:36:37 phintuka Exp $ + * $Id: xine_sxfe_frontend.c,v 1.34 2008-03-31 22:20:30 phintuka Exp $ * */ @@ -25,11 +25,14 @@ #include <pthread.h> #include <sched.h> #include <poll.h> +#include <sys/ipc.h> +#include <sys/shm.h> #include <X11/Xlib.h> #include <X11/Xatom.h> #include <X11/keysym.h> #include <X11/extensions/XShm.h> +#include <X11/extensions/Xrender.h> #include <X11/Xutil.h> #ifdef HAVE_XF86VIDMODE # include <X11/extensions/xf86vmode.h> @@ -63,6 +66,7 @@ #include <xine/plugin_catalog.h> #include "xine_input_vdr.h" +#include "xine_osd_command.h" #include "xine_frontend.h" #include "xine/post.h" @@ -84,6 +88,16 @@ typedef struct _mwmhints { uint32_t status; } MWMHints; +/* HUD Scaling */ +typedef struct _xrender_surf +{ + int w, h; + int depth; + Visual *vis; + Drawable draw; + Picture pic; + int allocated : 1; +} Xrender_Surf; /* * data @@ -161,6 +175,21 @@ typedef struct sxfe_s { char configfile[256]; char modeline[256]; + /* HUD stuff */ + uint8_t hud; + GC gc; + Window hud_window; + XImage *hud_img; + Visual *hud_vis; + XShmSegmentInfo hud_shminfo; + Xrender_Surf *surf_win; + Xrender_Surf *surf_img; + int osd_width; + int osd_height; + int osd_pad_x; + int osd_pad_y; + uint32_t* hud_img_mem; + } fe_t, sxfe_t; @@ -171,6 +200,10 @@ typedef struct sxfe_s { #define DOUBLECLICK_TIME 500 // ms +#define OSD_DEF_WIDTH 720 +#define OSD_DEF_HEIGHT 576 +#define HUD_MAX_WIDTH 1920 +#define HUD_MAX_HEIGHT 1080 static void fe_dest_size_cb (void *data, int video_width, int video_height, double video_pixel_aspect, @@ -389,6 +422,346 @@ static void set_cursor(Display *dpy, Window win, const int enable) } } +Xrender_Surf * xrender_surf_new(Display *dpy, Drawable draw, Visual *vis, int w, int h, int alpha) +{ + Xrender_Surf *rs; + XRenderPictFormat *fmt; + XRenderPictureAttributes att; + + rs = calloc(1, sizeof (Xrender_Surf)); + + if(alpha) + fmt = XRenderFindStandardFormat (dpy, PictStandardARGB32); + else + fmt = XRenderFindStandardFormat (dpy, PictStandardRGB24); + rs->w = w; + rs->h = h; + rs->depth = fmt->depth; + rs->vis = vis; + rs->draw = XCreatePixmap(dpy, draw, w, h, fmt->depth); + att.dither = 1; + att.component_alpha = 1; + att.repeat = 0; + rs->pic = XRenderCreatePicture(dpy, rs->draw, fmt, CPRepeat | CPDither | CPComponentAlpha, &att); + rs->allocated = 1; + return rs; +} + +void xrender_surf_blend(Display *dpy, Xrender_Surf *src, Xrender_Surf *dst, + int x, int y, int w, int h, XDouble scale_x, XDouble scale_y, int smooth) +{ + XTransform xf; + + if(!scale_x) + scale_x = 1; + if(!scale_y) + scale_y = 1; + + xf.matrix[0][0] = XDoubleToFixed(1 / scale_x); xf.matrix[0][1] = 0; xf.matrix[0][2] = 0; + xf.matrix[1][0] = 0; xf.matrix[1][1] = XDoubleToFixed(1 / scale_y); xf.matrix[1][2] = 0; + xf.matrix[2][0] = 0; xf.matrix[2][1] = 0; xf.matrix[2][2] = 65536; + if(smooth) + XRenderSetPictureFilter(dpy, src->pic, "bilinear", NULL, 0); + else + XRenderSetPictureFilter(dpy, src->pic, "nearest", NULL, 0); + XRenderSetPictureTransform(dpy, src->pic, &xf); + XRenderComposite(dpy, PictOpSrc, src->pic, None, dst->pic, + x * scale_x + 1, + y * scale_y + 1, + 0, 0, + x * scale_x, + y * scale_y, + w * scale_x + 1, + h * scale_y + 1); +} + +Xrender_Surf * xrender_surf_adopt(Display *dpy, Drawable draw, Visual *vis, int w, int h) +{ + Xrender_Surf *rs; + XRenderPictFormat *fmt; + XRenderPictureAttributes att; + + rs = calloc(1, sizeof(Xrender_Surf)); + + fmt = XRenderFindVisualFormat(dpy, vis); + rs->w = w; + rs->h = h; + rs->depth = fmt->depth; + rs->vis = vis; + rs->draw = draw; + att.dither = 1; + att.component_alpha = 1; + att.repeat = 0; + rs->pic = XRenderCreatePicture(dpy, rs->draw, fmt, CPRepeat | CPDither | CPComponentAlpha, &att); + rs->allocated = 0; + return rs; +} + +void xrender_surf_free(Display *dpy, Xrender_Surf *rs) +{ + if(rs->allocated) + XFreePixmap(dpy, rs->draw); + XRenderFreePicture(dpy, rs->pic); + free(rs); +} + +static Visual *find_argb_visual(Display *dpy, int scr) +{ + XVisualInfo *xvi, template; + int nvi, i; + XRenderPictFormat *format; + Visual *visual; + + template.screen = scr; + template.depth = 32; + template.class = TrueColor; + xvi = XGetVisualInfo(dpy, VisualScreenMask | VisualDepthMask | + VisualClassMask, &template, &nvi); + + if(!xvi) { + LOGERR("No xvi\n"); + return 0; + } + + visual = 0; + for(i = 0; i < nvi; i++) { + LOGDBG("iteration %d of %d\n", i, nvi); + format = XRenderFindVisualFormat(dpy, xvi[i].visual); + if((format->type == PictTypeDirect) && format->direct.alphaMask) { + visual = xvi[i].visual; + break; + } + } + + XFree(xvi); + + if(!visual) + LOGERR("No visual found\n"); + + return visual; +} + +static int hud_osd_open(frontend_t *this_gen) +{ + sxfe_t *this = (sxfe_t*)this_gen; + if(this && this->hud) { + XLockDisplay(this->display); + + LOGDBG("opening HUD window...\n"); + + this->hud_vis = find_argb_visual(this->display, DefaultScreen(this->display)); + + Colormap hud_colormap = XCreateColormap(this->display, + RootWindow(this->display, DefaultScreen(this->display)), + this->hud_vis, AllocNone); + + XSetWindowAttributes attributes; + attributes.override_redirect = True; + attributes.background_pixel = 0x00000000; + attributes.border_pixel = 0; + attributes.colormap = hud_colormap; + attributes.backing_store = Always; + + this->hud_window = XCreateWindow(this->display, DefaultRootWindow(this->display), + this->xpos, this->ypos, + this->width, this->height, + 0, 32, InputOutput, this->hud_vis, + CWBackPixel | CWBorderPixel | + CWOverrideRedirect | CWColormap, + &attributes); + + XSelectInput(this->display, this->hud_window, + StructureNotifyMask | + ExposureMask | + KeyPressMask | + ButtonPressMask | + FocusChangeMask); + + XStoreName(this->display, this->hud_window, "HUD"); + this->gc = XCreateGC(this->display, this->hud_window, 0, NULL); + + if(this->completion_event != -1) { + this->hud_img = XShmCreateImage(this->display, this->hud_vis, 32, ZPixmap, NULL, &(this->hud_shminfo), + HUD_MAX_WIDTH, HUD_MAX_HEIGHT); + + this->hud_shminfo.shmid = shmget(IPC_PRIVATE, this->hud_img->bytes_per_line * this->hud_img->height, + IPC_CREAT | 0777); + + this->hud_shminfo.shmaddr = this->hud_img->data = shmat(this->hud_shminfo.shmid, 0, 0); + this->hud_shminfo.readOnly = True; + + XShmAttach(this->display, &(this->hud_shminfo)); + } else { + /* Fall-back to traditional memory */ + LOGMSG("HUD falling back to normal (slow) memory\n"); + this->hud_img_mem = malloc(4 * HUD_MAX_WIDTH * HUD_MAX_HEIGHT); + this->hud_img = XCreateImage(this->display, this->hud_vis, 32, ZPixmap, 0, (char*)this->hud_img_mem, + HUD_MAX_WIDTH, HUD_MAX_HEIGHT, 32, 0); + } + + this->surf_win = xrender_surf_adopt(this->display, this->hud_window, this->hud_vis, HUD_MAX_WIDTH, HUD_MAX_HEIGHT); + this->surf_img = xrender_surf_new(this->display, this->hud_window, this->hud_vis, HUD_MAX_WIDTH, HUD_MAX_HEIGHT, 1); + + XUnlockDisplay(this->display); + } + return 1; +} + +static void hud_osd_close(frontend_t *this_gen) +{ + sxfe_t *this = (sxfe_t*)this_gen; + if(this && this->hud) { + XLockDisplay(this->display); + LOGDBG("closing hud window...\n"); + + if(this->completion_event != -1) { + XShmDetach(this->display, &(this->hud_shminfo)); + XDestroyImage(this->hud_img); + shmdt(this->hud_shminfo.shmaddr); + shmctl(this->hud_shminfo.shmid, IPC_RMID, 0); + } else + XDestroyImage(this->hud_img); + + if(this->surf_img) + xrender_surf_free(this->display, this->surf_img); + if(this->surf_win) + xrender_surf_free(this->display, this->surf_win); + + XDestroyWindow(this->display, this->hud_window); + XUnlockDisplay(this->display); + } +} + +static void hud_fill_img_memory(uint32_t* dst, const struct osd_command_s *cmd) +{ + int i, pixelcounter = 0; + int idx = cmd->y * HUD_MAX_WIDTH + cmd->x; + + for(i = 0; i < cmd->num_rle; ++i) { + const uint8_t alpha = (cmd->palette + (cmd->data + i)->color)->alpha; + const uint8_t r = (cmd->palette + (cmd->data + i)->color)->r; + const uint8_t g = (cmd->palette + (cmd->data + i)->color)->g; + const uint8_t b = (cmd->palette + (cmd->data + i)->color)->b; + int j, finalcolor = 0; + finalcolor |= ((alpha << 24) & 0xFF000000); + finalcolor |= ((r << 16) & 0x00FF0000); + finalcolor |= ((g << 8) & 0x0000FF00); + finalcolor |= (b & 0x000000FF); + + for(j = 0; j < (cmd->data + i)->len; ++j) { + if(pixelcounter >= cmd->w) { + idx += HUD_MAX_WIDTH - pixelcounter; + pixelcounter = 0; + } + dst[idx++] = finalcolor; + ++pixelcounter; + } + } +} + +static int hud_osd_command(frontend_t *this_gen, struct osd_command_s *cmd) +{ + sxfe_t *this = (sxfe_t*)this_gen; + if(this && this->hud && cmd) { + XLockDisplay(this->display); + switch(cmd->cmd) { + case OSD_Nop: /* Do nothing ; used to initialize delay_ms counter */ + LOGDBG("HUD osd NOP\n"); + break; + + case OSD_Size: /* Set size of VDR OSD area */ + LOGDBG("HUD Set Size\n"); + this->osd_width = (cmd->w > 0) ? cmd->w : OSD_DEF_WIDTH; + this->osd_height = (cmd->h > 0) ? cmd->h : OSD_DEF_HEIGHT; + this->osd_pad_x = (this->osd_width != OSD_DEF_WIDTH) ? 96 : 0; + this->osd_pad_y = (this->osd_height != OSD_DEF_HEIGHT) ? 90 : 0; + break; + + case OSD_Set_RLE: /* Create/update OSD window. Data is rle-compressed. */ + LOGDBG("HUD Set RLE\n"); + if(this->completion_event != -1) { + hud_fill_img_memory((uint32_t*)(this->hud_img->data), cmd); + if(!cmd->scaling) { + /* Place image directly onto hud window */ + XShmPutImage(this->display, this->hud_window, this->gc, this->hud_img, + cmd->x + cmd->dirty_area.x1, cmd->y + cmd->dirty_area.y1, + cmd->x + cmd->dirty_area.x1, cmd->y + cmd->dirty_area.y1, + cmd->dirty_area.x2 - cmd->dirty_area.x1, + cmd->dirty_area.y2 - cmd->dirty_area.y1, + False); + } else { + /* Place image onto Xrender surface which will be blended onto hud window */ + XShmPutImage(this->display, this->surf_img->draw, this->gc, this->hud_img, + cmd->x + cmd->dirty_area.x1 - 1, cmd->y + cmd->dirty_area.y1 - 1, + cmd->x + cmd->dirty_area.x1 - 1, cmd->y + cmd->dirty_area.y1 - 1, + cmd->dirty_area.x2 - cmd->dirty_area.x1 + 2, + cmd->dirty_area.y2 - cmd->dirty_area.y1 + 2, + False); + xrender_surf_blend(this->display, this->surf_img, this->surf_win, + cmd->x + cmd->dirty_area.x1 - 1, cmd->y + cmd->dirty_area.y1 - 1, + cmd->dirty_area.x2 - cmd->dirty_area.x1 + 2, + cmd->dirty_area.y2 - cmd->dirty_area.y1 + 2, + (XDouble)(this->width) / (XDouble)(this->osd_width + this->osd_pad_x), + (XDouble)(this->height) / (XDouble)(this->osd_height + this->osd_pad_y), + (cmd->scaling & 2)); // HUD_SCALING_BILINEAR=2 + } + } else { + hud_fill_img_memory(this->hud_img_mem, cmd); + if(!cmd->scaling) { + /* Place image directly onto hud window (always unscaled) */ + XPutImage(this->display, this->hud_window, this->gc, this->hud_img, + cmd->x + cmd->dirty_area.x1, cmd->y + cmd->dirty_area.y1, + cmd->x + cmd->dirty_area.x1, cmd->y + cmd->dirty_area.y1, + cmd->dirty_area.x2 - cmd->dirty_area.x1, + cmd->dirty_area.y2 - cmd->dirty_area.y1); + } else { + /* Place image onto Xrender surface which will be blended onto hud window */ + XPutImage(this->display, this->surf_img->draw, this->gc, this->hud_img, + cmd->x + cmd->dirty_area.x1 - 1, cmd->y + cmd->dirty_area.y1 - 1, + cmd->x + cmd->dirty_area.x1 - 1, cmd->y + cmd->dirty_area.y1 - 1, + cmd->dirty_area.x2 - cmd->dirty_area.x1 + 2, + cmd->dirty_area.y2 - cmd->dirty_area.y1 + 2); + xrender_surf_blend(this->display, this->surf_img, this->surf_win, + cmd->x + cmd->dirty_area.x1 - 1, cmd->y + cmd->dirty_area.y1 - 1, + cmd->dirty_area.x2 - cmd->dirty_area.x1 + 2, + cmd->dirty_area.y2 - cmd->dirty_area.y1 + 2, + (XDouble)(this->width) / (XDouble)(this->osd_width + this->osd_pad_x), + (XDouble)(this->height) / (XDouble)(this->osd_height + this->osd_pad_y), + (cmd->scaling & 2)); // HUD_SCALING_BILINEAR=2 + } + } + break; + + case OSD_SetPalette: /* Modify palette of already created OSD window */ + LOGDBG("HUD osd SetPalette\n"); + break; + + case OSD_Move: /* Change x/y position of already created OSD window */ + LOGDBG("HUD osd Move\n"); + break; + + case OSD_Set_YUV: /* Create/update OSD window. Data is in YUV420 format. */ + LOGDBG("HUD osd set YUV\n"); + break; + + case OSD_Close: /* Close OSD window */ + LOGDBG("HUD osd Close\n"); + XSetForeground(this->display, this->gc, 0x00000000); + XFillRectangle(this->display, this->hud_window, this->gc, + 0, 0, this->width, this->height); + XFlush(this->display); + break; + + default: + LOGDBG("unknown osd command\n"); + break; + } + XUnlockDisplay(this->display); + } + return 1; +} + + /* * sxfe_display_open * @@ -406,6 +779,18 @@ static int sxfe_display_open(frontend_t *this_gen, int width, int height, int fu XSizeHints hint; double res_h, res_v, aspect_diff; + if(hud) { + LOGDBG("Enabling HUD\n"); + this->hud = hud; + this->osd_width = OSD_DEF_WIDTH; + this->osd_height = OSD_DEF_HEIGHT; + this->osd_pad_x = 0; + this->osd_pad_y = 0; +#ifndef FE_STANDALONE + this->fe.xine_osd_command = hud_osd_command; +#endif + } + if(this->display) this->fe.fe_display_close(this_gen); @@ -423,8 +808,8 @@ static int sxfe_display_open(frontend_t *this_gen, int width, int height, int fu this->origypos = 0; this->width = width; this->height = height; - this->origwidth = width>0 ? width : 720; - this->origheight = height>0 ? height : 576; + this->origwidth = width>0 ? width : OSD_DEF_WIDTH; + this->origheight = height>0 ? height : OSD_DEF_HEIGHT; this->check_move = 0; this->fullscreen = fullscreen; @@ -533,12 +918,14 @@ static int sxfe_display_open(frontend_t *this_gen, int width, int height, int fu StructureNotifyMask | ExposureMask | KeyPressMask | - ButtonPressMask | ButtonReleaseMask | ButtonMotionMask); + ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | + FocusChangeMask); XSelectInput (this->display, this->window[1], StructureNotifyMask | ExposureMask | KeyPressMask | - ButtonPressMask); + ButtonPressMask | + FocusChangeMask); if(this->window_id <= 0) { @@ -616,7 +1003,7 @@ static int sxfe_display_open(frontend_t *this_gen, int width, int height, int fu set_fullscreen_props(this); - return 1; + return hud_osd_open(this_gen); } /* @@ -782,6 +1169,23 @@ static int sxfe_run(frontend_t *this_gen) XConfigureEvent *cev = (XConfigureEvent *) &event; Window tmp_win; + /* Move and resize HUD along with main or fullscreen window */ + if(this->hud) { + if(cev->window == this->window[0]) { + int hud_x, hud_y; + XTranslateCoordinates(this->display, this->window[0], + DefaultRootWindow(this->display), + 0, 0, &hud_x, &hud_y, &tmp_win); + XResizeWindow(this->display, this->hud_window, cev->width, cev->height); + XMoveWindow(this->display, this->hud_window, hud_x, hud_y); + set_cursor(this->display, this->hud_window, 1); + } else if(cev->window == this->window[1]) { + XResizeWindow(this->display, this->hud_window, cev->width, cev->height); + XMoveWindow(this->display, this->hud_window, 0, 0); + set_cursor(this->display, this->hud_window, 0); + } + } + this->width = cev->width; this->height = cev->height; @@ -809,6 +1213,28 @@ static int sxfe_run(frontend_t *this_gen) break; } + case FocusIn: + { + if(this->hud) { + XFocusChangeEvent *fev = (XFocusChangeEvent *) &event; + /* Show HUD again if sxfe window receives focus */ + if(fev->window == this->window[0] || fev->window == this->window[1]) { + XMapWindow(this->display, this->hud_window); + } + } + break; + } + case FocusOut: + { + if(this->hud) { + XFocusChangeEvent *fev = (XFocusChangeEvent *) &event; + /* Dismiss HUD window if focusing away from frontend window */ + if(fev->window == this->window[0] || fev->window == this->window[1]) { + XUnmapWindow(this->display, this->hud_window); + } + } + break; + } case ButtonRelease: { dragging = 0; @@ -934,6 +1360,8 @@ static void sxfe_display_close(frontend_t *this_gen) { sxfe_t *this = (sxfe_t*)this_gen; + hud_osd_close(this_gen); + if(this && this->display) { if(this->xine) @@ -951,6 +1379,24 @@ static void sxfe_display_close(frontend_t *this_gen) } } +static int sxfe_xine_play(frontend_t *this_gen) +{ + int r = fe_xine_play(this_gen); + +#ifdef FE_STANDALONE + sxfe_t *this = (sxfe_t*)this_gen; + + if(r && this->input && this->hud) { + vdr_input_plugin_t *input_vdr = (vdr_input_plugin_t *)this->input; + LOGDBG("Enabling HUD"); + input_vdr->f.fe_handle = this_gen; + input_vdr->f.intercept_osd = hud_osd_command; + } +#endif + + return r; +} + static frontend_t *sxfe_get_frontend(void) { sxfe_t *this = malloc(sizeof(sxfe_t)); @@ -964,7 +1410,7 @@ static frontend_t *sxfe_get_frontend(void) this->fe.xine_init = fe_xine_init; this->fe.xine_open = fe_xine_open; - this->fe.xine_play = fe_xine_play; + this->fe.xine_play = sxfe_xine_play; this->fe.xine_stop = fe_xine_stop; this->fe.xine_close = fe_xine_close; this->fe.xine_exit = fe_xine_exit; |