1 |
|
/* |
2 |
|
* video_x.cpp - Video/graphics emulation, X11 specific stuff |
3 |
|
* |
4 |
< |
* SheepShaver (C) 1997-2004 Marc Hellwig and Christian Bauer |
4 |
> |
* SheepShaver (C) 1997-2005 Marc Hellwig and Christian Bauer |
5 |
|
* |
6 |
|
* This program is free software; you can redistribute it and/or modify |
7 |
|
* it under the terms of the GNU General Public License as published by |
18 |
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
19 |
|
*/ |
20 |
|
|
21 |
+ |
/* |
22 |
+ |
* NOTES: |
23 |
+ |
* The Ctrl key works like a qualifier for special actions: |
24 |
+ |
* Ctrl-Tab = suspend DGA mode |
25 |
+ |
* Ctrl-Esc = emergency quit |
26 |
+ |
* Ctrl-F1 = mount floppy |
27 |
+ |
* Ctrl-F5 = grab mouse (in windowed mode) |
28 |
+ |
*/ |
29 |
+ |
|
30 |
|
#include "sysdeps.h" |
31 |
|
|
32 |
|
#include <X11/Xlib.h> |
40 |
|
|
41 |
|
#include <algorithm> |
42 |
|
|
43 |
+ |
#ifdef ENABLE_FBDEV_DGA |
44 |
+ |
# include <linux/fb.h> |
45 |
+ |
# include <sys/ioctl.h> |
46 |
+ |
#endif |
47 |
+ |
|
48 |
|
#ifdef ENABLE_XF86_DGA |
49 |
|
# include <X11/extensions/xf86dga.h> |
50 |
|
#endif |
123 |
|
static int rshift, rloss, gshift, gloss, bshift, bloss; // Pixel format of DirectColor/TrueColor modes |
124 |
|
static Colormap cmap[2]; // Two colormaps (DGA) for 8-bit mode |
125 |
|
static XColor x_palette[256]; // Color palette to be used as CLUT and gamma table |
126 |
+ |
static int orig_accel_numer, orig_accel_denom, orig_threshold; // Original mouse acceleration |
127 |
|
|
128 |
|
static XColor black, white; |
129 |
|
static unsigned long black_pixel, white_pixel; |
146 |
|
static uint32 the_buffer_size; // Size of allocated the_buffer |
147 |
|
|
148 |
|
// Variables for DGA mode |
149 |
+ |
static bool is_fbdev_dga_mode = false; // Flag: Use FBDev DGA mode? |
150 |
|
static int current_dga_cmap; |
151 |
|
|
152 |
+ |
#ifdef ENABLE_FBDEV_DGA |
153 |
+ |
static int fb_dev_fd = -1; // Handle to fb device name |
154 |
+ |
static struct fb_fix_screeninfo fb_finfo; // Fixed info |
155 |
+ |
static struct fb_var_screeninfo fb_vinfo; // Variable info |
156 |
+ |
static struct fb_var_screeninfo fb_orig_vinfo; // Variable info to restore later |
157 |
+ |
static struct fb_cmap fb_oldcmap; // Colormap to restore later |
158 |
+ |
#endif |
159 |
+ |
|
160 |
|
#ifdef ENABLE_XF86_VIDMODE |
161 |
|
// Variables for XF86 VidMode support |
162 |
|
static XF86VidModeModeInfo **x_video_modes; // Array of all available modes |
177 |
|
#define UNLOCK_PALETTE |
178 |
|
#endif |
179 |
|
|
180 |
+ |
// Mutex to protect frame buffer |
181 |
+ |
#ifdef HAVE_SPINLOCKS |
182 |
+ |
static spinlock_t frame_buffer_lock = SPIN_LOCK_UNLOCKED; |
183 |
+ |
#define LOCK_FRAME_BUFFER spin_lock(&frame_buffer_lock) |
184 |
+ |
#define UNLOCK_FRAME_BUFFER spin_unlock(&frame_buffer_lock) |
185 |
+ |
#elif defined(HAVE_PTHREADS) |
186 |
+ |
static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER; |
187 |
+ |
#define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock); |
188 |
+ |
#define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock); |
189 |
+ |
#else |
190 |
+ |
#define LOCK_FRAME_BUFFER |
191 |
+ |
#define UNLOCK_FRAME_BUFFER |
192 |
+ |
#endif |
193 |
+ |
|
194 |
|
|
195 |
|
// Prototypes |
196 |
|
static void *redraw_func(void *arg); |
402 |
|
* Open display (window or fullscreen) |
403 |
|
*/ |
404 |
|
|
405 |
+ |
// Set window name and class |
406 |
+ |
static void set_window_name(Window w, int name) |
407 |
+ |
{ |
408 |
+ |
const char *str = GetString(name); |
409 |
+ |
XStoreName(x_display, w, str); |
410 |
+ |
XSetIconName(x_display, w, str); |
411 |
+ |
|
412 |
+ |
XClassHint *hints; |
413 |
+ |
hints = XAllocClassHint(); |
414 |
+ |
if (hints) { |
415 |
+ |
hints->res_name = "SheepShaver"; |
416 |
+ |
hints->res_class = "SheepShaver"; |
417 |
+ |
XSetClassHint(x_display, w, hints); |
418 |
+ |
XFree(hints); |
419 |
+ |
} |
420 |
+ |
} |
421 |
+ |
|
422 |
+ |
// Set window input focus flag |
423 |
+ |
static void set_window_focus(Window w) |
424 |
+ |
{ |
425 |
+ |
XWMHints *hints = XAllocWMHints(); |
426 |
+ |
if (hints) { |
427 |
+ |
hints->input = True; |
428 |
+ |
hints->initial_state = NormalState; |
429 |
+ |
hints->flags = InputHint | StateHint; |
430 |
+ |
XSetWMHints(x_display, w, hints); |
431 |
+ |
XFree(hints); |
432 |
+ |
} |
433 |
+ |
} |
434 |
+ |
|
435 |
|
// Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget) |
436 |
|
static Atom WM_DELETE_WINDOW = (Atom)0; |
437 |
|
static void set_window_delete_protocol(Window w) |
457 |
|
} while ((e.type != UnmapNotify) || (e.xmap.event != w)); |
458 |
|
} |
459 |
|
|
460 |
+ |
// Disable mouse acceleration |
461 |
+ |
static void disable_mouse_accel(void) |
462 |
+ |
{ |
463 |
+ |
XChangePointerControl(x_display, True, False, 1, 1, 0); |
464 |
+ |
} |
465 |
+ |
|
466 |
+ |
// Restore mouse acceleration to original value |
467 |
+ |
static void restore_mouse_accel(void) |
468 |
+ |
{ |
469 |
+ |
XChangePointerControl(x_display, True, True, orig_accel_numer, orig_accel_denom, orig_threshold); |
470 |
+ |
} |
471 |
+ |
|
472 |
|
// Trap SHM errors |
473 |
|
static bool shm_error = false; |
474 |
|
static int (*old_error_handler)(Display *, XErrorEvent *); |
501 |
|
the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, |
502 |
|
InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap, &wattr); |
503 |
|
|
504 |
< |
// Set window name |
505 |
< |
XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE)); |
504 |
> |
// Set window name/class |
505 |
> |
set_window_name(the_win, STR_WINDOW_TITLE); |
506 |
> |
|
507 |
> |
// Indicate that we want keyboard input |
508 |
> |
set_window_focus(the_win); |
509 |
|
|
510 |
|
// Set delete protocol property |
511 |
|
set_window_delete_protocol(the_win); |
633 |
|
return true; |
634 |
|
} |
635 |
|
|
636 |
+ |
// Open FBDev display |
637 |
+ |
static bool open_fbdev(int width, int height) |
638 |
+ |
{ |
639 |
+ |
#ifdef ENABLE_FBDEV_DGA |
640 |
+ |
if (ioctl(fb_dev_fd, FBIOGET_FSCREENINFO, &fb_finfo) != 0) { |
641 |
+ |
D(bug("[fbdev] Can't get FSCREENINFO: %s\n", strerror(errno))); |
642 |
+ |
return false; |
643 |
+ |
} |
644 |
+ |
D(bug("[fbdev] Device ID: %s\n", fb_finfo.id)); |
645 |
+ |
D(bug("[fbdev] smem_start: %p [%d bytes]\n", fb_finfo.smem_start, fb_finfo.smem_len)); |
646 |
+ |
int fb_type = fb_finfo.type; |
647 |
+ |
const char *fb_type_str = NULL; |
648 |
+ |
switch (fb_type) { |
649 |
+ |
case FB_TYPE_PACKED_PIXELS: fb_type_str = "Packed Pixels"; break; |
650 |
+ |
case FB_TYPE_PLANES: fb_type_str = "Non interleaved planes"; break; |
651 |
+ |
case FB_TYPE_INTERLEAVED_PLANES: fb_type_str = "Interleaved planes"; break; |
652 |
+ |
case FB_TYPE_TEXT: fb_type_str = "Text/attributes"; break; |
653 |
+ |
case FB_TYPE_VGA_PLANES: fb_type_str = "EGA/VGA planes"; break; |
654 |
+ |
default: fb_type_str = "<unknown>"; break; |
655 |
+ |
} |
656 |
+ |
D(bug("[fbdev] type: %s\n", fb_type_str)); |
657 |
+ |
int fb_visual = fb_finfo.visual; |
658 |
+ |
const char *fb_visual_str; |
659 |
+ |
switch (fb_visual) { |
660 |
+ |
case FB_VISUAL_MONO01: fb_visual_str = "Monochrome 1=Black 0=White"; break; |
661 |
+ |
case FB_VISUAL_MONO10: fb_visual_str = "Monochrome 1=While 0=Black"; break; |
662 |
+ |
case FB_VISUAL_TRUECOLOR: fb_visual_str = "True color"; break; |
663 |
+ |
case FB_VISUAL_PSEUDOCOLOR: fb_visual_str = "Pseudo color (like atari)"; break; |
664 |
+ |
case FB_VISUAL_DIRECTCOLOR: fb_visual_str = "Direct color"; break; |
665 |
+ |
case FB_VISUAL_STATIC_PSEUDOCOLOR: fb_visual_str = "Pseudo color readonly"; break; |
666 |
+ |
default: fb_visual_str = "<unknown>"; break; |
667 |
+ |
} |
668 |
+ |
D(bug("[fbdev] visual: %s\n", fb_visual_str)); |
669 |
+ |
|
670 |
+ |
if (fb_type != FB_TYPE_PACKED_PIXELS) { |
671 |
+ |
D(bug("[fbdev] type %s not supported\n", fb_type_str)); |
672 |
+ |
return false; |
673 |
+ |
} |
674 |
+ |
|
675 |
+ |
// Map frame buffer |
676 |
+ |
the_buffer = (uint8 *)mmap(NULL, fb_finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb_dev_fd, 0); |
677 |
+ |
if (the_buffer == MAP_FAILED) { |
678 |
+ |
D(bug("[fbdev] Can't mmap /dev/fb0: %s\n", strerror(errno))); |
679 |
+ |
return false; |
680 |
+ |
} |
681 |
+ |
|
682 |
+ |
// Set absolute mouse mode |
683 |
+ |
ADBSetRelMouseMode(false); |
684 |
+ |
|
685 |
+ |
// Create window |
686 |
+ |
XSetWindowAttributes wattr; |
687 |
+ |
wattr.event_mask = eventmask = dga_eventmask; |
688 |
+ |
wattr.override_redirect = True; |
689 |
+ |
wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]); |
690 |
+ |
the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, |
691 |
+ |
InputOutput, vis, CWEventMask | CWOverrideRedirect | |
692 |
+ |
(color_class == DirectColor ? CWColormap : 0), &wattr); |
693 |
+ |
|
694 |
+ |
// Show window |
695 |
+ |
XMapRaised(x_display, the_win); |
696 |
+ |
wait_mapped(the_win); |
697 |
+ |
|
698 |
+ |
// Grab mouse and keyboard |
699 |
+ |
XGrabKeyboard(x_display, the_win, True, |
700 |
+ |
GrabModeAsync, GrabModeAsync, CurrentTime); |
701 |
+ |
XGrabPointer(x_display, the_win, True, |
702 |
+ |
PointerMotionMask | ButtonPressMask | ButtonReleaseMask, |
703 |
+ |
GrabModeAsync, GrabModeAsync, None, None, CurrentTime); |
704 |
+ |
disable_mouse_accel(); |
705 |
+ |
|
706 |
+ |
// Create no_cursor |
707 |
+ |
mac_cursor = XCreatePixmapCursor(x_display, |
708 |
+ |
XCreatePixmap(x_display, the_win, 1, 1, 1), |
709 |
+ |
XCreatePixmap(x_display, the_win, 1, 1, 1), |
710 |
+ |
&black, &white, 0, 0); |
711 |
+ |
XDefineCursor(x_display, the_win, mac_cursor); |
712 |
+ |
|
713 |
+ |
// Init blitting routines |
714 |
+ |
int bytes_per_row = TrivialBytesPerRow((width + 7) & ~7, DepthModeForPixelDepth(depth)); |
715 |
+ |
#if ENABLE_VOSF |
716 |
+ |
bool native_byte_order; |
717 |
+ |
#ifdef WORDS_BIGENDIAN |
718 |
+ |
native_byte_order = (XImageByteOrder(x_display) == MSBFirst); |
719 |
+ |
#else |
720 |
+ |
native_byte_order = (XImageByteOrder(x_display) == LSBFirst); |
721 |
+ |
#endif |
722 |
+ |
#if REAL_ADDRESSING || DIRECT_ADDRESSING |
723 |
+ |
// Screen_blitter_init() returns TRUE if VOSF is mandatory |
724 |
+ |
// i.e. the framebuffer update function is not Blit_Copy_Raw |
725 |
+ |
use_vosf = Screen_blitter_init(visualFormat, native_byte_order, depth); |
726 |
+ |
|
727 |
+ |
if (use_vosf) { |
728 |
+ |
// Allocate memory for frame buffer (SIZE is extended to page-boundary) |
729 |
+ |
the_host_buffer = the_buffer; |
730 |
+ |
the_buffer_size = page_extend((height + 2) * bytes_per_row); |
731 |
+ |
the_buffer_copy = (uint8 *)malloc(the_buffer_size); |
732 |
+ |
the_buffer = (uint8 *)vm_acquire(the_buffer_size); |
733 |
+ |
D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer)); |
734 |
+ |
} |
735 |
+ |
#else |
736 |
+ |
use_vosf = false; |
737 |
+ |
#endif |
738 |
+ |
#endif |
739 |
+ |
|
740 |
+ |
// Set frame buffer base |
741 |
+ |
D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf)); |
742 |
+ |
screen_base = Host2MacAddr(the_buffer); |
743 |
+ |
VModes[cur_mode].viRowBytes = bytes_per_row; |
744 |
+ |
return true; |
745 |
+ |
#else |
746 |
+ |
ErrorAlert("SheepShaver has been compiled with DGA support disabled."); |
747 |
+ |
return false; |
748 |
+ |
#endif |
749 |
+ |
} |
750 |
+ |
|
751 |
|
// Open DGA display (!! should use X11 VidMode extensions to set mode) |
752 |
|
static bool open_dga(int width, int height) |
753 |
|
{ |
754 |
+ |
if (is_fbdev_dga_mode) |
755 |
+ |
return false; |
756 |
+ |
|
757 |
|
#ifdef ENABLE_XF86_DGA |
758 |
|
// Set relative mouse mode |
759 |
|
ADBSetRelMouseMode(true); |
848 |
|
D(bug("open_display()\n")); |
849 |
|
const VideoInfo &mode = VModes[cur_mode]; |
850 |
|
|
851 |
+ |
// Get original mouse acceleration |
852 |
+ |
XGetPointerControl(x_display, &orig_accel_numer, &orig_accel_denom, &orig_threshold); |
853 |
+ |
|
854 |
|
// Find best available X visual |
855 |
|
if (!find_visual_for_depth(mode.viAppleMode)) { |
856 |
|
ErrorAlert(GetString(STR_NO_XVISUAL_ERR)); |
931 |
|
depth = depth_of_video_mode(mode.viAppleMode); |
932 |
|
|
933 |
|
bool display_open = false; |
934 |
< |
if (display_type == DIS_SCREEN) |
934 |
> |
if (display_type == DIS_SCREEN) { |
935 |
|
display_open = open_dga(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize); |
936 |
+ |
#ifdef ENABLE_FBDEV_DGA |
937 |
+ |
// Try to fallback to FBDev DGA mode |
938 |
+ |
if (!display_open) { |
939 |
+ |
is_fbdev_dga_mode = true; |
940 |
+ |
display_open = open_fbdev(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize); |
941 |
+ |
} |
942 |
+ |
#endif |
943 |
+ |
|
944 |
+ |
} |
945 |
|
else if (display_type == DIS_WINDOW) |
946 |
|
display_open = open_window(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize); |
947 |
|
|
990 |
|
XSync(x_display, false); |
991 |
|
} |
992 |
|
|
993 |
+ |
// Close FBDev mode |
994 |
+ |
static void close_fbdev(void) |
995 |
+ |
{ |
996 |
+ |
#ifdef ENABLE_FBDEV_DGA |
997 |
+ |
XUngrabPointer(x_display, CurrentTime); |
998 |
+ |
XUngrabKeyboard(x_display, CurrentTime); |
999 |
+ |
|
1000 |
+ |
uint8 *fb_base; |
1001 |
+ |
if (!use_vosf) { |
1002 |
+ |
// don't free() the screen buffer in driver_base dtor |
1003 |
+ |
fb_base = the_buffer; |
1004 |
+ |
the_buffer = NULL; |
1005 |
+ |
} |
1006 |
+ |
#ifdef ENABLE_VOSF |
1007 |
+ |
else { |
1008 |
+ |
// don't free() the screen buffer in driver_base dtor |
1009 |
+ |
fb_base = the_host_buffer; |
1010 |
+ |
the_host_buffer = NULL; |
1011 |
+ |
} |
1012 |
+ |
#endif |
1013 |
+ |
munmap(fb_base, fb_finfo.smem_len); |
1014 |
+ |
#endif |
1015 |
+ |
} |
1016 |
+ |
|
1017 |
|
// Close DGA mode |
1018 |
|
static void close_dga(void) |
1019 |
|
{ |
1020 |
+ |
if (is_fbdev_dga_mode) |
1021 |
+ |
return; |
1022 |
+ |
|
1023 |
|
#ifdef ENABLE_XF86_DGA |
1024 |
|
XF86DGADirectVideo(x_display, screen, 0); |
1025 |
|
XUngrabPointer(x_display, CurrentTime); |
1045 |
|
|
1046 |
|
static void close_display(void) |
1047 |
|
{ |
1048 |
< |
if (display_type == DIS_SCREEN) |
1049 |
< |
close_dga(); |
1048 |
> |
if (display_type == DIS_SCREEN) { |
1049 |
> |
if (is_fbdev_dga_mode) |
1050 |
> |
close_fbdev(); |
1051 |
> |
else |
1052 |
> |
close_dga(); |
1053 |
> |
} |
1054 |
|
else if (display_type == DIS_WINDOW) |
1055 |
|
close_window(); |
1056 |
|
|
1105 |
|
} |
1106 |
|
} |
1107 |
|
#endif |
1108 |
+ |
|
1109 |
+ |
// Restore mouse acceleration |
1110 |
+ |
restore_mouse_accel(); |
1111 |
|
} |
1112 |
|
|
1113 |
|
|
1139 |
|
|
1140 |
|
// Search for server vendor string, then read keycodes |
1141 |
|
const char *vendor = ServerVendor(x_display); |
895 |
– |
#if (defined(__APPLE__) && defined(__MACH__)) |
1142 |
|
// Force use of MacX mappings on MacOS X with Apple's X server |
1143 |
|
int dummy; |
1144 |
|
if (XQueryExtension(x_display, "Apple-DRI", &dummy, &dummy, &dummy)) |
1145 |
|
vendor = "MacX"; |
900 |
– |
#endif |
1146 |
|
bool vendor_found = false; |
1147 |
|
char line[256]; |
1148 |
|
while (fgets(line, 255, f)) { |
1217 |
|
return -1; |
1218 |
|
} |
1219 |
|
|
1220 |
+ |
// Add custom video mode |
1221 |
+ |
static void add_custom_mode(VideoInfo *&p, int type, uint32 x, uint32 y, int apple_mode, int apple_id) |
1222 |
+ |
{ |
1223 |
+ |
p->viType = type; |
1224 |
+ |
p->viXsize = x; |
1225 |
+ |
p->viYsize = y; |
1226 |
+ |
p->viRowBytes = TrivialBytesPerRow(p->viXsize, apple_mode); |
1227 |
+ |
p->viAppleMode = apple_mode; |
1228 |
+ |
p->viAppleID = apple_id; |
1229 |
+ |
p++; |
1230 |
+ |
} |
1231 |
+ |
|
1232 |
|
// Add mode to list of supported modes |
1233 |
|
static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, int apple_mode, int apple_id, int type) |
1234 |
|
{ |
1235 |
|
if (allow & test) { |
1236 |
< |
p->viType = type; |
1236 |
> |
uint32 x = 0, y = 0; |
1237 |
|
switch (apple_id) { |
1238 |
|
case APPLE_W_640x480: |
1239 |
|
case APPLE_640x480: |
1240 |
< |
p->viXsize = 640; |
1241 |
< |
p->viYsize = 480; |
1240 |
> |
x = 640; |
1241 |
> |
y = 480; |
1242 |
|
break; |
1243 |
|
case APPLE_W_800x600: |
1244 |
|
case APPLE_800x600: |
1245 |
< |
p->viXsize = 800; |
1246 |
< |
p->viYsize = 600; |
1245 |
> |
x = 800; |
1246 |
> |
y = 600; |
1247 |
|
break; |
1248 |
|
case APPLE_1024x768: |
1249 |
< |
p->viXsize = 1024; |
1250 |
< |
p->viYsize = 768; |
1249 |
> |
x = 1024; |
1250 |
> |
y = 768; |
1251 |
|
break; |
1252 |
|
case APPLE_1152x768: |
1253 |
< |
p->viXsize = 1152; |
1254 |
< |
p->viYsize = 768; |
1253 |
> |
x = 1152; |
1254 |
> |
y = 768; |
1255 |
|
break; |
1256 |
|
case APPLE_1152x900: |
1257 |
< |
p->viXsize = 1152; |
1258 |
< |
p->viYsize = 900; |
1257 |
> |
x = 1152; |
1258 |
> |
y = 900; |
1259 |
|
break; |
1260 |
|
case APPLE_1280x1024: |
1261 |
< |
p->viXsize = 1280; |
1262 |
< |
p->viYsize = 1024; |
1261 |
> |
x = 1280; |
1262 |
> |
y = 1024; |
1263 |
|
break; |
1264 |
|
case APPLE_1600x1200: |
1265 |
< |
p->viXsize = 1600; |
1266 |
< |
p->viYsize = 1200; |
1265 |
> |
x = 1600; |
1266 |
> |
y = 1200; |
1267 |
|
break; |
1268 |
|
} |
1269 |
< |
p->viRowBytes = TrivialBytesPerRow(p->viXsize, apple_mode); |
1013 |
< |
p->viAppleMode = apple_mode; |
1014 |
< |
p->viAppleID = apple_id; |
1015 |
< |
p++; |
1269 |
> |
add_custom_mode(p, type, x, y, apple_mode, apple_id); |
1270 |
|
} |
1271 |
|
} |
1272 |
|
|
1335 |
|
#ifdef ENABLE_XF86_DGA |
1336 |
|
// DGA available? |
1337 |
|
int event_base, error_base; |
1338 |
+ |
is_fbdev_dga_mode = false; |
1339 |
|
if (local_X11 && XF86DGAQueryExtension(x_display, &event_base, &error_base)) { |
1340 |
|
int dga_flags = 0; |
1341 |
|
XF86DGAQueryDirectVideo(x_display, screen, &dga_flags); |
1342 |
|
has_dga = dga_flags & XF86DGADirectPresent; |
1343 |
+ |
#if defined(__linux__) |
1344 |
+ |
// Check r/w permission on /dev/mem for DGA mode to work |
1345 |
+ |
if (has_dga && access("/dev/mem", R_OK | W_OK) != 0) |
1346 |
+ |
has_dga = false; |
1347 |
+ |
#endif |
1348 |
|
} else |
1349 |
|
has_dga = false; |
1350 |
|
#endif |
1357 |
|
XF86VidModeGetAllModeLines(x_display, screen, &num_x_video_modes, &x_video_modes); |
1358 |
|
#endif |
1359 |
|
|
1360 |
+ |
#ifdef ENABLE_FBDEV_DGA |
1361 |
+ |
// FBDev available? |
1362 |
+ |
bool has_fbdev_dga = false; |
1363 |
+ |
if (local_X11) { |
1364 |
+ |
if ((fb_dev_fd = open("/dev/fb0", O_RDWR)) > 0) { |
1365 |
+ |
if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo) != 0) |
1366 |
+ |
close(fb_dev_fd); |
1367 |
+ |
else { |
1368 |
+ |
has_fbdev_dga = true; |
1369 |
+ |
if (!has_dga) { |
1370 |
+ |
// Fallback to FBDev DGA mode if XF86 DGA is not possible |
1371 |
+ |
has_dga = true; |
1372 |
+ |
is_fbdev_dga_mode = true; |
1373 |
+ |
} |
1374 |
+ |
fb_orig_vinfo = fb_vinfo; |
1375 |
+ |
D(bug("Frame buffer device initial resolution: %dx%dx%d\n", fb_vinfo.xres, fb_vinfo.yres, fb_vinfo.bits_per_pixel)); |
1376 |
+ |
} |
1377 |
+ |
} |
1378 |
+ |
} |
1379 |
+ |
#endif |
1380 |
+ |
|
1381 |
|
// Find black and white colors |
1382 |
|
XParseColor(x_display, DefaultColormap(x_display, screen), "rgb:00/00/00", &black); |
1383 |
|
XAllocColor(x_display, DefaultColormap(x_display, screen), &black); |
1403 |
|
break; |
1404 |
|
} |
1405 |
|
|
1406 |
+ |
// Get screen mode from preferences |
1407 |
+ |
const char *mode_str = PrefsFindString("screen"); |
1408 |
+ |
int default_width = 640, default_height = 480; |
1409 |
+ |
if (mode_str) { |
1410 |
+ |
display_type = DIS_INVALID; |
1411 |
+ |
if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2) |
1412 |
+ |
display_type = DIS_WINDOW; |
1413 |
+ |
#ifdef ENABLE_XF86_DGA |
1414 |
+ |
else if (has_dga && sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2) |
1415 |
+ |
display_type = DIS_SCREEN; |
1416 |
+ |
#endif |
1417 |
+ |
#ifdef ENABLE_FBDEV_DGA |
1418 |
+ |
else if (has_fbdev_dga && sscanf(mode_str, "fbdev/%d/%d", &default_width, &default_height) == 2) { |
1419 |
+ |
is_fbdev_dga_mode = true; |
1420 |
+ |
display_type = DIS_SCREEN; |
1421 |
+ |
} |
1422 |
+ |
#endif |
1423 |
+ |
if (display_type == DIS_INVALID) { |
1424 |
+ |
D(bug("Invalid screen mode specified, defaulting to old modes selection\n")); |
1425 |
+ |
mode_str = NULL; |
1426 |
+ |
} |
1427 |
+ |
else { |
1428 |
+ |
if (default_width <= 0) |
1429 |
+ |
default_width = DisplayWidth(x_display, screen); |
1430 |
+ |
else if (default_width > DisplayWidth(x_display, screen)) |
1431 |
+ |
default_width = DisplayWidth(x_display, screen); |
1432 |
+ |
if (default_height <= 0) |
1433 |
+ |
default_height = DisplayHeight(x_display, screen); |
1434 |
+ |
else if (default_height > DisplayHeight(x_display, screen)) |
1435 |
+ |
default_height = DisplayHeight(x_display, screen); |
1436 |
+ |
} |
1437 |
+ |
} |
1438 |
+ |
|
1439 |
|
// Construct video mode table |
1440 |
|
uint32 window_modes = PrefsFindInt32("windowmodes"); |
1441 |
|
uint32 screen_modes = PrefsFindInt32("screenmodes"); |
1442 |
|
if (!has_dga) |
1443 |
|
screen_modes = 0; |
1444 |
< |
if (window_modes == 0 && screen_modes == 0) |
1444 |
> |
if (mode_str) |
1445 |
> |
window_modes = screen_modes = 0; |
1446 |
> |
else if (window_modes == 0 && screen_modes == 0) |
1447 |
|
window_modes |= 3; // Allow at least 640x480 and 800x600 window modes |
1448 |
|
|
1449 |
|
VideoInfo *p = VModes; |
1450 |
< |
for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++) |
1451 |
< |
if (find_visual_for_depth(d)) |
1452 |
< |
add_window_modes(p, window_modes, d); |
1453 |
< |
|
1454 |
< |
if (has_vidmode) { |
1450 |
> |
if (mode_str) { |
1451 |
> |
if (display_type == DIS_WINDOW) { |
1452 |
> |
for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++) { |
1453 |
> |
if (find_visual_for_depth(d)) { |
1454 |
> |
if (default_width > 640 && default_height > 480) |
1455 |
> |
add_mode(p, 3, 1, d, APPLE_W_640x480, DIS_WINDOW); |
1456 |
> |
if (default_width > 800 && default_height > 600) |
1457 |
> |
add_mode(p, 3, 2, d, APPLE_W_800x600, DIS_WINDOW); |
1458 |
> |
add_custom_mode(p, display_type, default_width, default_height, d, APPLE_CUSTOM); |
1459 |
> |
} |
1460 |
> |
} |
1461 |
> |
} else |
1462 |
> |
add_custom_mode(p, display_type, default_width, default_height, default_mode, APPLE_CUSTOM); |
1463 |
> |
} else if (window_modes) { |
1464 |
> |
for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++) |
1465 |
> |
if (find_visual_for_depth(d)) |
1466 |
> |
add_window_modes(p, window_modes, d); |
1467 |
> |
} else if (has_vidmode) { |
1468 |
|
if (has_mode(640, 480)) |
1469 |
|
add_mode(p, screen_modes, 1, default_mode, APPLE_640x480, DIS_SCREEN); |
1470 |
|
if (has_mode(800, 600)) |
1505 |
|
int apple_id = find_apple_resolution(screen_width, screen_height); |
1506 |
|
if (apple_id != -1) |
1507 |
|
cur_mode = find_mode(default_mode, apple_id, DIS_SCREEN); |
1508 |
< |
} |
1508 |
> |
} else if (has_dga && mode_str) |
1509 |
> |
cur_mode = find_mode(default_mode, APPLE_CUSTOM, DIS_SCREEN); |
1510 |
> |
|
1511 |
|
if (cur_mode == -1) { |
1512 |
|
// pick up first windowed mode available |
1513 |
|
for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) { |
1536 |
|
XSetErrorHandler(ignore_errors); |
1537 |
|
#endif |
1538 |
|
|
1539 |
+ |
// Lock down frame buffer |
1540 |
+ |
XSync(x_display, false); |
1541 |
+ |
LOCK_FRAME_BUFFER; |
1542 |
+ |
|
1543 |
|
// Start periodic thread |
1544 |
|
XSync(x_display, false); |
1545 |
|
Set_pthread_attr(&redraw_thread_attr, 0); |
1564 |
|
redraw_thread_active = false; |
1565 |
|
} |
1566 |
|
|
1567 |
+ |
// Unlock frame buffer |
1568 |
+ |
UNLOCK_FRAME_BUFFER; |
1569 |
+ |
XSync(x_display, false); |
1570 |
+ |
D(bug(" frame buffer unlocked\n")); |
1571 |
+ |
|
1572 |
|
#ifdef ENABLE_VOSF |
1573 |
|
if (use_vosf) { |
1574 |
|
// Deinitialize VOSF |
1583 |
|
XFlush(x_display); |
1584 |
|
XSync(x_display, false); |
1585 |
|
} |
1586 |
+ |
|
1587 |
+ |
#ifdef ENABLE_FBDEV_DGA |
1588 |
+ |
// Close framebuffer device |
1589 |
+ |
if (fb_dev_fd >= 0) { |
1590 |
+ |
close(fb_dev_fd); |
1591 |
+ |
fb_dev_fd = -1; |
1592 |
+ |
} |
1593 |
+ |
#endif |
1594 |
|
} |
1595 |
|
|
1596 |
|
|
1598 |
|
* Suspend/resume emulator |
1599 |
|
*/ |
1600 |
|
|
1253 |
– |
extern void PauseEmulator(void); |
1254 |
– |
extern void ResumeEmulator(void); |
1255 |
– |
|
1601 |
|
static void suspend_emul(void) |
1602 |
|
{ |
1603 |
|
if (display_type == DIS_SCREEN) { |
1605 |
|
ADBKeyUp(0x36); |
1606 |
|
ctrl_down = false; |
1607 |
|
|
1608 |
< |
// Pause MacOS thread |
1609 |
< |
PauseEmulator(); |
1265 |
< |
emul_suspended = true; |
1608 |
> |
// Lock frame buffer (this will stop the MacOS thread) |
1609 |
> |
LOCK_FRAME_BUFFER; |
1610 |
|
|
1611 |
|
// Save frame buffer |
1612 |
|
fb_save = malloc(VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); |
1614 |
|
Mac2Host_memcpy(fb_save, screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); |
1615 |
|
|
1616 |
|
// Close full screen display |
1617 |
+ |
#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) |
1618 |
|
#ifdef ENABLE_XF86_DGA |
1619 |
< |
XF86DGADirectVideo(x_display, screen, 0); |
1619 |
> |
if (!is_fbdev_dga_mode) |
1620 |
> |
XF86DGADirectVideo(x_display, screen, 0); |
1621 |
> |
#endif |
1622 |
|
XUngrabPointer(x_display, CurrentTime); |
1623 |
|
XUngrabKeyboard(x_display, CurrentTime); |
1624 |
|
#endif |
1625 |
+ |
restore_mouse_accel(); |
1626 |
+ |
XUnmapWindow(x_display, the_win); |
1627 |
+ |
wait_unmapped(the_win); |
1628 |
|
XSync(x_display, false); |
1629 |
|
|
1630 |
|
// Open "suspend" window |
1631 |
|
XSetWindowAttributes wattr; |
1632 |
|
wattr.event_mask = KeyPressMask; |
1633 |
< |
wattr.background_pixel = black_pixel; |
1284 |
< |
wattr.border_pixel = black_pixel; |
1633 |
> |
wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0); |
1634 |
|
wattr.backing_store = Always; |
1635 |
< |
wattr.backing_planes = xdepth; |
1636 |
< |
wattr.colormap = DefaultColormap(x_display, screen); |
1288 |
< |
XSync(x_display, false); |
1635 |
> |
wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]); |
1636 |
> |
|
1637 |
|
suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth, |
1638 |
< |
InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | |
1639 |
< |
CWBackingStore | CWBackingPlanes | (xdepth == 8 ? CWColormap : 0), &wattr); |
1640 |
< |
XSync(x_display, false); |
1641 |
< |
XStoreName(x_display, suspend_win, GetString(STR_SUSPEND_WINDOW_TITLE)); |
1642 |
< |
XMapRaised(x_display, suspend_win); |
1295 |
< |
XSync(x_display, false); |
1638 |
> |
InputOutput, vis, CWEventMask | CWBackPixel | CWBackingStore | CWColormap, &wattr); |
1639 |
> |
set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE); |
1640 |
> |
set_window_focus(suspend_win); |
1641 |
> |
XMapWindow(x_display, suspend_win); |
1642 |
> |
emul_suspended = true; |
1643 |
|
} |
1644 |
|
} |
1645 |
|
|
1650 |
|
XSync(x_display, false); |
1651 |
|
|
1652 |
|
// Reopen full screen display |
1653 |
< |
XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime); |
1654 |
< |
XGrabPointer(x_display, rootwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); |
1653 |
> |
XMapRaised(x_display, the_win); |
1654 |
> |
wait_mapped(the_win); |
1655 |
> |
XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0); |
1656 |
> |
Window w = is_fbdev_dga_mode ? the_win : rootwin; |
1657 |
> |
XGrabKeyboard(x_display, w, True, GrabModeAsync, GrabModeAsync, CurrentTime); |
1658 |
> |
XGrabPointer(x_display, w, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); |
1659 |
> |
disable_mouse_accel(); |
1660 |
|
#ifdef ENABLE_XF86_DGA |
1661 |
< |
XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse); |
1662 |
< |
XF86DGASetViewPort(x_display, screen, 0, 0); |
1661 |
> |
if (!is_fbdev_dga_mode) { |
1662 |
> |
XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse); |
1663 |
> |
XF86DGASetViewPort(x_display, screen, 0, 0); |
1664 |
> |
} |
1665 |
|
#endif |
1666 |
|
XSync(x_display, false); |
1667 |
|
|
1687 |
|
free(fb_save); |
1688 |
|
fb_save = NULL; |
1689 |
|
} |
1336 |
– |
if (depth == 8) |
1337 |
– |
palette_changed = true; |
1690 |
|
|
1691 |
< |
// Resume MacOS thread |
1691 |
> |
// Unlock frame buffer (and continue MacOS thread) |
1692 |
> |
UNLOCK_FRAME_BUFFER; |
1693 |
|
emul_suspended = false; |
1341 |
– |
ResumeEmulator(); |
1694 |
|
} |
1695 |
|
|
1696 |
|
|
2006 |
|
if (emerg_quit) |
2007 |
|
QuitEmulator(); |
2008 |
|
|
2009 |
+ |
// Temporarily give up frame buffer lock (this is the point where |
2010 |
+ |
// we are suspended when the user presses Ctrl-Tab) |
2011 |
+ |
UNLOCK_FRAME_BUFFER; |
2012 |
+ |
LOCK_FRAME_BUFFER; |
2013 |
+ |
|
2014 |
|
// Execute video VBL |
2015 |
|
if (private_data != NULL && private_data->interruptsEnabled) |
2016 |
|
VSLDoInterruptService(private_data->vslServiceID); |
2290 |
|
} |
2291 |
|
|
2292 |
|
#ifdef ENABLE_XF86_DGA |
2293 |
< |
if (display_type == DIS_SCREEN) { |
2293 |
> |
if (display_type == DIS_SCREEN && !is_fbdev_dga_mode) { |
2294 |
|
current_dga_cmap ^= 1; |
2295 |
|
if (!IsDirectMode(mode) && cmap[current_dga_cmap]) |
2296 |
|
XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); |
2335 |
|
quit_full_screen = false; |
2336 |
|
if (display_type == DIS_SCREEN) { |
2337 |
|
XDisplayLock(); |
2338 |
+ |
#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) |
2339 |
|
#ifdef ENABLE_XF86_DGA |
2340 |
< |
XF86DGADirectVideo(x_display, screen, 0); |
2340 |
> |
if (is_fbdev_dga_mode) |
2341 |
> |
XF86DGADirectVideo(x_display, screen, 0); |
2342 |
> |
#endif |
2343 |
|
XUngrabPointer(x_display, CurrentTime); |
2344 |
|
XUngrabKeyboard(x_display, CurrentTime); |
2345 |
|
XUnmapWindow(x_display, the_win); |