This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_vglvideo.c
662 lines (573 loc) · 18.4 KB
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
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/* libvga based SDL video driver implementation.
*/
#include <err.h>
#include <osreldate.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/fbio.h>
#include <sys/consio.h>
#include <sys/kbio.h>
#include <vgl.h>
#include "SDL_video.h"
#include "SDL_mouse.h"
39
40
41
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
42
43
44
45
46
47
#include "SDL_vglvideo.h"
#include "SDL_vglevents_c.h"
#include "SDL_vglmouse_c.h"
/* Initialization/Query functions */
48
49
50
51
52
53
54
55
static int VGL_VideoInit(_THIS, SDL_PixelFormat * vformat);
static SDL_Rect **VGL_ListModes(_THIS, SDL_PixelFormat * format,
Uint32 flags);
static SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface * current, int width,
int height, int bpp, Uint32 flags);
static int VGL_SetColors(_THIS, int firstcolor, int ncolors,
SDL_Color * colors);
static void VGL_VideoQuit(_THIS);
56
57
/* Hardware surface functions */
58
59
60
61
62
static int VGL_AllocHWSurface(_THIS, SDL_Surface * surface);
static int VGL_LockHWSurface(_THIS, SDL_Surface * surface);
static int VGL_FlipHWSurface(_THIS, SDL_Surface * surface);
static void VGL_UnlockHWSurface(_THIS, SDL_Surface * surface);
static void VGL_FreeHWSurface(_THIS, SDL_Surface * surface);
63
64
/* Misc function */
65
66
static VGLMode **VGLListModes(int depth, int mem_model);
static void VGLWaitRetrace(void);
67
68
69
/* VGL driver bootstrap functions */
70
static int
71
VGL_Available(void)
72
{
73
74
75
76
77
78
79
80
81
82
83
84
85
/*
* Check to see if we are root and stdin is a
* virtual console. Also try to ensure that
* modes other than 320x200 are available
*/
int console, hires_available, i;
VGLMode **modes;
console = STDIN_FILENO;
if (console >= 0) {
struct stat sb;
struct vt_mode dummy;
86
87
if ((fstat(console, &sb) < 0) ||
(ioctl(console, VT_GETMODE, &dummy) < 0)) {
88
89
90
console = -1;
}
}
91
if (geteuid() != 0 && console == -1)
92
93
return 0;
94
modes = VGLListModes(8, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
95
96
97
98
99
100
101
102
103
104
105
106
hires_available = 0;
for (i = 0; modes[i] != NULL; i++) {
if ((modes[i]->ModeInfo.Xsize > 320) &&
(modes[i]->ModeInfo.Ysize > 200) &&
((modes[i]->ModeInfo.Type == VIDBUF8) ||
(modes[i]->ModeInfo.Type == VIDBUF16) ||
(modes[i]->ModeInfo.Type == VIDBUF32))) {
hires_available = 1;
break;
}
}
return hires_available;
107
108
}
109
static void
110
VGL_DeleteDevice(SDL_VideoDevice * device)
111
{
112
113
SDL_free(device->hidden);
SDL_free(device);
114
115
}
116
static SDL_VideoDevice *
117
VGL_CreateDevice(int devindex)
118
{
119
120
121
SDL_VideoDevice *device;
/* Initialize all variables that we clean on shutdown */
122
device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
123
if (device) {
124
SDL_memset(device, 0, (sizeof *device));
125
device->hidden = (struct SDL_PrivateVideoData *)
126
SDL_malloc((sizeof *device->hidden));
127
128
}
if ((device == NULL) || (device->hidden == NULL)) {
129
SDL_OutOfMemory();
130
if (device) {
131
SDL_free(device);
132
133
134
}
return (0);
}
135
SDL_memset(device->hidden, 0, (sizeof *device->hidden));
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
/* Set the function pointers */
device->VideoInit = VGL_VideoInit;
device->ListModes = VGL_ListModes;
device->SetVideoMode = VGL_SetVideoMode;
device->SetColors = VGL_SetColors;
device->UpdateRects = NULL;
device->VideoQuit = VGL_VideoQuit;
device->AllocHWSurface = VGL_AllocHWSurface;
device->CheckHWBlit = NULL;
device->FillHWRect = NULL;
device->SetHWColorKey = NULL;
device->SetHWAlpha = NULL;
device->LockHWSurface = VGL_LockHWSurface;
device->UnlockHWSurface = VGL_UnlockHWSurface;
device->FlipHWSurface = VGL_FlipHWSurface;
device->FreeHWSurface = VGL_FreeHWSurface;
device->SetIcon = NULL;
device->SetCaption = NULL;
device->GetWMInfo = NULL;
device->FreeWMCursor = VGL_FreeWMCursor;
device->CreateWMCursor = VGL_CreateWMCursor;
device->ShowWMCursor = VGL_ShowWMCursor;
device->WarpWMCursor = VGL_WarpWMCursor;
device->InitOSKeymap = VGL_InitOSKeymap;
device->PumpEvents = VGL_PumpEvents;
device->free = VGL_DeleteDevice;
return device;
166
167
168
}
VideoBootStrap VGL_bootstrap = {
169
170
"vgl", "FreeBSD libVGL",
VGL_Available, VGL_CreateDevice
171
172
};
173
static int
174
VGL_AddMode(_THIS, VGLMode * inmode)
175
{
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
SDL_Rect *mode;
int i, index;
int next_mode;
/* Check to see if we already have this mode */
if (inmode->Depth < 8) { /* Not supported */
return 0;
}
index = ((inmode->Depth + 7) / 8) - 1;
for (i = 0; i < SDL_nummodes[index]; ++i) {
mode = SDL_modelist[index][i];
if ((mode->w == inmode->ModeInfo.Xsize) &&
(mode->h == inmode->ModeInfo.Ysize))
return 0;
}
/* Set up the new video mode rectangle */
194
mode = (SDL_Rect *) SDL_malloc(sizeof *mode);
195
if (mode == NULL) {
196
SDL_OutOfMemory();
197
198
199
200
201
202
203
204
205
206
return -1;
}
mode->x = 0;
mode->y = 0;
mode->w = inmode->ModeInfo.Xsize;
mode->h = inmode->ModeInfo.Ysize;
/* Allocate the new list of modes, and fill in the new mode */
next_mode = SDL_nummodes[index];
SDL_modelist[index] = (SDL_Rect **)
207
208
SDL_realloc(SDL_modelist[index],
(1 + next_mode + 1) * sizeof(SDL_Rect *));
209
if (SDL_modelist[index] == NULL) {
210
SDL_OutOfMemory();
211
SDL_nummodes[index] = 0;
212
SDL_free(mode);
213
214
215
216
217
218
219
return -1;
}
SDL_modelist[index][next_mode] = mode;
SDL_modelist[index][next_mode + 1] = NULL;
SDL_nummodes[index]++;
return 0;
220
221
}
222
static void
223
VGL_UpdateVideoInfo(_THIS)
224
{
225
226
227
228
229
230
231
232
233
234
this->info.wm_available = 0;
this->info.hw_available = 1;
this->info.video_mem = 0;
if (VGLCurMode == NULL) {
return;
}
if (VGLCurMode->ModeInfo.PixelBytes > 0) {
this->info.video_mem = VGLCurMode->ModeInfo.PixelBytes *
VGLCurMode->ModeInfo.Xsize * VGLCurMode->ModeInfo.Ysize;
}
235
236
}
237
int
238
VGL_VideoInit(_THIS, SDL_PixelFormat * vformat)
239
{
240
241
242
243
244
245
246
247
248
249
250
int i;
int total_modes;
VGLMode **modes;
/* Initialize all variables that we clean on shutdown */
for (i = 0; i < NUM_MODELISTS; ++i) {
SDL_nummodes[i] = 0;
SDL_modelist[i] = NULL;
}
/* Enable mouse and keyboard support */
251
252
253
if (SDL_getenv("SDL_NO_RAWKBD") == NULL) {
if (VGLKeyboardInit(VGL_CODEKEYS) != 0) {
SDL_SetError("Unable to initialize keyboard");
254
255
256
return -1;
}
} else {
257
warnx("Requiest to put keyboard into a raw mode ignored");
258
}
259
260
if (VGL_initkeymaps(STDIN_FILENO) != 0) {
SDL_SetError("Unable to initialize keymap");
261
262
return -1;
}
263
264
if (VGL_initmouse(STDIN_FILENO) != 0) {
SDL_SetError("Unable to initialize mouse");
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
return -1;
}
/* Determine the current screen size */
if (VGLCurMode != NULL) {
this->info.current_w = VGLCurMode->ModeInfo.Xsize;
this->info.current_h = VGLCurMode->ModeInfo.Ysize;
}
/* Determine the screen depth */
if (VGLCurMode != NULL)
vformat->BitsPerPixel = VGLCurMode->Depth;
else
vformat->BitsPerPixel = 16; /* Good default */
/* Query for the list of available video modes */
total_modes = 0;
282
modes = VGLListModes(-1, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
283
284
285
286
for (i = 0; modes[i] != NULL; i++) {
if ((modes[i]->ModeInfo.Type == VIDBUF8) ||
(modes[i]->ModeInfo.Type == VIDBUF16) ||
(modes[i]->ModeInfo.Type == VIDBUF32)) {
287
VGL_AddMode(this, modes[i]);
288
289
290
291
total_modes++;
}
}
if (total_modes == 0) {
292
SDL_SetError("No linear video modes available");
293
294
295
296
return -1;
}
/* Fill in our hardware acceleration capabilities */
297
VGL_UpdateVideoInfo(this);
298
299
/* Create the hardware surface lock mutex */
300
hw_lock = SDL_CreateMutex();
301
if (hw_lock == NULL) {
302
303
SDL_SetError("Unable to create lock mutex");
VGL_VideoQuit(this);
304
305
306
307
308
return -1;
}
/* We're done! */
return 0;
309
310
}
311
SDL_Rect **
312
VGL_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
313
{
314
return SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1];
315
316
317
}
/* Various screen update functions available */
318
319
static void VGL_DirectUpdate(_THIS, int numrects, SDL_Rect * rects);
static void VGL_BankedUpdate(_THIS, int numrects, SDL_Rect * rects);
320
321
SDL_Surface *
322
323
VGL_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp, Uint32 flags)
324
{
325
326
327
328
int mode_found;
int i;
VGLMode **modes;
329
modes = VGLListModes(bpp, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
330
331
332
333
334
335
336
337
338
339
340
341
mode_found = 0;
for (i = 0; modes[i] != NULL; i++) {
if ((modes[i]->ModeInfo.Xsize == width) &&
(modes[i]->ModeInfo.Ysize == height) &&
((modes[i]->ModeInfo.Type == VIDBUF8) ||
(modes[i]->ModeInfo.Type == VIDBUF16) ||
(modes[i]->ModeInfo.Type == VIDBUF32))) {
mode_found = 1;
break;
}
}
if (mode_found == 0) {
342
SDL_SetError("No matching video mode found");
343
344
345
346
347
return NULL;
}
/* Shutdown previous videomode (if any) */
if (VGLCurMode != NULL)
348
VGLEnd();
349
350
/* Try to set the requested linear video mode */
351
352
if (VGLInit(modes[i]->ModeId) != 0) {
SDL_SetError("Unable to switch to requested mode");
353
354
355
return NULL;
}
356
VGLCurMode = SDL_realloc(VGLCurMode, sizeof(VGLMode));
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
VGLCurMode->ModeInfo = *VGLDisplay;
VGLCurMode->Depth = modes[i]->Depth;
VGLCurMode->ModeId = modes[i]->ModeId;
VGLCurMode->Rmask = modes[i]->Rmask;
VGLCurMode->Gmask = modes[i]->Gmask;
VGLCurMode->Bmask = modes[i]->Bmask;
/* Workaround a bug in libvgl */
if (VGLCurMode->ModeInfo.PixelBytes == 0)
(VGLCurMode->ModeInfo.PixelBytes = 1);
current->w = VGLCurMode->ModeInfo.Xsize;
current->h = VGLCurMode->ModeInfo.Ysize;
current->pixels = VGLCurMode->ModeInfo.Bitmap;
current->pitch = VGLCurMode->ModeInfo.Xsize *
VGLCurMode->ModeInfo.PixelBytes;
current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE);
/* Check if we are in a pseudo-color mode */
if (VGLCurMode->ModeInfo.Type == VIDBUF8)
current->flags |= SDL_HWPALETTE;
/* Check if we can do doublebuffering */
if (flags & SDL_DOUBLEBUF) {
if (VGLCurMode->ModeInfo.Xsize * 2 <= VGLCurMode->ModeInfo.VYsize) {
current->flags |= SDL_DOUBLEBUF;
flip_page = 0;
flip_address[0] = (byte *) current->pixels;
flip_address[1] = (byte *) current->pixels +
current->h * current->pitch;
387
VGL_FlipHWSurface(this, current);
388
389
390
}
}
391
392
if (!SDL_ReallocFormat(current, modes[i]->Depth, VGLCurMode->Rmask,
VGLCurMode->Gmask, VGLCurMode->Bmask, 0)) {
393
394
395
396
return NULL;
}
/* Update hardware acceleration info */
397
VGL_UpdateVideoInfo(this);
398
399
400
401
402
403
/* Set the blit function */
this->UpdateRects = VGL_DirectUpdate;
/* We're done */
return current;
404
405
406
}
/* We don't actually allow hardware surfaces other than the main one */
407
static int
408
VGL_AllocHWSurface(_THIS, SDL_Surface * surface)
409
{
410
return -1;
411
}
412
static void
413
VGL_FreeHWSurface(_THIS, SDL_Surface * surface)
414
{
415
return;
416
417
418
}
/* We need to wait for vertical retrace on page flipped displays */
419
static int
420
VGL_LockHWSurface(_THIS, SDL_Surface * surface)
421
{
422
if (surface == SDL_VideoSurface) {
423
SDL_mutexP(hw_lock);
424
425
}
return 0;
426
}
427
static void
428
VGL_UnlockHWSurface(_THIS, SDL_Surface * surface)
429
{
430
if (surface == SDL_VideoSurface) {
431
SDL_mutexV(hw_lock);
432
}
433
434
}
435
static int
436
VGL_FlipHWSurface(_THIS, SDL_Surface * surface)
437
{
438
// VGLWaitRetrace();
439
440
if (VGLPanScreen(VGLDisplay, 0, flip_page * surface->h) < 0) {
SDL_SetError("VGLPanSreen() failed");
441
442
return -1;
}
443
444
445
flip_page = !flip_page;
surface->pixels = flip_address[flip_page];
446
447
return 0;
448
449
}
450
static void
451
VGL_DirectUpdate(_THIS, int numrects, SDL_Rect * rects)
452
{
453
return;
454
455
}
456
static void
457
VGL_BankedUpdate(_THIS, int numrects, SDL_Rect * rects)
458
{
459
return;
460
461
}
462
int
463
VGL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
464
{
465
466
467
int i;
for (i = 0; i < ncolors; i++) {
468
469
470
VGLSetPaletteIndex(firstcolor + i,
colors[i].r >> 2,
colors[i].g >> 2, colors[i].b >> 2);
471
472
}
return 1;
473
474
475
476
477
}
/* Note: If we are terminated, this could be called in the middle of
another SDL video routine -- notably UpdateRects.
*/
478
void
479
VGL_VideoQuit(_THIS)
480
{
481
482
483
int i, j;
/* Return the keyboard to the normal state */
484
VGLKeyboardEnd();
485
486
487
/* Reset the console video mode if we actually initialised one */
if (VGLCurMode != NULL) {
488
489
VGLEnd();
SDL_free(VGLCurMode);
490
491
492
493
494
VGLCurMode = NULL;
}
/* Clear the lock mutex */
if (hw_lock != NULL) {
495
SDL_DestroyMutex(hw_lock);
496
497
498
499
500
501
502
hw_lock = NULL;
}
/* Free video mode lists */
for (i = 0; i < NUM_MODELISTS; i++) {
if (SDL_modelist[i] != NULL) {
for (j = 0; SDL_modelist[i][j] != NULL; ++j) {
503
SDL_free(SDL_modelist[i][j]);
504
}
505
SDL_free(SDL_modelist[i]);
506
507
508
509
510
511
512
513
SDL_modelist[i] = NULL;
}
}
if (this->screen && (this->screen->flags & SDL_HWSURFACE)) {
/* Direct screen access, not a memory buffer */
this->screen->pixels = NULL;
}
514
515
516
517
518
519
520
}
#define VGL_RED_INDEX 0
#define VGL_GREEN_INDEX 1
#define VGL_BLUE_INDEX 2
static VGLMode **
521
VGLListModes(int depth, int mem_model)
522
{
523
524
525
526
527
528
529
530
static VGLMode **modes = NULL;
VGLBitmap *vminfop;
VGLMode **modesp, *modescp;
video_info_t minfo;
int adptype, i, modenum;
if (modes == NULL) {
531
532
modes = SDL_malloc(sizeof(VGLMode *) * M_VESA_MODE_MAX);
bzero(modes, sizeof(VGLMode *) * M_VESA_MODE_MAX);
533
534
535
536
537
}
modesp = modes;
for (modenum = 0; modenum < M_VESA_MODE_MAX; modenum++) {
minfo.vi_mode = modenum;
538
539
if (ioctl(0, CONS_MODEINFO, &minfo)
|| ioctl(0, CONS_CURRENT, &adptype))
540
541
542
543
544
545
546
547
548
549
550
continue;
if (minfo.vi_mode != modenum)
continue;
if ((minfo.vi_flags & V_INFO_GRAPHICS) == 0)
continue;
if ((mem_model != -1) && ((minfo.vi_mem_model & mem_model) == 0))
continue;
if ((depth > 1) && (minfo.vi_depth != depth))
continue;
/* reallocf can fail */
551
if ((*modesp = reallocf(*modesp, sizeof(VGLMode))) == NULL)
552
553
554
555
return NULL;
modescp = *modesp;
vminfop = &(modescp->ModeInfo);
556
bzero(vminfop, sizeof(VGLBitmap));
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
vminfop->Type = NOBUF;
vminfop->PixelBytes = 1; /* Good default value */
switch (minfo.vi_mem_model) {
case V_INFO_MM_PLANAR:
/* we can handle EGA/VGA planar modes only */
if (!(minfo.vi_depth != 4 || minfo.vi_planes != 4
|| (adptype != KD_EGA && adptype != KD_VGA)))
vminfop->Type = VIDBUF4;
break;
case V_INFO_MM_PACKED:
/* we can do only 256 color packed modes */
if (minfo.vi_depth == 8)
vminfop->Type = VIDBUF8;
break;
case V_INFO_MM_VGAX:
vminfop->Type = VIDBUF8X;
break;
576
#if defined(__FREEBSD__) && (defined(__DragonFly__) || __FreeBSD_version >= 500000)
577
578
579
580
581
582
case V_INFO_MM_DIRECT:
vminfop->PixelBytes = minfo.vi_pixel_size;
switch (vminfop->PixelBytes) {
case 2:
vminfop->Type = VIDBUF16;
break;
583
#if notyet
584
585
586
case 3:
vminfop->Type = VIDBUF24;
break;
587
#endif
588
589
590
591
592
593
case 4:
vminfop->Type = VIDBUF32;
break;
default:
break;
}
594
#endif
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
default:
break;
}
if (vminfop->Type == NOBUF)
continue;
switch (vminfop->Type) {
case VIDBUF16:
case VIDBUF32:
modescp->Rmask =
((1 << minfo.vi_pixel_fsizes[VGL_RED_INDEX]) -
1) << minfo.vi_pixel_fields[VGL_RED_INDEX];
modescp->Gmask =
((1 << minfo.vi_pixel_fsizes[VGL_GREEN_INDEX]) -
1) << minfo.vi_pixel_fields[VGL_GREEN_INDEX];
modescp->Bmask =
((1 << minfo.vi_pixel_fsizes[VGL_BLUE_INDEX]) -
1) << minfo.vi_pixel_fields[VGL_BLUE_INDEX];
break;
default:
break;
}
vminfop->Xsize = minfo.vi_width;
vminfop->Ysize = minfo.vi_height;
modescp->Depth = minfo.vi_depth;
/* XXX */
if (minfo.vi_mode >= M_VESA_BASE)
625
modescp->ModeId = _IO('V', minfo.vi_mode - M_VESA_BASE);
626
else
627
modescp->ModeId = _IO('S', minfo.vi_mode);
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
/* Sort list */
for (i = 0; modes + i < modesp; i++) {
if (modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize >
vminfop->Xsize * modes[i]->ModeInfo.Ysize)
continue;
if ((modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize ==
vminfop->Xsize * vminfop->Ysize) &&
(modes[i]->Depth >= modescp->Depth))
continue;
*modesp = modes[i];
modes[i] = modescp;
modescp = *modesp;
vminfop = &(modescp->ModeInfo);
}
modesp++;
}
if (*modesp != NULL) {
648
SDL_free(*modesp);
649
650
651
652
*modesp = NULL;
}
return modes;
653
654
655
}
static void
656
VGLWaitRetrace(void)
657
{
658
659
while (!(inb(0x3DA) & 8));
while (inb(0x3DA) & 8);
660
661
}
662
/* vi: set ts=4 sw=4 expandtab: */