From 5403fb7a68093ad609aada2902e900d69cd465cd Mon Sep 17 00:00:00 2001 From: Miguel Freitas Date: Sun, 11 Sep 2005 23:59:15 +0000 Subject: new directfb plugin by Claudio Ciccani CVS patchset: 7728 CVS date: 2005/09/11 23:59:15 --- src/video_out/Makefile.am | 2 +- src/video_out/video_out_directfb.c | 2274 ++++++++++++++++++++++++++---------- 2 files changed, 1664 insertions(+), 612 deletions(-) (limited to 'src') diff --git a/src/video_out/Makefile.am b/src/video_out/Makefile.am index 4246068c0..6bbc68970 100644 --- a/src/video_out/Makefile.am +++ b/src/video_out/Makefile.am @@ -149,7 +149,7 @@ xineplug_vo_out_fb_la_LIBADD = $(MLIB_LIBS) $(XINE_LIB) xineplug_vo_out_fb_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@ xineplug_vo_out_directfb_la_SOURCES = alphablend.c video_out_directfb.c -xineplug_vo_out_directfb_la_LIBADD = $(DIRECTFB_LIBS) +xineplug_vo_out_directfb_la_LIBADD = $(DIRECTFB_LIBS) $(X_LIBS) xineplug_vo_out_directfb_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@ xineplug_vo_out_sdl_la_SOURCES = alphablend.c video_out_sdl.c diff --git a/src/video_out/video_out_directfb.c b/src/video_out/video_out_directfb.c index 84af34eb1..79646e885 100644 --- a/src/video_out/video_out_directfb.c +++ b/src/video_out/video_out_directfb.c @@ -1,611 +1,1663 @@ -/* - * Copyright (C) 2000-2003 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine 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 this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - * - * $Id: video_out_directfb.c,v 1.28 2004/11/24 16:11:03 mroi Exp $ - * - * DirectFB based output plugin. - * Rich Wareham - * - * Based on video_out_xshm.c and video_out_xv.c - */ - -#if 0 -# define DEBUGF(x) fprintf x -#else -# define DEBUGF(x) ((void) 0) -#endif - -/* Uncomment for some fun! */ -/* -#define SPHERE -*/ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include -#include -#include -#include - -#include "video_out.h" - -#include -#include - -#include "xine.h" -#include "xine_internal.h" -#include "alphablend.h" -#include "yuv2rgb.h" -#include "xineutils.h" -#include - -#define DFBCHECK(x...) \ - { \ - DFBResult err = x; \ - \ - if (err != DFB_OK) \ - { \ - fprintf( stderr, "%s <%d>:\n\t", __FILE__, __LINE__ ); \ - DirectFBErrorFatal( #x, err ); \ - } \ - } - -typedef struct directfb_frame_s { - vo_frame_t vo_frame; - xine_t *xine; - - int width, height; - double ratio; - int format; - int locked; - - IDirectFBSurface *surface; -} directfb_frame_t; - -typedef struct directfb_driver_s { - vo_driver_t vo_driver; - - xine_t *xine; - config_values_t *config; - - directfb_frame_t *cur_frame; - vo_overlay_t *overlay; - - /* DirectFB related stuff */ - IDirectFB *dfb; - IDirectFBDisplayLayer *layer; - - /* output area */ - int frame_width; - int frame_height; - - /* last displayed frame */ - int last_frame_width; /* original size */ - int last_frame_height; /* original size */ - double last_frame_ratio; - - /* display anatomy */ - double display_ratio; /* given by visual parameter from init function */ - void *user_data; - - /* gui callbacks */ - - void (*request_dest_size) (void *user_data, - int video_width, int video_height, - int *dest_x, int *dest_y, - int *dest_height, int *dest_width); - - void (*calc_dest_size) (void *user_data, - int video_width, int video_height, - int *dest_width, int *dest_height); - - alphablend_t alphablend_extra_data; -} directfb_driver_t; - -typedef struct { - video_driver_class_t driver_class; - xine_t *xine; -} directfb_class_t; - -#define CONTEXT_BAD 0 -#define CONTEXT_SAME_DRAWABLE 1 -#define CONTEXT_SET 2 -#define CONTEXT_RELOAD 3 - - -/* - * and now, the driver functions - */ - -static uint32_t directfb_get_capabilities (vo_driver_t *this_gen) { - return VO_CAP_YV12 | VO_CAP_YUY2; -} - -static void directfb_frame_field (vo_frame_t *vo_img, int which_field) { - directfb_frame_t *frame = (directfb_frame_t *) vo_img ; - - switch(which_field) { - case VO_BOTH_FIELDS: - break; - default: - xprintf(frame->xine, XINE_VERBOSITY_DEBUG, "Interlaced images not supported\n"); - } -#if 0 - switch (which_field) { - case VO_TOP_FIELD: - frame->rgb_dst = frame->texture; - frame->stripe_inc = 2*STRIPE_HEIGHT * frame->width * BYTES_PER_PIXEL; - break; - case VO_BOTTOM_FIELD: - frame->rgb_dst = frame->texture + frame->width * BYTES_PER_PIXEL ; - frame->stripe_inc = 2*STRIPE_HEIGHT * frame->width * BYTES_PER_PIXEL; - break; - case VO_BOTH_FIELDS: - frame->rgb_dst = frame->texture; - frame->stripe_inc = STRIPE_HEIGHT * frame->width * BYTES_PER_PIXEL; - break; - } -#endif -} - -static void directfb_frame_dispose (vo_frame_t *vo_img) { - - directfb_frame_t *frame = (directfb_frame_t *) vo_img ; - - if (frame) { - if(frame->locked) - DFBCHECK(frame->surface->Unlock(frame->surface)); - DFBCHECK(frame->surface->Release(frame->surface)); - frame->surface = NULL; - } - free (frame); -} - - -static vo_frame_t *directfb_alloc_frame (vo_driver_t *this_gen) { - directfb_driver_t *this = (directfb_driver_t *) this_gen; - directfb_frame_t *frame ; - - frame = (directfb_frame_t *) calloc (1, sizeof (directfb_frame_t)); - if (frame==NULL) { - xprintf (this->xine, XINE_VERBOSITY_DEBUG, "directfb_alloc_frame: out of memory\n"); - return NULL; - } - - memset (frame, 0, sizeof(directfb_frame_t)); - - pthread_mutex_init (&frame->vo_frame.mutex, NULL); - - /* - * supply required functions - */ - - frame->vo_frame.proc_slice = NULL; - frame->vo_frame.proc_frame = NULL; - frame->vo_frame.field = directfb_frame_field; - frame->vo_frame.dispose = directfb_frame_dispose; - - frame->surface = NULL; - frame->locked = 0; - frame->xine = this->xine; - - return (vo_frame_t *) frame; -} - - -static void directfb_adapt_to_output_area (directfb_driver_t *this, - int dest_width, int dest_height) -{ - this->frame_width = dest_width; - this->frame_height = dest_height; - -} - -static void directfb_update_frame_format (vo_driver_t *this_gen, - vo_frame_t *frame_gen, - uint32_t width, uint32_t height, - double ratio, int format, int flags) { - - directfb_driver_t *this = (directfb_driver_t *) this_gen; - directfb_frame_t *frame = (directfb_frame_t *) frame_gen; - DFBSurfaceDescription s_dsc; - DFBDisplayLayerConfig l_dsc; - DFBResult ret; - DFBDisplayLayerConfigFlags failed; - int pitch; - uint8_t *data; - - flags &= VO_BOTH_FIELDS; - - if ((frame->width != width) - || (frame->height != height) - || (frame->format != format)) { - if(frame->locked && frame->surface) { - DFBCHECK(frame->surface->Unlock(frame->surface)); - } - - if(frame->surface) { - DFBCHECK(frame->surface->Release(frame->surface)); - } - - frame->surface = NULL; - - frame->format = format; - frame->width = width; - frame->height = height; - - switch(frame->format) { - case XINE_IMGFMT_YV12: - s_dsc.pixelformat = DSPF_YV12; - l_dsc.pixelformat = DSPF_YV12; - break; - case XINE_IMGFMT_YUY2: - s_dsc.pixelformat = DSPF_YUY2; - l_dsc.pixelformat = DSPF_YUY2; - break; - default: - xprintf(this->xine, XINE_VERBOSITY_DEBUG, - "Error unknown image format (%i), assuming YV12\n", frame->format); - s_dsc.pixelformat = DSPF_YV12; - l_dsc.pixelformat = DSPF_YV12; - } - - s_dsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT - | DSDESC_WIDTH | DSDESC_HEIGHT; - s_dsc.caps = 0; - s_dsc.width = frame->width; - s_dsc.height = frame->height; - DFBCHECK(this->dfb->CreateSurface(this->dfb, &s_dsc, &(frame->surface))); - - l_dsc.flags = DLCONF_WIDTH | DLCONF_HEIGHT - | DLCONF_PIXELFORMAT | DLCONF_OPTIONS; - l_dsc.width = frame->width; - l_dsc.height = frame->height; - l_dsc.options = 0; - ret = this->layer->TestConfiguration(this->layer, &l_dsc, &failed ); - if (ret == DFB_UNSUPPORTED) { - xprintf(this->xine, XINE_VERBOSITY_DEBUG, "Error: Unsupported operation\n"); - return; - } - DFBCHECK(this->layer->SetConfiguration(this->layer, &l_dsc)); - - /* Set correct locations for planes in surface */ - DFBCHECK(frame->surface->Lock(frame->surface, DSLF_WRITE, - (void**)(&data), &pitch)); - memset(data, 128, 6 * width*height / 4); - - frame->locked = 1; - switch(frame->format) { - case XINE_IMGFMT_YV12: - frame->vo_frame.pitches[0] = pitch; - frame->vo_frame.pitches[1] = pitch/2; - frame->vo_frame.pitches[2] = pitch/2; - frame->vo_frame.base[0] = data; - frame->vo_frame.base[2] = data + pitch*height; - frame->vo_frame.base[1] = data + pitch*height + pitch*height/4; - break; - case XINE_IMGFMT_YUY2: - frame->vo_frame.pitches[0] = 2*pitch; - frame->vo_frame.base[0] = data; - frame->vo_frame.base[1] = data; - frame->vo_frame.base[2] = data; - break; - default: - break; - } - - frame->ratio = ratio; - - directfb_frame_field ((vo_frame_t *)frame, flags); - } -} - -static void directfb_overlay_clut_yuv2rgb(directfb_driver_t *this, vo_overlay_t *overlay) -{ -#if 0 - int i; - clut_t* clut = (clut_t*) overlay->color; - if (!overlay->rgb_clut) { - for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) { - *((uint32_t *)&clut[i]) = - this->yuv2rgb->yuv2rgb_single_pixel_fun(this->yuv2rgb, - clut[i].y, clut[i].cb, clut[i].cr); - } - overlay->rgb_clut++; - } - if (!overlay->clip_rgb_clut) { - clut = (clut_t*) overlay->clip_color; - for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) { - *((uint32_t *)&clut[i]) = - this->yuv2rgb->yuv2rgb_single_pixel_fun(this->yuv2rgb, - clut[i].y, clut[i].cb, clut[i].cr); - } - overlay->clip_rgb_clut++; - } -#endif - -} - -static void directfb_overlay_blend (vo_driver_t *this_gen, vo_frame_t *frame_gen, vo_overlay_t *overlay) { - /* directfb_driver_t *this = (directfb_driver_t *) this_gen; */ - /* directfb_frame_t *frame = (directfb_frame_t *) frame_gen; */ - -#if 0 - /* Alpha Blend here */ - if (overlay->rle) { - if( !overlay->rgb_clut || !overlay->clip_rgb_clut) - directfb_overlay_clut_yuv2rgb(this,overlay); - - _x_assert(this->delivered_width == frame->width); - _x_assert(this->delivered_height == frame->height); -# if BYTES_PER_PIXEL == 3 - blend_rgb24 ((uint8_t *)frame->texture, overlay, - frame->width, frame->height, - this->delivered_width, this->delivered_height, - &this->alphablend_extra_data); -# elif BYTES_PER_PIXEL == 4 - blend_rgb32 ((uint8_t *)frame->texture, overlay, - frame->width, frame->height, - this->delivered_width, this->delivered_height, - &this->alphablend_extra_data); -# else -# error "bad BYTES_PER_PIXEL" -# endif - } -#endif -} - -static void directfb_render_image (directfb_driver_t *this, directfb_frame_t *frame) -{ - if(frame && frame->surface) { - IDirectFBSurface *surface; - - if(frame->locked) { - frame->surface->Unlock(frame->surface); - frame->locked = 0; - } - - DFBCHECK(this->layer->GetSurface(this->layer, &surface)); - DFBCHECK(surface->Blit(surface, - frame->surface, NULL,0,0)); - /* DFBCHECK(surface->Flip(surface, NULL, 0)); */ - } -} - - -static void directfb_display_frame (vo_driver_t *this_gen, vo_frame_t *frame_gen) { - - directfb_driver_t *this = (directfb_driver_t *) this_gen; - directfb_frame_t *frame = (directfb_frame_t *) frame_gen; - - if( this->cur_frame ) - this->cur_frame->vo_frame.free (&this->cur_frame->vo_frame); - this->cur_frame = frame; - - if ( (frame->width != this->last_frame_width) || - (frame->height != this->last_frame_height)) - { - this->last_frame_width = frame->width; - this->last_frame_height = frame->height; - this->last_frame_ratio = frame->ratio; - - xprintf (this->xine, XINE_VERBOSITY_DEBUG, - "video_out_directfb: frame size %d x %d\n", this->frame_width, this->frame_height); - } - - directfb_render_image (this, frame); - - frame->vo_frame.free (&frame->vo_frame); - this->cur_frame = NULL; -} - - -static int directfb_get_property (vo_driver_t *this_gen, int property) { - - directfb_driver_t *this = (directfb_driver_t *) this_gen; - - if ( property == VO_PROP_ASPECT_RATIO) { - return 1; - } else { - xprintf (this->xine, XINE_VERBOSITY_DEBUG, - "video_out_directfb: tried to get unsupported property %d\n", property); - } - - return 0; -} - - -static char *aspect_ratio_name(int a) -{ - switch (a) { - case XINE_VO_ASPECT_AUTO: - return "auto"; - case XINE_VO_ASPECT_SQUARE: - return "square"; - case XINE_VO_ASPECT_4_3: - return "4:3"; - case XINE_VO_ASPECT_ANAMORPHIC: - return "16:9"; - case XINE_VO_ASPECT_DVB: - return "2:1"; - default: - return "unknown"; - } -} - -static int directfb_set_property (vo_driver_t *this_gen, - int property, int value) { - - directfb_driver_t *this = (directfb_driver_t *) this_gen; - - if ( property == VO_PROP_ASPECT_RATIO) { - if (value>=XINE_VO_ASPECT_NUM_RATIOS) - value = XINE_VO_ASPECT_AUTO; - /* this->user_ratio = value; */ - xprintf(this->xine, XINE_VERBOSITY_DEBUG, - "video_out_directfb: aspect ratio changed to %s\n", aspect_ratio_name(value)); - } else { - xprintf (this->xine, XINE_VERBOSITY_DEBUG, - "video_out_directfb: tried to set unsupported property %d\n", property); - } - - return value; -} - -static void directfb_get_property_min_max (vo_driver_t *this_gen, - int property, int *min, int *max) { - *min = 0; - *max = 0; -} - - -static int is_fullscreen_size (directfb_driver_t *this, int w, int h) { - /* Always fullscreen*/ - return 1; -} - -static void directfb_translate_gui2video(directfb_driver_t *this, - int x, int y, - int *vid_x, int *vid_y) -{ - *vid_x = x; - *vid_y = y; -} - -static int directfb_gui_data_exchange (vo_driver_t *this_gen, - int data_type, void *data) { - - directfb_driver_t *this = (directfb_driver_t *) this_gen; - - - switch (data_type) { - default: - return -1; - } - - xprintf (this->xine, XINE_VERBOSITY_DEBUG, "done gui_data_exchange\n"); - return 0; -} - -static int directfb_redraw_needed (vo_driver_t *this_gen) { -/* directfb_driver_t *this = (directfb_driver_t *) this_gen; */ - - return 0; -} - - -static void directfb_dispose (vo_driver_t *this_gen) { - directfb_driver_t *this = (directfb_driver_t *) this_gen; - - _x_alphablend_free(&this->alphablend_extra_data); - - free(this); -} - -typedef struct { - IDirectFB *dfb; - IDirectFBDisplayLayer *video_layer; -} dfb_visual_info_t; - -static vo_driver_t *open_plugin (video_driver_class_t *class_gen, const void *visual_gen) { - - directfb_class_t *class = (directfb_class_t *) class_gen; - directfb_driver_t *this; - dfb_visual_info_t *visual_info = (dfb_visual_info_t*)visual_gen; - - xprintf (class->xine, XINE_VERBOSITY_DEBUG, "EXPERIMENTAL directfb output plugin\n"); - /* - * allocate plugin struct - */ - - this = xine_xmalloc (sizeof (directfb_driver_t)); - if (!this) - return NULL; - - _x_alphablend_init(&this->alphablend_extra_data, class->xine); - - this->xine = class->xine; - this->frame_width = 0; - this->frame_height = 0; - - this->vo_driver.get_capabilities = directfb_get_capabilities; - this->vo_driver.alloc_frame = directfb_alloc_frame; - this->vo_driver.update_frame_format = directfb_update_frame_format; - this->vo_driver.overlay_begin = NULL; /* not used */ - this->vo_driver.overlay_blend = directfb_overlay_blend; - this->vo_driver.overlay_end = NULL; /* not used */ - this->vo_driver.display_frame = directfb_display_frame; - this->vo_driver.get_property = directfb_get_property; - this->vo_driver.set_property = directfb_set_property; - this->vo_driver.get_property_min_max = directfb_get_property_min_max; - this->vo_driver.gui_data_exchange = directfb_gui_data_exchange; - this->vo_driver.redraw_needed = directfb_redraw_needed; - this->vo_driver.dispose = directfb_dispose; - - this->dfb = visual_info->dfb; - this->layer = visual_info->video_layer; - DFBCHECK(this->layer->SetCooperativeLevel(this->layer, - DLSCL_ADMINISTRATIVE)); - - return &this->vo_driver; -} - -static char* get_identifier (video_driver_class_t *this_gen) { - return "DirectFB"; -} - -static char* get_description (video_driver_class_t *this_gen) { - return _("xine video output plugin using the DirectFB library."); -} - -static void dispose_class (video_driver_class_t *this_gen) { - - directfb_class_t *this = (directfb_class_t *) this_gen; - - free (this); -} - -static void *init_class (xine_t *xine, void *visual_gen) { - - directfb_class_t *this; - - this = (directfb_class_t *) xine_xmalloc (sizeof (directfb_class_t)); - this->driver_class.open_plugin = open_plugin; - this->driver_class.get_identifier = get_identifier; - this->driver_class.get_description = get_description; - this->driver_class.dispose = dispose_class; - - this->xine = xine; - - return this; -} - -static vo_info_t vo_info_directfb = { - 8, /* priority */ - XINE_VISUAL_TYPE_DFB /* visual type */ -}; - -plugin_info_t xine_plugin_info[] = { - /* type, API, "name", version, special_info, init_function */ - { PLUGIN_VIDEO_OUT, 20, "DirectFB", XINE_VERSION_CODE, &vo_info_directfb, init_class }, - { PLUGIN_NONE, 0, "", 0, NULL, NULL } -}; - +/* + * Copyright (C) 2000-2005 the xine project and Claudio Ciccani + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * + * DirectFB based output plugin by Claudio Ciccani + * + * Based on video_out_xv.c and video_out_vidix.c. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include +#include + +#ifdef HAVE_X11 +# include +#endif + +#ifdef HAVE_FB +# include +# include +# include +# include +#endif + +#define LOG_MODULE "video_out_directfb" +#define LOG_VERBOSE + +#include "xine.h" +#include "xine_internal.h" +#include "video_out.h" +#include "alphablend.h" +#include "xineutils.h" +#include "vo_scale.h" + +#include +#include + + +typedef struct directfb_frame_s { + vo_frame_t vo_frame; + + int width; + int height; + DFBSurfacePixelFormat format; + double ratio; + + IDirectFBSurface *surface; + int locked; +} directfb_frame_t; + +typedef struct directfb_driver_s { + vo_driver_t vo_driver; + + int visual_type; + + xine_t *xine; + + directfb_frame_t *recent_frames[VO_NUM_RECENT_FRAMES]; + + /* DirectFB related stuff */ + IDirectFB *dfb; + IDirectFBDisplayLayer *layer; + IDirectFBSurface *surface; + DFBDisplayLayerCapabilities caps; + DFBDisplayLayerConfig config; + DFBColorAdjustment default_cadj; + DFBColorAdjustment cadj; + + /* for hardware scaling */ + IDirectFBSurface *temp; + int temp_frame_width; + int temp_frame_height; + DFBSurfacePixelFormat temp_frame_format; + + /* wheter card supports stretchblit with deinterlacing */ + int hw_deinterlace; + + /* wheter to enable deinterlacing */ + int deinterlace; + + /* configurable options */ + int buffermode; + int vsync; + int colorkeying; + uint32_t colorkey; + int flicker_filtering; + int field_parity; + +#ifdef HAVE_X11 + /* X11 related stuff */ + Display *display; + int screen; + Drawable drawable; + GC gc; + int depth; +#endif + + /* screen size */ + int screen_width; + int screen_height; + + /* size / aspect ratio calculations */ + vo_scale_t sc; + + /* gui callbacks */ + alphablend_t alphablend_extra_data; +} directfb_driver_t; + +typedef struct { + video_driver_class_t driver_class; + xine_t *xine; +} directfb_class_t; + + +#define DEFAULT_COLORKEY 0x202040 + + +#ifndef MAX +# define MAX(a,b) (((a) > (b)) ? (a) : (b)) +#endif + +/*** driver functions ***/ + +static uint32_t directfb_get_capabilities (vo_driver_t *this_gen) { + return VO_CAP_YV12 | VO_CAP_YUY2 | VO_CAP_CROP; +} + +static void directfb_frame_field (vo_frame_t *vo_img, int which_field) { + /* not needed */ +} + +static void directfb_frame_dispose (vo_frame_t *vo_img) { + directfb_frame_t *frame = (directfb_frame_t *) vo_img; + + if (frame) { + if (frame->surface) { + if (frame->locked) + frame->surface->Unlock (frame->surface); + frame->surface->Release (frame->surface); + } + + free (frame); + } +} + +static vo_frame_t *directfb_alloc_frame (vo_driver_t *this_gen) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + directfb_frame_t *frame; + + frame = (directfb_frame_t *) xine_xmalloc (sizeof (directfb_frame_t)); + if (!frame) { + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: directfb_alloc_frame: out of memory\n"); + return NULL; + } + + pthread_mutex_init (&frame->vo_frame.mutex, NULL); + + frame->vo_frame.proc_slice = NULL; + frame->vo_frame.proc_frame = NULL; + frame->vo_frame.field = directfb_frame_field; + frame->vo_frame.dispose = directfb_frame_dispose; + frame->vo_frame.driver = this_gen; + + return &frame->vo_frame; +} + +static void directfb_update_frame_format (vo_driver_t *this_gen, + vo_frame_t *frame_gen, + uint32_t width, uint32_t height, + double ratio, int fmt, int flags) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + directfb_frame_t *frame = (directfb_frame_t *) frame_gen; + DFBSurfacePixelFormat format = (fmt == XINE_IMGFMT_YUY2) ? DSPF_YUY2 : DSPF_YV12; + + if (frame->surface == NULL || + frame->width != width || + frame->height != height || + frame->format != format) + { + DFBSurfaceDescription dsc; + DFBResult ret; + + lprintf ("frame %p: format changed to %dx%d %s.\n", + frame, width, height, (format == DSPF_YUY2) ? "YUY2" : "YV12"); + + if (frame->surface) { + if (frame->locked) + frame->surface->Unlock (frame->surface); + frame->surface->Release (frame->surface); + frame->surface = NULL; + frame->locked = 0; + } + + dsc.flags = DSDESC_CAPS | DSDESC_WIDTH | + DSDESC_HEIGHT | DSDESC_PIXELFORMAT; + dsc.caps = DSCAPS_SYSTEMONLY; + dsc.width = (width + 7) & ~7; + dsc.height = (height + 1) & ~1; + dsc.pixelformat = format; + + ret = this->dfb->CreateSurface (this->dfb, &dsc, &frame->surface); + if (ret != DFB_OK) { + DirectFBError ("IDirectFB::CreateSurface()", ret); + return; + } + + frame->width = width; + frame->height = height; + frame->format = format; + + ret = frame->surface->Lock (frame->surface, + DSLF_READ | DSLF_WRITE, + (void**)&frame->vo_frame.base[0], + (int *)&frame->vo_frame.pitches[0]); + if (ret != DFB_OK) { + DirectFBError ("IDirectFBSurface::Lock()", ret); + return; + } + frame->locked = 1; + + if (frame->format == DSPF_YV12) { + frame->vo_frame.pitches[1] = frame->vo_frame.pitches[0]/2; + frame->vo_frame.pitches[2] = frame->vo_frame.pitches[0]/2; + frame->vo_frame.base[2] = frame->vo_frame.base[0] + + dsc.height * frame->vo_frame.pitches[0]; + frame->vo_frame.base[1] = frame->vo_frame.base[2] + + dsc.height/2 * frame->vo_frame.pitches[2]; + } + } + + frame->ratio = ratio; +} + +static void directfb_clean_output_area (directfb_driver_t *this) { + if (this->visual_type == XINE_VISUAL_TYPE_X11) { +#ifdef HAVE_X11 + if (this->config.options & DLOP_DST_COLORKEY) { + uint32_t pixel; + int i; + + switch (this->depth) { + case 8: + pixel = ((this->colorkey & 0xe00000) >> 16) | + ((this->colorkey & 0x00e000) >> 11) | + ((this->colorkey & 0x0000c0) >> 6); + break; + case 15: + pixel = ((this->colorkey & 0xf80000) >> 9) | + ((this->colorkey & 0x00f800) >> 6) | + ((this->colorkey & 0x0000f8) >> 3); + break; + case 16: + pixel = ((this->colorkey & 0xf80000) >> 8) | + ((this->colorkey & 0x00fc00) >> 5) | + ((this->colorkey & 0x0000f8) >> 3); + break; + default: + pixel = this->colorkey; + break; + } + + XLockDisplay (this->display); + + XSetForeground (this->display, this->gc, BlackPixel(this->display, this->screen)); + + for (i = 0; i < 4; i++) { + if (this->sc.border[i].w && this->sc.border[i].h) { + XFillRectangle (this->display, this->drawable, this->gc, + this->sc.border[i].x, this->sc.border[i].y, + this->sc.border[i].w, this->sc.border[i].h); + } + } + + XSetForeground (this->display, this->gc, pixel); + XFillRectangle (this->display, this->drawable, this->gc, + this->sc.output_xoffset, this->sc.output_yoffset, + this->sc.output_width, this->sc.output_height); + + XFlush (this->display); + + XUnlockDisplay (this->display); + } +#endif + } + else if (!(this->caps & DLCAPS_SCREEN_LOCATION)) { + DFBRectangle rect[4]; + int i; + + for (i = 0; i < 4; i++) { + rect[i].x = MAX(this->sc.border[i].x, 0); + rect[i].y = MAX(this->sc.border[i].y, 0); + rect[i].w = MAX(this->sc.border[i].w, 0); + rect[i].h = MAX(this->sc.border[i].h, 0); + } + + this->surface->SetColor (this->surface, 0x00, 0x00, 0x00, 0xff); + this->surface->FillRectangles (this->surface, &rect[0], 4); + } +} + +static void directfb_overlay_blend (vo_driver_t *this_gen, + vo_frame_t *frame_gen, vo_overlay_t *overlay) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + directfb_frame_t *frame = (directfb_frame_t *) frame_gen; + + if (frame->format == DSPF_YUY2) { + blend_yuy2 (frame->vo_frame.base[0], overlay, + frame->width, frame->height, + frame->vo_frame.pitches[0], + &this->alphablend_extra_data); + } + else { + blend_yuv (frame->vo_frame.base, overlay, + frame->width, frame->height, + frame->vo_frame.pitches, + &this->alphablend_extra_data); + } +} + +static int directfb_redraw_needed (vo_driver_t *this_gen) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + + if (_x_vo_scale_redraw_needed (&this->sc)) { + _x_vo_scale_compute_output_size (&this->sc); + + if (this->caps & DLCAPS_SCREEN_LOCATION) { + this->layer->SetSourceRectangle (this->layer, + this->sc.displayed_xoffset, + this->sc.displayed_yoffset, + this->sc.displayed_width, + this->sc.displayed_height ); + this->layer->SetScreenRectangle (this->layer, + this->sc.gui_win_x+this->sc.output_xoffset, + this->sc.gui_win_y+this->sc.output_yoffset, + this->sc.output_width, + this->sc.output_height); + } + + directfb_clean_output_area (this); + } + + return 0; +} + +static void directfb_add_recent_frame (directfb_driver_t *this, directfb_frame_t *frame) { + int i; + + i = VO_NUM_RECENT_FRAMES-1; + if (this->recent_frames[i]) + this->recent_frames[i]->vo_frame.free (&this->recent_frames[i]->vo_frame); + + for (; i; i--) + this->recent_frames[i] = this->recent_frames[i-1]; + + this->recent_frames[0] = frame; +} + +/* directfb_display_frame(): output to overlay */ +static void directfb_display_frame (vo_driver_t *this_gen, vo_frame_t *frame_gen) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + directfb_frame_t *frame = (directfb_frame_t *) frame_gen; + DFBResult ret; + + directfb_add_recent_frame (this, frame); + + this->config.flags = DLCONF_NONE; + + if (frame->width != this->config.width) { + this->config.flags |= DLCONF_WIDTH; + this->config.width = frame->width; + } + + if (frame->height != this->config.height) { + this->config.flags |= DLCONF_HEIGHT; + this->config.height = frame->height; + } + + if (frame->format != this->config.pixelformat) { + this->config.flags |= DLCONF_PIXELFORMAT; + this->config.pixelformat = frame->format; + } + + if (this->caps & DLCAPS_DEINTERLACING) { + if (this->deinterlace && + !(this->config.options & DLOP_DEINTERLACING)) { + this->config.flags |= DLCONF_OPTIONS; + this->config.options |= DLOP_DEINTERLACING; + } + else if (!this->deinterlace && + (this->config.options & DLOP_DEINTERLACING)) { + this->config.flags |= DLCONF_OPTIONS; + this->config.options &= ~DLOP_DEINTERLACING; + } + } + + if (this->config.flags) { + lprintf ("changing layer configuration to %dx%d %s.\n", + this->config.width, this->config.height, + (this->config.pixelformat == DSPF_YUY2) ? "YUY2" : "YV12"); + + ret = this->layer->SetConfiguration (this->layer, &this->config); + if (ret != DFB_OK) + DirectFBError( "IDirectFBDisplayLayer::SetConfiguration()", ret ); + this->layer->GetConfiguration (this->layer, &this->config); + } + + if (this->sc.delivered_width != frame->width || + this->sc.delivered_height != frame->height || + this->sc.delivered_ratio != frame->ratio) + { + this->sc.delivered_width = frame->width; + this->sc.delivered_height = frame->height; + this->sc.delivered_ratio = frame->ratio; + this->sc.crop_left = frame->vo_frame.crop_left; + this->sc.crop_right = frame->vo_frame.crop_right; + this->sc.crop_top = frame->vo_frame.crop_top; + this->sc.crop_bottom = frame->vo_frame.crop_bottom; + + _x_vo_scale_compute_ideal_size (&this->sc); + this->sc.force_redraw = 1; + } + + directfb_redraw_needed (&this->vo_driver); + + this->layer->SetOpacity (this->layer, 0xff); + + if (frame->locked) { + frame->surface->Unlock (frame->surface); + frame->locked = 0; + } + + if (this->deinterlace) { + if (!(this->config.options & DLOP_DEINTERLACING)) + this->surface->SetBlittingFlags (this->surface, DSBLIT_DEINTERLACE); + } else + this->surface->SetBlittingFlags (this->surface, DSBLIT_NOFX); + + this->surface->Blit (this->surface, frame->surface, NULL, 0, 0); + this->surface->Flip (this->surface, NULL, + (this->vsync) ? DSFLIP_WAITFORSYNC : DSFLIP_ONSYNC); + + frame->surface->Lock (frame->surface, + DSLF_READ | DSLF_WRITE, + (void**)&frame->vo_frame.base[0], + (int *)&frame->vo_frame.pitches[0]); + frame->locked = 1; +} + +/* directfb_display_frame2(): output to a generic (fixed) layer */ +static void directfb_display_frame2 (vo_driver_t *this_gen, vo_frame_t *frame_gen) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + directfb_frame_t *frame = (directfb_frame_t *) frame_gen; + DFBSurfaceBlittingFlags flags; + DFBRectangle s, d; + DFBResult ret; + + directfb_add_recent_frame (this, frame); + + /* TODO: try to change video mode when frame size changes */ + + if (this->temp) { + /* try to reduce video memory fragmentation */ + if (this->temp_frame_width < frame->width || + this->temp_frame_height < frame->height || + this->temp_frame_format != frame->format) + { + DFBSurfaceDescription dsc; + + lprintf ("reallocating temporary surface.\n"); + + this->temp->Release (this->temp); + this->temp = NULL; + + dsc.flags = DSDESC_CAPS | DSDESC_WIDTH | + DSDESC_HEIGHT | DSDESC_PIXELFORMAT; + dsc.caps = DSCAPS_VIDEOONLY; + dsc.width = frame->width; + dsc.height = frame->height; + dsc.pixelformat = frame->format; + + ret = this->dfb->CreateSurface (this->dfb, &dsc, &this->temp); + if (ret != DFB_OK) + DirectFBError ("IDirectFB::CreateSurface()", ret); + + this->temp_frame_width = frame->width; + this->temp_frame_height = frame->height; + this->temp_frame_format = frame->format; + } + } + + if (this->sc.delivered_width != frame->width || + this->sc.delivered_height != frame->height || + this->sc.delivered_ratio != frame->ratio) + { + this->sc.delivered_width = frame->width; + this->sc.delivered_height = frame->height; + this->sc.delivered_ratio = frame->ratio; + this->sc.crop_left = frame->vo_frame.crop_left; + this->sc.crop_right = frame->vo_frame.crop_right; + this->sc.crop_top = frame->vo_frame.crop_top; + this->sc.crop_bottom = frame->vo_frame.crop_bottom; + + _x_vo_scale_compute_ideal_size (&this->sc); + this->sc.force_redraw = 1; + } + + directfb_redraw_needed (&this->vo_driver); + + this->layer->SetOpacity (this->layer, 0xff); + + if (frame->locked) { + frame->surface->Unlock (frame->surface); + frame->locked = 0; + } + + /* source rectangle */ + s.x = this->sc.displayed_xoffset; + s.y = this->sc.displayed_yoffset; + s.w = this->sc.displayed_width; + s.h = this->sc.displayed_height; + + /* destination rectangle */ + d.x = this->sc.gui_win_x+this->sc.output_xoffset; + d.y = this->sc.gui_win_y+this->sc.output_yoffset; + d.w = this->sc.output_width; + d.h = this->sc.output_height; + + flags = (this->deinterlace) ? DSBLIT_DEINTERLACE : DSBLIT_NOFX; + + if (this->temp) { + if (this->hw_deinterlace) + this->surface->SetBlittingFlags (this->surface, flags); + else + this->temp->SetBlittingFlags (this->temp, flags); + + this->temp->Blit (this->temp, frame->surface, &s, s.x, s.y); + this->surface->StretchBlit (this->surface, this->temp, &s, &d); + } + else { + this->surface->SetBlittingFlags (this->surface, flags); + this->surface->StretchBlit (this->surface, frame->surface, &s, &d); + } + + this->surface->Flip (this->surface, NULL, + (this->vsync) ? DSFLIP_WAITFORSYNC : DSFLIP_ONSYNC); + + frame->surface->Lock (frame->surface, + DSLF_READ | DSLF_WRITE, + (void**)&frame->vo_frame.base[0], + (int *)&frame->vo_frame.pitches[0]); + frame->locked = 1; +} + +static int directfb_get_property (vo_driver_t *this_gen, int property) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + + switch (property) { + case VO_PROP_INTERLACED: + return this->deinterlace; + + case VO_PROP_ASPECT_RATIO: + return this->sc.user_ratio; + + case VO_PROP_HUE: + if (this->caps & DLCAPS_HUE) + return this->cadj.hue; + break; + + case VO_PROP_SATURATION: + if (this->caps & DLCAPS_SATURATION) + return this->cadj.saturation; + break; + + case VO_PROP_CONTRAST: + if (this->caps & DLCAPS_CONTRAST) + return this->cadj.contrast; + break; + + case VO_PROP_BRIGHTNESS: + if (this->caps & DLCAPS_BRIGHTNESS) + return this->cadj.brightness; + break; + + case VO_PROP_COLORKEY: + if (this->caps & DLCAPS_DST_COLORKEY) + return this->colorkey; + break; + + case VO_PROP_ZOOM_X: + return this->sc.zoom_factor_x * XINE_VO_ZOOM_STEP; + + case VO_PROP_ZOOM_Y: + return this->sc.zoom_factor_y * XINE_VO_ZOOM_STEP; + + case VO_PROP_WINDOW_WIDTH: + return this->sc.gui_width; + + case VO_PROP_WINDOW_HEIGHT: + return this->sc.gui_height; + + default: + break; + } + + return 0; +} + +static int directfb_set_property (vo_driver_t *this_gen, + int property, int value) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + + switch (property) { + case VO_PROP_INTERLACED: + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: deinterlacing set to %d.\n", value); + this->deinterlace = value; + break; + + case VO_PROP_ASPECT_RATIO: + if (value >= XINE_VO_ASPECT_NUM_RATIOS) + value = XINE_VO_ASPECT_NUM_RATIOS-1; + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: aspect ratio changed to %s.\n", + _x_vo_scale_aspect_ratio_name (value)); + this->sc.user_ratio = value; + _x_vo_scale_compute_ideal_size (&this->sc); + this->sc.force_redraw = 1; + break; + + case VO_PROP_HUE: + if (this->caps & DLCAPS_HUE) { + if (value > 0xffff) + value = 0xffff; + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: setting hue to %d.\n", value); + this->cadj.flags = DCAF_HUE; + this->cadj.hue = value; + this->layer->SetColorAdjustment (this->layer, &this->cadj); + } + break; + + case VO_PROP_SATURATION: + if (this->caps & DLCAPS_SATURATION) { + if (value > 0xffff) + value = 0xffff; + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: setting saturation to %d.\n", value); + this->cadj.flags = DCAF_SATURATION; + this->cadj.saturation = value; + this->layer->SetColorAdjustment (this->layer, &this->cadj); + } + break; + + case VO_PROP_CONTRAST: + if (this->caps & DLCAPS_CONTRAST) { + if (value > 0xffff) + value = 0xffff; + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: setting contrast to %d.\n", value); + this->cadj.flags = DCAF_CONTRAST; + this->cadj.contrast = value; + this->layer->SetColorAdjustment (this->layer, &this->cadj); + } + break; + + case VO_PROP_BRIGHTNESS: + if (this->caps & DLCAPS_BRIGHTNESS) { + if (value > 0xffff) + value = 0xffff; + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: setting brightness to %d.\n", value); + this->cadj.flags = DCAF_BRIGHTNESS; + this->cadj.brightness = value; + this->layer->SetColorAdjustment (this->layer, &this->cadj); + } + break; + + case VO_PROP_COLORKEY: + if (this->caps & DLCAPS_DST_COLORKEY) { + if (value > 0xffffff) + value = 0xffffff; + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: setting colorkey to 0x%06x.\n", value); + this->colorkey = value; + this->layer->SetDstColorKey (this->layer, (value & 0xff0000) >> 16, + (value & 0x00ff00) >> 8, + (value & 0x0000ff) >> 0); + directfb_clean_output_area (this); + } + break; + + case VO_PROP_ZOOM_X: + if (value >= XINE_VO_ZOOM_MIN && value <= XINE_VO_ZOOM_MAX) { + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: Zoom X by factor %d.\n", value); + this->sc.zoom_factor_x = (double)value / (double)XINE_VO_ZOOM_STEP; + _x_vo_scale_compute_ideal_size (&this->sc); + this->sc.force_redraw = 1; + } + break; + + case VO_PROP_ZOOM_Y: + if (value >= XINE_VO_ZOOM_MIN && value <= XINE_VO_ZOOM_MAX) { + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: Zoom Y by factor %d.\n", value); + this->sc.zoom_factor_y = (double)value / (double)XINE_VO_ZOOM_STEP; + _x_vo_scale_compute_ideal_size (&this->sc); + this->sc.force_redraw = 1; + } + break; + + default: + break; + } + + return value; +} + +static void directfb_get_property_min_max (vo_driver_t *this_gen, + int property, int *min, int *max) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + + switch (property) { + case VO_PROP_INTERLACED: + *min = 0; + *max = 1; + return; + + case VO_PROP_ASPECT_RATIO: + *min = 0; + *max = XINE_VO_ASPECT_NUM_RATIOS-1; + return; + + case VO_PROP_HUE: + if (this->caps & DLCAPS_HUE) { + *min = 0x0000; + *max = 0xffff; + return; + } + break; + + case VO_PROP_SATURATION: + if (this->caps & DLCAPS_SATURATION) { + *min = 0x0000; + *max = 0xffff; + return; + } + break; + + case VO_PROP_CONTRAST: + if (this->caps & DLCAPS_CONTRAST) { + *min = 0x0000; + *max = 0xffff; + return; + } + break; + + case VO_PROP_BRIGHTNESS: + if (this->caps & DLCAPS_BRIGHTNESS) { + *min = 0x0000; + *max = 0xffff; + return; + } + break; + + case VO_PROP_COLORKEY: + if (this->caps & DLCAPS_DST_COLORKEY) { + *min = 0x000000; + *max = 0xffffff; + return; + } + break; + + case VO_PROP_ZOOM_X: + case VO_PROP_ZOOM_Y: + *min = XINE_VO_ZOOM_MIN; + *max = XINE_VO_ZOOM_MAX; + return; + + default: + break; + } + + *min = 0; + *max = 0; +} + +static int directfb_gui_data_exchange (vo_driver_t *this_gen, + int data_type, void *data) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + + switch (data_type) { + case XINE_GUI_SEND_DRAWABLE_CHANGED: +#ifdef HAVE_X11 + if (this->visual_type == XINE_VISUAL_TYPE_X11) { + this->drawable = (Drawable) data; + XLockDisplay (this->display); + XFreeGC (this->display, this->gc); + this->gc = XCreateGC (this->display, this->drawable, 0, NULL); + XUnlockDisplay (this->display); + } +#endif + return 0; + + case XINE_GUI_SEND_TRANSLATE_GUI_TO_VIDEO: { + int x1, y1, x2, y2; + x11_rectangle_t *rect = data; + + _x_vo_scale_translate_gui2video (&this->sc, + rect->x, rect->y, + &x1, &y1); + _x_vo_scale_translate_gui2video (&this->sc, + rect->x + rect->w, rect->y + rect->h, + &x2, &y2); + rect->x = x1; + rect->y = y1; + rect->w = x2-x1; + rect->h = y2-y1; + } return 0; + + default: + break; + } + + return -1; +} + +static void directfb_dispose (vo_driver_t *this_gen) { + directfb_driver_t *this = (directfb_driver_t *) this_gen; + + if (this) { + int i; + + for (i = 0; i < VO_NUM_RECENT_FRAMES; i++) { + directfb_frame_t *frame = this->recent_frames[i]; + if (frame) + frame->vo_frame.free (&frame->vo_frame); + } + +#ifdef HAVE_X11 + if (this->visual_type == XINE_VISUAL_TYPE_X11) { + XLockDisplay (this->display); + XFreeGC (this->display, this->gc); + XUnlockDisplay (this->display); + } +#endif + + if (this->temp) + this->temp->Release (this->temp); + + if (this->surface) + this->surface->Release (this->surface); + + if (this->layer) { + this->layer->SetColorAdjustment (this->layer, &this->default_cadj); + this->layer->Release (this->layer); + } + + if (this->dfb) + this->dfb->Release (this->dfb); + + _x_alphablend_free (&this->alphablend_extra_data); + + free (this); + } +} + +/*** misc functions ****/ + +static DFBEnumerationResult find_overlay (DFBDisplayLayerID id, + DFBDisplayLayerDescription dsc, void *ctx) { + DFBDisplayLayerID *ret_id = (DFBDisplayLayerID *) ctx; + + if (dsc.caps & DLCAPS_SURFACE && + dsc.caps & DLCAPS_SCREEN_LOCATION) { + *ret_id = id; + return DFENUM_CANCEL; + } + + return DFENUM_OK; +} + +static DFBResult probe_device (directfb_driver_t *this, DFBDisplayLayerID id) { + IDirectFBDisplayLayer *layer; + DFBDisplayLayerDescription dsc; + DFBDisplayLayerConfig config; + DFBResult ret; + + ret = this->dfb->GetDisplayLayer (this->dfb, id, &layer); + if (ret != DFB_OK) { + DirectFBError( "IDirectFB::GetDisplayLayer()", ret ); + return ret; + } + + layer->SetCooperativeLevel (layer, DLSCL_EXCLUSIVE); + + /* hide */ + layer->SetOpacity (layer, 0x00); + + /* check if YUY2 is supported */ + config.flags = DLCONF_PIXELFORMAT; + config.pixelformat = DSPF_YUY2; + + ret = layer->TestConfiguration (layer, &config, NULL); + if (ret != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_LOG, + "video_out_directfb: Display Layer #%d doesn't support YUY2.\n", id); + layer->Release (layer); + return DFB_UNSUPPORTED; + } + + /* check if YV12 is supported */ + config.flags = DLCONF_PIXELFORMAT; + config.pixelformat = DSPF_YV12; + + ret = layer->TestConfiguration (layer, &config, NULL); + if (ret != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_LOG, + "video_out_directfb: Display Layer #%d doesn't support YV12.\n", id); + layer->Release (layer); + return DFB_UNSUPPORTED; + } + + layer->GetDescription (layer, &dsc); + + this->layer = layer; + this->caps = dsc.caps; + + xprintf (this->xine, XINE_VERBOSITY_LOG, + "video_out_directfb: using Display Layer #%d.\n", id); + + return DFB_OK; +} + +static void update_config_cb (void *data, xine_cfg_entry_t *entry) { + directfb_driver_t *this = (directfb_driver_t *) data; + + if (strcmp (entry->key, "video.device.directfb_buffermode") == 0) { + DFBDisplayLayerConfig config = { .flags = DLCONF_BUFFERMODE }; + + switch (entry->num_value) { + case 0: + config.buffermode = DLBM_FRONTONLY; + break; + case 2: + config.buffermode = DLBM_TRIPLE; + break; + default: + config.buffermode = DLBM_BACKVIDEO; + break; + } + + if (config.buffermode != this->config.buffermode) { + if (this->layer->SetConfiguration (this->layer, &config) != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_NONE, + "video_out_directfb: failed to set buffermode to %d!\n", + entry->num_value); + return; + } + + this->layer->GetConfiguration (this->layer, &this->config); + } + } + else if (strcmp (entry->key, "video.device.directfb_colorkeying") == 0) { + DFBDisplayLayerConfig config = { .flags = DLCONF_OPTIONS }; + + if (entry->num_value) + config.options = this->config.options | DLOP_DST_COLORKEY; + else + config.options = this->config.options & ~DLOP_DST_COLORKEY; + + if (config.options != this->config.options) { + if (this->layer->SetConfiguration (this->layer, &config) != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_NONE, + "video_out_directfb: failed to set colorkeying to %d!\n", + entry->num_value); + return; + } + + this->layer->GetConfiguration (this->layer, &this->config); + directfb_clean_output_area (this); + } + } + else if (strcmp (entry->key, "video.device.directfb_colorkey") == 0) { + this->colorkey = entry->num_value; + this->layer->SetDstColorKey (this->layer, (this->colorkey & 0xff0000) >> 16, + (this->colorkey & 0x00ff00) >> 8, + (this->colorkey & 0x0000ff) >> 0); + directfb_clean_output_area (this); + } + else if (strcmp (entry->key, "video.device.directfb_flicker_filtering") == 0) { + DFBDisplayLayerConfig config = { .flags = DLCONF_OPTIONS }; + + if (entry->num_value) + config.options = this->config.options | DLOP_FLICKER_FILTERING; + else + config.options = this->config.options & ~DLOP_FLICKER_FILTERING; + + if (config.options != this->config.options) { + if (this->layer->SetConfiguration (this->layer, &config) != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_NONE, + "video_out_directfb: failed to set flicker_filtering to %d!\n", + entry->num_value); + return; + } + + this->layer->GetConfiguration (this->layer, &this->config); + } + } + else if (strcmp (entry->key, "video.device.directfb_field_parity") == 0) { + DFBDisplayLayerConfig config = { .flags = DLCONF_OPTIONS }; + + if (entry->num_value) + config.options = this->config.options | DLOP_FIELD_PARITY; + else + config.options = this->config.options & ~DLOP_FIELD_PARITY; + + if (config.options != this->config.options) { + if (this->layer->SetConfiguration (this->layer, &config) != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_NONE, + "video_out_directfb: failed to set field_parity to %d!\n", + entry->num_value); + return; + } + + this->layer->GetConfiguration (this->layer, &this->config); + } + } + else if (strcmp (entry->key, "video.device.directfb_vsync") == 0) { + this->vsync = entry->num_value; + } +} + +static void init_config (directfb_driver_t *this) { + config_values_t *config = this->xine->config; + static const char *buffermode_enum[] = {"single", "double", "triple", 0}; + static const char *fieldparity_enum[] = {"none", "top", "bottom", 0}; + + this->buffermode = config->register_enum (config, + "video.device.directfb_buffermode", this->buffermode, (char**)buffermode_enum, + _("video layer buffering mode"), + _("Select the buffering mode of the output layer. " + "Double or triple buffering give a smoother playback, " + "but consume more video memory."), + 10, update_config_cb, (void *)this); + + this->vsync = config->register_bool (config, + "video.device.directfb_vsync", this->vsync, + _("wait for vertical retrace"), + _("Enable synchronizing the update of the video image to the " + "repainting of the entire screen (\"vertical retrace\")."), + 10, update_config_cb, (void *)this); + + if (this->caps & DLCAPS_DST_COLORKEY) { + this->colorkeying = config->register_bool (config, + "video.device.directfb_colorkeying", this->colorkeying, + _("enable video color key"), + _("Enable using a color key to tell the graphics card " + "where to overlay the video image."), + 20, update_config_cb, (void *)this); + + this->colorkey = config->register_range (config, + "video.device.directfb_colorkey", this->colorkey, 0, 0xffffff, + _("video color key"), + _("The color key is used to tell the graphics card " + "where to overlay the video image. Try different values, " + "if you experience windows becoming transparent."), + 10, update_config_cb, (void *)this); + } + + if (this->caps & DLCAPS_FLICKER_FILTERING) { + this->flicker_filtering = config->register_bool( config, + "video.device.directfb_flicker_filtering", this->flicker_filtering, + _("flicker filtering"), + _("Enable Flicker Filetring for a smooth output on an interlaced display."), + 10, update_config_cb, (void *)this); + } + + if (this->caps & DLCAPS_FIELD_PARITY) { + this->field_parity = config->register_enum( config, + "video.device.directfb_field_parity", this->field_parity, (char**)fieldparity_enum, + _("field parity"), + _("For an interlaced display, enable controlling " + "the field parity (\"none\"=disabled)."), + 10, update_config_cb, (void *)this); + } +} + +static DFBResult init_device (directfb_driver_t *this) { + IDirectFBSurface *surface; + DFBDisplayLayerConfig config; + DFBDisplayLayerConfigFlags failed = 0; + DFBResult ret; + + /* get current color cadjustment */ + this->layer->GetColorAdjustment (this->layer, &this->default_cadj); + this->cadj = this->default_cadj; + + /* set layer configuration */ + config.flags = DLCONF_BUFFERMODE | DLCONF_PIXELFORMAT | DLCONF_OPTIONS; + config.pixelformat = DSPF_YV12; + config.options = DLOP_NONE; + + switch (this->buffermode) { + case 0: + config.buffermode = DLBM_FRONTONLY; + break; + case 2: + config.buffermode = DLBM_TRIPLE; + break; + default: + config.buffermode = DLBM_BACKVIDEO; + break; + } + + if (this->colorkeying) + config.options |= DLOP_DST_COLORKEY; + + if (this->flicker_filtering) + config.options |= DLOP_FLICKER_FILTERING; + + if (this->field_parity) + config.options |= DLOP_FIELD_PARITY; + + /* test current configuration */ + ret = this->layer->TestConfiguration (this->layer, &config, &failed); + if (failed & DLCONF_BUFFERMODE) { + xprintf (this->xine, XINE_VERBOSITY_LOG, + "video_out_directfb: layer doesn't support buffermode %d!\n", + this->buffermode); + config.flags &= ~DLCONF_BUFFERMODE; + } + if (failed & DLCONF_OPTIONS) { + xprintf (this->xine, XINE_VERBOSITY_LOG, + "video_out_directfb: layer doesn't support options 0x%08x!\n", + config.options); + config.flags &= ~DLCONF_OPTIONS; + } + + ret = this->layer->SetConfiguration (this->layer, &config); + /* this should never happen */ + if (ret != DFB_OK) { + DirectFBError ("IDirectFBDisplayLayer::SetConfiguration()", ret); + return ret; + } + + this->layer->GetConfiguration (this->layer, &this->config); + + if (this->caps & DLCAPS_DST_COLORKEY) { + this->layer->SetDstColorKey (this->layer, (this->colorkey & 0xff0000) >> 16, + (this->colorkey & 0x00ff00) >> 8, + (this->colorkey & 0x0000ff) >> 0); + } + + if (this->field_parity) + this->layer->SetFieldParity (this->layer, this->field_parity-1); + + /* retrieve layer's surface */ + ret = this->layer->GetSurface (this->layer, &surface); + if (ret != DFB_OK) { + DirectFBError ("IDirectFBDisplayLayer::GetSurface()", ret); + return ret; + } + + /* clear surface buffers */ + surface->Clear (surface, 0x00, 0x00, 0x00, 0xff); + surface->Flip (surface, NULL, 0); + surface->Clear (surface, 0x00, 0x00, 0x00, 0xff); + surface->Flip (surface, NULL, 0); + surface->Clear (surface, 0x00, 0x00, 0x00, 0xff); + surface->Flip (surface, NULL, 0); + + this->surface = surface; + + /* check if stretchblit is hardware accelerated */ + if (!(this->caps & DLCAPS_SCREEN_LOCATION)) { + IDirectFBSurface *temp; + DFBSurfaceDescription dsc; + DFBAccelerationMask mask = DFXL_NONE; + + dsc.flags = DSDESC_CAPS | DSDESC_WIDTH | + DSDESC_HEIGHT | DSDESC_PIXELFORMAT; + dsc.caps = DSCAPS_VIDEOONLY; + dsc.width = 352; + dsc.height = 240; + dsc.pixelformat = DSPF_YV12; + + if (this->dfb->CreateSurface (this->dfb, &dsc, &temp) == DFB_OK) { + this->surface->GetAccelerationMask (this->surface, temp, &mask); + + if (mask & DFXL_STRETCHBLIT) { + xprintf (this->xine, XINE_VERBOSITY_LOG, + _("video_out_directfb: " + "using hardware accelerated image scaling.\n")); + this->temp = temp; + + /* check if stretchblit with deinterlacing is supported */ + this->surface->SetBlittingFlags (this->surface, DSBLIT_DEINTERLACE); + this->surface->GetAccelerationMask (this->surface, temp, &mask); + this->surface->SetBlittingFlags (this->surface, DSBLIT_NOFX); + + this->hw_deinterlace = (mask & DFXL_STRETCHBLIT) ? 1 : 0; + if (this->hw_deinterlace) { + xprintf (this->xine, XINE_VERBOSITY_LOG, + _("video_out_directfb: " + "image scaling with deinterlacing is hardware accelerated.\n")); + } + + /* used to decide reallocation */ + this->temp_frame_width = 352; + this->temp_frame_height = 240; + this->temp_frame_format = DSPF_YV12; + } + else + temp->Release (temp); + } + } + + return DFB_OK; +} + +static void get_screen_size (directfb_driver_t *this, int *ret_w, int *ret_h) { + int w = -640, h = -480; +#ifdef HAVE_FB + int fd; + struct fb_var_screeninfo var; + + fd = open (getenv ("FRAMEBUFFER") ? : "/dev/fb0", O_RDONLY); + if (fd > 0) { + if (ioctl (fd, FBIOGET_VSCREENINFO, &var) == 0) { + w = var.xres; + h = var.yres; + } + close (fd); + } +#endif + if (w < 1 || h < 1) { + IDirectFBDisplayLayer *primary; + DFBDisplayLayerConfig config; + DFBResult ret; + + ret = this->dfb->GetDisplayLayer (this->dfb, DLID_PRIMARY, &primary); + if (ret == DFB_OK) { + if (primary->GetConfiguration (primary, &config) == DFB_OK) { + w = config.width; + h = config.height; + } + primary->Release (primary); + } + else + DirectFBError( "IDirectFB::GetDisplayLayer( DLID_PRIMARY )", ret ); + } + + xprintf (this->xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: screen size is %dx%d.\n", abs(w), abs(h)); + *ret_w = abs(w); *ret_h = abs(h); +} + +static void directfb_frame_output_cb (void *user_data, int video_width, int video_height, + double video_pixel_aspect, int *dest_x, int *dest_y, + int *dest_width, int *dest_height, + double *dest_pixel_aspect, int *win_x, int *win_y) { + directfb_driver_t *this = (directfb_driver_t *) user_data; + + *dest_x = 0; + *dest_y = 0; + *dest_width = this->screen_width; + *dest_height = this->screen_height; + *dest_pixel_aspect = video_pixel_aspect ? : 1.0; + *win_x = 0; + *win_y = 0; +} + +/*** DirectFB plugin functions ***/ + +static vo_driver_t *open_plugin_fb (video_driver_class_t *class_gen, const void *visual_gen) { + directfb_class_t *class = (directfb_class_t *) class_gen; + directfb_driver_t *this; + fb_visual_t *visual = (fb_visual_t *) visual_gen; + config_values_t *config = class->xine->config; + IDirectFBScreen *screen; + DFBDisplayLayerID id = DLID_PRIMARY; + DFBResult ret; + + this = xine_xmalloc (sizeof (directfb_driver_t)); + if (!this) + return NULL; + + this->visual_type = XINE_VISUAL_TYPE_FB; + this->xine = class->xine; + + /* initialize DirectFB */ + ret = DirectFBInit (NULL, NULL); + if (ret != DFB_OK) { + DirectFBError ("DirectFBInit()", ret); + free (this); + return NULL; + } + + DirectFBSetOption ("bg-none", NULL); + DirectFBSetOption ("no-vt" , NULL); + /* linux_input blocks input from console, disable it */ + DirectFBSetOption ("disable-module", "linux_input"); + + /* create the main interface or retrieve an already existing one */ + ret = DirectFBCreate (&this->dfb); + if (ret != DFB_OK) { + DirectFBError ("DirectFBCreate()", ret); + free (this); + return NULL; + } + + /* retrieve an interface to the current screen */ + ret = this->dfb->GetScreen (this->dfb, DSCID_PRIMARY, &screen); + if (ret != DFB_OK) { + DirectFBError ("IDirectFB::GetScreen( DSCID_PRIMARY )", ret); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + /* find an overlay layer on the current screen */ + ret = screen->EnumDisplayLayers (screen, find_overlay, (void*)&id); + screen->Release (screen); + if (ret != DFB_OK) { + DirectFBError( "IDirectFBScreen::EnumDisplayLayers()", ret); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + /* allow user/application to select a different layer */ + id = config->register_num (config, + "video.device.directfb_layer_id", id, + _("video layer id"), + _("Select the video output layer by its id."), + 20, NULL, 0); + + if (probe_device (this, id) != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_NONE, + _("video_out_directfb: no usable output layer was found!\n")); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + /* debugging option */ + if (this->caps & DLCAPS_SCREEN_LOCATION) { + if (config->register_bool (config, "video.device.directfb_fixed_overlay", 0, + _("make the overlay behave like a fixed layer (for debugging)"), + _("make the overlay behave like a fixed layer (for debugging)"), + 100, NULL, 0)) { + this->caps &= ~DLCAPS_SCREEN_LOCATION; + } + } + + /* set default configuration */ + this->buffermode = 1; // double + this->vsync = 0; + this->colorkeying = 0; + this->colorkey = DEFAULT_COLORKEY; + this->flicker_filtering = 0; + this->field_parity = 0; + + /* get user configuration */ + init_config (this); + + /* set layer configuration */ + if (init_device (this) != DFB_OK) { + this->layer->Release (this->layer); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + if (!(this->caps & DLCAPS_SCREEN_LOCATION)) { + this->screen_width = this->config.width; + this->screen_height = this->config.height; + } else + get_screen_size (this, &this->screen_width, &this->screen_height ); + + _x_alphablend_init (&this->alphablend_extra_data, this->xine); + + _x_vo_scale_init (&this->sc, 1, 0, this->xine->config); + this->sc.user_ratio = XINE_VO_ASPECT_AUTO; + this->sc.gui_width = this->screen_width; + this->sc.gui_height = this->screen_height; + + if (visual) { + this->sc.frame_output_cb = visual->frame_output_cb; + this->sc.user_data = visual->user_data; + } else { + this->sc.frame_output_cb = directfb_frame_output_cb; + this->sc.user_data = (void *) this; + } + + this->vo_driver.get_capabilities = directfb_get_capabilities; + this->vo_driver.alloc_frame = directfb_alloc_frame; + this->vo_driver.update_frame_format = directfb_update_frame_format; + this->vo_driver.overlay_begin = NULL; /* not used */ + this->vo_driver.overlay_blend = directfb_overlay_blend; + this->vo_driver.overlay_end = NULL; /* not used */ + this->vo_driver.display_frame = (this->caps & DLCAPS_SCREEN_LOCATION) + ? directfb_display_frame + : directfb_display_frame2; + this->vo_driver.get_property = directfb_get_property; + this->vo_driver.set_property = directfb_set_property; + this->vo_driver.get_property_min_max = directfb_get_property_min_max; + this->vo_driver.gui_data_exchange = directfb_gui_data_exchange; + this->vo_driver.redraw_needed = directfb_redraw_needed; + this->vo_driver.dispose = directfb_dispose; + + return &this->vo_driver; +} + +static char* get_identifier_fb (video_driver_class_t *this_gen) { + return "DirectFB"; +} + +static char* get_description_fb (video_driver_class_t *this_gen) { + return _("xine video output plugin using DirectFB."); +} + +static void dispose_class_fb (video_driver_class_t *this_gen) { + directfb_class_t *this = (directfb_class_t *) this_gen; + + free (this); +} + +static void *init_class_fb (xine_t *xine, void *visual_gen) { + directfb_class_t *this; + const char *error; + + /* check DirectFB version */ + error = DirectFBCheckVersion( DIRECTFB_MAJOR_VERSION, + DIRECTFB_MINOR_VERSION, + DIRECTFB_MICRO_VERSION ); + if (error) { + xprintf (xine, XINE_VERBOSITY_NONE, + "video_out_directfb: %s!\n", error); + return NULL; + } + + this = (directfb_class_t *) xine_xmalloc (sizeof (directfb_class_t)); + this->driver_class.open_plugin = open_plugin_fb; + this->driver_class.get_identifier = get_identifier_fb; + this->driver_class.get_description = get_description_fb; + this->driver_class.dispose = dispose_class_fb; + + this->xine = xine; + + return this; +} + +static vo_info_t vo_info_directfb_fb = { + 8, /* priority */ + XINE_VISUAL_TYPE_FB /* visual type */ +}; + +/*** XDirectFB plugin functions ****/ + +#ifdef HAVE_X11 +static vo_driver_t *open_plugin_x11 (video_driver_class_t *class_gen, const void *visual_gen) { + directfb_class_t *class = (directfb_class_t *) class_gen; + directfb_driver_t *this; + x11_visual_t *visual = (x11_visual_t *) visual_gen; + XWindowAttributes attrs; + IDirectFBScreen *screen; + DFBDisplayLayerID id = (DFBDisplayLayerID) -1; + DFBResult ret; + + this = xine_xmalloc (sizeof (directfb_driver_t)); + if (!this) + return NULL; + + this->visual_type = XINE_VISUAL_TYPE_X11; + this->xine = class->xine; + + /* initialize DirectFB */ + ret = DirectFBInit (NULL, NULL); + if (ret != DFB_OK) { + DirectFBError ("DirectFBInit()", ret); + free (this); + return NULL; + } + + /* create the main interface or retrieve an already existing one */ + ret = DirectFBCreate (&this->dfb); + if (ret != DFB_OK) { + DirectFBError ("DirectFBCreate()", ret); + free (this); + return NULL; + } + + /* retrieve an interface to the current screen */ + ret = this->dfb->GetScreen (this->dfb, DSCID_PRIMARY, &screen); + if (ret != DFB_OK) { + DirectFBError ("IDirectFB::GetScreen( DSCID_PRIMARY )", ret); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + /* find an overlay layer on the current screen */ + ret = screen->EnumDisplayLayers (screen, find_overlay, (void*)&id); + screen->Release (screen); + if (ret != DFB_OK) { + DirectFBError( "IDirectFBScreen::EnumDisplayLayers()", ret); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + if (probe_device (this, id) != DFB_OK) { + xprintf (this->xine, XINE_VERBOSITY_NONE, + _("video_out_directfb: no usable overlay layer was found!\n")); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + /* set default configuration */ + this->buffermode = 1; // double + this->vsync = 0; + this->colorkeying = (this->caps & DLCAPS_DST_COLORKEY) ? 1 : 0; + this->colorkey = DEFAULT_COLORKEY; + this->flicker_filtering = 0; + this->field_parity = 0; + + /* get user configuration */ + init_config (this); + + /* set layer configuration */ + if (init_device (this) != DFB_OK) { + this->layer->Release (this->layer); + this->dfb->Release (this->dfb); + free (this); + return NULL; + } + + this->display = visual->display; + this->screen = visual->screen; + this->drawable = visual->d; + this->gc = XCreateGC (this->display, this->drawable, 0, NULL); + + XGetWindowAttributes (this->display, this->drawable, &attrs); + this->depth = attrs.depth; + + _x_alphablend_init (&this->alphablend_extra_data, this->xine); + + _x_vo_scale_init (&this->sc, 0, 0, this->xine->config); + this->sc.user_ratio = XINE_VO_ASPECT_AUTO; + this->sc.gui_width = attrs.width; + this->sc.gui_height = attrs.height; + this->sc.frame_output_cb = visual->frame_output_cb; + this->sc.user_data = visual->user_data; + + this->vo_driver.get_capabilities = directfb_get_capabilities; + this->vo_driver.alloc_frame = directfb_alloc_frame; + this->vo_driver.update_frame_format = directfb_update_frame_format; + this->vo_driver.overlay_begin = NULL; /* not used */ + this->vo_driver.overlay_blend = directfb_overlay_blend; + this->vo_driver.overlay_end = NULL; /* not used */ + this->vo_driver.display_frame = directfb_display_frame; + this->vo_driver.get_property = directfb_get_property; + this->vo_driver.set_property = directfb_set_property; + this->vo_driver.get_property_min_max = directfb_get_property_min_max; + this->vo_driver.gui_data_exchange = directfb_gui_data_exchange; + this->vo_driver.redraw_needed = directfb_redraw_needed; + this->vo_driver.dispose = directfb_dispose; + + return &this->vo_driver; +} + +static char* get_identifier_x11 (video_driver_class_t *this_gen) { + return "XDirectFB"; +} + +static char* get_description_x11 (video_driver_class_t *this_gen) { + return _("xine video output plugin using DirectFB under XDirectFB."); +} + +static void dispose_class_x11 (video_driver_class_t *this_gen) { + directfb_class_t *this = (directfb_class_t *) this_gen; + + free (this); +} + +static void *init_class_x11 (xine_t *xine, void *visual_gen) { + directfb_class_t *this; + x11_visual_t *visual = (x11_visual_t *) visual_gen; + const char *error; + + /* check DirectFB version */ + error = DirectFBCheckVersion( DIRECTFB_MAJOR_VERSION, + DIRECTFB_MINOR_VERSION, + DIRECTFB_MICRO_VERSION ); + if (error) { + xprintf (xine, XINE_VERBOSITY_NONE, + "video_out_directfb: %s!\n", error); + return NULL; + } + + if (!visual) { + xprintf (xine, XINE_VERBOSITY_DEBUG, + "video_out_directfb: x11 visual is required!\n"); + return NULL; + } + + /* check if we are running under XDirectFB */ + if (strcmp (XServerVendor (visual->display), "Denis Oliver Kropp")) + return NULL; + + this = (directfb_class_t *) xine_xmalloc (sizeof (directfb_class_t)); + this->driver_class.open_plugin = open_plugin_x11; + this->driver_class.get_identifier = get_identifier_x11; + this->driver_class.get_description = get_description_x11; + this->driver_class.dispose = dispose_class_x11; + + this->xine = xine; + + return this; +} + +static vo_info_t vo_info_directfb_x11 = { + 8, /* priority */ + XINE_VISUAL_TYPE_X11 /* visual type */ +}; +#endif /* HAVE_X11 */ + +/*********/ + +plugin_info_t xine_plugin_info[] = { + /* type, API, "name", version, special_info, init_function */ + { PLUGIN_VIDEO_OUT, VIDEO_OUT_DRIVER_IFACE_VERSION, "DirectFB", + XINE_VERSION_CODE, &vo_info_directfb_fb, init_class_fb }, +#ifdef HAVE_X11 + { PLUGIN_VIDEO_OUT, VIDEO_OUT_DRIVER_IFACE_VERSION, "XDirectFB", + XINE_VERSION_CODE, &vo_info_directfb_x11, init_class_x11 }, +#endif + { PLUGIN_NONE, 0, "", 0, NULL, NULL } +}; -- cgit v1.2.3