|
1 /* |
|
2 SDL - Simple DirectMedia Layer |
|
3 Copyright (C) 1997-2006 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 #include <sys/time.h> |
|
25 #include <sys/mman.h> |
|
26 #include <sys/ioctl.h> |
|
27 #include <dev/wscons/wsdisplay_usl_io.h> |
|
28 #include <fcntl.h> |
|
29 #include <unistd.h> |
|
30 #include <errno.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 |
|
38 #include "SDL_wsconsvideo.h" |
|
39 #include "SDL_wsconsevents_c.h" |
|
40 #include "SDL_wsconsmouse_c.h" |
|
41 |
|
42 #define WSCONSVID_DRIVER_NAME "wscons" |
|
43 enum { |
|
44 WSCONS_ROTATE_NONE = 0, |
|
45 WSCONS_ROTATE_CCW = 90, |
|
46 WSCONS_ROTATE_UD = 180, |
|
47 WSCONS_ROTATE_CW = 270 |
|
48 }; |
|
49 |
|
50 #define min(a,b) ((a)<(b)?(a):(b)) |
|
51 |
|
52 /* Initialization/Query functions */ |
|
53 static int WSCONS_VideoInit(_THIS, SDL_PixelFormat *vformat); |
|
54 static SDL_Rect **WSCONS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); |
|
55 static SDL_Surface *WSCONS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); |
|
56 static int WSCONS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); |
|
57 static void WSCONS_VideoQuit(_THIS); |
|
58 |
|
59 /* Hardware surface functions */ |
|
60 static int WSCONS_AllocHWSurface(_THIS, SDL_Surface *surface); |
|
61 static int WSCONS_LockHWSurface(_THIS, SDL_Surface *surface); |
|
62 static void WSCONS_UnlockHWSurface(_THIS, SDL_Surface *surface); |
|
63 static void WSCONS_FreeHWSurface(_THIS, SDL_Surface *surface); |
|
64 |
|
65 /* etc. */ |
|
66 static WSCONS_bitBlit WSCONS_blit16; |
|
67 static WSCONS_bitBlit WSCONS_blit16blocked; |
|
68 static void WSCONS_UpdateRects(_THIS, int numrects, SDL_Rect *rects); |
|
69 |
|
70 void WSCONS_ReportError(char *fmt, ...) |
|
71 { |
|
72 char message[200]; |
|
73 va_list vaArgs; |
|
74 |
|
75 message[199] = '\0'; |
|
76 |
|
77 va_start(vaArgs, fmt); |
|
78 vsnprintf(message, 199, fmt, vaArgs); |
|
79 va_end(vaArgs); |
|
80 |
|
81 SDL_SetError(message); |
|
82 fprintf(stderr, "WSCONS error: %s\n", message); |
|
83 } |
|
84 |
|
85 /* WSCONS driver bootstrap functions */ |
|
86 |
|
87 static int WSCONS_Available(void) |
|
88 { |
|
89 return 1; |
|
90 } |
|
91 |
|
92 static void WSCONS_DeleteDevice(SDL_VideoDevice *device) |
|
93 { |
|
94 SDL_free(device->hidden); |
|
95 SDL_free(device); |
|
96 } |
|
97 |
|
98 static SDL_VideoDevice *WSCONS_CreateDevice(int devindex) |
|
99 { |
|
100 SDL_VideoDevice *device; |
|
101 |
|
102 /* Initialize all variables that we clean on shutdown */ |
|
103 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); |
|
104 if (device == NULL) { |
|
105 SDL_OutOfMemory(); |
|
106 return 0; |
|
107 } |
|
108 SDL_memset(device, 0, (sizeof *device)); |
|
109 device->hidden = |
|
110 (struct SDL_PrivateVideoData *)SDL_malloc((sizeof *device->hidden)); |
|
111 if (device->hidden == NULL) { |
|
112 SDL_OutOfMemory(); |
|
113 SDL_free(device); |
|
114 return(0); |
|
115 } |
|
116 SDL_memset(device->hidden, 0, (sizeof *device->hidden)); |
|
117 device->hidden->fd = -1; |
|
118 |
|
119 /* Set the function pointers */ |
|
120 device->VideoInit = WSCONS_VideoInit; |
|
121 device->ListModes = WSCONS_ListModes; |
|
122 device->SetVideoMode = WSCONS_SetVideoMode; |
|
123 device->SetColors = WSCONS_SetColors; |
|
124 device->UpdateRects = WSCONS_UpdateRects; |
|
125 device->VideoQuit = WSCONS_VideoQuit; |
|
126 device->AllocHWSurface = WSCONS_AllocHWSurface; |
|
127 device->LockHWSurface = WSCONS_LockHWSurface; |
|
128 device->UnlockHWSurface = WSCONS_UnlockHWSurface; |
|
129 device->FreeHWSurface = WSCONS_FreeHWSurface; |
|
130 device->InitOSKeymap = WSCONS_InitOSKeymap; |
|
131 device->PumpEvents = WSCONS_PumpEvents; |
|
132 device->free = WSCONS_DeleteDevice; |
|
133 |
|
134 return device; |
|
135 } |
|
136 |
|
137 VideoBootStrap WSCONS_bootstrap = { |
|
138 WSCONSVID_DRIVER_NAME, |
|
139 "SDL wscons video driver", |
|
140 WSCONS_Available, |
|
141 WSCONS_CreateDevice |
|
142 }; |
|
143 |
|
144 #define WSCONSDEV_FORMAT "/dev/ttyC%01x" |
|
145 |
|
146 int WSCONS_VideoInit(_THIS, SDL_PixelFormat *vformat) |
|
147 { |
|
148 char devnamebuf[30]; |
|
149 char *devname; |
|
150 char *rotation; |
|
151 int wstype; |
|
152 int wsmode = WSDISPLAYIO_MODE_DUMBFB; |
|
153 size_t len, mapsize; |
|
154 int pagemask; |
|
155 int width, height; |
|
156 |
|
157 devname = SDL_getenv("SDL_WSCONSDEV"); |
|
158 if (devname == NULL) { |
|
159 int activeVT; |
|
160 if (ioctl(STDIN_FILENO, VT_GETACTIVE, &activeVT) == -1) { |
|
161 WSCONS_ReportError("Unable to determine active terminal: %s", |
|
162 strerror(errno)); |
|
163 return -1; |
|
164 } |
|
165 SDL_snprintf(devnamebuf, sizeof(devnamebuf), WSCONSDEV_FORMAT, activeVT - 1); |
|
166 devname = devnamebuf; |
|
167 } |
|
168 |
|
169 private->fd = open(devname, O_RDWR | O_NONBLOCK, 0); |
|
170 if (private->fd == -1) { |
|
171 WSCONS_ReportError("open %s: %s", devname, strerror(errno)); |
|
172 return -1; |
|
173 } |
|
174 if (ioctl(private->fd, WSDISPLAYIO_GINFO, &private->info) == -1) { |
|
175 WSCONS_ReportError("ioctl WSDISPLAY_GINFO: %s", strerror(errno)); |
|
176 return -1; |
|
177 } |
|
178 if (ioctl(private->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) { |
|
179 WSCONS_ReportError("ioctl WSDISPLAY_GTYPE: %s", strerror(errno)); |
|
180 return -1; |
|
181 } |
|
182 if (ioctl(private->fd, WSDISPLAYIO_LINEBYTES, &private->physlinebytes) == -1) { |
|
183 WSCONS_ReportError("ioctl WSDISPLAYIO_LINEBYTES: %s", strerror(errno)); |
|
184 return -1; |
|
185 } |
|
186 if (private->info.depth > 8) { |
|
187 if (wstype == WSDISPLAY_TYPE_SUN24 || |
|
188 wstype == WSDISPLAY_TYPE_SUNCG12 || |
|
189 wstype == WSDISPLAY_TYPE_SUNCG14 || |
|
190 wstype == WSDISPLAY_TYPE_SUNTCX || |
|
191 wstype == WSDISPLAY_TYPE_SUNFFB) { |
|
192 private->redMask = 0x0000ff; |
|
193 private->greenMask = 0x00ff00; |
|
194 private->blueMask = 0xff0000; |
|
195 #ifdef WSDISPLAY_TYPE_PXALCD |
|
196 } else if (wstype == WSDISPLAY_TYPE_PXALCD) { |
|
197 private->redMask = 0x1f << 11; |
|
198 private->greenMask = 0x3f << 5; |
|
199 private->blueMask = 0x1f; |
|
200 #endif |
|
201 } else { |
|
202 WSCONS_ReportError("Unknown video hardware"); |
|
203 return -1; |
|
204 } |
|
205 } else { |
|
206 WSCONS_ReportError("Displays with 8 bpp or less are not supported"); |
|
207 return -1; |
|
208 } |
|
209 |
|
210 private->rotate = WSCONS_ROTATE_NONE; |
|
211 rotation = SDL_getenv("SDL_VIDEO_WSCONS_ROTATION"); |
|
212 if (rotation != NULL) { |
|
213 if (SDL_strlen(rotation) == 0) { |
|
214 private->shadowFB = 0; |
|
215 private->rotate = WSCONS_ROTATE_NONE; |
|
216 printf("Not rotating, no shadow\n"); |
|
217 } else if (!SDL_strcmp(rotation, "NONE")) { |
|
218 private->shadowFB = 1; |
|
219 private->rotate = WSCONS_ROTATE_NONE; |
|
220 printf("Not rotating, but still using shadow\n"); |
|
221 } else if (!SDL_strcmp(rotation, "CW")) { |
|
222 private->shadowFB = 1; |
|
223 private->rotate = WSCONS_ROTATE_CW; |
|
224 printf("Rotating screen clockwise\n"); |
|
225 } else if (!SDL_strcmp(rotation, "CCW")) { |
|
226 private->shadowFB = 1; |
|
227 private->rotate = WSCONS_ROTATE_CCW; |
|
228 printf("Rotating screen counter clockwise\n"); |
|
229 } else if (!SDL_strcmp(rotation, "UD")) { |
|
230 private->shadowFB = 1; |
|
231 private->rotate = WSCONS_ROTATE_UD; |
|
232 printf("Rotating screen upside down\n"); |
|
233 } else { |
|
234 WSCONS_ReportError("\"%s\" is not a valid value for " |
|
235 "SDL_VIDEO_WSCONS_ROTATION", rotation); |
|
236 return -1; |
|
237 } |
|
238 } |
|
239 |
|
240 switch (private->info.depth) { |
|
241 case 1: |
|
242 case 4: |
|
243 case 8: |
|
244 len = private->physlinebytes * private->info.height; |
|
245 break; |
|
246 case 16: |
|
247 if (private->physlinebytes == private->info.width) { |
|
248 len = private->info.width * private->info.height * sizeof(short); |
|
249 } else { |
|
250 len = private->physlinebytes * private->info.height; |
|
251 } |
|
252 if (private->rotate == WSCONS_ROTATE_NONE || |
|
253 private->rotate == WSCONS_ROTATE_UD) { |
|
254 private->blitFunc = WSCONS_blit16; |
|
255 } else { |
|
256 private->blitFunc = WSCONS_blit16blocked; |
|
257 } |
|
258 break; |
|
259 case 32: |
|
260 if (private->physlinebytes == private->info.width) { |
|
261 len = private->info.width * private->info.height * sizeof(int); |
|
262 } else { |
|
263 len = private->physlinebytes * private->info.height; |
|
264 } |
|
265 break; |
|
266 default: |
|
267 WSCONS_ReportError("unsupported depth %d", private->info.depth); |
|
268 return -1; |
|
269 } |
|
270 |
|
271 if (private->shadowFB && private->blitFunc == NULL) { |
|
272 WSCONS_ReportError("Using software buffer, but no blitter function is " |
|
273 "available for this %d bpp.", private->info.depth); |
|
274 return -1; |
|
275 } |
|
276 |
|
277 if (ioctl(private->fd, WSDISPLAYIO_SMODE, &wsmode) == -1) { |
|
278 WSCONS_ReportError("ioctl SMODE"); |
|
279 return -1; |
|
280 } |
|
281 |
|
282 pagemask = getpagesize() - 1; |
|
283 mapsize = ((int)len + pagemask) & ~pagemask; |
|
284 private->physmem = (Uint8 *)mmap(NULL, mapsize, |
|
285 PROT_READ | PROT_WRITE, MAP_SHARED, |
|
286 private->fd, (off_t)0); |
|
287 if (private->physmem == (Uint8 *)MAP_FAILED) { |
|
288 private->physmem = NULL; |
|
289 WSCONS_ReportError("mmap: %s", strerror(errno)); |
|
290 return -1; |
|
291 } |
|
292 private->fbmem_len = len; |
|
293 |
|
294 if (private->rotate == WSCONS_ROTATE_CW || |
|
295 private->rotate == WSCONS_ROTATE_CCW) { |
|
296 width = private->info.height; |
|
297 height = private->info.width; |
|
298 } else { |
|
299 width = private->info.width; |
|
300 height = private->info.height; |
|
301 } |
|
302 |
|
303 this->info.current_w = width; |
|
304 this->info.current_h = height; |
|
305 |
|
306 if (private->shadowFB) { |
|
307 private->shadowmem = (Uint8 *)SDL_malloc(len); |
|
308 if (private->shadowmem == NULL) { |
|
309 WSCONS_ReportError("No memory for shadow"); |
|
310 return -1; |
|
311 } |
|
312 private->fbstart = private->shadowmem; |
|
313 private->fblinebytes = width * ((private->info.depth + 7) / 8); |
|
314 } else { |
|
315 private->fbstart = private->physmem; |
|
316 private->fblinebytes = private->physlinebytes; |
|
317 } |
|
318 |
|
319 private->SDL_modelist[0] = (SDL_Rect *)SDL_malloc(sizeof(SDL_Rect)); |
|
320 private->SDL_modelist[0]->w = width; |
|
321 private->SDL_modelist[0]->h = height; |
|
322 |
|
323 vformat->BitsPerPixel = private->info.depth; |
|
324 vformat->BytesPerPixel = private->info.depth / 8; |
|
325 |
|
326 if (WSCONS_InitKeyboard(this) == -1) { |
|
327 return -1; |
|
328 } |
|
329 |
|
330 return 0; |
|
331 } |
|
332 |
|
333 SDL_Rect **WSCONS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) |
|
334 { |
|
335 if (format->BitsPerPixel == private->info.depth) { |
|
336 return private->SDL_modelist; |
|
337 } else { |
|
338 return NULL; |
|
339 } |
|
340 } |
|
341 |
|
342 SDL_Surface *WSCONS_SetVideoMode(_THIS, SDL_Surface *current, |
|
343 int width, int height, int bpp, Uint32 flags) |
|
344 { |
|
345 if (width != private->SDL_modelist[0]->w || |
|
346 height != private->SDL_modelist[0]->h) { |
|
347 WSCONS_ReportError("Requested video mode %dx%d not supported.", |
|
348 width, height); |
|
349 return NULL; |
|
350 } |
|
351 if (bpp != private->info.depth) { |
|
352 WSCONS_ReportError("Requested video depth %d bpp not supported.", bpp); |
|
353 return NULL; |
|
354 } |
|
355 |
|
356 if (!SDL_ReallocFormat(current, |
|
357 bpp, |
|
358 private->redMask, |
|
359 private->greenMask, |
|
360 private->blueMask, |
|
361 0)) { |
|
362 WSCONS_ReportError("Couldn't allocate new pixel format"); |
|
363 return NULL; |
|
364 } |
|
365 |
|
366 current->flags &= SDL_FULLSCREEN; |
|
367 if (private->shadowFB) { |
|
368 current->flags |= SDL_SWSURFACE; |
|
369 } else { |
|
370 current->flags |= SDL_HWSURFACE; |
|
371 } |
|
372 current->w = width; |
|
373 current->h = height; |
|
374 current->pitch = private->fblinebytes; |
|
375 current->pixels = private->fbstart; |
|
376 |
|
377 SDL_memset(private->fbstart, 0, private->fbmem_len); |
|
378 |
|
379 return current; |
|
380 } |
|
381 |
|
382 static int WSCONS_AllocHWSurface(_THIS, SDL_Surface *surface) |
|
383 { |
|
384 return -1; |
|
385 } |
|
386 static void WSCONS_FreeHWSurface(_THIS, SDL_Surface *surface) |
|
387 { |
|
388 } |
|
389 |
|
390 static int WSCONS_LockHWSurface(_THIS, SDL_Surface *surface) |
|
391 { |
|
392 return 0; |
|
393 } |
|
394 |
|
395 static void WSCONS_UnlockHWSurface(_THIS, SDL_Surface *surface) |
|
396 { |
|
397 } |
|
398 |
|
399 static void WSCONS_blit16(Uint8 *byte_src_pos, |
|
400 int srcRightDelta, |
|
401 int srcDownDelta, |
|
402 Uint8 *byte_dst_pos, |
|
403 int dst_linebytes, |
|
404 int width, |
|
405 int height) |
|
406 { |
|
407 int w; |
|
408 Uint16 *src_pos = (Uint16 *)byte_src_pos; |
|
409 Uint16 *dst_pos = (Uint16 *)byte_dst_pos; |
|
410 |
|
411 while (height) { |
|
412 Uint16 *src = src_pos; |
|
413 Uint16 *dst = dst_pos; |
|
414 for (w = width; w != 0; w--) { |
|
415 *dst = *src; |
|
416 src += srcRightDelta; |
|
417 dst++; |
|
418 } |
|
419 dst_pos = (Uint16 *)((Uint8 *)dst_pos + dst_linebytes); |
|
420 src_pos += srcDownDelta; |
|
421 height--; |
|
422 } |
|
423 } |
|
424 |
|
425 #define BLOCKSIZE_W 32 |
|
426 #define BLOCKSIZE_H 32 |
|
427 |
|
428 static void WSCONS_blit16blocked(Uint8 *byte_src_pos, |
|
429 int srcRightDelta, |
|
430 int srcDownDelta, |
|
431 Uint8 *byte_dst_pos, |
|
432 int dst_linebytes, |
|
433 int width, |
|
434 int height) |
|
435 { |
|
436 int w; |
|
437 Uint16 *src_pos = (Uint16 *)byte_src_pos; |
|
438 Uint16 *dst_pos = (Uint16 *)byte_dst_pos; |
|
439 |
|
440 while (height > 0) { |
|
441 Uint16 *src = src_pos; |
|
442 Uint16 *dst = dst_pos; |
|
443 for (w = width; w > 0; w -= BLOCKSIZE_W) { |
|
444 WSCONS_blit16((Uint8 *)src, |
|
445 srcRightDelta, |
|
446 srcDownDelta, |
|
447 (Uint8 *)dst, |
|
448 dst_linebytes, |
|
449 min(w, BLOCKSIZE_W), |
|
450 min(height, BLOCKSIZE_H)); |
|
451 src += srcRightDelta * BLOCKSIZE_W; |
|
452 dst += BLOCKSIZE_W; |
|
453 } |
|
454 dst_pos = (Uint16 *)((Uint8 *)dst_pos + dst_linebytes * BLOCKSIZE_H); |
|
455 src_pos += srcDownDelta * BLOCKSIZE_H; |
|
456 height -= BLOCKSIZE_H; |
|
457 } |
|
458 } |
|
459 |
|
460 static void WSCONS_UpdateRects(_THIS, int numrects, SDL_Rect *rects) |
|
461 { |
|
462 int width = private->SDL_modelist[0]->w; |
|
463 int height = private->SDL_modelist[0]->h; |
|
464 int bytesPerPixel = (private->info.depth + 7) / 8; |
|
465 int i; |
|
466 |
|
467 if (!private->shadowFB) { |
|
468 return; |
|
469 } |
|
470 |
|
471 if (private->info.depth != 16) { |
|
472 WSCONS_ReportError("Shadow copy only implemented for 16 bpp"); |
|
473 return; |
|
474 } |
|
475 |
|
476 for (i = 0; i < numrects; i++) { |
|
477 int x1, y1, x2, y2; |
|
478 int scr_x1, scr_y1, scr_x2, scr_y2; |
|
479 int sha_x1, sha_y1; |
|
480 int shadowRightDelta; /* Address change when moving right in dest */ |
|
481 int shadowDownDelta; /* Address change when moving down in dest */ |
|
482 Uint8 *src_start; |
|
483 Uint8 *dst_start; |
|
484 |
|
485 x1 = rects[i].x; |
|
486 y1 = rects[i].y; |
|
487 x2 = x1 + rects[i].w; |
|
488 y2 = y1 + rects[i].h; |
|
489 |
|
490 if (x1 < 0) { |
|
491 x1 = 0; |
|
492 } else if (x1 > width) { |
|
493 x1 = width; |
|
494 } |
|
495 if (x2 < 0) { |
|
496 x2 = 0; |
|
497 } else if (x2 > width) { |
|
498 x2 = width; |
|
499 } |
|
500 if (y1 < 0) { |
|
501 y1 = 0; |
|
502 } else if (y1 > height) { |
|
503 y1 = height; |
|
504 } |
|
505 if (y2 < 0) { |
|
506 y2 = 0; |
|
507 } else if (y2 > height) { |
|
508 y2 = height; |
|
509 } |
|
510 if (x2 <= x1 || y2 <= y1) { |
|
511 continue; |
|
512 } |
|
513 |
|
514 switch (private->rotate) { |
|
515 case WSCONS_ROTATE_NONE: |
|
516 sha_x1 = scr_x1 = x1; |
|
517 sha_y1 = scr_y1 = y1; |
|
518 scr_x2 = x2; |
|
519 scr_y2 = y2; |
|
520 shadowRightDelta = 1; |
|
521 shadowDownDelta = width; |
|
522 break; |
|
523 case WSCONS_ROTATE_CCW: |
|
524 scr_x1 = y1; |
|
525 scr_y1 = width - x2; |
|
526 scr_x2 = y2; |
|
527 scr_y2 = width - x1; |
|
528 sha_x1 = x2 - 1; |
|
529 sha_y1 = y1; |
|
530 shadowRightDelta = width; |
|
531 shadowDownDelta = -1; |
|
532 break; |
|
533 case WSCONS_ROTATE_UD: |
|
534 scr_x1 = width - x2; |
|
535 scr_y1 = height - y2; |
|
536 scr_x2 = width - x1; |
|
537 scr_y2 = height - y1; |
|
538 sha_x1 = x2 - 1; |
|
539 sha_y1 = y2 - 1; |
|
540 shadowRightDelta = -1; |
|
541 shadowDownDelta = -width; |
|
542 break; |
|
543 case WSCONS_ROTATE_CW: |
|
544 scr_x1 = height - y2; |
|
545 scr_y1 = x1; |
|
546 scr_x2 = height - y1; |
|
547 scr_y2 = x2; |
|
548 sha_x1 = x1; |
|
549 sha_y1 = y2 - 1; |
|
550 shadowRightDelta = -width; |
|
551 shadowDownDelta = 1; |
|
552 break; |
|
553 default: |
|
554 WSCONS_ReportError("Unknown rotation"); |
|
555 return; |
|
556 } |
|
557 |
|
558 src_start = private->shadowmem + (sha_y1 * width + sha_x1) * bytesPerPixel; |
|
559 dst_start = private->physmem + scr_y1 * private->physlinebytes + |
|
560 scr_x1 * bytesPerPixel; |
|
561 |
|
562 private->blitFunc(src_start, |
|
563 shadowRightDelta, |
|
564 shadowDownDelta, |
|
565 dst_start, |
|
566 private->physlinebytes, |
|
567 scr_x2 - scr_x1, |
|
568 scr_y2 - scr_y1); |
|
569 } |
|
570 } |
|
571 |
|
572 int WSCONS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) |
|
573 { |
|
574 return 0; |
|
575 } |
|
576 |
|
577 /* |
|
578 * Note: If we are terminated, this could be called in the middle of |
|
579 * another SDL video routine -- notably UpdateRects. |
|
580 */ |
|
581 void WSCONS_VideoQuit(_THIS) |
|
582 { |
|
583 int mode = WSDISPLAYIO_MODE_EMUL; |
|
584 |
|
585 if (private->shadowmem != NULL) { |
|
586 SDL_free(private->shadowmem); |
|
587 private->shadowmem = NULL; |
|
588 } |
|
589 private->fbstart = NULL; |
|
590 if (this->screen != NULL) { |
|
591 this->screen->pixels = NULL; |
|
592 } |
|
593 |
|
594 if (private->SDL_modelist[0] != NULL) { |
|
595 SDL_free(private->SDL_modelist[0]); |
|
596 private->SDL_modelist[0] = NULL; |
|
597 } |
|
598 |
|
599 if (ioctl(private->fd, WSDISPLAYIO_SMODE, &mode) == -1) { |
|
600 WSCONS_ReportError("ioctl SMODE"); |
|
601 } |
|
602 |
|
603 WSCONS_ReleaseKeyboard(this); |
|
604 |
|
605 if (private->fd != -1) { |
|
606 close(private->fd); |
|
607 private->fd = -1; |
|
608 } |
|
609 } |