Home | History | Annotate | Download | only in directfb
      1 /*
      2     SDL - Simple DirectMedia Layer
      3     Copyright (C) 1997-2006 Sam Lantinga
      4 
      5     This library is free software; you can redistribute it and/or
      6     modify it under the terms of the GNU Lesser General Public
      7     License as published by the Free Software Foundation; either
      8     version 2.1 of the License, or (at your option) any later version.
      9 
     10     This library is distributed in the hope that it will be useful,
     11     but WITHOUT ANY WARRANTY; without even the implied warranty of
     12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13     Lesser General Public License for more details.
     14 
     15     You should have received a copy of the GNU Lesser General Public
     16     License along with this library; if not, write to the Free Software
     17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
     18 
     19     Sam Lantinga
     20     slouken (at) libsdl.org
     21 
     22 	MGA CRTC2 support by Thomas Jarosch - tomj (at) simonv.com
     23 	CRTC2 support is inspired by mplayer's dfbmga driver
     24 	written by Ville Syrj<syrjala (at) sci.fi>
     25 */
     26 #include "SDL_config.h"
     27 
     28 /* DirectFB video driver implementation.
     29 */
     30 
     31 #include <fcntl.h>
     32 #include <unistd.h>
     33 #include <sys/mman.h>
     34 
     35 #include <directfb.h>
     36 #include <directfb_version.h>
     37 
     38 #include "SDL_video.h"
     39 #include "SDL_mouse.h"
     40 #include "../SDL_sysvideo.h"
     41 #include "../SDL_pixels_c.h"
     42 #include "../../events/SDL_events_c.h"
     43 #include "SDL_DirectFB_video.h"
     44 #include "SDL_DirectFB_events.h"
     45 #include "SDL_DirectFB_yuv.h"
     46 
     47 /* The implementation dependent data for the window manager cursor */
     48 struct WMcursor {
     49 	int unused;
     50 };
     51 
     52 
     53 /* Initialization/Query functions */
     54 static int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat);
     55 static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
     56 static SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
     57 static int DirectFB_SetColors(_THIS, int firstcolor, int ncolors,
     58 			 SDL_Color *colors);
     59 static void DirectFB_VideoQuit(_THIS);
     60 
     61 /* Hardware surface functions */
     62 static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface);
     63 static int DirectFB_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
     64 static int DirectFB_LockHWSurface(_THIS, SDL_Surface *surface);
     65 static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface);
     66 static void DirectFB_FreeHWSurface(_THIS, SDL_Surface *surface);
     67 static int DirectFB_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst);
     68 static int DirectFB_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
     69                                 SDL_Surface *dst, SDL_Rect *dstrect);
     70 static int DirectFB_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
     71 static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha);
     72 static int DirectFB_FlipHWSurface(_THIS, SDL_Surface *surface);
     73 static int DirectFB_ShowWMCursor(_THIS, WMcursor *cursor);
     74 
     75 /* Various screen update functions available */
     76 static void DirectFB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
     77 static void DirectFB_WindowedUpdate(_THIS, int numrects, SDL_Rect *rects);
     78 
     79 /* This is the rect EnumModes2 uses */
     80 struct DirectFBEnumRect {
     81 	SDL_Rect r;
     82 	struct DirectFBEnumRect* next;
     83 };
     84 
     85 static struct DirectFBEnumRect *enumlist = NULL;
     86 
     87 
     88 /* DirectFB driver bootstrap functions */
     89 
     90 static int DirectFB_Available(void)
     91 {
     92   return 1;
     93 }
     94 
     95 static void DirectFB_DeleteDevice(SDL_VideoDevice *device)
     96 {
     97   SDL_free(device->hidden);
     98   SDL_free(device);
     99 }
    100 
    101 static SDL_VideoDevice *DirectFB_CreateDevice(int devindex)
    102 {
    103   SDL_VideoDevice *device;
    104 
    105   /* Initialize all variables that we clean on shutdown */
    106   device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
    107   if (device)
    108     {
    109       SDL_memset (device, 0, (sizeof *device));
    110       device->hidden = (struct SDL_PrivateVideoData *) malloc (sizeof (*device->hidden));
    111     }
    112   if (device == NULL  ||  device->hidden == NULL)
    113     {
    114       SDL_OutOfMemory();
    115       if (device)
    116         {
    117           free (device);
    118         }
    119       return(0);
    120     }
    121   SDL_memset (device->hidden, 0, sizeof (*device->hidden));
    122 
    123   /* Set the function pointers */
    124   device->VideoInit = DirectFB_VideoInit;
    125   device->ListModes = DirectFB_ListModes;
    126   device->SetVideoMode = DirectFB_SetVideoMode;
    127   device->SetColors = DirectFB_SetColors;
    128   device->UpdateRects = NULL;
    129   device->CreateYUVOverlay = DirectFB_CreateYUVOverlay;
    130   device->VideoQuit = DirectFB_VideoQuit;
    131   device->AllocHWSurface = DirectFB_AllocHWSurface;
    132   device->CheckHWBlit = DirectFB_CheckHWBlit;
    133   device->FillHWRect = DirectFB_FillHWRect;
    134   device->SetHWColorKey = DirectFB_SetHWColorKey;
    135   device->SetHWAlpha = DirectFB_SetHWAlpha;
    136   device->LockHWSurface = DirectFB_LockHWSurface;
    137   device->UnlockHWSurface = DirectFB_UnlockHWSurface;
    138   device->FlipHWSurface = DirectFB_FlipHWSurface;
    139   device->FreeHWSurface = DirectFB_FreeHWSurface;
    140   device->ShowWMCursor = DirectFB_ShowWMCursor;
    141   device->SetCaption = NULL;
    142   device->SetIcon = NULL;
    143   device->IconifyWindow = NULL;
    144   device->GrabInput = NULL;
    145   device->GetWMInfo = NULL;
    146   device->InitOSKeymap = DirectFB_InitOSKeymap;
    147   device->PumpEvents = DirectFB_PumpEvents;
    148 
    149   device->free = DirectFB_DeleteDevice;
    150 
    151   return device;
    152 }
    153 
    154 VideoBootStrap DirectFB_bootstrap = {
    155   "directfb", "DirectFB",
    156   DirectFB_Available, DirectFB_CreateDevice
    157 };
    158 
    159 static DFBSurfacePixelFormat GetFormatForBpp (int bpp, IDirectFBDisplayLayer *layer)
    160 {
    161   DFBDisplayLayerConfig dlc;
    162   int                   bytes = (bpp + 7) / 8;
    163 
    164   layer->GetConfiguration (layer, &dlc);
    165 
    166   if (bytes == DFB_BYTES_PER_PIXEL(dlc.pixelformat) && bytes > 1)
    167     return dlc.pixelformat;
    168 
    169   switch (bytes)
    170     {
    171     case 1:
    172       return DSPF_LUT8;
    173     case 2:
    174       return DSPF_RGB16;
    175     case 3:
    176       return DSPF_RGB24;
    177     case 4:
    178       return DSPF_RGB32;
    179     }
    180 
    181   return DSPF_UNKNOWN;
    182 }
    183 
    184 static DFBEnumerationResult EnumModesCallback (int  width,
    185                                                int  height,
    186                                                int  bpp,
    187                                                void *data)
    188 {
    189   SDL_VideoDevice *this = (SDL_VideoDevice *)data;
    190   struct DirectFBEnumRect *enumrect;
    191 
    192   HIDDEN->nummodes++;
    193 
    194   if (enumlist && enumlist->r.w == width && enumlist->r.h == height)
    195     return DFENUM_OK;
    196 
    197   enumrect = SDL_calloc(1, sizeof(struct DirectFBEnumRect));
    198   if (!enumrect)
    199     {
    200       SDL_OutOfMemory();
    201       return DFENUM_CANCEL;
    202     }
    203 
    204   enumrect->r.w  = (Uint16)width;
    205   enumrect->r.h  = (Uint16)height;
    206   enumrect->next = enumlist;
    207 
    208   enumlist = enumrect;
    209 
    210   return DFENUM_OK;
    211 }
    212 
    213 struct private_hwdata {
    214   IDirectFBSurface *surface;
    215   IDirectFBPalette *palette;
    216 };
    217 
    218 void SetDirectFBerror (const char *function, DFBResult code)
    219 {
    220   const char *error = DirectFBErrorString (code);
    221 
    222   if (error)
    223     SDL_SetError("%s: %s", function, error);
    224   else
    225     SDL_SetError("Unknown error code from %s", function);
    226 }
    227 
    228 static DFBSurfacePixelFormat SDLToDFBPixelFormat (SDL_PixelFormat *format)
    229 {
    230   if (format->Rmask && format->Gmask && format->Bmask)
    231     {
    232       switch (format->BitsPerPixel)
    233         {
    234         case 8:
    235           return DSPF_LUT8;
    236 
    237         case 16:
    238           if (format->Rmask == 0xF800 &&
    239               format->Gmask == 0x07E0 &&
    240               format->Bmask == 0x001F)
    241             return DSPF_RGB16;
    242           /* fall through */
    243 
    244         case 15:
    245           if (format->Rmask == 0x7C00 &&
    246               format->Gmask == 0x03E0 &&
    247               format->Bmask == 0x001F)
    248             return DSPF_ARGB1555;
    249           break;
    250 
    251         case 24:
    252           if (format->Rmask == 0xFF0000 &&
    253               format->Gmask == 0x00FF00 &&
    254               format->Bmask == 0x0000FF)
    255             return DSPF_RGB24;
    256           break;
    257 
    258         case 32:
    259           if (format->Rmask == 0xFF0000 &&
    260               format->Gmask == 0x00FF00 &&
    261               format->Bmask == 0x0000FF)
    262             {
    263               if (format->Amask == 0xFF000000)
    264                 return DSPF_ARGB;
    265               else
    266                 return DSPF_RGB32;
    267             }
    268           break;
    269         }
    270     }
    271   else
    272     {
    273       switch (format->BitsPerPixel)
    274 	{
    275         case 8:
    276           return DSPF_LUT8;
    277 	case 15:
    278 	  return DSPF_ARGB1555;
    279 	case 16:
    280 	  return DSPF_RGB16;
    281 	case 24:
    282 	  return DSPF_RGB24;
    283 	case 32:
    284 	  return DSPF_RGB32;
    285 	}
    286     }
    287 
    288   return DSPF_UNKNOWN;
    289 }
    290 
    291 static SDL_Palette *AllocatePalette(int size)
    292 {
    293   SDL_Palette *palette;
    294   SDL_Color   *colors;
    295 
    296   palette = SDL_calloc (1, sizeof(SDL_Palette));
    297   if (!palette)
    298     {
    299       SDL_OutOfMemory();
    300       return NULL;
    301     }
    302 
    303   colors = SDL_calloc (size, sizeof(SDL_Color));
    304   if (!colors)
    305     {
    306       SDL_OutOfMemory();
    307       return NULL;
    308     }
    309 
    310   palette->ncolors = size;
    311   palette->colors  = colors;
    312 
    313   return palette;
    314 }
    315 
    316 static int DFBToSDLPixelFormat (DFBSurfacePixelFormat pixelformat, SDL_PixelFormat *format)
    317 {
    318   format->Amask = format->Rmask = format->Gmask = format->Bmask = 0;
    319   format->BitsPerPixel = format->BytesPerPixel = 0;
    320 
    321   switch (pixelformat)
    322     {
    323     case DSPF_A8:
    324       format->Amask = 0x000000FF;
    325       break;
    326 
    327     case DSPF_ARGB1555:
    328       format->Rmask = 0x00007C00;
    329       format->Gmask = 0x000003E0;
    330       format->Bmask = 0x0000001F;
    331       break;
    332 
    333     case DSPF_RGB16:
    334       format->Rmask = 0x0000F800;
    335       format->Gmask = 0x000007E0;
    336       format->Bmask = 0x0000001F;
    337       break;
    338 
    339     case DSPF_ARGB:
    340       format->Amask = 0; /* apps don't seem to like that:  0xFF000000; */
    341       /* fall through */
    342     case DSPF_RGB24:
    343     case DSPF_RGB32:
    344       format->Rmask = 0x00FF0000;
    345       format->Gmask = 0x0000FF00;
    346       format->Bmask = 0x000000FF;
    347       break;
    348 
    349     case DSPF_LUT8:
    350       format->Rmask = 0x000000FF;
    351       format->Gmask = 0x000000FF;
    352       format->Bmask = 0x000000FF;
    353 
    354       if (!format->palette)
    355         format->palette = AllocatePalette(256);
    356       break;
    357 
    358     default:
    359       fprintf (stderr, "SDL_DirectFB: Unsupported pixelformat (0x%08x)!\n", pixelformat);
    360       return -1;
    361     }
    362 
    363   format->BitsPerPixel  = DFB_BYTES_PER_PIXEL(pixelformat) * 8;
    364   format->BytesPerPixel = DFB_BYTES_PER_PIXEL(pixelformat);
    365 
    366   return 0;
    367 }
    368 
    369 
    370 int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat)
    371 {
    372   int                      i;
    373   DFBResult                ret;
    374 #if (DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)
    375   DFBCardCapabilities      caps;
    376 #else
    377   DFBGraphicsDeviceDescription caps;
    378 #endif
    379   DFBDisplayLayerConfig    dlc;
    380   struct DirectFBEnumRect *rect;
    381   IDirectFB               *dfb    = NULL;
    382   IDirectFBDisplayLayer   *layer  = NULL;
    383   IDirectFBEventBuffer    *events = NULL;
    384 
    385   HIDDEN->c2layer = NULL, HIDDEN->c2frame = NULL;
    386   HIDDEN->enable_mga_crtc2 = 0;
    387   HIDDEN->mga_crtc2_stretch_overscan = 1;
    388 
    389   ret = DirectFBInit (NULL, NULL);
    390   if (ret)
    391     {
    392       SetDirectFBerror ("DirectFBInit", ret);
    393       goto error;
    394     }
    395 
    396   ret = DirectFBCreate (&dfb);
    397   if (ret)
    398     {
    399       SetDirectFBerror ("DirectFBCreate", ret);
    400       goto error;
    401     }
    402 
    403   ret = dfb->GetDisplayLayer (dfb, DLID_PRIMARY, &layer);
    404   if (ret)
    405     {
    406       SetDirectFBerror ("dfb->GetDisplayLayer", ret);
    407       goto error;
    408     }
    409 
    410   ret = dfb->CreateInputEventBuffer (dfb, DICAPS_ALL, DFB_FALSE, &events);
    411   if (ret)
    412     {
    413       SetDirectFBerror ("dfb->CreateEventBuffer", ret);
    414       goto error;
    415     }
    416 
    417   layer->EnableCursor (layer, 1);
    418 
    419   /* Query layer configuration to determine the current mode and pixelformat */
    420   layer->GetConfiguration (layer, &dlc);
    421 
    422   /* If current format is not supported use LUT8 as the default */
    423   if (DFBToSDLPixelFormat (dlc.pixelformat, vformat))
    424     DFBToSDLPixelFormat (DSPF_LUT8, vformat);
    425 
    426   /* Enumerate the available fullscreen modes */
    427   ret = dfb->EnumVideoModes (dfb, EnumModesCallback, this);
    428   if (ret)
    429     {
    430       SetDirectFBerror ("dfb->EnumVideoModes", ret);
    431       goto error;
    432     }
    433 
    434   HIDDEN->modelist = SDL_calloc (HIDDEN->nummodes + 1, sizeof(SDL_Rect *));
    435   if (!HIDDEN->modelist)
    436     {
    437       SDL_OutOfMemory();
    438       goto error;
    439     }
    440 
    441   for (i = 0, rect = enumlist; rect; ++i, rect = rect->next )
    442     {
    443       HIDDEN->modelist[i] = &rect->r;
    444     }
    445 
    446   HIDDEN->modelist[i] = NULL;
    447 
    448 
    449   /* Query card capabilities to get the video memory size */
    450 #if (DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)
    451   dfb->GetCardCapabilities (dfb, &caps);
    452 #else
    453   dfb->GetDeviceDescription (dfb, &caps);
    454 #endif
    455 
    456   this->info.wm_available = 1;
    457   this->info.hw_available = 1;
    458   this->info.blit_hw      = 1;
    459   this->info.blit_hw_CC   = 1;
    460   this->info.blit_hw_A    = 1;
    461   this->info.blit_fill    = 1;
    462   this->info.video_mem    = caps.video_memory / 1024;
    463   this->info.current_w    = dlc.width;
    464   this->info.current_h    = dlc.height;
    465 
    466   HIDDEN->initialized = 1;
    467   HIDDEN->dfb         = dfb;
    468   HIDDEN->layer       = layer;
    469   HIDDEN->eventbuffer = events;
    470 
    471   if (SDL_getenv("SDL_DIRECTFB_MGA_CRTC2") != NULL)
    472     HIDDEN->enable_mga_crtc2 = 1;
    473 
    474   if (HIDDEN->enable_mga_crtc2)
    475     {
    476       DFBDisplayLayerConfig      dlc;
    477       DFBDisplayLayerConfigFlags failed;
    478 
    479       ret = dfb->GetDisplayLayer (dfb, 2, &HIDDEN->c2layer);
    480       if (ret)
    481         {
    482           SetDirectFBerror ("dfb->GetDisplayLayer(CRTC2)", ret);
    483           goto error;
    484         }
    485 
    486       ret = HIDDEN->layer->SetCooperativeLevel(HIDDEN->layer, DLSCL_EXCLUSIVE);
    487       if (ret)
    488         {
    489           SetDirectFBerror ("layer->SetCooperativeLevel(CRTC2, EXCLUSIVE)", ret);
    490           goto error;
    491         }
    492 
    493       ret = HIDDEN->c2layer->SetCooperativeLevel(HIDDEN->c2layer, DLSCL_EXCLUSIVE);
    494       if (ret)
    495         {
    496           SetDirectFBerror ("c2layer->SetCooperativeLevel(CRTC2, EXCLUSIVE)", ret);
    497           goto error;
    498         }
    499 
    500       HIDDEN->c2layer->SetOpacity(HIDDEN->c2layer, 0x0);
    501 
    502       /* Init the surface here as it got a fixed size */
    503       dlc.flags      = DLCONF_PIXELFORMAT | DLCONF_BUFFERMODE;
    504       dlc.buffermode = DLBM_BACKVIDEO;
    505       dlc.pixelformat = DSPF_RGB32;
    506 
    507       ret = HIDDEN->c2layer->TestConfiguration( HIDDEN->c2layer, &dlc, &failed );
    508       if (ret)
    509         {
    510           SetDirectFBerror ("c2layer->TestConfiguration", ret);
    511           goto error;
    512         }
    513 
    514       ret = HIDDEN->c2layer->SetConfiguration( HIDDEN->c2layer, &dlc );
    515       if (ret)
    516         {
    517           SetDirectFBerror ("c2layer->SetConfiguration", ret);
    518           goto error;
    519         }
    520 
    521       ret = HIDDEN->c2layer->GetSurface( HIDDEN->c2layer, &HIDDEN->c2frame );
    522       if (ret)
    523         {
    524           SetDirectFBerror ("c2layer->GetSurface", ret);
    525           goto error;
    526         }
    527 
    528       HIDDEN->c2framesize.x = 0;
    529       HIDDEN->c2framesize.y = 0;
    530       HIDDEN->c2frame->GetSize( HIDDEN->c2frame, &HIDDEN->c2framesize.w, &HIDDEN->c2framesize.h);
    531 
    532       HIDDEN->c2frame->SetBlittingFlags( HIDDEN->c2frame, DSBLIT_NOFX );
    533       HIDDEN->c2frame->SetColor( HIDDEN->c2frame, 0, 0, 0, 0xff );
    534 
    535       /* Clear CRTC2 */
    536       HIDDEN->c2frame->Clear(HIDDEN->c2frame, 0, 0, 0, 0xff );
    537       HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, 0 );
    538       HIDDEN->c2frame->Clear(HIDDEN->c2frame, 0, 0, 0, 0xff );
    539       HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, 0 );
    540       HIDDEN->c2frame->Clear(HIDDEN->c2frame, 0, 0, 0, 0xff );
    541 
    542       HIDDEN->c2layer->SetOpacity(HIDDEN->c2layer, 0xFF );
    543 
    544       /* Check if overscan is possibly set */
    545       if (SDL_getenv("SDL_DIRECTFB_MGA_OVERSCAN") != NULL)
    546         {
    547 	    float overscan = 0;
    548 	    if (SDL_sscanf(SDL_getenv("SDL_DIRECTFB_MGA_OVERSCAN"), "%f", &overscan) == 1)
    549                if (overscan > 0 && overscan < 2)
    550 		  HIDDEN->mga_crtc2_stretch_overscan = overscan;
    551 	}
    552 
    553       #ifdef DIRECTFB_CRTC2_DEBUG
    554       printf("CRTC2 overscan: %f\n", HIDDEN->mga_crtc2_stretch_overscan);
    555       #endif
    556     }
    557 
    558   return 0;
    559 
    560  error:
    561   if (events)
    562     events->Release (events);
    563 
    564   if (HIDDEN->c2frame)
    565     HIDDEN->c2frame->Release (HIDDEN->c2frame);
    566 
    567   if (HIDDEN->c2layer)
    568     HIDDEN->c2layer->Release (HIDDEN->c2layer);
    569 
    570   if (layer)
    571     layer->Release (layer);
    572 
    573   if (dfb)
    574     dfb->Release (dfb);
    575 
    576   return -1;
    577 }
    578 
    579 static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
    580 {
    581   if (flags & SDL_FULLSCREEN)
    582     return HIDDEN->modelist;
    583   else
    584     if (SDLToDFBPixelFormat (format) != DSPF_UNKNOWN)
    585       return (SDL_Rect**) -1;
    586 
    587   return NULL;
    588 }
    589 
    590 static SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
    591 {
    592   DFBResult              ret;
    593   DFBSurfaceDescription  dsc;
    594   DFBSurfacePixelFormat  pixelformat;
    595   IDirectFBSurface      *surface;
    596 
    597   fprintf (stderr, "SDL DirectFB_SetVideoMode: %dx%d@%d, flags: 0x%08x\n",
    598            width, height, bpp, flags);
    599 
    600   flags |= SDL_FULLSCREEN;
    601 
    602   /* Release previous primary surface */
    603   if (current->hwdata && current->hwdata->surface)
    604     {
    605       current->hwdata->surface->Release (current->hwdata->surface);
    606       current->hwdata->surface = NULL;
    607 
    608       /* And its palette if present */
    609       if (current->hwdata->palette)
    610         {
    611           current->hwdata->palette->Release (current->hwdata->palette);
    612           current->hwdata->palette = NULL;
    613         }
    614     }
    615   else if (!current->hwdata)
    616     {
    617       /* Allocate the hardware acceleration data */
    618       current->hwdata = (struct private_hwdata *) SDL_calloc (1, sizeof(*current->hwdata));
    619       if (!current->hwdata)
    620         {
    621           SDL_OutOfMemory();
    622           return NULL;
    623 	}
    624     }
    625 
    626   /* Set cooperative level depending on flag SDL_FULLSCREEN */
    627   if (flags & SDL_FULLSCREEN)
    628     {
    629       ret = HIDDEN->dfb->SetCooperativeLevel (HIDDEN->dfb, DFSCL_FULLSCREEN);
    630       if (ret && !HIDDEN->enable_mga_crtc2)
    631         {
    632           DirectFBError ("dfb->SetCooperativeLevel", ret);
    633           flags &= ~SDL_FULLSCREEN;
    634         }
    635     }
    636   else
    637     HIDDEN->dfb->SetCooperativeLevel (HIDDEN->dfb, DFSCL_NORMAL);
    638 
    639   /* Set video mode */
    640   ret = HIDDEN->dfb->SetVideoMode (HIDDEN->dfb, width, height, bpp);
    641   if (ret)
    642     {
    643       if (flags & SDL_FULLSCREEN)
    644         {
    645           flags &= ~SDL_FULLSCREEN;
    646           HIDDEN->dfb->SetCooperativeLevel (HIDDEN->dfb, DFSCL_NORMAL);
    647           ret = HIDDEN->dfb->SetVideoMode (HIDDEN->dfb, width, height, bpp);
    648         }
    649 
    650       if (ret)
    651         {
    652           SetDirectFBerror ("dfb->SetVideoMode", ret);
    653           return NULL;
    654         }
    655     }
    656 
    657   /* Create primary surface */
    658   dsc.flags       = DSDESC_CAPS | DSDESC_PIXELFORMAT;
    659   dsc.caps        = DSCAPS_PRIMARY | ((flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0);
    660   dsc.pixelformat = GetFormatForBpp (bpp, HIDDEN->layer);
    661 
    662   ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &surface);
    663   if (ret && (flags & SDL_DOUBLEBUF))
    664     {
    665       /* Try without double buffering */
    666       dsc.caps &= ~DSCAPS_FLIPPING;
    667       ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &surface);
    668     }
    669   if (ret)
    670     {
    671       SetDirectFBerror ("dfb->CreateSurface", ret);
    672       return NULL;
    673     }
    674 
    675   current->w     = width;
    676   current->h     = height;
    677   current->flags = SDL_HWSURFACE | SDL_PREALLOC;
    678 
    679   if (flags & SDL_FULLSCREEN)
    680     {
    681       current->flags |= SDL_FULLSCREEN;
    682       this->UpdateRects = DirectFB_DirectUpdate;
    683     }
    684   else
    685     this->UpdateRects = DirectFB_WindowedUpdate;
    686 
    687   if (dsc.caps & DSCAPS_FLIPPING)
    688     current->flags |= SDL_DOUBLEBUF;
    689 
    690   surface->GetPixelFormat (surface, &pixelformat);
    691 
    692   DFBToSDLPixelFormat (pixelformat, current->format);
    693 
    694   /* Get the surface palette (if supported) */
    695   if (DFB_PIXELFORMAT_IS_INDEXED( pixelformat ))
    696     {
    697       surface->GetPalette (surface, &current->hwdata->palette);
    698 
    699       current->flags |= SDL_HWPALETTE;
    700     }
    701 
    702   current->hwdata->surface = surface;
    703 
    704   /* MGA CRTC2 stuff */
    705   if (HIDDEN->enable_mga_crtc2)
    706     {
    707       /* no stretching if c2ssize == c2framesize */
    708       HIDDEN->c2ssize.x = 0, HIDDEN->c2ssize.y = 0;
    709       HIDDEN->c2ssize.w = width;
    710       HIDDEN->c2ssize.h = height;
    711 
    712       HIDDEN->c2dsize.x = 0, HIDDEN->c2dsize.y = 0;
    713       HIDDEN->c2dsize.w = width;
    714       HIDDEN->c2dsize.h = height;
    715 
    716       HIDDEN->mga_crtc2_stretch = 0;
    717 
    718       if (SDL_getenv("SDL_DIRECTFB_MGA_STRETCH") != NULL)
    719         {
    720 	    /* Normally assume a picture aspect ratio of 4:3 */
    721 	    int zoom_aspect_x = 4, zoom_aspect_y = 3, i, j;
    722 
    723 	    for (i = 1; i < 20; i++)
    724 	      {
    725 		for (j = 1; j < 10; j++)
    726 		  {
    727 		    if ((float)width/(float)i*(float)j == height)
    728 		      {
    729 			zoom_aspect_x = i;
    730 			zoom_aspect_y = j;
    731 
    732 			/* break the loop */
    733 			i = 21;
    734 			break;
    735 		      }
    736 		  }
    737 	      }
    738 
    739             #ifdef DIRECTFB_CRTC2_DEBUG
    740             printf("Source resolution: X: %d, Y: %d, Aspect ratio: %d:%d\n", width, height, zoom_aspect_x, zoom_aspect_y);
    741             printf("CRTC2 resolution: X: %d, Y: %d\n", HIDDEN->c2framesize.w, HIDDEN->c2framesize.h);
    742             #endif
    743 
    744           /* don't stretch only slightly smaller/larger images */
    745           if ((float)width < (float)HIDDEN->c2framesize.w*0.95 || (float)height < (float)HIDDEN->c2framesize.h*0.95)
    746             {
    747               while ((float)HIDDEN->c2dsize.w < (float)HIDDEN->c2framesize.w*HIDDEN->mga_crtc2_stretch_overscan && (float)HIDDEN->c2dsize.h < (float)HIDDEN->c2framesize.h*HIDDEN->mga_crtc2_stretch_overscan)
    748                 {
    749                    HIDDEN->c2dsize.w+=zoom_aspect_x;
    750                    HIDDEN->c2dsize.h+=zoom_aspect_y;
    751                 }
    752 
    753               /* one step down */
    754                 HIDDEN->c2dsize.w-=zoom_aspect_x;
    755                 HIDDEN->c2dsize.h-=zoom_aspect_y;
    756 
    757               #ifdef DIRECTFB_CRTC2_DEBUG
    758               printf("Stretched resolution: X: %d, Y: %d\n", HIDDEN->c2dsize.w, HIDDEN->c2dsize.h);
    759               #endif
    760 
    761               HIDDEN->mga_crtc2_stretch = 1;
    762             }
    763           else if ((float)width > (float)HIDDEN->c2framesize.w*0.95 || (float)height > (float)HIDDEN->c2framesize.h*0.95)
    764             {
    765                while ((float)HIDDEN->c2dsize.w > (float)HIDDEN->c2framesize.w*HIDDEN->mga_crtc2_stretch_overscan || (float)HIDDEN->c2dsize.h > (float)HIDDEN->c2framesize.h*HIDDEN->mga_crtc2_stretch_overscan)
    766                 {
    767               HIDDEN->c2dsize.w-=zoom_aspect_x;
    768               HIDDEN->c2dsize.h-=zoom_aspect_y;
    769                 }
    770 
    771               #ifdef DIRECTFB_CRTC2_DEBUG
    772               printf("Down-Stretched resolution: X: %d, Y: %d\n", HIDDEN->c2dsize.w, HIDDEN->c2dsize.h);
    773               #endif
    774 
    775               HIDDEN->mga_crtc2_stretch = 1;
    776              } else {
    777           #ifdef DIRECTFB_CRTC2_DEBUG
    778           printf("Not stretching image\n");
    779           #endif
    780         }
    781 
    782       /* Panning */
    783       if (HIDDEN->c2framesize.w > HIDDEN->c2dsize.w)
    784         HIDDEN->c2dsize.x = (HIDDEN->c2framesize.w - HIDDEN->c2dsize.w)  / 2;
    785       else
    786         HIDDEN->c2dsize.x = (HIDDEN->c2dsize.w - HIDDEN->c2framesize.w)  / 2;
    787 
    788       if (HIDDEN->c2framesize.h > HIDDEN->c2dsize.h)
    789         HIDDEN->c2dsize.y = (HIDDEN->c2framesize.h - HIDDEN->c2dsize.h)  / 2;
    790       else
    791         HIDDEN->c2dsize.y = (HIDDEN->c2dsize.h - HIDDEN->c2framesize.h)  / 2;
    792 
    793       #ifdef DIRECTFB_CRTC2_DEBUG
    794     printf("CRTC2 position X: %d, Y: %d\n", HIDDEN->c2dsize.x, HIDDEN->c2dsize.y);
    795       #endif
    796    }
    797   }
    798 
    799   return current;
    800 }
    801 
    802 static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface)
    803 {
    804   DFBResult             ret;
    805   DFBSurfaceDescription dsc;
    806 
    807   /*  fprintf(stderr, "SDL: DirectFB_AllocHWSurface (%dx%d@%d, flags: 0x%08x)\n",
    808       surface->w, surface->h, surface->format->BitsPerPixel, surface->flags);*/
    809 
    810   if (surface->w < 8 || surface->h < 8)
    811     return -1;
    812 
    813   /* fill surface description */
    814   dsc.flags  = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
    815   dsc.width  = surface->w;
    816   dsc.height = surface->h;
    817   dsc.caps   = (surface->flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0;
    818 
    819   /* find the right pixelformat */
    820   dsc.pixelformat = SDLToDFBPixelFormat (surface->format);
    821   if (dsc.pixelformat == DSPF_UNKNOWN)
    822     return -1;
    823 
    824   /* Allocate the hardware acceleration data */
    825   surface->hwdata = (struct private_hwdata *) SDL_calloc (1, sizeof(*surface->hwdata));
    826   if (surface->hwdata == NULL)
    827     {
    828       SDL_OutOfMemory();
    829       return -1;
    830     }
    831 
    832   /* Create the surface */
    833   ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &surface->hwdata->surface);
    834   if (ret)
    835     {
    836       SetDirectFBerror ("dfb->CreateSurface", ret);
    837       free (surface->hwdata);
    838       surface->hwdata = NULL;
    839       return -1;
    840     }
    841 
    842   surface->flags |= SDL_HWSURFACE | SDL_PREALLOC;
    843 
    844   return 0;
    845 }
    846 
    847 static void DirectFB_FreeHWSurface(_THIS, SDL_Surface *surface)
    848 {
    849   if (surface->hwdata && HIDDEN->initialized)
    850     {
    851       surface->hwdata->surface->Release (surface->hwdata->surface);
    852       free (surface->hwdata);
    853       surface->hwdata = NULL;
    854     }
    855 }
    856 
    857 static int DirectFB_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
    858 {
    859   /*  fprintf(stderr, "SDL: DirectFB_CheckHWBlit (src->hwdata: %p, dst->hwdata: %p)\n",
    860       src->hwdata, dst->hwdata);*/
    861 
    862   if (!src->hwdata || !dst->hwdata)
    863     return 0;
    864 
    865   src->flags |= SDL_HWACCEL;
    866   src->map->hw_blit = DirectFB_HWAccelBlit;
    867 
    868   return 1;
    869 }
    870 
    871 static int DirectFB_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
    872                                 SDL_Surface *dst, SDL_Rect *dstrect)
    873 {
    874   DFBSurfaceBlittingFlags flags = DSBLIT_NOFX;
    875 
    876   DFBRectangle sr = { srcrect->x, srcrect->y, srcrect->w, srcrect->h };
    877   DFBRectangle dr = { dstrect->x, dstrect->y, dstrect->w, dstrect->h };
    878 
    879   IDirectFBSurface *surface = dst->hwdata->surface;
    880 
    881   if (src->flags & SDL_SRCCOLORKEY)
    882     {
    883       flags |= DSBLIT_SRC_COLORKEY;
    884       DirectFB_SetHWColorKey (NULL, src, src->format->colorkey);
    885     }
    886 
    887   if (src->flags & SDL_SRCALPHA)
    888     {
    889       flags |= DSBLIT_BLEND_COLORALPHA;
    890       surface->SetColor (surface, 0xff, 0xff, 0xff, src->format->alpha);
    891     }
    892 
    893   surface->SetBlittingFlags (surface, flags);
    894 
    895   if (sr.w == dr.w && sr.h == dr.h)
    896     surface->Blit (surface, src->hwdata->surface, &sr, dr.x, dr.y);
    897   else
    898     surface->StretchBlit (surface, src->hwdata->surface, &sr, &dr);
    899 
    900   return 0;
    901 }
    902 
    903 static int DirectFB_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
    904 {
    905   SDL_PixelFormat  *fmt     = dst->format;
    906   IDirectFBSurface *surface = dst->hwdata->surface;
    907 
    908   /* ugly */
    909   surface->SetColor (surface,
    910                      (color & fmt->Rmask) >> (fmt->Rshift - fmt->Rloss),
    911                      (color & fmt->Gmask) >> (fmt->Gshift - fmt->Gloss),
    912                      (color & fmt->Bmask) << (fmt->Bloss - fmt->Bshift), 0xFF);
    913   surface->FillRectangle (surface, dstrect->x, dstrect->y, dstrect->w, dstrect->h);
    914 
    915   return 0;
    916 }
    917 
    918 static int DirectFB_SetHWColorKey(_THIS, SDL_Surface *src, Uint32 key)
    919 {
    920   SDL_PixelFormat  *fmt     = src->format;
    921   IDirectFBSurface *surface = src->hwdata->surface;
    922 
    923   if (fmt->BitsPerPixel == 8)
    924     surface->SetSrcColorKeyIndex (surface, key);
    925   else
    926     /* ugly */
    927     surface->SetSrcColorKey (surface,
    928                              (key & fmt->Rmask) >> (fmt->Rshift - fmt->Rloss),
    929                              (key & fmt->Gmask) >> (fmt->Gshift - fmt->Gloss),
    930                              (key & fmt->Bmask) << (fmt->Bloss - fmt->Bshift));
    931 
    932   return 0;
    933 }
    934 
    935 static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha)
    936 {
    937   return 0;
    938 }
    939 
    940 static int DirectFB_FlipHWSurface(_THIS, SDL_Surface *surface)
    941 {
    942   if (HIDDEN->enable_mga_crtc2)
    943     {
    944        int rtn = surface->hwdata->surface->Flip (surface->hwdata->surface, NULL, 0);
    945        if (HIDDEN->mga_crtc2_stretch)
    946          HIDDEN->c2frame->StretchBlit(HIDDEN->c2frame, surface->hwdata->surface, &HIDDEN->c2ssize, &HIDDEN->c2dsize);
    947        else
    948          HIDDEN->c2frame->Blit(HIDDEN->c2frame, surface->hwdata->surface, NULL, HIDDEN->c2dsize.x, HIDDEN->c2dsize.y);
    949 
    950        HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, DSFLIP_WAITFORSYNC);
    951        return rtn;
    952     }
    953   else
    954      return surface->hwdata->surface->Flip (surface->hwdata->surface, NULL, DSFLIP_WAITFORSYNC);
    955 }
    956 
    957 static int DirectFB_LockHWSurface(_THIS, SDL_Surface *surface)
    958 {
    959   DFBResult  ret;
    960   void      *data;
    961   int        pitch;
    962 
    963   ret = surface->hwdata->surface->Lock (surface->hwdata->surface,
    964                                         DSLF_WRITE, &data, &pitch);
    965   if (ret)
    966     {
    967       SetDirectFBerror ("surface->Lock", ret);
    968       return -1;
    969     }
    970 
    971   surface->pixels = data;
    972   surface->pitch  = pitch;
    973 
    974   return 0;
    975 }
    976 
    977 static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface)
    978 {
    979   surface->hwdata->surface->Unlock (surface->hwdata->surface);
    980   surface->pixels = NULL;
    981 }
    982 
    983 static void DirectFB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
    984 {
    985   if (HIDDEN->enable_mga_crtc2)
    986     {
    987        if (HIDDEN->mga_crtc2_stretch)
    988          HIDDEN->c2frame->StretchBlit(HIDDEN->c2frame, this->screen->hwdata->surface, &HIDDEN->c2ssize, &HIDDEN->c2dsize);
    989        else
    990          HIDDEN->c2frame->Blit(HIDDEN->c2frame, this->screen->hwdata->surface, NULL, HIDDEN->c2dsize.x, HIDDEN->c2dsize.y);
    991 
    992        HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, DSFLIP_WAITFORSYNC);
    993     }
    994 }
    995 
    996 static void DirectFB_WindowedUpdate(_THIS, int numrects, SDL_Rect *rects)
    997 {
    998   DFBRegion         region;
    999   int               i;
   1000   int               region_valid = 0;
   1001   IDirectFBSurface *surface = this->screen->hwdata->surface;
   1002 
   1003   for (i=0; i<numrects; ++i)
   1004     {
   1005       int x2, y2;
   1006 
   1007       if ( ! rects[i].w ) /* Clipped? */
   1008         continue;
   1009 
   1010       x2 = rects[i].x + rects[i].w - 1;
   1011       y2 = rects[i].y + rects[i].h - 1;
   1012 
   1013       if (region_valid)
   1014         {
   1015           if (rects[i].x < region.x1)
   1016             region.x1 = rects[i].x;
   1017 
   1018           if (rects[i].y < region.y1)
   1019             region.y1 = rects[i].y;
   1020 
   1021           if (x2 > region.x2)
   1022             region.x2 = x2;
   1023 
   1024           if (y2 > region.y2)
   1025             region.y2 = y2;
   1026         }
   1027       else
   1028         {
   1029             region.x1 = rects[i].x;
   1030             region.y1 = rects[i].y;
   1031             region.x2 = x2;
   1032             region.y2 = y2;
   1033 
   1034             region_valid = 1;
   1035         }
   1036     }
   1037 
   1038   if (region_valid)
   1039     {
   1040       if (HIDDEN->enable_mga_crtc2)
   1041         {
   1042           if (HIDDEN->mga_crtc2_stretch)
   1043             HIDDEN->c2frame->StretchBlit(HIDDEN->c2frame, surface, &HIDDEN->c2ssize, &HIDDEN->c2dsize);
   1044           else
   1045             HIDDEN->c2frame->Blit(HIDDEN->c2frame, surface, NULL, HIDDEN->c2dsize.x, HIDDEN->c2dsize.y);
   1046 
   1047           HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, DSFLIP_WAITFORSYNC);
   1048         }
   1049       else
   1050         surface->Flip (surface, &region, DSFLIP_WAITFORSYNC);
   1051     }
   1052 }
   1053 
   1054 int DirectFB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
   1055 {
   1056   IDirectFBPalette *palette = this->screen->hwdata->palette;
   1057 
   1058   if (!palette)
   1059     return 0;
   1060 
   1061   if (firstcolor > 255)
   1062     return 0;
   1063 
   1064   if (firstcolor + ncolors > 256)
   1065     ncolors = 256 - firstcolor;
   1066 
   1067   if (ncolors > 0)
   1068     {
   1069       int      i;
   1070       DFBColor entries[ncolors];
   1071 
   1072       for (i=0; i<ncolors; i++)
   1073         {
   1074           entries[i].a = 0xff;
   1075           entries[i].r = colors[i].r;
   1076           entries[i].g = colors[i].g;
   1077           entries[i].b = colors[i].b;
   1078         }
   1079 
   1080       palette->SetEntries (palette, entries, ncolors, firstcolor);
   1081     }
   1082 
   1083   return 1;
   1084 }
   1085 
   1086 void DirectFB_VideoQuit(_THIS)
   1087 {
   1088   struct DirectFBEnumRect *rect    = enumlist;
   1089 
   1090   if (this->screen && this->screen->hwdata)
   1091     {
   1092       IDirectFBSurface        *surface = this->screen->hwdata->surface;
   1093       IDirectFBPalette        *palette = this->screen->hwdata->palette;
   1094 
   1095       if (palette)
   1096         palette->Release (palette);
   1097 
   1098       if (surface)
   1099         surface->Release (surface);
   1100 
   1101       this->screen->hwdata->surface = NULL;
   1102       this->screen->hwdata->palette = NULL;
   1103     }
   1104 
   1105   if (HIDDEN->c2frame)
   1106     {
   1107       HIDDEN->c2frame->Release (HIDDEN->c2frame);
   1108       HIDDEN->c2frame = NULL;
   1109     }
   1110 
   1111   if (HIDDEN->eventbuffer)
   1112     {
   1113       HIDDEN->eventbuffer->Release (HIDDEN->eventbuffer);
   1114       HIDDEN->eventbuffer = NULL;
   1115     }
   1116 
   1117   if (HIDDEN->c2layer)
   1118     {
   1119       HIDDEN->c2layer->Release (HIDDEN->c2layer);
   1120       HIDDEN->c2layer = NULL;
   1121     }
   1122 
   1123   if (HIDDEN->layer)
   1124     {
   1125       HIDDEN->layer->Release (HIDDEN->layer);
   1126       HIDDEN->layer = NULL;
   1127     }
   1128 
   1129   if (HIDDEN->dfb)
   1130     {
   1131       HIDDEN->dfb->Release (HIDDEN->dfb);
   1132       HIDDEN->dfb = NULL;
   1133     }
   1134 
   1135   /* Free video mode list */
   1136   if (HIDDEN->modelist)
   1137     {
   1138       free (HIDDEN->modelist);
   1139       HIDDEN->modelist = NULL;
   1140     }
   1141 
   1142   /* Free mode enumeration list */
   1143   while (rect)
   1144     {
   1145       struct DirectFBEnumRect *next = rect->next;
   1146       free (rect);
   1147       rect = next;
   1148     }
   1149   enumlist = NULL;
   1150 
   1151   HIDDEN->initialized = 0;
   1152 }
   1153 
   1154 
   1155 int DirectFB_ShowWMCursor(_THIS, WMcursor *cursor)
   1156 {
   1157   /* We can only hide or show the default cursor */
   1158   if ( cursor == NULL )
   1159     {
   1160       HIDDEN->layer->SetCursorOpacity(HIDDEN->layer, 0x00);
   1161     }
   1162     else
   1163     {
   1164       HIDDEN->layer->SetCursorOpacity(HIDDEN->layer, 0xFF);
   1165     }
   1166   return 1;
   1167 }
   1168 
   1169 void DirectFB_FinalQuit(void)
   1170 {
   1171 }
   1172