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