e14743d1 |
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 | /* Dummy SDL video driver implementation; this is just enough to make an |
25 | * SDL-based application THINK it's got a working video driver, for |
26 | * applications that call SDL_Init(SDL_INIT_VIDEO) when they don't need it, |
27 | * and also for use as a collection of stubs when porting SDL to a new |
28 | * platform for which you haven't yet written a valid video driver. |
29 | * |
30 | * This is also a great way to determine bottlenecks: if you think that SDL |
31 | * is a performance problem for a given platform, enable this driver, and |
32 | * then see if your application runs faster without video overhead. |
33 | * |
34 | * Initial work by Ryan C. Gordon (icculus@icculus.org). A good portion |
35 | * of this was cut-and-pasted from Stephane Peter's work in the AAlib |
36 | * SDL video driver. Renamed to "DUMMY" by Sam Lantinga. |
37 | */ |
38 | |
39 | #include "SDL_video.h" |
40 | #include "SDL_mouse.h" |
41 | #include "../SDL_sysvideo.h" |
42 | #include "../SDL_pixels_c.h" |
43 | #include "../../events/SDL_events_c.h" |
44 | |
45 | #include "SDL_nullvideo.h" |
46 | #include "SDL_nullevents_c.h" |
47 | #include "SDL_nullmouse_c.h" |
48 | |
49 | #define DUMMYVID_DRIVER_NAME "dummy" |
50 | |
51 | /* Initialization/Query functions */ |
52 | static int DUMMY_VideoInit(_THIS, SDL_PixelFormat *vformat); |
53 | static SDL_Rect **DUMMY_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); |
54 | static SDL_Surface *DUMMY_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); |
55 | static int DUMMY_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); |
56 | static void DUMMY_VideoQuit(_THIS); |
57 | |
58 | /* Hardware surface functions */ |
59 | static int DUMMY_AllocHWSurface(_THIS, SDL_Surface *surface); |
60 | static int DUMMY_LockHWSurface(_THIS, SDL_Surface *surface); |
61 | static void DUMMY_UnlockHWSurface(_THIS, SDL_Surface *surface); |
62 | static void DUMMY_FreeHWSurface(_THIS, SDL_Surface *surface); |
63 | |
64 | /* etc. */ |
65 | static void DUMMY_UpdateRects(_THIS, int numrects, SDL_Rect *rects); |
66 | |
67 | /* DUMMY driver bootstrap functions */ |
68 | |
69 | static int DUMMY_Available(void) |
70 | { |
71 | const char *envr = SDL_getenv("SDL_VIDEODRIVER"); |
72 | if ((envr) && (SDL_strcmp(envr, DUMMYVID_DRIVER_NAME) == 0)) { |
73 | return(1); |
74 | } |
75 | |
76 | return(0); |
77 | } |
78 | |
79 | static void DUMMY_DeleteDevice(SDL_VideoDevice *device) |
80 | { |
81 | SDL_free(device->hidden); |
82 | SDL_free(device); |
83 | } |
84 | |
85 | static SDL_VideoDevice *DUMMY_CreateDevice(int devindex) |
86 | { |
87 | SDL_VideoDevice *device; |
88 | |
89 | /* Initialize all variables that we clean on shutdown */ |
90 | device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); |
91 | if ( device ) { |
92 | SDL_memset(device, 0, (sizeof *device)); |
93 | device->hidden = (struct SDL_PrivateVideoData *) |
94 | SDL_malloc((sizeof *device->hidden)); |
95 | } |
96 | if ( (device == NULL) || (device->hidden == NULL) ) { |
97 | SDL_OutOfMemory(); |
98 | if ( device ) { |
99 | SDL_free(device); |
100 | } |
101 | return(0); |
102 | } |
103 | SDL_memset(device->hidden, 0, (sizeof *device->hidden)); |
104 | |
105 | /* Set the function pointers */ |
106 | device->VideoInit = DUMMY_VideoInit; |
107 | device->ListModes = DUMMY_ListModes; |
108 | device->SetVideoMode = DUMMY_SetVideoMode; |
109 | device->CreateYUVOverlay = NULL; |
110 | device->SetColors = DUMMY_SetColors; |
111 | device->UpdateRects = DUMMY_UpdateRects; |
112 | device->VideoQuit = DUMMY_VideoQuit; |
113 | device->AllocHWSurface = DUMMY_AllocHWSurface; |
114 | device->CheckHWBlit = NULL; |
115 | device->FillHWRect = NULL; |
116 | device->SetHWColorKey = NULL; |
117 | device->SetHWAlpha = NULL; |
118 | device->LockHWSurface = DUMMY_LockHWSurface; |
119 | device->UnlockHWSurface = DUMMY_UnlockHWSurface; |
120 | device->FlipHWSurface = NULL; |
121 | device->FreeHWSurface = DUMMY_FreeHWSurface; |
122 | device->SetCaption = NULL; |
123 | device->SetIcon = NULL; |
124 | device->IconifyWindow = NULL; |
125 | device->GrabInput = NULL; |
126 | device->GetWMInfo = NULL; |
127 | device->InitOSKeymap = DUMMY_InitOSKeymap; |
128 | device->PumpEvents = DUMMY_PumpEvents; |
129 | |
130 | device->free = DUMMY_DeleteDevice; |
131 | |
132 | return device; |
133 | } |
134 | |
135 | VideoBootStrap DUMMY_bootstrap = { |
136 | DUMMYVID_DRIVER_NAME, "SDL dummy video driver", |
137 | DUMMY_Available, DUMMY_CreateDevice |
138 | }; |
139 | |
140 | |
141 | int DUMMY_VideoInit(_THIS, SDL_PixelFormat *vformat) |
142 | { |
143 | /* |
144 | fprintf(stderr, "WARNING: You are using the SDL dummy video driver!\n"); |
145 | */ |
146 | |
147 | /* Determine the screen depth (use default 8-bit depth) */ |
148 | /* we change this during the SDL_SetVideoMode implementation... */ |
149 | vformat->BitsPerPixel = 8; |
150 | vformat->BytesPerPixel = 1; |
151 | |
152 | /* We're done! */ |
153 | return(0); |
154 | } |
155 | |
156 | SDL_Rect **DUMMY_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) |
157 | { |
158 | return (SDL_Rect **) -1; |
159 | } |
160 | |
161 | SDL_Surface *DUMMY_SetVideoMode(_THIS, SDL_Surface *current, |
162 | int width, int height, int bpp, Uint32 flags) |
163 | { |
164 | if ( this->hidden->buffer ) { |
165 | SDL_free( this->hidden->buffer ); |
166 | } |
167 | |
168 | this->hidden->buffer = SDL_malloc(width * height * (bpp / 8)); |
169 | if ( ! this->hidden->buffer ) { |
170 | SDL_SetError("Couldn't allocate buffer for requested mode"); |
171 | return(NULL); |
172 | } |
173 | |
174 | /* printf("Setting mode %dx%d\n", width, height); */ |
175 | |
176 | SDL_memset(this->hidden->buffer, 0, width * height * (bpp / 8)); |
177 | |
178 | /* Allocate the new pixel format for the screen */ |
179 | if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) { |
180 | SDL_free(this->hidden->buffer); |
181 | this->hidden->buffer = NULL; |
182 | SDL_SetError("Couldn't allocate new pixel format for requested mode"); |
183 | return(NULL); |
184 | } |
185 | |
186 | /* Set up the new mode framebuffer */ |
187 | current->flags = flags & SDL_FULLSCREEN; |
188 | this->hidden->w = current->w = width; |
189 | this->hidden->h = current->h = height; |
190 | current->pitch = current->w * (bpp / 8); |
191 | current->pixels = this->hidden->buffer; |
192 | |
193 | /* We're done */ |
194 | return(current); |
195 | } |
196 | |
197 | /* We don't actually allow hardware surfaces other than the main one */ |
198 | static int DUMMY_AllocHWSurface(_THIS, SDL_Surface *surface) |
199 | { |
200 | return(-1); |
201 | } |
202 | static void DUMMY_FreeHWSurface(_THIS, SDL_Surface *surface) |
203 | { |
204 | return; |
205 | } |
206 | |
207 | /* We need to wait for vertical retrace on page flipped displays */ |
208 | static int DUMMY_LockHWSurface(_THIS, SDL_Surface *surface) |
209 | { |
210 | return(0); |
211 | } |
212 | |
213 | static void DUMMY_UnlockHWSurface(_THIS, SDL_Surface *surface) |
214 | { |
215 | return; |
216 | } |
217 | |
218 | static void DUMMY_UpdateRects(_THIS, int numrects, SDL_Rect *rects) |
219 | { |
220 | /* do nothing. */ |
221 | } |
222 | |
223 | int DUMMY_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) |
224 | { |
225 | /* do nothing of note. */ |
226 | return(1); |
227 | } |
228 | |
229 | /* Note: If we are terminated, this could be called in the middle of |
230 | another SDL video routine -- notably UpdateRects. |
231 | */ |
232 | void DUMMY_VideoQuit(_THIS) |
233 | { |
234 | if (this->screen->pixels != NULL) |
235 | { |
236 | SDL_free(this->screen->pixels); |
237 | this->screen->pixels = NULL; |
238 | } |
239 | } |