1/*
2    SDL - Simple DirectMedia Layer
3    Copyright (C) 1997-2012 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@libsdl.org
21
22	MGA CRTC2 support by Thomas Jarosch - tomj@simonv.com
23	CRTC2 support is inspired by mplayer's dfbmga driver
24	written by Ville Syrj��<syrjala@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 */
48struct WMcursor {
49	int unused;
50};
51
52
53/* Initialization/Query functions */
54static int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat);
55static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
56static SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
57static int DirectFB_SetColors(_THIS, int firstcolor, int ncolors,
58			 SDL_Color *colors);
59static void DirectFB_VideoQuit(_THIS);
60
61/* Hardware surface functions */
62static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface);
63static int DirectFB_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
64static int DirectFB_LockHWSurface(_THIS, SDL_Surface *surface);
65static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface);
66static void DirectFB_FreeHWSurface(_THIS, SDL_Surface *surface);
67static int DirectFB_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst);
68static int DirectFB_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
69                                SDL_Surface *dst, SDL_Rect *dstrect);
70static int DirectFB_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
71static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha);
72static int DirectFB_FlipHWSurface(_THIS, SDL_Surface *surface);
73static int DirectFB_ShowWMCursor(_THIS, WMcursor *cursor);
74
75/* Various screen update functions available */
76static void DirectFB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
77static void DirectFB_WindowedUpdate(_THIS, int numrects, SDL_Rect *rects);
78
79/* This is the rect EnumModes2 uses */
80struct DirectFBEnumRect {
81	SDL_Rect r;
82	struct DirectFBEnumRect* next;
83};
84
85static struct DirectFBEnumRect *enumlist = NULL;
86
87
88/* DirectFB driver bootstrap functions */
89
90static int DirectFB_Available(void)
91{
92  return 1;
93}
94
95static void DirectFB_DeleteDevice(SDL_VideoDevice *device)
96{
97  SDL_free(device->hidden);
98  SDL_free(device);
99}
100
101static 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
154VideoBootStrap DirectFB_bootstrap = {
155  "directfb", "DirectFB",
156  DirectFB_Available, DirectFB_CreateDevice
157};
158
159static 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
184static 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
213struct private_hwdata {
214  IDirectFBSurface *surface;
215  IDirectFBPalette *palette;
216};
217
218void 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
228static 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
291static 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
316static 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
370int 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
579static 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
590static 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
802static 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
847static 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
857static 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
871static 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
903static 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
918static 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
935static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha)
936{
937  return 0;
938}
939
940static 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
957static 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
977static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface)
978{
979  surface->hwdata->surface->Unlock (surface->hwdata->surface);
980  surface->pixels = NULL;
981}
982
983static 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
996static 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
1054int 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
1086void 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
1155int 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
1169void DirectFB_FinalQuit(void)
1170{
1171}
1172