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