|
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 /* Framebuffer console based SDL video driver implementation. |
|
25 */ |
|
26 |
|
27 #include <fcntl.h> |
|
28 #include <unistd.h> |
|
29 #include <sys/ioctl.h> |
|
30 #include <sys/mman.h> |
|
31 |
|
32 #include "SDL_video.h" |
|
33 #include "SDL_mouse.h" |
|
34 #include "../SDL_sysvideo.h" |
|
35 #include "../SDL_pixels_c.h" |
|
36 #include "../../events/SDL_events_c.h" |
|
37 #include "../SDL_cursor_c.h" |
|
38 #include "SDL_gsvideo.h" |
|
39 #include "SDL_gsmouse_c.h" |
|
40 #include "SDL_gsevents_c.h" |
|
41 #include "SDL_gsyuv_c.h" |
|
42 |
|
43 |
|
44 /* Initialization/Query functions */ |
|
45 static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat); |
|
46 static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); |
|
47 static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); |
|
48 static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); |
|
49 static void GS_VideoQuit(_THIS); |
|
50 |
|
51 /* Hardware surface functions */ |
|
52 static int GS_AllocHWSurface(_THIS, SDL_Surface *surface); |
|
53 static int GS_LockHWSurface(_THIS, SDL_Surface *surface); |
|
54 static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface); |
|
55 static void GS_FreeHWSurface(_THIS, SDL_Surface *surface); |
|
56 |
|
57 /* GS driver bootstrap functions */ |
|
58 |
|
59 static int GS_Available(void) |
|
60 { |
|
61 int console, memory; |
|
62 |
|
63 console = open(PS2_DEV_GS, O_RDWR, 0); |
|
64 if ( console >= 0 ) { |
|
65 close(console); |
|
66 } |
|
67 memory = open(PS2_DEV_MEM, O_RDWR, 0); |
|
68 if ( memory >= 0 ) { |
|
69 close(memory); |
|
70 } |
|
71 return((console >= 0) && (memory >= 0)); |
|
72 } |
|
73 |
|
74 static void GS_DeleteDevice(SDL_VideoDevice *device) |
|
75 { |
|
76 SDL_free(device->hidden); |
|
77 SDL_free(device); |
|
78 } |
|
79 |
|
80 static SDL_VideoDevice *GS_CreateDevice(int devindex) |
|
81 { |
|
82 SDL_VideoDevice *this; |
|
83 |
|
84 /* Initialize all variables that we clean on shutdown */ |
|
85 this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); |
|
86 if ( this ) { |
|
87 SDL_memset(this, 0, (sizeof *this)); |
|
88 this->hidden = (struct SDL_PrivateVideoData *) |
|
89 SDL_malloc((sizeof *this->hidden)); |
|
90 } |
|
91 if ( (this == NULL) || (this->hidden == NULL) ) { |
|
92 SDL_OutOfMemory(); |
|
93 if ( this ) { |
|
94 SDL_free(this); |
|
95 } |
|
96 return(0); |
|
97 } |
|
98 SDL_memset(this->hidden, 0, (sizeof *this->hidden)); |
|
99 mouse_fd = -1; |
|
100 keyboard_fd = -1; |
|
101 |
|
102 /* Set the function pointers */ |
|
103 this->VideoInit = GS_VideoInit; |
|
104 this->ListModes = GS_ListModes; |
|
105 this->SetVideoMode = GS_SetVideoMode; |
|
106 this->CreateYUVOverlay = GS_CreateYUVOverlay; |
|
107 this->SetColors = GS_SetColors; |
|
108 this->UpdateRects = NULL; |
|
109 this->VideoQuit = GS_VideoQuit; |
|
110 this->AllocHWSurface = GS_AllocHWSurface; |
|
111 this->CheckHWBlit = NULL; |
|
112 this->FillHWRect = NULL; |
|
113 this->SetHWColorKey = NULL; |
|
114 this->SetHWAlpha = NULL; |
|
115 this->LockHWSurface = GS_LockHWSurface; |
|
116 this->UnlockHWSurface = GS_UnlockHWSurface; |
|
117 this->FlipHWSurface = NULL; |
|
118 this->FreeHWSurface = GS_FreeHWSurface; |
|
119 this->SetIcon = NULL; |
|
120 this->SetCaption = NULL; |
|
121 this->GetWMInfo = NULL; |
|
122 this->FreeWMCursor = GS_FreeWMCursor; |
|
123 this->CreateWMCursor = GS_CreateWMCursor; |
|
124 this->ShowWMCursor = GS_ShowWMCursor; |
|
125 this->MoveWMCursor = GS_MoveWMCursor; |
|
126 this->InitOSKeymap = GS_InitOSKeymap; |
|
127 this->PumpEvents = GS_PumpEvents; |
|
128 |
|
129 this->free = GS_DeleteDevice; |
|
130 |
|
131 return this; |
|
132 } |
|
133 |
|
134 VideoBootStrap PS2GS_bootstrap = { |
|
135 "ps2gs", "PlayStation 2 Graphics Synthesizer", |
|
136 GS_Available, GS_CreateDevice |
|
137 }; |
|
138 |
|
139 /* These are the pixel formats for the 32, 24, and 16 bit video modes */ |
|
140 static struct { |
|
141 int bpp; |
|
142 Uint32 r; |
|
143 Uint32 g; |
|
144 Uint32 b; |
|
145 } GS_pixelmasks[] = { |
|
146 { 32, 0x000000FF, /* RGB little-endian */ |
|
147 0x0000FF00, |
|
148 0x00FF0000 }, |
|
149 { 24, 0x000000FF, /* RGB little-endian */ |
|
150 0x0000FF00, |
|
151 0x00FF0000 }, |
|
152 { 16, 0x0000001f, /* RGB little-endian */ |
|
153 0x000003e0, |
|
154 0x00007c00 }, |
|
155 }; |
|
156 /* This is a mapping from SDL bytes-per-pixel to GS pixel format */ |
|
157 static int GS_formatmap[] = { |
|
158 -1, /* 0 bpp, not a legal value */ |
|
159 -1, /* 8 bpp, not supported (yet?) */ |
|
160 PS2_GS_PSMCT16, /* 16 bpp */ |
|
161 PS2_GS_PSMCT24, /* 24 bpp */ |
|
162 PS2_GS_PSMCT32 /* 32 bpp */ |
|
163 }; |
|
164 |
|
165 static unsigned long long head_tags[] __attribute__((aligned(16))) = { |
|
166 4 | (1LL << 60), /* GIFtag */ |
|
167 0x0e, /* A+D */ |
|
168 0, /* 2 */ |
|
169 PS2_GS_BITBLTBUF, |
|
170 0, /* 4 */ |
|
171 PS2_GS_TRXPOS, |
|
172 0, /* 6 */ |
|
173 PS2_GS_TRXREG, |
|
174 0, /* 8 */ |
|
175 PS2_GS_TRXDIR |
|
176 }; |
|
177 |
|
178 #define MAXIMG (32767 * 16) |
|
179 #define MAXTAGS 8 |
|
180 |
|
181 static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size, |
|
182 unsigned long long *hm, |
|
183 unsigned long long *im) |
|
184 { |
|
185 struct ps2_plist plist; |
|
186 struct ps2_packet packet[1 + MAXTAGS * 2]; |
|
187 int isize; |
|
188 int pnum, it, eop; |
|
189 char *data; |
|
190 |
|
191 /* initialize the variables */ |
|
192 data = (char *)image->ptr; |
|
193 pnum = it = eop = 0; |
|
194 plist.packet = packet; |
|
195 |
|
196 /* make BITBLT packet */ |
|
197 packet[pnum].ptr = hm; |
|
198 packet[pnum].len = sizeof(head_tags); |
|
199 pnum++; |
|
200 hm[2] = ((unsigned long long)image->fbp << 32) | |
|
201 ((unsigned long long)image->fbw << 48) | |
|
202 ((unsigned long long)image->psm << 56); |
|
203 hm[4] = ((unsigned long long)image->x << 32) | |
|
204 ((unsigned long long)image->y << 48); |
|
205 hm[6] = (unsigned long long)image->w | |
|
206 ((unsigned long long)image->h << 32); |
|
207 |
|
208 /* make image mode tags */ |
|
209 while (!eop) { |
|
210 isize = size > MAXIMG ? MAXIMG : size; |
|
211 size -= isize; |
|
212 eop = (size == 0); |
|
213 |
|
214 packet[pnum].ptr = &im[it]; |
|
215 packet[pnum].len = sizeof(unsigned long long) * 2; |
|
216 pnum++; |
|
217 im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58); |
|
218 im[it++] = 0; |
|
219 |
|
220 packet[pnum].ptr = (void *)data; |
|
221 packet[pnum].len = isize; |
|
222 pnum++; |
|
223 data += isize; |
|
224 } |
|
225 plist.num = pnum; |
|
226 |
|
227 return ioctl(fd, PS2IOC_SENDL, &plist); |
|
228 } |
|
229 |
|
230 static unsigned long long tex_tags[] __attribute__((aligned(16))) = { |
|
231 3 | (1LL << 60), /* GIFtag */ |
|
232 0x0e, /* A+D */ |
|
233 0, /* 2 */ |
|
234 PS2_GS_TEX0_1, |
|
235 (1 << 5) + (1 << 6), |
|
236 PS2_GS_TEX1_1, |
|
237 0, |
|
238 PS2_GS_TEXFLUSH |
|
239 }; |
|
240 static unsigned long long scale_tags[] __attribute__((aligned(16))) = { |
|
241 5 | (1LL << 60), /* GIFtag */ |
|
242 0x0e, /* A+D */ |
|
243 6 + (1 << 4) + (1 << 8), |
|
244 PS2_GS_PRIM, |
|
245 ((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16), |
|
246 PS2_GS_UV, |
|
247 ((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16), |
|
248 PS2_GS_XYZ2, |
|
249 0, /* 8 */ |
|
250 PS2_GS_UV, |
|
251 0, /* 10 */ |
|
252 PS2_GS_XYZ2 |
|
253 }; |
|
254 |
|
255 |
|
256 int scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm) |
|
257 { |
|
258 struct ps2_plist plist; |
|
259 struct ps2_packet packet[2]; |
|
260 |
|
261 /* initialize the variables */ |
|
262 plist.num = 2; |
|
263 plist.packet = packet; |
|
264 |
|
265 packet[0].ptr = tm; |
|
266 packet[0].len = sizeof(tex_tags); |
|
267 packet[1].ptr = sm; |
|
268 packet[1].len = sizeof(scale_tags); |
|
269 |
|
270 return ioctl(fd, PS2IOC_SENDL, &plist); |
|
271 } |
|
272 |
|
273 static int power_of_2(int value) |
|
274 { |
|
275 int shift; |
|
276 |
|
277 for ( shift = 0; (1<<shift) < value; ++shift ) { |
|
278 /* Keep looking */ ; |
|
279 } |
|
280 return(shift); |
|
281 } |
|
282 |
|
283 static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat) |
|
284 { |
|
285 struct ps2_screeninfo vinfo; |
|
286 |
|
287 /* Initialize the library */ |
|
288 console_fd = open(PS2_DEV_GS, O_RDWR, 0); |
|
289 if ( console_fd < 0 ) { |
|
290 SDL_SetError("Unable to open %s", PS2_DEV_GS); |
|
291 return(-1); |
|
292 } |
|
293 memory_fd = open(PS2_DEV_MEM, O_RDWR, 0); |
|
294 if ( memory_fd < 0 ) { |
|
295 close(console_fd); |
|
296 console_fd = -1; |
|
297 SDL_SetError("Unable to open %s", PS2_DEV_MEM); |
|
298 return(-1); |
|
299 } |
|
300 |
|
301 if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) { |
|
302 close(memory_fd); |
|
303 close(console_fd); |
|
304 console_fd = -1; |
|
305 SDL_SetError("Couldn't get console pixel format"); |
|
306 return(-1); |
|
307 } |
|
308 |
|
309 /* Determine the current screen size */ |
|
310 this->info.current_w = vinfo.w; |
|
311 this->info.current_h = vinfo.h; |
|
312 |
|
313 /* Determine the current screen depth */ |
|
314 switch (vinfo.psm) { |
|
315 /* Supported pixel formats */ |
|
316 case PS2_GS_PSMCT32: |
|
317 case PS2_GS_PSMCT24: |
|
318 case PS2_GS_PSMCT16: |
|
319 break; |
|
320 default: |
|
321 GS_VideoQuit(this); |
|
322 SDL_SetError("Unknown console pixel format: %d", vinfo.psm); |
|
323 return(-1); |
|
324 } |
|
325 vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp; |
|
326 vformat->Rmask = GS_pixelmasks[vinfo.psm].r; |
|
327 vformat->Gmask = GS_pixelmasks[vinfo.psm].g; |
|
328 vformat->Bmask = GS_pixelmasks[vinfo.psm].b; |
|
329 saved_vinfo = vinfo; |
|
330 |
|
331 /* Enable mouse and keyboard support */ |
|
332 if ( GS_OpenKeyboard(this) < 0 ) { |
|
333 GS_VideoQuit(this); |
|
334 SDL_SetError("Unable to open keyboard"); |
|
335 return(-1); |
|
336 } |
|
337 if ( GS_OpenMouse(this) < 0 ) { |
|
338 const char *sdl_nomouse; |
|
339 |
|
340 sdl_nomouse = SDL_getenv("SDL_NOMOUSE"); |
|
341 if ( ! sdl_nomouse ) { |
|
342 GS_VideoQuit(this); |
|
343 SDL_SetError("Unable to open mouse"); |
|
344 return(-1); |
|
345 } |
|
346 } |
|
347 |
|
348 /* We're done! */ |
|
349 return(0); |
|
350 } |
|
351 |
|
352 static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) |
|
353 { |
|
354 static SDL_Rect GS_vesa_mode_list[] = { |
|
355 { 0, 0, 1280, 1024 }, |
|
356 { 0, 0, 1024, 768 }, |
|
357 { 0, 0, 800, 600 }, |
|
358 { 0, 0, 640, 480 } |
|
359 }; |
|
360 static SDL_Rect *GS_vesa_modes[] = { |
|
361 &GS_vesa_mode_list[0], |
|
362 &GS_vesa_mode_list[1], |
|
363 &GS_vesa_mode_list[2], |
|
364 &GS_vesa_mode_list[3], |
|
365 NULL |
|
366 }; |
|
367 static SDL_Rect GS_tvout_stretch; |
|
368 static SDL_Rect GS_tvout_mode; |
|
369 static SDL_Rect *GS_tvout_modes[3]; |
|
370 SDL_Rect **modes = NULL; |
|
371 |
|
372 switch (format->BitsPerPixel) { |
|
373 case 16: |
|
374 case 24: |
|
375 case 32: |
|
376 if ( saved_vinfo.mode == PS2_GS_VESA ) { |
|
377 modes = GS_vesa_modes; |
|
378 } else { |
|
379 int i, j = 0; |
|
380 |
|
381 // FIXME - what's wrong with the stretch code at 16 bpp? |
|
382 if ( format->BitsPerPixel != 32 ) break; |
|
383 /* Add a mode that we could possibly stretch to */ |
|
384 for ( i=0; GS_vesa_modes[i]; ++i ) { |
|
385 if ( (GS_vesa_modes[i]->w == saved_vinfo.w) && |
|
386 (GS_vesa_modes[i]->h != saved_vinfo.h) ) { |
|
387 GS_tvout_stretch.w=GS_vesa_modes[i]->w; |
|
388 GS_tvout_stretch.h=GS_vesa_modes[i]->h; |
|
389 GS_tvout_modes[j++] = &GS_tvout_stretch; |
|
390 break; |
|
391 } |
|
392 } |
|
393 /* Add the current TV video mode */ |
|
394 GS_tvout_mode.w = saved_vinfo.w; |
|
395 GS_tvout_mode.h = saved_vinfo.h; |
|
396 GS_tvout_modes[j++] = &GS_tvout_mode; |
|
397 GS_tvout_modes[j++] = NULL; |
|
398 |
|
399 /* Return the created list of modes */ |
|
400 modes = GS_tvout_modes; |
|
401 } |
|
402 break; |
|
403 default: |
|
404 break; |
|
405 } |
|
406 return(modes); |
|
407 } |
|
408 |
|
409 /* Various screen update functions available */ |
|
410 static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects); |
|
411 |
|
412 static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, |
|
413 int width, int height, int bpp, Uint32 flags) |
|
414 { |
|
415 struct ps2_screeninfo vinfo; |
|
416 |
|
417 /* Set the terminal into graphics mode */ |
|
418 if ( GS_EnterGraphicsMode(this) < 0 ) { |
|
419 return(NULL); |
|
420 } |
|
421 |
|
422 /* Set the video mode and get the final screen format */ |
|
423 if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) { |
|
424 SDL_SetError("Couldn't get console screen info"); |
|
425 return(NULL); |
|
426 } |
|
427 if ( (vinfo.w != width) || (vinfo.h != height) || |
|
428 (GS_pixelmasks[vinfo.psm].bpp != bpp) ) { |
|
429 /* If we're not in VESA mode, we have to scale resolution */ |
|
430 if ( saved_vinfo.mode == PS2_GS_VESA ) { |
|
431 switch (width) { |
|
432 case 640: |
|
433 vinfo.res = PS2_GS_640x480; |
|
434 break; |
|
435 case 800: |
|
436 vinfo.res = PS2_GS_800x600; |
|
437 break; |
|
438 case 1024: |
|
439 vinfo.res = PS2_GS_1024x768; |
|
440 break; |
|
441 case 1280: |
|
442 vinfo.res = PS2_GS_1280x1024; |
|
443 break; |
|
444 default: |
|
445 SDL_SetError("Unsupported resolution: %dx%d\n", |
|
446 width, height); |
|
447 return(NULL); |
|
448 } |
|
449 vinfo.res |= (PS2_GS_75Hz << 8); |
|
450 vinfo.w = width; |
|
451 vinfo.h = height; |
|
452 } |
|
453 vinfo.fbp = 0; |
|
454 vinfo.psm = GS_formatmap[bpp/8]; |
|
455 if ( vinfo.psm < 0 ) { |
|
456 SDL_SetError("Unsupported depth: %d bpp\n", bpp); |
|
457 return(NULL); |
|
458 } |
|
459 if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) { |
|
460 SDL_SetError("Couldn't set console screen info"); |
|
461 return(NULL); |
|
462 } |
|
463 |
|
464 /* Unmap the previous DMA buffer */ |
|
465 if ( mapped_mem ) { |
|
466 munmap(mapped_mem, mapped_len); |
|
467 mapped_mem = NULL; |
|
468 } |
|
469 } |
|
470 if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp, |
|
471 GS_pixelmasks[vinfo.psm].r, |
|
472 GS_pixelmasks[vinfo.psm].g, |
|
473 GS_pixelmasks[vinfo.psm].b, 0) ) { |
|
474 return(NULL); |
|
475 } |
|
476 |
|
477 /* Set up the new mode framebuffer */ |
|
478 current->flags = SDL_FULLSCREEN; |
|
479 current->w = width; |
|
480 current->h = height; |
|
481 current->pitch = SDL_CalculatePitch(current); |
|
482 |
|
483 /* Memory map the DMA area for block memory transfer */ |
|
484 if ( ! mapped_mem ) { |
|
485 pixels_len = height * current->pitch; |
|
486 mapped_len = pixels_len + |
|
487 /* Screen update DMA command area */ |
|
488 sizeof(head_tags) + ((2 * MAXTAGS) * 16); |
|
489 if ( saved_vinfo.mode != PS2_GS_VESA ) { |
|
490 mapped_len += sizeof(tex_tags) + sizeof(scale_tags); |
|
491 } |
|
492 mapped_mem = mmap(0, mapped_len, PROT_READ|PROT_WRITE, |
|
493 MAP_SHARED, memory_fd, 0); |
|
494 if ( mapped_mem == MAP_FAILED ) { |
|
495 SDL_SetError("Unable to map %d bytes for DMA", |
|
496 mapped_len); |
|
497 mapped_mem = NULL; |
|
498 return(NULL); |
|
499 } |
|
500 |
|
501 /* Set up the entire screen for DMA transfer */ |
|
502 screen_image.ptr = mapped_mem; |
|
503 screen_image.fbp = 0; |
|
504 screen_image.fbw = (vinfo.w + 63) / 64; |
|
505 screen_image.psm = vinfo.psm; |
|
506 screen_image.x = 0; |
|
507 if ( vinfo.h == height ) { |
|
508 screen_image.y = 0; |
|
509 } else { |
|
510 /* Put image offscreen and scale to screen height */ |
|
511 screen_image.y = vinfo.h; |
|
512 } |
|
513 screen_image.w = current->w; |
|
514 screen_image.h = current->h; |
|
515 |
|
516 /* get screen image data size (qword aligned) */ |
|
517 screen_image_size = (screen_image.w * screen_image.h); |
|
518 switch (screen_image.psm) { |
|
519 case PS2_GS_PSMCT32: |
|
520 screen_image_size *= 4; |
|
521 break; |
|
522 case PS2_GS_PSMCT24: |
|
523 screen_image_size *= 3; |
|
524 break; |
|
525 case PS2_GS_PSMCT16: |
|
526 screen_image_size *= 2; |
|
527 break; |
|
528 } |
|
529 screen_image_size = (screen_image_size + 15) & ~15; |
|
530 |
|
531 /* Set up the memory for screen update DMA commands */ |
|
532 head_tags_mem = (unsigned long long *) |
|
533 (mapped_mem + pixels_len); |
|
534 image_tags_mem = (unsigned long long *) |
|
535 ((caddr_t)head_tags_mem + sizeof(head_tags)); |
|
536 SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags)); |
|
537 if ( saved_vinfo.mode != PS2_GS_VESA ) { |
|
538 tex_tags_mem = (unsigned long long *) |
|
539 ((caddr_t)image_tags_mem + ((2*MAXTAGS)*16)); |
|
540 scale_tags_mem = (unsigned long long *) |
|
541 ((caddr_t)tex_tags_mem + sizeof(tex_tags)); |
|
542 SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags)); |
|
543 tex_tags_mem[2] = |
|
544 (vinfo.h * vinfo.w) / 64 + |
|
545 ((unsigned long long)screen_image.fbw << 14) + |
|
546 ((unsigned long long)screen_image.psm << 20) + |
|
547 ((unsigned long long)power_of_2(screen_image.w) << 26) + |
|
548 ((unsigned long long)power_of_2(screen_image.h) << 30) + |
|
549 ((unsigned long long)1 << 34) + |
|
550 ((unsigned long long)1 << 35); |
|
551 SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags)); |
|
552 scale_tags_mem[8] = |
|
553 ((unsigned long long)screen_image.w * 16) + |
|
554 (((unsigned long long)screen_image.h * 16) << 16); |
|
555 scale_tags_mem[10] = |
|
556 ((unsigned long long)vinfo.w * 16) + |
|
557 (((unsigned long long)vinfo.h * 16) << 16); |
|
558 } |
|
559 } |
|
560 current->pixels = NULL; |
|
561 if ( SDL_getenv("SDL_FULLSCREEN_UPDATE") ) { |
|
562 /* Correct semantics */ |
|
563 current->flags |= SDL_ASYNCBLIT; |
|
564 } else { |
|
565 /* We lie here - the screen memory isn't really the visible |
|
566 display memory and still requires an update, but this |
|
567 has the desired effect for most applications. |
|
568 */ |
|
569 current->flags |= SDL_HWSURFACE; |
|
570 } |
|
571 |
|
572 /* Set the update rectangle function */ |
|
573 this->UpdateRects = GS_DMAFullUpdate; |
|
574 |
|
575 /* We're done */ |
|
576 return(current); |
|
577 } |
|
578 |
|
579 /* We don't support hardware surfaces yet */ |
|
580 static int GS_AllocHWSurface(_THIS, SDL_Surface *surface) |
|
581 { |
|
582 return(-1); |
|
583 } |
|
584 static void GS_FreeHWSurface(_THIS, SDL_Surface *surface) |
|
585 { |
|
586 return; |
|
587 } |
|
588 static int GS_LockHWSurface(_THIS, SDL_Surface *surface) |
|
589 { |
|
590 if ( surface == this->screen ) { |
|
591 /* Since mouse motion affects 'pixels', lock it */ |
|
592 SDL_LockCursor(); |
|
593 |
|
594 /* Make sure any pending DMA has completed */ |
|
595 if ( dma_pending ) { |
|
596 ioctl(console_fd, PS2IOC_SENDQCT, 1); |
|
597 dma_pending = 0; |
|
598 } |
|
599 |
|
600 /* If the cursor is drawn on the DMA area, remove it */ |
|
601 if ( cursor_drawn ) { |
|
602 surface->pixels = mapped_mem + surface->offset; |
|
603 SDL_EraseCursorNoLock(this->screen); |
|
604 cursor_drawn = 0; |
|
605 } |
|
606 |
|
607 /* Set the surface pixels to the base of the DMA area */ |
|
608 surface->pixels = mapped_mem; |
|
609 |
|
610 /* We're finished! */ |
|
611 SDL_UnlockCursor(); |
|
612 } |
|
613 return(0); |
|
614 } |
|
615 static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface) |
|
616 { |
|
617 if ( surface == this->screen ) { |
|
618 /* Since mouse motion affects 'pixels', lock it */ |
|
619 SDL_LockCursor(); |
|
620 surface->pixels = NULL; |
|
621 SDL_UnlockCursor(); |
|
622 } |
|
623 } |
|
624 |
|
625 static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects) |
|
626 { |
|
627 /* Lock so we aren't interrupted by a mouse update */ |
|
628 SDL_LockCursor(); |
|
629 |
|
630 /* Make sure any pending DMA has completed */ |
|
631 if ( dma_pending ) { |
|
632 ioctl(console_fd, PS2IOC_SENDQCT, 1); |
|
633 dma_pending = 0; |
|
634 } |
|
635 |
|
636 /* If the mouse is visible, draw it on the DMA area */ |
|
637 if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) { |
|
638 this->screen->pixels = mapped_mem + this->screen->offset; |
|
639 SDL_DrawCursorNoLock(this->screen); |
|
640 this->screen->pixels = NULL; |
|
641 cursor_drawn = 1; |
|
642 } |
|
643 |
|
644 /* Put the image onto the screen */ |
|
645 loadimage_nonblock(console_fd, |
|
646 &screen_image, screen_image_size, |
|
647 head_tags_mem, image_tags_mem); |
|
648 if ( screen_image.y > 0 ) { |
|
649 /* Need to scale offscreen image to TV output */ |
|
650 ioctl(console_fd, PS2IOC_SENDQCT, 1); |
|
651 dma_pending = 0; |
|
652 scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem); |
|
653 } else { |
|
654 dma_pending = 1; |
|
655 } |
|
656 |
|
657 /* We're finished! */ |
|
658 SDL_UnlockCursor(); |
|
659 } |
|
660 |
|
661 static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) |
|
662 { |
|
663 return(0); |
|
664 } |
|
665 |
|
666 static void GS_VideoQuit(_THIS) |
|
667 { |
|
668 /* Close console and input file descriptors */ |
|
669 if ( console_fd > 0 ) { |
|
670 /* Unmap the video framebuffer */ |
|
671 if ( mapped_mem ) { |
|
672 /* Unmap the video framebuffer */ |
|
673 munmap(mapped_mem, mapped_len); |
|
674 mapped_mem = NULL; |
|
675 } |
|
676 close(memory_fd); |
|
677 |
|
678 /* Restore the original video mode */ |
|
679 if ( GS_InGraphicsMode(this) ) { |
|
680 ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo); |
|
681 } |
|
682 |
|
683 /* We're all done with the graphics device */ |
|
684 close(console_fd); |
|
685 console_fd = -1; |
|
686 } |
|
687 GS_CloseMouse(this); |
|
688 GS_CloseKeyboard(this); |
|
689 } |