• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 */
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 
DirectFB_Available(void)90 static int DirectFB_Available(void)
91 {
92   return 1;
93 }
94 
DirectFB_DeleteDevice(SDL_VideoDevice * device)95 static void DirectFB_DeleteDevice(SDL_VideoDevice *device)
96 {
97   SDL_free(device->hidden);
98   SDL_free(device);
99 }
100 
DirectFB_CreateDevice(int devindex)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 
GetFormatForBpp(int bpp,IDirectFBDisplayLayer * layer)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 
EnumModesCallback(int width,int height,int bpp,void * data)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 
SetDirectFBerror(const char * function,DFBResult code)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 
SDLToDFBPixelFormat(SDL_PixelFormat * format)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 
AllocatePalette(int size)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 
DFBToSDLPixelFormat(DFBSurfacePixelFormat pixelformat,SDL_PixelFormat * format)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 
DirectFB_VideoInit(_THIS,SDL_PixelFormat * vformat)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 
DirectFB_ListModes(_THIS,SDL_PixelFormat * format,Uint32 flags)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 
DirectFB_SetVideoMode(_THIS,SDL_Surface * current,int width,int height,int bpp,Uint32 flags)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 
DirectFB_AllocHWSurface(_THIS,SDL_Surface * surface)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 
DirectFB_FreeHWSurface(_THIS,SDL_Surface * surface)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 
DirectFB_CheckHWBlit(_THIS,SDL_Surface * src,SDL_Surface * dst)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 
DirectFB_HWAccelBlit(SDL_Surface * src,SDL_Rect * srcrect,SDL_Surface * dst,SDL_Rect * dstrect)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 
DirectFB_FillHWRect(_THIS,SDL_Surface * dst,SDL_Rect * dstrect,Uint32 color)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 
DirectFB_SetHWColorKey(_THIS,SDL_Surface * src,Uint32 key)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 
DirectFB_SetHWAlpha(_THIS,SDL_Surface * surface,Uint8 alpha)935 static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha)
936 {
937   return 0;
938 }
939 
DirectFB_FlipHWSurface(_THIS,SDL_Surface * surface)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 
DirectFB_LockHWSurface(_THIS,SDL_Surface * surface)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 
DirectFB_UnlockHWSurface(_THIS,SDL_Surface * surface)977 static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface)
978 {
979   surface->hwdata->surface->Unlock (surface->hwdata->surface);
980   surface->pixels = NULL;
981 }
982 
DirectFB_DirectUpdate(_THIS,int numrects,SDL_Rect * rects)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 
DirectFB_WindowedUpdate(_THIS,int numrects,SDL_Rect * rects)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 
DirectFB_SetColors(_THIS,int firstcolor,int ncolors,SDL_Color * colors)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 
DirectFB_VideoQuit(_THIS)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 
DirectFB_ShowWMCursor(_THIS,WMcursor * cursor)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 
DirectFB_FinalQuit(void)1169 void DirectFB_FinalQuit(void)
1170 {
1171 }
1172