src/video/dga/SDL_dgavideo.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 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 #include "SDL_config.h"
  23
  24 /* DGA 2.0 based SDL video driver implementation.
  25 */
  26
  27 #include <stdio.h>
  28
  29 #include <X11/Xlib.h>
  30 #include "../Xext/extensions/xf86dga.h"
  31
  32 #include "SDL_video.h"
  33 #include "SDL_mouse.h"
  34 #include "../SDL_sysvideo.h"
  35 #include "../SDL_pixels_c.h"
  36 #include "../../events/SDL_events_c.h"
  37 #include "SDL_dgavideo.h"
  38 #include "SDL_dgamouse_c.h"
  39 #include "SDL_dgaevents_c.h"
  40
  41 /* get function pointers... */
  42 #include "../x11/SDL_x11dyn.h"
  43
  44 /*#define DGA_DEBUG*/
  45
  46 /* Initialization/Query functions */
  47 static int DGA_VideoInit(_THIS, SDL_PixelFormat *vformat);
  48 static SDL_Rect **DGA_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  49 static SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  50 static int DGA_SetColors(_THIS, int firstcolor, int ncolors,
  51                          SDL_Color *colors);
  52 static int DGA_SetGammaRamp(_THIS, Uint16 *ramp);
  53 static void DGA_VideoQuit(_THIS);
  54
  55 /* Hardware surface functions */
  56 static int DGA_InitHWSurfaces(_THIS, SDL_Surface *screen, Uint8 *base, int size);
  57 static void DGA_FreeHWSurfaces(_THIS);
  58 static int DGA_AllocHWSurface(_THIS, SDL_Surface *surface);
  59 static int DGA_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
  60 static int DGA_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst);
  61 static int DGA_LockHWSurface(_THIS, SDL_Surface *surface);
  62 static void DGA_UnlockHWSurface(_THIS, SDL_Surface *surface);
  63 static void DGA_FreeHWSurface(_THIS, SDL_Surface *surface);
  64 static int DGA_FlipHWSurface(_THIS, SDL_Surface *surface);
  65
  66 /* DGA driver bootstrap functions */
  67
  68 static int DGA_Available(void)
  69 {
  70         const char *display = NULL;
  71         Display *dpy = NULL;
  72         int available = 0;
  73
  74         /* The driver is available is available if the display is local
  75            and the DGA 2.0+ extension is available, and we can map mem.
  76         */
  77         if ( SDL_X11_LoadSymbols() ) {
  78                 if ( (SDL_strncmp(XDisplayName(display), ":", 1) == 0) ||
  79                      (SDL_strncmp(XDisplayName(display), "unix:", 5) == 0) ) {
  80                         dpy = XOpenDisplay(display);
  81                         if ( dpy ) {
  82                                 int events, errors, major, minor;
  83
  84                                 if ( SDL_NAME(XDGAQueryExtension)(dpy, &events, &errors) &&
  85                                      SDL_NAME(XDGAQueryVersion)(dpy, &major, &minor) ) {
  86                                         int screen;
  87
  88                                         screen = DefaultScreen(dpy);
  89                                         if ( (major >= 2) &&
  90                                              SDL_NAME(XDGAOpenFramebuffer)(dpy, screen) ) {
  91                                                 available = 1;
  92                                                 SDL_NAME(XDGACloseFramebuffer)(dpy, screen);
  93                                         }
  94                                 }
  95                                 XCloseDisplay(dpy);
  96                         }
  97                 }
  98                 SDL_X11_UnloadSymbols();
  99         }
 100         return(available);
 101 }
 102
 103 static void DGA_DeleteDevice(SDL_VideoDevice *device)
 104 {
 105         if (device != NULL) {
 106                 SDL_free(device->hidden);
 107                 SDL_free(device);
 108                 SDL_X11_UnloadSymbols();
 109         }
 110 }
 111
 112 static SDL_VideoDevice *DGA_CreateDevice(int devindex)
 113 {
 114         SDL_VideoDevice *device = NULL;
 115
 116         /* Initialize all variables that we clean on shutdown */
 117         if (SDL_X11_LoadSymbols()) {
 118                 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
 119                 if ( device ) {
 120                         SDL_memset(device, 0, (sizeof *device));
 121                         device->hidden = (struct SDL_PrivateVideoData *)
 122                                         SDL_malloc((sizeof *device->hidden));
 123                 }
 124                 if ( (device == NULL) || (device->hidden == NULL) ) {
 125                         SDL_OutOfMemory();
 126                         if ( device ) {
 127                                 SDL_free(device);
 128                         }
 129                         SDL_X11_UnloadSymbols();
 130                         return(0);
 131                 }
 132                 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
 133
 134                 /* Set the function pointers */
 135                 device->VideoInit = DGA_VideoInit;
 136                 device->ListModes = DGA_ListModes;
 137                 device->SetVideoMode = DGA_SetVideoMode;
 138                 device->SetColors = DGA_SetColors;
 139                 device->UpdateRects = NULL;
 140                 device->VideoQuit = DGA_VideoQuit;
 141                 device->AllocHWSurface = DGA_AllocHWSurface;
 142                 device->CheckHWBlit = DGA_CheckHWBlit;
 143                 device->FillHWRect = DGA_FillHWRect;
 144                 device->SetHWColorKey = NULL;
 145                 device->SetHWAlpha = NULL;
 146                 device->LockHWSurface = DGA_LockHWSurface;
 147                 device->UnlockHWSurface = DGA_UnlockHWSurface;
 148                 device->FlipHWSurface = DGA_FlipHWSurface;
 149                 device->FreeHWSurface = DGA_FreeHWSurface;
 150                 device->SetGammaRamp = DGA_SetGammaRamp;
 151                 device->GetGammaRamp = NULL;
 152                 device->SetCaption = NULL;
 153                 device->SetIcon = NULL;
 154                 device->IconifyWindow = NULL;
 155                 device->GrabInput = NULL;
 156                 device->GetWMInfo = NULL;
 157                 device->InitOSKeymap = DGA_InitOSKeymap;
 158                 device->PumpEvents = DGA_PumpEvents;
 159
 160                 device->free = DGA_DeleteDevice;
 161         }
 162
 163         return device;
 164 }
 165
 166 VideoBootStrap DGA_bootstrap = {
 167         "dga", "XFree86 DGA 2.0",
 168         DGA_Available, DGA_CreateDevice
 169 };
 170
 171 static int DGA_AddMode(_THIS, int bpp, int w, int h)
 172 {
 173         SDL_Rect *mode;
 174         int index;
 175         int next_mode;
 176
 177         /* Check to see if we already have this mode */
 178         if ( bpp < 8 ) {  /* Not supported */
 179                 return(0);
 180         }
 181         index = ((bpp+7)/8)-1;
 182         if ( SDL_nummodes[index] > 0 ) {
 183                 mode = SDL_modelist[index][SDL_nummodes[index]-1];
 184                 if ( (mode->w == w) && (mode->h == h) ) {
 185                         return(0);
 186                 }
 187         }
 188
 189         /* Set up the new video mode rectangle */
 190         mode = (SDL_Rect *)SDL_malloc(sizeof *mode);
 191         if ( mode == NULL ) {
 192                 SDL_OutOfMemory();
 193                 return(-1);
 194         }
 195         mode->x = 0;
 196         mode->y = 0;
 197         mode->w = w;
 198         mode->h = h;
 199
 200         /* Allocate the new list of modes, and fill in the new mode */
 201         next_mode = SDL_nummodes[index];
 202         SDL_modelist[index] = (SDL_Rect **)
 203                SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
 204         if ( SDL_modelist[index] == NULL ) {
 205                 SDL_OutOfMemory();
 206                 SDL_nummodes[index] = 0;
 207                 SDL_free(mode);
 208                 return(-1);
 209         }
 210         SDL_modelist[index][next_mode] = mode;
 211         SDL_modelist[index][next_mode+1] = NULL;
 212         SDL_nummodes[index]++;
 213
 214         return(0);
 215 }
 216
 217 /* This whole function is a hack. :) */
 218 static Uint32 get_video_size(_THIS)
 219 {
 220         /* This is a non-exported function from libXxf86dga.a */
 221         extern unsigned char *SDL_NAME(XDGAGetMappedMemory)(int screen);
 222         FILE *proc;
 223         unsigned long mem;
 224         unsigned start, stop;
 225         char line[BUFSIZ];
 226         Uint32 size;
 227
 228         mem = (unsigned long)SDL_NAME(XDGAGetMappedMemory)(DGA_Screen);
 229         size = 0;
 230         proc = fopen("/proc/self/maps", "r");
 231         if ( proc ) {
 232                 while ( fgets(line, sizeof(line)-1, proc) ) {
 233                         SDL_sscanf(line, "%x-%x", &start, &stop);
 234                         if ( start == mem ) {
 235                                 size = (Uint32)((stop-start)/1024);
 236                                 break;
 237                         }
 238                 }
 239                 fclose(proc);
 240         }
 241         return(size);
 242 }
 243
 244 #ifdef DGA_DEBUG
 245 static void PrintMode(SDL_NAME(XDGAMode) *mode)
 246 {
 247         printf("Mode: %s (%dx%d) at %d bpp (%f refresh, %d pitch) num: %d\n",
 248                 mode->name,
 249                 mode->viewportWidth, mode->viewportHeight,
 250                 mode->depth == 24 ? mode->bitsPerPixel : mode->depth,
 251                 mode->verticalRefresh, mode->bytesPerScanline, mode->num);
 252         printf("\tRGB: 0x%8.8x 0x%8.8x 0x%8.8x (%d - %s)\n",
 253                 mode->redMask, mode->greenMask, mode->blueMask,
 254                 mode->visualClass,
 255                 mode->visualClass == TrueColor ? "truecolor" :
 256                 mode->visualClass == DirectColor ? "directcolor" :
 257                 mode->visualClass == PseudoColor ? "pseudocolor" : "unknown");
 258         printf("\tFlags: ");
 259         if ( mode->flags & XDGAConcurrentAccess )
 260                 printf(" XDGAConcurrentAccess");
 261         if ( mode->flags & XDGASolidFillRect )
 262                 printf(" XDGASolidFillRect");
 263         if ( mode->flags & XDGABlitRect )
 264                 printf(" XDGABlitRect");
 265         if ( mode->flags & XDGABlitTransRect )
 266                 printf(" XDGABlitTransRect");
 267         if ( mode->flags & XDGAPixmap )
 268                 printf(" XDGAPixmap");
 269         if ( mode->flags & XDGAInterlaced )
 270                 printf(" XDGAInterlaced");
 271         if ( mode->flags & XDGADoublescan )
 272                 printf(" XDGADoublescan");
 273         if ( mode->viewportFlags & XDGAFlipRetrace )
 274                 printf(" XDGAFlipRetrace");
 275         if ( mode->viewportFlags & XDGAFlipImmediate )
 276                 printf(" XDGAFlipImmediate");
 277         printf("\n");
 278 }
 279 #endif /* DGA_DEBUG */
 280
 281 static int cmpmodes(const void *va, const void *vb)
 282 {
 283     const SDL_NAME(XDGAMode) *a = (const SDL_NAME(XDGAMode) *)va;
 284     const SDL_NAME(XDGAMode) *b = (const SDL_NAME(XDGAMode) *)vb;
 285
 286     if ( (a->viewportWidth == b->viewportWidth) &&
 287          (b->viewportHeight == a->viewportHeight) ) {
 288         /* Prefer 32 bpp over 24 bpp, 16 bpp over 15 bpp */
 289         int a_bpp = a->depth == 24 ? a->bitsPerPixel : a->depth;
 290         int b_bpp = b->depth == 24 ? b->bitsPerPixel : b->depth;
 291         if ( a_bpp != b_bpp ) {
 292             return b_bpp - a_bpp;
 293         }
 294         /* Prefer DirectColor visuals, for gamma support */
 295         if ( a->visualClass == DirectColor && b->visualClass != DirectColor )
 296             return -1;
 297         if ( b->visualClass == DirectColor && a->visualClass != DirectColor )
 298             return 1;
 299         /* Maintain server refresh rate sorting */
 300         return a->num - b->num;
 301     } else if ( a->viewportWidth == b->viewportWidth ) {
 302         return b->viewportHeight - a->viewportHeight;
 303     } else {
 304         return b->viewportWidth - a->viewportWidth;
 305     }
 306 }
 307 static void UpdateHWInfo(_THIS, SDL_NAME(XDGAMode) *mode)
 308 {
 309         this->info.wm_available = 0;
 310         this->info.hw_available = 1;
 311         if ( mode->flags & XDGABlitRect ) {
 312                 this->info.blit_hw = 1;
 313         } else {
 314                 this->info.blit_hw = 0;
 315         }
 316         if ( mode->flags & XDGABlitTransRect ) {
 317                 this->info.blit_hw_CC = 1;
 318         } else {
 319                 this->info.blit_hw_CC = 0;
 320         }
 321         if ( mode->flags & XDGASolidFillRect ) {
 322                 this->info.blit_fill = 1;
 323         } else {
 324                 this->info.blit_fill = 0;
 325         }
 326         this->info.video_mem = get_video_size(this);
 327 }
 328
 329 static int DGA_VideoInit(_THIS, SDL_PixelFormat *vformat)
 330 {
 331         const char *env;
 332         const char *display;
 333         int event_base, error_base;
 334         int major_version, minor_version;
 335         Visual *visual;
 336         SDL_NAME(XDGAMode) *modes;
 337         int i, num_modes;
 338
 339         /* Open the X11 display */
 340         display = NULL;         /* Get it from DISPLAY environment variable */
 341
 342         DGA_Display = XOpenDisplay(display);
 343         if ( DGA_Display == NULL ) {
 344                 SDL_SetError("Couldn't open X11 display");
 345                 return(-1);
 346         }
 347
 348         /* Check for the DGA extension */
 349         if ( ! SDL_NAME(XDGAQueryExtension)(DGA_Display, &event_base, &error_base) ||
 350              ! SDL_NAME(XDGAQueryVersion)(DGA_Display, &major_version, &minor_version) ) {
 351                 SDL_SetError("DGA extension not available");
 352                 XCloseDisplay(DGA_Display);
 353                 return(-1);
 354         }
 355         if ( major_version < 2 ) {
 356                 SDL_SetError("DGA driver requires DGA 2.0 or newer");
 357                 XCloseDisplay(DGA_Display);
 358                 return(-1);
 359         }
 360         DGA_event_base = event_base;
 361
 362         /* Determine the current screen size */
 363         this->info.current_w = DisplayWidth(DGA_Display, DGA_Screen);
 364         this->info.current_h = DisplayHeight(DGA_Display, DGA_Screen);
 365
 366         /* Determine the current screen depth */
 367         visual = DefaultVisual(DGA_Display, DGA_Screen);
 368         {
 369                 XPixmapFormatValues *pix_format;
 370                 int i, num_formats;
 371
 372                 vformat->BitsPerPixel = DefaultDepth(DGA_Display, DGA_Screen);
 373                 pix_format = XListPixmapFormats(DGA_Display, &num_formats);
 374                 if ( pix_format == NULL ) {
 375                         SDL_SetError("Couldn't determine screen formats");
 376                         XCloseDisplay(DGA_Display);
 377                         return(-1);
 378                 }
 379                 for ( i=0; i<num_formats; ++i ) {
 380                         if ( vformat->BitsPerPixel == pix_format[i].depth )
 381                                 break;
 382                 }
 383                 if ( i != num_formats )
 384                         vformat->BitsPerPixel = pix_format[i].bits_per_pixel;
 385                 XFree((char *)pix_format);
 386         }
 387         if ( vformat->BitsPerPixel > 8 ) {
 388                 vformat->Rmask = visual->red_mask;
 389                 vformat->Gmask = visual->green_mask;
 390                 vformat->Bmask = visual->blue_mask;
 391         }
 392
 393         /* Open access to the framebuffer */
 394         if ( ! SDL_NAME(XDGAOpenFramebuffer)(DGA_Display, DGA_Screen) ) {
 395                 SDL_SetError("Unable to map the video memory");
 396                 XCloseDisplay(DGA_Display);
 397                 return(-1);
 398         }
 399
 400         /* Allow environment override of screensaver disable. */
 401         env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
 402         if ( env ) {
 403                 allow_screensaver = SDL_atoi(env);
 404         } else {
 405 #ifdef SDL_VIDEO_DISABLE_SCREENSAVER
 406                 allow_screensaver = 0;
 407 #else
 408                 allow_screensaver = 1;
 409 #endif
 410         }
 411
 412         /* Query for the list of available video modes */
 413         modes = SDL_NAME(XDGAQueryModes)(DGA_Display, DGA_Screen, &num_modes);
 414         SDL_qsort(modes, num_modes, sizeof *modes, cmpmodes);
 415         for ( i=0; i<num_modes; ++i ) {
 416                 if ( ((modes[i].visualClass == PseudoColor) ||
 417                       (modes[i].visualClass == DirectColor) ||
 418                       (modes[i].visualClass == TrueColor)) &&
 419                      !(modes[i].flags & (XDGAInterlaced|XDGADoublescan)) ) {
 420 #ifdef DGA_DEBUG
 421                         PrintMode(&modes[i]);
 422 #endif
 423                         DGA_AddMode(this, modes[i].bitsPerPixel,
 424                                     modes[i].viewportWidth,
 425                                     modes[i].viewportHeight);
 426                 }
 427         }
 428         UpdateHWInfo(this, modes);
 429         XFree(modes);
 430
 431         /* Create the hardware surface lock mutex */
 432         hw_lock = SDL_CreateMutex();
 433         if ( hw_lock == NULL ) {
 434                 SDL_SetError("Unable to create lock mutex");
 435                 DGA_VideoQuit(this);
 436                 return(-1);
 437         }
 438
 439 #ifdef LOCK_DGA_DISPLAY
 440         /* Create the event lock so we're thread-safe.. :-/ */
 441         event_lock = SDL_CreateMutex();
 442 #endif /* LOCK_DGA_DISPLAY */
 443
 444         /* We're done! */
 445         return(0);
 446 }
 447
 448 SDL_Rect **DGA_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
 449 {
 450         return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]);
 451 }
 452
 453 /* Various screen update functions available */
 454 static void DGA_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
 455
 456 SDL_Surface *DGA_SetVideoMode(_THIS, SDL_Surface *current,
 457                                 int width, int height, int bpp, Uint32 flags)
 458 {
 459         SDL_NAME(XDGAMode) *modes;
 460         int i, num_modes;
 461         SDL_NAME(XDGADevice) *mode;
 462         int screen_len;
 463         Uint8 *surfaces_mem;
 464         int surfaces_len;
 465
 466         /* Free any previous colormap */
 467         if ( DGA_colormap ) {
 468                 XFreeColormap(DGA_Display, DGA_colormap);
 469                 DGA_colormap = 0;
 470         }
 471
 472         /* Search for a matching video mode */
 473         modes = SDL_NAME(XDGAQueryModes)(DGA_Display, DGA_Screen, &num_modes);
 474         SDL_qsort(modes, num_modes, sizeof *modes, cmpmodes);
 475         for ( i=0; i<num_modes; ++i ) {
 476                 int depth;
 477
 478                 depth = modes[i].depth;
 479                 if ( depth == 24 ) { /* Distinguish between 24 and 32 bpp */
 480                         depth = modes[i].bitsPerPixel;
 481                 }
 482                 if ( (depth == bpp) &&
 483                      (modes[i].viewportWidth == width) &&
 484                      (modes[i].viewportHeight == height) &&
 485                      ((modes[i].visualClass == PseudoColor) ||
 486                       (modes[i].visualClass == DirectColor) ||
 487                       (modes[i].visualClass == TrueColor)) &&
 488                      !(modes[i].flags & (XDGAInterlaced|XDGADoublescan)) ) {
 489                         break;
 490                 }
 491         }
 492         if ( i == num_modes ) {
 493                 SDL_SetError("No matching video mode found");
 494                 return(NULL);
 495         }
 496 #ifdef DGA_DEBUG
 497         PrintMode(&modes[i]);
 498 #endif
 499
 500         /* Set the video mode */
 501         mode = SDL_NAME(XDGASetMode)(DGA_Display, DGA_Screen, modes[i].num);
 502         XFree(modes);
 503         if ( mode == NULL ) {
 504                 SDL_SetError("Unable to switch to requested mode");
 505                 return(NULL);
 506         }
 507         DGA_visualClass = mode->mode.visualClass;
 508         memory_base = (Uint8 *)mode->data;
 509         memory_pitch = mode->mode.bytesPerScanline;
 510
 511         /* Set up the new mode framebuffer */
 512         current->flags = (SDL_FULLSCREEN|SDL_HWSURFACE);
 513         current->w = mode->mode.viewportWidth;
 514         current->h = mode->mode.viewportHeight;
 515         current->pitch = memory_pitch;
 516         current->pixels = memory_base;
 517         if ( ! SDL_ReallocFormat(current, mode->mode.bitsPerPixel,
 518                                           mode->mode.redMask,
 519                                           mode->mode.greenMask,
 520                                           mode->mode.blueMask, 0) ) {
 521                 return(NULL);
 522         }
 523         screen_len = current->h*current->pitch;
 524
 525         /* Create a colormap if necessary */
 526         if ( (DGA_visualClass == PseudoColor) ||
 527              (DGA_visualClass == DirectColor) ) {
 528                 DGA_colormap = SDL_NAME(XDGACreateColormap)(DGA_Display, DGA_Screen,
 529                                                         mode, AllocAll);
 530                 if ( DGA_visualClass == PseudoColor ) {
 531                         current->flags |= SDL_HWPALETTE;
 532                 } else {
 533                         /* Initialize the colormap to the identity mapping */
 534                         SDL_GetGammaRamp(0, 0, 0);
 535                         this->screen = current;
 536                         DGA_SetGammaRamp(this, this->gamma);
 537                         this->screen = NULL;
 538                 }
 539         } else {
 540                 DGA_colormap = SDL_NAME(XDGACreateColormap)(DGA_Display, DGA_Screen,
 541                                                         mode, AllocNone);
 542         }
 543         SDL_NAME(XDGAInstallColormap)(DGA_Display, DGA_Screen, DGA_colormap);
 544
 545         /* Update the hardware capabilities */
 546         UpdateHWInfo(this, &mode->mode);
 547
 548         /* Set up the information for hardware surfaces */
 549         surfaces_mem = (Uint8 *)current->pixels + screen_len;
 550         surfaces_len = (mode->mode.imageHeight*current->pitch - screen_len);
 551
 552         /* Update for double-buffering, if we can */
 553         SDL_NAME(XDGASetViewport)(DGA_Display, DGA_Screen, 0, 0, XDGAFlipRetrace);
 554         if ( flags & SDL_DOUBLEBUF ) {
 555                 if ( mode->mode.imageHeight >= (current->h*2) ) {
 556                         current->flags |= SDL_DOUBLEBUF;
 557                         flip_page = 0;
 558                         flip_yoffset[0] = 0;
 559                         flip_yoffset[1] = current->h;
 560                         flip_address[0] = memory_base;
 561                         flip_address[1] = memory_base+screen_len;
 562                         surfaces_mem += screen_len;
 563                         surfaces_len -= screen_len;
 564                 }
 565         }
 566
 567         /* Allocate memory tracking for hardware surfaces */
 568         DGA_FreeHWSurfaces(this);
 569         if ( surfaces_len < 0 ) {
 570                 surfaces_len = 0;
 571         }
 572         DGA_InitHWSurfaces(this, current, surfaces_mem, surfaces_len);
 573
 574         /* Expose the back buffer as surface memory */
 575         if ( current->flags & SDL_DOUBLEBUF ) {
 576                 this->screen = current;
 577                 DGA_FlipHWSurface(this, current);
 578                 this->screen = NULL;
 579         }
 580
 581         /* Set the update rectangle function */
 582         this->UpdateRects = DGA_DirectUpdate;
 583
 584         /* Enable mouse and keyboard support */
 585         { long input_mask;
 586           input_mask = (KeyPressMask | KeyReleaseMask);
 587           input_mask |= (ButtonPressMask | ButtonReleaseMask);
 588           input_mask |= PointerMotionMask;
 589           SDL_NAME(XDGASelectInput)(DGA_Display, DGA_Screen, input_mask);
 590         }
 591
 592         /* We're done */
 593         return(current);
 594 }
 595
 596 #ifdef DGA_DEBUG
 597 static void DGA_DumpHWSurfaces(_THIS)
 598 {
 599         vidmem_bucket *bucket;
 600
 601         printf("Memory left: %d (%d total)\n", surfaces_memleft, surfaces_memtotal);
 602         printf("\n");
 603         printf("         Base  Size\n");
 604         for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
 605                 printf("Bucket:  %p, %d (%s)\n", bucket->base, bucket->size, bucket->used ? "used" : "free");
 606                 if ( bucket->prev ) {
 607                         if ( bucket->base != bucket->prev->base+bucket->prev->size ) {
 608                                 printf("Warning, corrupt bucket list! (prev)\n");
 609                         }
 610                 } else {
 611                         if ( bucket != &surfaces ) {
 612                                 printf("Warning, corrupt bucket list! (!prev)\n");
 613                         }
 614                 }
 615                 if ( bucket->next ) {
 616                         if ( bucket->next->base != bucket->base+bucket->size ) {
 617                                 printf("Warning, corrupt bucket list! (next)\n");
 618                         }
 619                 }
 620         }
 621         printf("\n");
 622 }
 623 #endif
 624
 625 static int DGA_InitHWSurfaces(_THIS, SDL_Surface *screen, Uint8 *base, int size)
 626 {
 627         vidmem_bucket *bucket;
 628
 629         surfaces_memtotal = size;
 630         surfaces_memleft = size;
 631
 632         if ( surfaces_memleft > 0 ) {
 633                 bucket = (vidmem_bucket *)SDL_malloc(sizeof(*bucket));
 634                 if ( bucket == NULL ) {
 635                         SDL_OutOfMemory();
 636                         return(-1);
 637                 }
 638                 bucket->prev = &surfaces;
 639                 bucket->used = 0;
 640                 bucket->dirty = 0;
 641                 bucket->base = base;
 642                 bucket->size = size;
 643                 bucket->next = NULL;
 644         } else {
 645                 bucket = NULL;
 646         }
 647
 648         surfaces.prev = NULL;
 649         surfaces.used = 1;
 650         surfaces.dirty = 0;
 651         surfaces.base = screen->pixels;
 652         surfaces.size = (unsigned int)((long)base - (long)surfaces.base);
 653         surfaces.next = bucket;
 654         screen->hwdata = (struct private_hwdata *)&surfaces;
 655         return(0);
 656 }
 657 static void DGA_FreeHWSurfaces(_THIS)
 658 {
 659         vidmem_bucket *bucket, *freeable;
 660
 661         bucket = surfaces.next;
 662         while ( bucket ) {
 663                 freeable = bucket;
 664                 bucket = bucket->next;
 665                 SDL_free(freeable);
 666         }
 667         surfaces.next = NULL;
 668 }
 669
 670 static __inline__ void DGA_AddBusySurface(SDL_Surface *surface)
 671 {
 672         ((vidmem_bucket *)surface->hwdata)->dirty = 1;
 673 }
 674
 675 static __inline__ int DGA_IsSurfaceBusy(SDL_Surface *surface)
 676 {
 677         return ((vidmem_bucket *)surface->hwdata)->dirty;
 678 }
 679
 680 static __inline__ void DGA_WaitBusySurfaces(_THIS)
 681 {
 682         vidmem_bucket *bucket;
 683
 684         /* Wait for graphic operations to complete */
 685         SDL_NAME(XDGASync)(DGA_Display, DGA_Screen);
 686
 687         /* Clear all surface dirty bits */
 688         for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
 689                 bucket->dirty = 0;
 690         }
 691 }
 692
 693 static int DGA_AllocHWSurface(_THIS, SDL_Surface *surface)
 694 {
 695         vidmem_bucket *bucket;
 696         int size;
 697         int extra;
 698         int retval = 0;
 699
 700 /* Temporarily, we only allow surfaces the same width as display.
 701    Some blitters require the pitch between two hardware surfaces
 702    to be the same.  Others have interesting alignment restrictions.
 703 */
 704 if ( surface->pitch > SDL_VideoSurface->pitch ) {
 705         SDL_SetError("Surface requested wider than screen");
 706         return(-1);
 707 }
 708 surface->pitch = SDL_VideoSurface->pitch;
 709         size = surface->h * surface->pitch;
 710 #ifdef DGA_DEBUG
 711         fprintf(stderr, "Allocating bucket of %d bytes\n", size);
 712 #endif
 713         LOCK_DISPLAY();
 714
 715         /* Quick check for available mem */
 716         if ( size > surfaces_memleft ) {
 717                 SDL_SetError("Not enough video memory");
 718                 retval = -1;
 719                 goto done;
 720         }
 721
 722         /* Search for an empty bucket big enough */
 723         for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
 724                 if ( ! bucket->used && (size <= bucket->size) ) {
 725                         break;
 726                 }
 727         }
 728         if ( bucket == NULL ) {
 729                 SDL_SetError("Video memory too fragmented");
 730                 retval = -1;
 731                 goto done;
 732         }
 733
 734         /* Create a new bucket for left-over memory */
 735         extra = (bucket->size - size);
 736         if ( extra ) {
 737                 vidmem_bucket *newbucket;
 738
 739 #ifdef DGA_DEBUG
 740         fprintf(stderr, "Adding new free bucket of %d bytes\n", extra);
 741 #endif
 742                 newbucket = (vidmem_bucket *)SDL_malloc(sizeof(*newbucket));
 743                 if ( newbucket == NULL ) {
 744                         SDL_OutOfMemory();
 745                         retval = -1;
 746                         goto done;
 747                 }
 748                 newbucket->prev = bucket;
 749                 newbucket->used = 0;
 750                 newbucket->base = bucket->base+size;
 751                 newbucket->size = extra;
 752                 newbucket->next = bucket->next;
 753                 if ( bucket->next ) {
 754                         bucket->next->prev = newbucket;
 755                 }
 756                 bucket->next = newbucket;
 757         }
 758
 759         /* Set the current bucket values and return it! */
 760         bucket->used = 1;
 761         bucket->size = size;
 762         bucket->dirty = 0;
 763 #ifdef DGA_DEBUG
 764         fprintf(stderr, "Allocated %d bytes at %p\n", bucket->size, bucket->base);
 765 #endif
 766         surfaces_memleft -= size;
 767         surface->flags |= SDL_HWSURFACE;
 768         surface->pixels = bucket->base;
 769         surface->hwdata = (struct private_hwdata *)bucket;
 770 done:
 771         UNLOCK_DISPLAY();
 772         return(retval);
 773 }
 774 static void DGA_FreeHWSurface(_THIS, SDL_Surface *surface)
 775 {
 776         vidmem_bucket *bucket, *freeable;
 777
 778         /* Wait for any pending operations involving this surface */
 779         if ( DGA_IsSurfaceBusy(surface) ) {
 780                 LOCK_DISPLAY();
 781                 DGA_WaitBusySurfaces(this);
 782                 UNLOCK_DISPLAY();
 783         }
 784
 785         /* Look for the bucket in the current list */
 786         for ( bucket=&surfaces; bucket; bucket=bucket->next ) {
 787                 if ( bucket == (vidmem_bucket *)surface->hwdata ) {
 788                         break;
 789                 }
 790         }
 791         if ( bucket && bucket->used ) {
 792                 /* Add the memory back to the total */
 793 #ifdef DGA_DEBUG
 794         printf("Freeing bucket of %d bytes\n", bucket->size);
 795 #endif
 796                 surfaces_memleft += bucket->size;
 797
 798                 /* Can we merge the space with surrounding buckets? */
 799                 bucket->used = 0;
 800                 if ( bucket->next && ! bucket->next->used ) {
 801 #ifdef DGA_DEBUG
 802         printf("Merging with next bucket, for %d total bytes\n", bucket->size+bucket->next->size);
 803 #endif
 804                         freeable = bucket->next;
 805                         bucket->size += bucket->next->size;
 806                         bucket->next = bucket->next->next;
 807                         if ( bucket->next ) {
 808                                 bucket->next->prev = bucket;
 809                         }
 810                         SDL_free(freeable);
 811                 }
 812                 if ( bucket->prev && ! bucket->prev->used ) {
 813 #ifdef DGA_DEBUG
 814         printf("Merging with previous bucket, for %d total bytes\n", bucket->prev->size+bucket->size);
 815 #endif
 816                         freeable = bucket;
 817                         bucket->prev->size += bucket->size;
 818                         bucket->prev->next = bucket->next;
 819                         if ( bucket->next ) {
 820                                 bucket->next->prev = bucket->prev;
 821                         }
 822                         SDL_free(freeable);
 823                 }
 824         }
 825         surface->pixels = NULL;
 826         surface->hwdata = NULL;
 827 }
 828
 829 static __inline__ void DGA_dst_to_xy(_THIS, SDL_Surface *dst, int *x, int *y)
 830 {
 831         *x = (long)((Uint8 *)dst->pixels - memory_base)%memory_pitch;
 832         *y = (long)((Uint8 *)dst->pixels - memory_base)/memory_pitch;
 833 }
 834
 835 static int DGA_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color)
 836 {
 837         int x, y;
 838         unsigned int w, h;
 839
 840         /* Don't fill the visible part of the screen, wait until flipped */
 841         LOCK_DISPLAY();
 842         if ( was_flipped && (dst == this->screen) ) {
 843                 while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) )
 844                         /* Keep waiting for the hardware ... */ ;
 845                 was_flipped = 0;
 846         }
 847         DGA_dst_to_xy(this, dst, &x, &y);
 848         x += rect->x;
 849         y += rect->y;
 850         w = rect->w;
 851         h = rect->h;
 852 #if 0
 853   printf("Hardware accelerated rectangle fill: %dx%d at %d,%d\n", w, h, x, y);
 854 #endif
 855         SDL_NAME(XDGAFillRectangle)(DGA_Display, DGA_Screen, x, y, w, h, color);
 856         if ( !(this->screen->flags & SDL_DOUBLEBUF) ) {
 857                 XFlush(DGA_Display);
 858         }
 859         DGA_AddBusySurface(dst);
 860         UNLOCK_DISPLAY();
 861         return(0);
 862 }
 863
 864 static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
 865                        SDL_Surface *dst, SDL_Rect *dstrect)
 866 {
 867         SDL_VideoDevice *this;
 868         int srcx, srcy;
 869         int dstx, dsty;
 870         unsigned int w, h;
 871
 872         this = current_video;
 873         /* Don't blit to the visible part of the screen, wait until flipped */
 874         LOCK_DISPLAY();
 875         if ( was_flipped && (dst == this->screen) ) {
 876                 while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) )
 877                         /* Keep waiting for the hardware ... */ ;
 878                 was_flipped = 0;
 879         }
 880         DGA_dst_to_xy(this, src, &srcx, &srcy);
 881         srcx += srcrect->x;
 882         srcy += srcrect->y;
 883         DGA_dst_to_xy(this, dst, &dstx, &dsty);
 884         dstx += dstrect->x;
 885         dsty += dstrect->y;
 886         w = srcrect->w;
 887         h = srcrect->h;
 888 #if 0
 889   printf("Blitting %dx%d from %d,%d to %d,%d\n", w, h, srcx, srcy, dstx, dsty);
 890 #endif
 891         if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
 892                 SDL_NAME(XDGACopyTransparentArea)(DGA_Display, DGA_Screen,
 893                         srcx, srcy, w, h, dstx, dsty, src->format->colorkey);
 894         } else {
 895                 SDL_NAME(XDGACopyArea)(DGA_Display, DGA_Screen,
 896                         srcx, srcy, w, h, dstx, dsty);
 897         }
 898         if ( !(this->screen->flags & SDL_DOUBLEBUF) ) {
 899                 XFlush(DGA_Display);
 900         }
 901         DGA_AddBusySurface(src);
 902         DGA_AddBusySurface(dst);
 903         UNLOCK_DISPLAY();
 904         return(0);
 905 }
 906
 907 static int DGA_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
 908 {
 909         int accelerated;
 910
 911         /* Set initial acceleration on */
 912         src->flags |= SDL_HWACCEL;
 913
 914         /* Set the surface attributes */
 915         if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
 916                 if ( ! this->info.blit_hw_A ) {
 917                         src->flags &= ~SDL_HWACCEL;
 918                 }
 919         }
 920         if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
 921                 if ( ! this->info.blit_hw_CC ) {
 922                         src->flags &= ~SDL_HWACCEL;
 923                 }
 924         }
 925
 926         /* Check to see if final surface blit is accelerated */
 927         accelerated = !!(src->flags & SDL_HWACCEL);
 928         if ( accelerated ) {
 929                 src->map->hw_blit = HWAccelBlit;
 930         }
 931         return(accelerated);
 932 }
 933
 934 static __inline__ void DGA_WaitFlip(_THIS)
 935 {
 936         if ( was_flipped ) {
 937                 while ( SDL_NAME(XDGAGetViewportStatus)(DGA_Display, DGA_Screen) )
 938                         /* Keep waiting for the hardware ... */ ;
 939                 was_flipped = 0;
 940         }
 941 }
 942
 943 static int DGA_LockHWSurface(_THIS, SDL_Surface *surface)
 944 {
 945         if ( surface == this->screen ) {
 946                 SDL_mutexP(hw_lock);
 947                 LOCK_DISPLAY();
 948                 if ( DGA_IsSurfaceBusy(surface) ) {
 949                         DGA_WaitBusySurfaces(this);
 950                 }
 951                 DGA_WaitFlip(this);
 952                 UNLOCK_DISPLAY();
 953         } else {
 954                 if ( DGA_IsSurfaceBusy(surface) ) {
 955                         LOCK_DISPLAY();
 956                         DGA_WaitBusySurfaces(this);
 957                         UNLOCK_DISPLAY();
 958                 }
 959         }
 960         return(0);
 961 }
 962 static void DGA_UnlockHWSurface(_THIS, SDL_Surface *surface)
 963 {
 964         if ( surface == this->screen ) {
 965                 SDL_mutexV(hw_lock);
 966         }
 967 }
 968
 969 static int DGA_FlipHWSurface(_THIS, SDL_Surface *surface)
 970 {
 971         /* Wait for vertical retrace and then flip display */
 972         LOCK_DISPLAY();
 973         if ( DGA_IsSurfaceBusy(this->screen) ) {
 974                 DGA_WaitBusySurfaces(this);
 975         }
 976         DGA_WaitFlip(this);
 977         SDL_NAME(XDGASetViewport)(DGA_Display, DGA_Screen,
 978                         0, flip_yoffset[flip_page], XDGAFlipRetrace);
 979         XFlush(DGA_Display);
 980         UNLOCK_DISPLAY();
 981         was_flipped = 1;
 982         flip_page = !flip_page;
 983
 984         surface->pixels = flip_address[flip_page];
 985         return(0);
 986 }
 987
 988 static void DGA_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
 989 {
 990         /* The application is already updating the visible video memory */
 991         return;
 992 }
 993
 994 static int DGA_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 995 {
 996         int i;
 997         XColor  *xcmap;
 998
 999         /* This happens on initialization */
1000         if ( ! DGA_colormap ) {
1001                 return(0);
1002         }
1003         xcmap = SDL_stack_alloc(XColor, ncolors);
1004         for ( i=0; i<ncolors; ++i ) {
1005                 xcmap[i].pixel = firstcolor + i;
1006                 xcmap[i].red   = (colors[i].r<<8)|colors[i].r;
1007                 xcmap[i].green = (colors[i].g<<8)|colors[i].g;
1008                 xcmap[i].blue  = (colors[i].b<<8)|colors[i].b;
1009                 xcmap[i].flags = (DoRed|DoGreen|DoBlue);
1010         }
1011         LOCK_DISPLAY();
1012         XStoreColors(DGA_Display, DGA_colormap, xcmap, ncolors);
1013         XSync(DGA_Display, False);
1014         UNLOCK_DISPLAY();
1015         SDL_stack_free(xcmap);
1016
1017         /* That was easy. :) */
1018         return(1);
1019 }
1020
1021 int DGA_SetGammaRamp(_THIS, Uint16 *ramp)
1022 {
1023         int i, ncolors;
1024         XColor xcmap[256];
1025
1026         /* See if actually setting the gamma is supported */
1027         if ( DGA_visualClass != DirectColor ) {
1028             SDL_SetError("Gamma correction not supported on this visual");
1029             return(-1);
1030         }
1031
1032         /* Calculate the appropriate palette for the given gamma ramp */
1033         if ( this->screen->format->BitsPerPixel <= 16 ) {
1034                 ncolors = 64; /* Is this right? */
1035         } else {
1036                 ncolors = 256;
1037         }
1038         for ( i=0; i<ncolors; ++i ) {
1039                 Uint8 c = (256 * i / ncolors);
1040                 xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c);
1041                 xcmap[i].red   = ramp[0*256+c];
1042                 xcmap[i].green = ramp[1*256+c];
1043                 xcmap[i].blue  = ramp[2*256+c];
1044                 xcmap[i].flags = (DoRed|DoGreen|DoBlue);
1045         }
1046         LOCK_DISPLAY();
1047         XStoreColors(DGA_Display, DGA_colormap, xcmap, ncolors);
1048         XSync(DGA_Display, False);
1049         UNLOCK_DISPLAY();
1050         return(0);
1051 }
1052
1053 void DGA_VideoQuit(_THIS)
1054 {
1055         int i, j;
1056
1057         if ( DGA_Display ) {
1058                 /* Free colormap, if necessary */
1059                 if ( DGA_colormap ) {
1060                         XFreeColormap(DGA_Display, DGA_colormap);
1061                         DGA_colormap = 0;
1062                 }
1063
1064                 /* Unmap memory and reset video mode */
1065                 SDL_NAME(XDGACloseFramebuffer)(DGA_Display, DGA_Screen);
1066                 if ( this->screen ) {
1067                         /* Tell SDL not to free the pixels */
1068                         DGA_FreeHWSurface(this, this->screen);
1069                 }
1070                 SDL_NAME(XDGASetMode)(DGA_Display, DGA_Screen, 0);
1071
1072                 /* Clear the lock mutex */
1073                 if ( hw_lock != NULL ) {
1074                         SDL_DestroyMutex(hw_lock);
1075                         hw_lock = NULL;
1076                 }
1077 #ifdef LOCK_DGA_DISPLAY
1078                 if ( event_lock != NULL ) {
1079                         SDL_DestroyMutex(event_lock);
1080                         event_lock = NULL;
1081                 }
1082 #endif /* LOCK_DGA_DISPLAY */
1083
1084                 /* Clean up defined video modes */
1085                 for ( i=0; i<NUM_MODELISTS; ++i ) {
1086                         if ( SDL_modelist[i] != NULL ) {
1087                                 for ( j=0; SDL_modelist[i][j]; ++j ) {
1088                                         SDL_free(SDL_modelist[i][j]);
1089                                 }
1090                                 SDL_free(SDL_modelist[i]);
1091                                 SDL_modelist[i] = NULL;
1092                         }
1093                 }
1094
1095                 /* Clean up the memory bucket list */
1096                 DGA_FreeHWSurfaces(this);
1097
1098                 /* Close up the display */
1099                 XCloseDisplay(DGA_Display);
1100         }
1101 }