--- BasiliskII/src/Unix/video_x.cpp 2000/11/03 18:27:55 1.30 +++ BasiliskII/src/Unix/video_x.cpp 2005/03/21 23:57:34 1.77 @@ -1,7 +1,7 @@ /* * video_x.cpp - Video/graphics emulation, X11 specific stuff * - * Basilisk II (C) 1997-2000 Christian Bauer + * Basilisk II (C) 1997-2005 Christian Bauer * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -24,6 +24,7 @@ * Ctrl-Tab = suspend DGA mode * Ctrl-Esc = emergency quit * Ctrl-F1 = mount floppy + * Ctrl-F5 = grab mouse (in windowed mode) */ #include "sysdeps.h" @@ -36,6 +37,8 @@ #include #include +#include + #ifdef HAVE_PTHREADS # include #endif @@ -52,13 +55,6 @@ # include #endif -#ifdef ENABLE_VOSF -# include -# include -# include -# include -#endif - #include "cpu_emulation.h" #include "main.h" #include "adb.h" @@ -66,11 +62,15 @@ #include "prefs.h" #include "user_strings.h" #include "video.h" +#include "video_blit.h" #define DEBUG 0 #include "debug.h" +// Supported video modes +static vector VideoModes; + // Display types enum { DISPLAY_WINDOW, // X11 window, using MIT SHM extensions if possible @@ -79,27 +79,39 @@ enum { // Constants const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes"; -const char FBDEVICES_FILE_NAME[] = DATADIR "/fbdevices"; + +static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask; +static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask; // Global variables static int32 frame_skip; // Prefs items -static int16 mouse_wheel_mode = 1; -static int16 mouse_wheel_lines = 3; +static int16 mouse_wheel_mode; +static int16 mouse_wheel_lines; static int display_type = DISPLAY_WINDOW; // See enum above static bool local_X11; // Flag: X server running on local machine? -static uint8 *the_buffer; // Mac frame buffer +static uint8 *the_buffer = NULL; // Mac frame buffer (where MacOS draws into) +static uint8 *the_buffer_copy = NULL; // Copy of Mac frame buffer (for refreshed modes) +static uint32 the_buffer_size; // Size of allocated the_buffer -#ifdef HAVE_PTHREADS static bool redraw_thread_active = false; // Flag: Redraw thread installed -static volatile bool redraw_thread_cancel = false; // Flag: Cancel Redraw thread +#ifdef HAVE_PTHREADS +static pthread_attr_t redraw_thread_attr; // Redraw thread attributes +static volatile bool redraw_thread_cancel; // Flag: Cancel Redraw thread +static volatile bool redraw_thread_cancel_ack; // Flag: Acknowledge for redraw thread cancellation static pthread_t redraw_thread; // Redraw thread #endif static bool has_dga = false; // Flag: Video DGA capable static bool has_vidmode = false; // Flag: VidMode extension available +#ifdef ENABLE_VOSF +static bool use_vosf = true; // Flag: VOSF enabled +#else +static const bool use_vosf = false; // VOSF not possible +#endif + static bool ctrl_down = false; // Flag: Ctrl key pressed static bool caps_on = false; // Flag: Caps Lock on static bool quit_full_screen = false; // Flag: DGA close requested from redraw thread @@ -112,213 +124,292 @@ static bool use_keycodes = false; // static int keycode_table[256]; // X keycode -> Mac keycode translation table // X11 variables +char *x_display_name = NULL; // X11 display name +Display *x_display = NULL; // X11 display handle static int screen; // Screen number -static int xdepth; // Depth of X screen -static int depth; // Depth of Mac frame buffer -static Window rootwin, the_win; // Root window and our window -static XVisualInfo visualInfo; -static Visual *vis; -static Colormap cmap[2]; // Two colormaps (DGA) for 8-bit mode +static Window rootwin; // Root window and our window +static int num_depths = 0; // Number of available X depths +static int *avail_depths = NULL; // List of available X depths static XColor black, white; static unsigned long black_pixel, white_pixel; static int eventmask; -static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask; -static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask; -static Atom WM_DELETE_WINDOW = (Atom)0; -static XColor palette[256]; // Color palette for 8-bit mode -static bool palette_changed = false; // Flag: Palette changed, redraw thread must set new colors -#ifdef HAVE_PTHREADS -static pthread_mutex_t palette_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect palette -#define LOCK_PALETTE pthread_mutex_lock(&palette_lock) -#define UNLOCK_PALETTE pthread_mutex_unlock(&palette_lock) -#else -#define LOCK_PALETTE -#define UNLOCK_PALETTE -#endif +static int xdepth; // Depth of X screen +static VisualFormat visualFormat; +static XVisualInfo visualInfo; +static Visual *vis; +static int color_class; -// Variables for window mode -static GC the_gc; -static XImage *img = NULL; -static XShmSegmentInfo shminfo; -static Cursor mac_cursor; -static uint8 *the_buffer_copy = NULL; // Copy of Mac frame buffer -static bool have_shm = false; // Flag: SHM extensions available -static bool updt_box[17][17]; // Flag for Update -static int nr_boxes; -static const int sm_uptd[] = {4,1,6,3,0,5,2,7}; -static int sm_no_boxes[] = {1,8,32,64,128,300}; +static int rshift, rloss, gshift, gloss, bshift, bloss; // Pixel format of DirectColor/TrueColor modes -// Variables for XF86 DGA mode -static int current_dga_cmap; // Number (0 or 1) of currently installed DGA colormap -static Window suspend_win; // "Suspend" window -static void *fb_save = NULL; // Saved frame buffer for suspend -#ifdef HAVE_PTHREADS -static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect frame buffer -#define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock); -#define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock); -#else -#define LOCK_FRAME_BUFFER -#define UNLOCK_FRAME_BUFFER -#endif +static Colormap cmap[2] = {0, 0}; // Colormaps for indexed modes (DGA needs two of them) -// Variables for fbdev DGA mode -const char FBDEVICE_FILE_NAME[] = "/dev/fb"; -static int fbdev_fd; +static XColor x_palette[256]; // Color palette to be used as CLUT and gamma table +static bool x_palette_changed = false; // Flag: Palette changed, redraw thread must set new colors + +#ifdef ENABLE_FBDEV_DGA +static int fbdev_fd = -1; +#endif #ifdef ENABLE_XF86_VIDMODE -// Variables for XF86 VidMode support -static XF86VidModeModeInfo **x_video_modes; // Array of all available modes +static XF86VidModeModeInfo **x_video_modes = NULL; // Array of all available modes static int num_x_video_modes; #endif -#ifdef ENABLE_VOSF -static bool use_vosf = true; // Flag: VOSF enabled +// Mutex to protect palette +#ifdef HAVE_PTHREADS +static pthread_mutex_t x_palette_lock = PTHREAD_MUTEX_INITIALIZER; +#define LOCK_PALETTE pthread_mutex_lock(&x_palette_lock) +#define UNLOCK_PALETTE pthread_mutex_unlock(&x_palette_lock) #else -static const bool use_vosf = false; // Flag: VOSF enabled +#define LOCK_PALETTE +#define UNLOCK_PALETTE #endif -#ifdef ENABLE_VOSF -// Variables for Video on SEGV support (taken from the Win32 port) -static uint8 *the_host_buffer; // Host frame buffer in VOSF mode -static uint32 the_buffer_size; // Size of allocated the_buffer - -struct ScreenPageInfo { - int top, bottom; // Mapping between this virtual page and Mac scanlines -}; - -struct ScreenInfo { - uint32 memBase; // Real start address - uint32 memStart; // Start address aligned to page boundary - uint32 memEnd; // Address of one-past-the-end of the screen - uint32 memLength; // Length of the memory addressed by the screen pages - - uint32 pageSize; // Size of a page - int pageBits; // Shift count to get the page number - uint32 pageCount; // Number of pages allocated to the screen - - uint8 * dirtyPages; // Table of flags set if page was altered - ScreenPageInfo * pageInfo; // Table of mappings page -> Mac scanlines -}; - -static ScreenInfo mainBuffer; - -#define PFLAG_SET(page) mainBuffer.dirtyPages[page] = 1 -#define PFLAG_CLEAR(page) mainBuffer.dirtyPages[page] = 0 -#define PFLAG_ISSET(page) mainBuffer.dirtyPages[page] -#define PFLAG_ISCLEAR(page) (mainBuffer.dirtyPages[page] == 0) -#ifdef UNALIGNED_PROFITABLE -# define PFLAG_ISCLEAR_4(page) (*((uint32 *)(mainBuffer.dirtyPages + page)) == 0) -#else -# define PFLAG_ISCLEAR_4(page) \ - (mainBuffer.dirtyPages[page ] == 0) \ - && (mainBuffer.dirtyPages[page+1] == 0) \ - && (mainBuffer.dirtyPages[page+2] == 0) \ - && (mainBuffer.dirtyPages[page+3] == 0) -#endif -#define PFLAG_CLEAR_ALL memset(mainBuffer.dirtyPages, 0, mainBuffer.pageCount) -#define PFLAG_SET_ALL memset(mainBuffer.dirtyPages, 1, mainBuffer.pageCount) - -static int zero_fd = -1; -static bool Screen_fault_handler_init(); -static struct sigaction vosf_sa; - +// Mutex to protect frame buffer #ifdef HAVE_PTHREADS -static pthread_mutex_t vosf_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect frame buffer (dirtyPages in fact) -#define LOCK_VOSF pthread_mutex_lock(&vosf_lock); -#define UNLOCK_VOSF pthread_mutex_unlock(&vosf_lock); +static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER; +#define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock); +#define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock); #else -#define LOCK_VOSF -#define UNLOCK_VOSF +#define LOCK_FRAME_BUFFER +#define UNLOCK_FRAME_BUFFER #endif -static int log_base_2(uint32 x) -{ - uint32 mask = 0x80000000; - int l = 31; - while (l >= 0 && (x & mask) == 0) { - mask >>= 1; - l--; - } - return l; -} - -#endif +// Variables for non-VOSF incremental refresh +static const int sm_uptd[] = {4,1,6,3,0,5,2,7}; +static int sm_no_boxes[] = {1,8,32,64,128,300}; +static bool updt_box[17][17]; +static int nr_boxes; -// VideoRefresh function -void VideoRefreshInit(void); +// Video refresh function +static void VideoRefreshInit(void); static void (*video_refresh)(void); + // Prototypes static void *redraw_func(void *arg); -static int event2keycode(XKeyEvent &ev); - // From main_unix.cpp extern char *x_display_name; extern Display *x_display; +extern void *vm_acquire_mac(size_t size); // From sys_unix.cpp extern void SysMountFirstFloppy(void); -#ifdef ENABLE_VOSF -# include "video_vosf.h" -#endif +// From clip_unix.cpp +extern void ClipboardSelectionClear(XSelectionClearEvent *); +extern void ClipboardSelectionRequest(XSelectionRequestEvent *); /* - * Initialization + * monitor_desc subclass for X11 display */ -// Set VideoMonitor according to video mode -void set_video_monitor(int width, int height, int bytes_per_row, bool native_byte_order) +class X11_monitor_desc : public monitor_desc { +public: + X11_monitor_desc(const vector &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {} + ~X11_monitor_desc() {} + + virtual void switch_to_current_mode(void); + virtual void set_palette(uint8 *pal, int num); + + bool video_open(void); + void video_close(void); +}; + + +/* + * Utility functions + */ + +// Map video_mode depth ID to numerical depth value +static inline int depth_of_video_mode(video_mode const & mode) { -#if !REAL_ADDRESSING && !DIRECT_ADDRESSING - int layout = FLAYOUT_DIRECT; + int depth = -1; + switch (mode.depth) { + case VDEPTH_1BIT: + depth = 1; + break; + case VDEPTH_2BIT: + depth = 2; + break; + case VDEPTH_4BIT: + depth = 4; + break; + case VDEPTH_8BIT: + depth = 8; + break; + case VDEPTH_16BIT: + depth = 16; + break; + case VDEPTH_32BIT: + depth = 32; + break; + default: + abort(); + } + return depth; +} + +// Map RGB color to pixel value (this only works in TrueColor/DirectColor visuals) +static inline uint32 map_rgb(uint8 red, uint8 green, uint8 blue) +{ + return ((red >> rloss) << rshift) | ((green >> gloss) << gshift) | ((blue >> bloss) << bshift); +} + +// Do we have a visual for handling the specified Mac depth? If so, set the +// global variables "xdepth", "visualInfo", "vis" and "color_class". +static bool find_visual_for_depth(video_depth depth) +{ + D(bug("have_visual_for_depth(%d)\n", 1 << depth)); + + // 1-bit works always and uses default visual + if (depth == VDEPTH_1BIT) { + vis = DefaultVisual(x_display, screen); + visualInfo.visualid = XVisualIDFromVisual(vis); + int num = 0; + XVisualInfo *vi = XGetVisualInfo(x_display, VisualIDMask, &visualInfo, &num); + visualInfo = vi[0]; + XFree(vi); + xdepth = visualInfo.depth; + color_class = visualInfo.c_class; + D(bug(" found visual ID 0x%02x, depth %d\n", visualInfo.visualid, xdepth)); + return true; + } + + // Calculate minimum and maximum supported X depth + int min_depth = 1, max_depth = 32; switch (depth) { - case 1: - layout = FLAYOUT_DIRECT; - break; - case 8: - layout = FLAYOUT_DIRECT; +#ifdef ENABLE_VOSF + case VDEPTH_2BIT: + case VDEPTH_4BIT: // VOSF blitters can convert 2/4/8-bit -> 8/16/32-bit + case VDEPTH_8BIT: + min_depth = 8; + max_depth = 32; break; - case 15: - layout = FLAYOUT_HOST_555; +#else + case VDEPTH_2BIT: + case VDEPTH_4BIT: // 2/4-bit requires VOSF blitters + return false; + case VDEPTH_8BIT: // 8-bit without VOSF requires an 8-bit visual + min_depth = 8; + max_depth = 8; break; - case 16: - layout = FLAYOUT_HOST_565; +#endif + case VDEPTH_16BIT: // 16-bit requires a 15/16-bit visual + min_depth = 15; + max_depth = 16; break; - case 24: - case 32: - layout = FLAYOUT_HOST_888; + case VDEPTH_32BIT: // 32-bit requires a 24/32-bit visual + min_depth = 24; + max_depth = 32; break; } + D(bug(" minimum required X depth is %d, maximum supported X depth is %d\n", min_depth, max_depth)); + + // Try to find a visual for one of the color depths + bool visual_found = false; + for (int i=0; i max_depth) + continue; + + // Determine best color class for this depth + switch (xdepth) { + case 1: // Try StaticGray or StaticColor + if (XMatchVisualInfo(x_display, screen, xdepth, StaticGray, &visualInfo) + || XMatchVisualInfo(x_display, screen, xdepth, StaticColor, &visualInfo)) + visual_found = true; + break; + case 8: // Need PseudoColor + if (XMatchVisualInfo(x_display, screen, xdepth, PseudoColor, &visualInfo)) + visual_found = true; + break; + case 15: + case 16: + case 24: + case 32: // Try DirectColor first, as this will allow gamma correction + if (XMatchVisualInfo(x_display, screen, xdepth, DirectColor, &visualInfo) + || XMatchVisualInfo(x_display, screen, xdepth, TrueColor, &visualInfo)) + visual_found = true; + break; + default: + D(bug(" not a supported depth\n")); + break; + } + } + if (!visual_found) + return false; + + // Visual was found + vis = visualInfo.visual; + color_class = visualInfo.c_class; + D(bug(" found visual ID 0x%02x, depth %d, class ", visualInfo.visualid, xdepth)); +#if DEBUG + switch (color_class) { + case StaticGray: D(bug("StaticGray\n")); break; + case GrayScale: D(bug("GrayScale\n")); break; + case StaticColor: D(bug("StaticColor\n")); break; + case PseudoColor: D(bug("PseudoColor\n")); break; + case TrueColor: D(bug("TrueColor\n")); break; + case DirectColor: D(bug("DirectColor\n")); break; + } +#endif + return true; +} + +// Add mode to list of supported modes +static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth) +{ + video_mode mode; + mode.x = width; + mode.y = height; + mode.resolution_id = resolution_id; + mode.bytes_per_row = bytes_per_row; + mode.depth = depth; + VideoModes.push_back(mode); +} + +// Add standard list of windowed modes for given color depth +static void add_window_modes(video_depth depth) +{ + add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth), depth); + add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth), depth); + add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth), depth); + add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth), depth); + add_mode(1152, 870, 0x84, TrivialBytesPerRow(1152, depth), depth); + add_mode(1280, 1024, 0x85, TrivialBytesPerRow(1280, depth), depth); + add_mode(1600, 1200, 0x86, TrivialBytesPerRow(1600, depth), depth); +} + +// Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac) +static void set_mac_frame_buffer(X11_monitor_desc &monitor, video_depth depth, bool native_byte_order) +{ +#if !REAL_ADDRESSING && !DIRECT_ADDRESSING + int layout = FLAYOUT_DIRECT; + if (depth == VDEPTH_16BIT) + layout = (xdepth == 15) ? FLAYOUT_HOST_555 : FLAYOUT_HOST_565; + else if (depth == VDEPTH_32BIT) + layout = (xdepth == 24) ? FLAYOUT_HOST_888 : FLAYOUT_DIRECT; if (native_byte_order) MacFrameLayout = layout; else MacFrameLayout = FLAYOUT_DIRECT; + monitor.set_mac_frame_base(MacFrameBaseMac); + + // Set variables used by UAE memory banking + const video_mode &mode = monitor.get_current_mode(); + MacFrameBaseHost = the_buffer; + MacFrameSize = mode.bytes_per_row * mode.y; + InitFrameBufferMapping(); +#else + monitor.set_mac_frame_base(Host2MacAddr(the_buffer)); #endif - switch (depth) { - case 1: - VideoMonitor.mode = VMODE_1BIT; - break; - case 8: - VideoMonitor.mode = VMODE_8BIT; - break; - case 15: - VideoMonitor.mode = VMODE_16BIT; - break; - case 16: - VideoMonitor.mode = VMODE_16BIT; - break; - case 24: - case 32: - VideoMonitor.mode = VMODE_32BIT; - break; - } - VideoMonitor.x = width; - VideoMonitor.y = height; - VideoMonitor.bytes_per_row = bytes_per_row; + D(bug("monitor.mac_frame_base = %08x\n", monitor.get_mac_frame_base())); } // Set window name and class @@ -334,7 +425,7 @@ static void set_window_name(Window w, in hints->res_name = "BasiliskII"; hints->res_class = "BasiliskII"; XSetClassHint(x_display, w, hints); - XFree((char *)hints); + XFree(hints); } } @@ -347,11 +438,12 @@ static void set_window_focus(Window w) hints->initial_state = NormalState; hints->flags = InputHint | StateHint; XSetWMHints(x_display, w, hints); - XFree((char *)hints); + XFree(hints); } } // Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget) +static Atom WM_DELETE_WINDOW = (Atom)0; static void set_window_delete_protocol(Window w) { WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false); @@ -388,35 +480,190 @@ static int error_handler(Display *d, XEr return old_error_handler(d, e); } -// Init window mode -static bool init_window(int width, int height) + +/* + * Display "driver" classes + */ + +class driver_base { +public: + driver_base(X11_monitor_desc &m); + virtual ~driver_base(); + + virtual void update_palette(void); + virtual void suspend(void) {} + virtual void resume(void) {} + virtual void toggle_mouse_grab(void) {} + virtual void mouse_moved(int x, int y) { ADBMouseMoved(x, y); } + + void disable_mouse_accel(void); + void restore_mouse_accel(void); + + virtual void grab_mouse(void) {} + virtual void ungrab_mouse(void) {} + +public: + X11_monitor_desc &monitor; // Associated video monitor + const video_mode &mode; // Video mode handled by the driver + + bool init_ok; // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer) + Window w; // The window we draw into + + int orig_accel_numer, orig_accel_denom, orig_threshold; // Original mouse acceleration +}; + +class driver_window; +static void update_display_window_vosf(driver_window *drv); +static void update_display_dynamic(int ticker, driver_window *drv); +static void update_display_static(driver_window *drv); + +class driver_window : public driver_base { + friend void update_display_window_vosf(driver_window *drv); + friend void update_display_dynamic(int ticker, driver_window *drv); + friend void update_display_static(driver_window *drv); + +public: + driver_window(X11_monitor_desc &monitor); + ~driver_window(); + + void toggle_mouse_grab(void); + void mouse_moved(int x, int y); + + void grab_mouse(void); + void ungrab_mouse(void); + +private: + GC gc; + XImage *img; + bool have_shm; // Flag: SHM extensions available + XShmSegmentInfo shminfo; + Cursor mac_cursor; + bool mouse_grabbed; // Flag: mouse pointer grabbed, using relative mouse mode + int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode) +}; + +static driver_base *drv = NULL; // Pointer to currently used driver object + +#ifdef ENABLE_VOSF +# include "video_vosf.h" +#endif + +driver_base::driver_base(X11_monitor_desc &m) + : monitor(m), mode(m.get_current_mode()), init_ok(false), w(0) +{ + the_buffer = NULL; + the_buffer_copy = NULL; + XGetPointerControl(x_display, &orig_accel_numer, &orig_accel_denom, &orig_threshold); +} + +driver_base::~driver_base() +{ + ungrab_mouse(); + restore_mouse_accel(); + + if (w) { + XUnmapWindow(x_display, w); + wait_unmapped(w); + XDestroyWindow(x_display, w); + } + + XFlush(x_display); + XSync(x_display, false); + + // Free frame buffer(s) + if (!use_vosf) { + if (the_buffer) { + free(the_buffer); + the_buffer = NULL; + } + if (the_buffer_copy) { + free(the_buffer_copy); + the_buffer_copy = NULL; + } + } +#ifdef ENABLE_VOSF + else { + // the_buffer shall always be mapped through vm_acquire() so that we can vm_protect() it at will + if (the_buffer != VM_MAP_FAILED) { + D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size)); + vm_release(the_buffer, the_buffer_size); + the_buffer = NULL; + } + if (the_host_buffer) { + D(bug(" freeing the_host_buffer at %p\n", the_host_buffer)); + free(the_host_buffer); + the_host_buffer = NULL; + } + if (the_buffer_copy) { + D(bug(" freeing the_buffer_copy at %p\n", the_buffer_copy)); + free(the_buffer_copy); + the_buffer_copy = NULL; + } + } +#endif +} + +// Palette has changed +void driver_base::update_palette(void) { + if (color_class == PseudoColor || color_class == DirectColor) { + int num = vis->map_entries; + if (!IsDirectMode(monitor.get_current_mode()) && color_class == DirectColor) + return; // Indexed mode on true color screen, don't set CLUT + XStoreColors(x_display, cmap[0], x_palette, num); + XStoreColors(x_display, cmap[1], x_palette, num); + } + XSync(x_display, false); +} + +// Disable mouse acceleration +void driver_base::disable_mouse_accel(void) +{ + XChangePointerControl(x_display, True, False, 1, 1, 0); +} + +// Restore mouse acceleration to original value +void driver_base::restore_mouse_accel(void) +{ + XChangePointerControl(x_display, True, True, orig_accel_numer, orig_accel_denom, orig_threshold); +} + + +/* + * Windowed display driver + */ + +// Open display +driver_window::driver_window(X11_monitor_desc &m) + : driver_base(m), gc(0), img(NULL), have_shm(false), mac_cursor(0), mouse_grabbed(false) +{ + int width = mode.x, height = mode.y; int aligned_width = (width + 15) & ~15; int aligned_height = (height + 15) & ~15; // Set absolute mouse mode - ADBSetRelMouseMode(false); - - // Read frame skip prefs - frame_skip = PrefsFindInt32("frameskip"); + ADBSetRelMouseMode(mouse_grabbed); - // Create window + // Create window (setting background_pixel, border_pixel and colormap is + // mandatory when using a non-default visual; in 1-bit mode we use the + // default visual, so we can also use the default colormap) XSetWindowAttributes wattr; wattr.event_mask = eventmask = win_eventmask; - wattr.background_pixel = black_pixel; - wattr.colormap = cmap[0]; - - the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, - InputOutput, vis, CWEventMask | CWBackPixel | (depth == 8 ? CWColormap : 0), &wattr); + wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0); + wattr.border_pixel = 0; + wattr.colormap = (mode.depth == VDEPTH_1BIT ? DefaultColormap(x_display, screen) : cmap[0]); + w = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, + InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWColormap, &wattr); + D(bug(" window created\n")); // Set window name/class - set_window_name(the_win, STR_WINDOW_TITLE); + set_window_name(w, STR_WINDOW_TITLE); // Indicate that we want keyboard input - set_window_focus(the_win); + set_window_focus(w); // Set delete protocol property - set_window_delete_protocol(the_win); + set_window_delete_protocol(w); // Make window unresizable { @@ -427,21 +674,27 @@ static bool init_window(int width, int h hints->min_height = height; hints->max_height = height; hints->flags = PMinSize | PMaxSize; - XSetWMNormalHints(x_display, the_win, hints); - XFree((char *)hints); + XSetWMNormalHints(x_display, w, hints); + XFree(hints); } } + D(bug(" window attributes set\n")); // Show window - XMapWindow(x_display, the_win); - wait_mapped(the_win); + XMapWindow(x_display, w); + wait_mapped(w); + D(bug(" window mapped\n")); + + // 1-bit mode is big-endian; if the X server is little-endian, we can't + // use SHM because that doesn't allow changing the image byte order + bool need_msb_image = (mode.depth == VDEPTH_1BIT && XImageByteOrder(x_display) == LSBFirst); // Try to create and attach SHM image - have_shm = false; - if (depth != 1 && local_X11 && XShmQueryExtension(x_display)) { + if (local_X11 && !need_msb_image && XShmQueryExtension(x_display)) { // Create SHM image ("height + 2" for safety) - img = XShmCreateImage(x_display, vis, depth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height); + img = XShmCreateImage(x_display, vis, mode.depth == VDEPTH_1BIT ? 1 : xdepth, mode.depth == VDEPTH_1BIT ? XYBitmap : ZPixmap, 0, &shminfo, width, height); + D(bug(" shm image created\n")); shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT | 0777); the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0); shminfo.shmaddr = img->data = (char *)the_buffer_copy; @@ -456,95 +709,320 @@ static bool init_window(int width, int h if (shm_error) { shmdt(shminfo.shmaddr); XDestroyImage(img); + img = NULL; shminfo.shmid = -1; } else { have_shm = true; shmctl(shminfo.shmid, IPC_RMID, 0); } + D(bug(" shm image attached\n")); } // Create normal X image if SHM doesn't work ("height + 2" for safety) if (!have_shm) { - int bytes_per_row = aligned_width; - switch (depth) { - case 1: - bytes_per_row /= 8; - break; - case 15: - case 16: - bytes_per_row *= 2; - break; - case 24: - case 32: - bytes_per_row *= 4; - break; - } + int bytes_per_row = (mode.depth == VDEPTH_1BIT ? aligned_width/8 : TrivialBytesPerRow(aligned_width, DepthModeForPixelDepth(xdepth))); the_buffer_copy = (uint8 *)malloc((aligned_height + 2) * bytes_per_row); - img = XCreateImage(x_display, vis, depth, depth == 1 ? XYBitmap : ZPixmap, 0, (char *)the_buffer_copy, aligned_width, aligned_height, 32, bytes_per_row); + img = XCreateImage(x_display, vis, mode.depth == VDEPTH_1BIT ? 1 : xdepth, mode.depth == VDEPTH_1BIT ? XYBitmap : ZPixmap, 0, (char *)the_buffer_copy, aligned_width, aligned_height, 32, bytes_per_row); + D(bug(" X image created\n")); } - // 1-Bit mode is big-endian - if (depth == 1) { + if (need_msb_image) { img->byte_order = MSBFirst; img->bitmap_bit_order = MSBFirst; } #ifdef ENABLE_VOSF - // Allocate a page-aligned chunk of memory for frame buffer - the_buffer_size = align_on_page_boundary((aligned_height + 2) * img->bytes_per_line); + use_vosf = true; + // Allocate memory for frame buffer (SIZE is extended to page-boundary) the_host_buffer = the_buffer_copy; - - the_buffer_copy = (uint8 *)allocate_framebuffer(the_buffer_size); - memset(the_buffer_copy, 0, the_buffer_size); - - the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size); - memset(the_buffer, 0, the_buffer_size); + the_buffer_size = page_extend((aligned_height + 2) * img->bytes_per_line); + the_buffer = (uint8 *)vm_acquire_mac(the_buffer_size); + the_buffer_copy = (uint8 *)malloc(the_buffer_size); + D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer)); #else // Allocate memory for frame buffer the_buffer = (uint8 *)malloc((aligned_height + 2) * img->bytes_per_line); + D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy)); #endif // Create GC - the_gc = XCreateGC(x_display, the_win, 0, 0); - XSetState(x_display, the_gc, black_pixel, white_pixel, GXcopy, AllPlanes); + gc = XCreateGC(x_display, w, 0, 0); + XSetState(x_display, gc, black_pixel, white_pixel, GXcopy, AllPlanes); // Create no_cursor mac_cursor = XCreatePixmapCursor(x_display, - XCreatePixmap(x_display, the_win, 1, 1, 1), - XCreatePixmap(x_display, the_win, 1, 1, 1), + XCreatePixmap(x_display, w, 1, 1, 1), + XCreatePixmap(x_display, w, 1, 1, 1), &black, &white, 0, 0); - XDefineCursor(x_display, the_win, mac_cursor); + XDefineCursor(x_display, w, mac_cursor); - // Set VideoMonitor + // Init blitting routines bool native_byte_order; #ifdef WORDS_BIGENDIAN - native_byte_order = (img->bitmap_bit_order == MSBFirst); + native_byte_order = (XImageByteOrder(x_display) == MSBFirst); #else - native_byte_order = (img->bitmap_bit_order == LSBFirst); + native_byte_order = (XImageByteOrder(x_display) == LSBFirst); #endif #ifdef ENABLE_VOSF - do_update_framebuffer = GET_FBCOPY_FUNC(depth, native_byte_order, DISPLAY_WINDOW); + Screen_blitter_init(visualFormat, native_byte_order, depth_of_video_mode(mode)); #endif - set_video_monitor(width, height, img->bytes_per_line, native_byte_order); - -#if REAL_ADDRESSING || DIRECT_ADDRESSING - VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer); + + // Set frame buffer base + set_mac_frame_buffer(monitor, mode.depth, native_byte_order); + + // Everything went well + init_ok = true; +} + +// Close display +driver_window::~driver_window() +{ + if (have_shm) { + XShmDetach(x_display, &shminfo); +#ifdef ENABLE_VOSF + the_host_buffer = NULL; // don't free() in driver_base dtor #else - VideoMonitor.mac_frame_base = MacFrameBaseMac; + the_buffer_copy = NULL; // don't free() in driver_base dtor #endif - return true; + } + if (img) { + if (!have_shm) + img->data = NULL; + XDestroyImage(img); + } + if (have_shm) { + shmdt(shminfo.shmaddr); + shmctl(shminfo.shmid, IPC_RMID, 0); + } + if (gc) + XFreeGC(x_display, gc); +} + +// Toggle mouse grab +void driver_window::toggle_mouse_grab(void) +{ + if (mouse_grabbed) + ungrab_mouse(); + else + grab_mouse(); +} + +// Grab mouse, switch to relative mouse mode +void driver_window::grab_mouse(void) +{ + int result; + for (int i=0; i<10; i++) { + result = XGrabPointer(x_display, w, True, 0, + GrabModeAsync, GrabModeAsync, w, None, CurrentTime); + if (result != AlreadyGrabbed) + break; + Delay_usec(100000); + } + if (result == GrabSuccess) { + XStoreName(x_display, w, GetString(STR_WINDOW_TITLE_GRABBED)); + ADBSetRelMouseMode(mouse_grabbed = true); + disable_mouse_accel(); + } +} + +// Ungrab mouse, switch to absolute mouse mode +void driver_window::ungrab_mouse(void) +{ + if (mouse_grabbed) { + XUngrabPointer(x_display, CurrentTime); + XStoreName(x_display, w, GetString(STR_WINDOW_TITLE)); + ADBSetRelMouseMode(mouse_grabbed = false); + restore_mouse_accel(); + } } -// Init fbdev DGA display -static bool init_fbdev_dga(char *in_fb_name) +// Mouse moved +void driver_window::mouse_moved(int x, int y) { + if (!mouse_grabbed) { + mouse_last_x = x; mouse_last_y = y; + ADBMouseMoved(x, y); + return; + } + + // Warped mouse motion (this code is taken from SDL) + + // Post first mouse event + int width = monitor.get_current_mode().x, height = monitor.get_current_mode().y; + int delta_x = x - mouse_last_x, delta_y = y - mouse_last_y; + mouse_last_x = x; mouse_last_y = y; + ADBMouseMoved(delta_x, delta_y); + + // Only warp the pointer when it has reached the edge + const int MOUSE_FUDGE_FACTOR = 8; + if (x < MOUSE_FUDGE_FACTOR || x > (width - MOUSE_FUDGE_FACTOR) + || y < MOUSE_FUDGE_FACTOR || y > (height - MOUSE_FUDGE_FACTOR)) { + XEvent event; + while (XCheckTypedEvent(x_display, MotionNotify, &event)) { + delta_x = x - mouse_last_x; delta_y = y - mouse_last_y; + mouse_last_x = x; mouse_last_y = y; + ADBMouseMoved(delta_x, delta_y); + } + mouse_last_x = width/2; + mouse_last_y = height/2; + XWarpPointer(x_display, None, w, 0, 0, 0, 0, mouse_last_x, mouse_last_y); + for (int i=0; i<10; i++) { + XMaskEvent(x_display, PointerMotionMask, &event); + if (event.xmotion.x > (mouse_last_x - MOUSE_FUDGE_FACTOR) + && event.xmotion.x < (mouse_last_x + MOUSE_FUDGE_FACTOR) + && event.xmotion.y > (mouse_last_y - MOUSE_FUDGE_FACTOR) + && event.xmotion.y < (mouse_last_y + MOUSE_FUDGE_FACTOR)) + break; + } + } +} + + +#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) +/* + * DGA display driver base class + */ + +class driver_dga : public driver_base { +public: + driver_dga(X11_monitor_desc &monitor); + ~driver_dga(); + + void suspend(void); + void resume(void); + +private: + Window suspend_win; // "Suspend" information window + void *fb_save; // Saved frame buffer for suspend/resume +}; + +driver_dga::driver_dga(X11_monitor_desc &m) + : driver_base(m), suspend_win(0), fb_save(NULL) +{ +} + +driver_dga::~driver_dga() +{ + XUngrabPointer(x_display, CurrentTime); + XUngrabKeyboard(x_display, CurrentTime); +} + +// Suspend emulation +void driver_dga::suspend(void) +{ + // Release ctrl key + ADBKeyUp(0x36); + ctrl_down = false; + + // Lock frame buffer (this will stop the MacOS thread) + LOCK_FRAME_BUFFER; + + // Save frame buffer + fb_save = malloc(mode.y * mode.bytes_per_row); + if (fb_save) + memcpy(fb_save, the_buffer, mode.y * mode.bytes_per_row); + + // Close full screen display +#ifdef ENABLE_XF86_DGA + XF86DGADirectVideo(x_display, screen, 0); +#endif + XUngrabPointer(x_display, CurrentTime); + XUngrabKeyboard(x_display, CurrentTime); + restore_mouse_accel(); + XUnmapWindow(x_display, w); + wait_unmapped(w); + + // Open "suspend" window + XSetWindowAttributes wattr; + wattr.event_mask = KeyPressMask; + wattr.background_pixel = black_pixel; + + suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth, + InputOutput, vis, CWEventMask | CWBackPixel, &wattr); + set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE); + set_window_focus(suspend_win); + XMapWindow(x_display, suspend_win); + emul_suspended = true; +} + +// Resume emulation +void driver_dga::resume(void) +{ + // Close "suspend" window + XDestroyWindow(x_display, suspend_win); + XSync(x_display, false); + + // Reopen full screen display + XMapRaised(x_display, w); + wait_mapped(w); + XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0); + XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime); + XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); + disable_mouse_accel(); +#ifdef ENABLE_XF86_DGA + XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse); + XF86DGASetViewPort(x_display, screen, 0, 0); +#endif + XSync(x_display, false); + + // the_buffer already contains the data to restore. i.e. since a temporary + // frame buffer is used when VOSF is actually used, fb_save is therefore + // not necessary. +#ifdef ENABLE_VOSF + if (use_vosf) { + LOCK_VOSF; + PFLAG_SET_ALL; + UNLOCK_VOSF; + memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y); + } +#endif + + // Restore frame buffer + if (fb_save) { +#ifdef ENABLE_VOSF + // Don't copy fb_save to the temporary frame buffer in VOSF mode + if (!use_vosf) +#endif + memcpy(the_buffer, fb_save, mode.y * mode.bytes_per_row); + free(fb_save); + fb_save = NULL; + } + + // Unlock frame buffer (and continue MacOS thread) + UNLOCK_FRAME_BUFFER; + emul_suspended = false; +} +#endif + + #ifdef ENABLE_FBDEV_DGA +/* + * fbdev DGA display driver + */ + +const char FBDEVICES_FILE_NAME[] = DATADIR "/fbdevices"; +const char FBDEVICE_FILE_NAME[] = "/dev/fb"; + +class driver_fbdev : public driver_dga { +public: + driver_fbdev(X11_monitor_desc &monitor); + ~driver_fbdev(); +}; + +// Open display +driver_fbdev::driver_fbdev(X11_monitor_desc &m) : driver_dga(m) +{ + int width = mode.x, height = mode.y; + + // Set absolute mouse mode + ADBSetRelMouseMode(false); + // Find the maximum depth available int ndepths, max_depth(0); int *depths = XListDepths(x_display, screen, &ndepths); if (depths == NULL) { printf("FATAL: Could not determine the maximal depth available\n"); - return false; + return; } else { while (ndepths-- > 0) { if (depths[ndepths] > max_depth) @@ -561,7 +1039,7 @@ static bool init_fbdev_dga(char *in_fb_n char str[256]; sprintf(str, GetString(STR_NO_FBDEVICE_FILE_ERR), fbd_path ? fbd_path : FBDEVICES_FILE_NAME, strerror(errno)); ErrorAlert(str); - return false; + return; } int fb_depth; // supported depth @@ -580,8 +1058,8 @@ static bool init_fbdev_dga(char *in_fb_n if ((line[0] == '#') || (line[0] == ';') || (line[0] == '\0')) continue; - if ((sscanf(line, "%19s %d %x", &fb_name, &fb_depth, &fb_offset) == 3) - && (strcmp(fb_name, in_fb_name) == 0) && (fb_depth == max_depth)) { + if ((sscanf(line, "%19s %d %x", fb_name, &fb_depth, &fb_offset) == 3) + && (strcmp(fb_name, fb_name) == 0) && (fb_depth == max_depth)) { device_found = true; break; } @@ -593,18 +1071,11 @@ static bool init_fbdev_dga(char *in_fb_n // Frame buffer name not found ? Then, display warning if (!device_found) { char str[256]; - sprintf(str, GetString(STR_FBDEV_NAME_ERR), in_fb_name, max_depth); + sprintf(str, GetString(STR_FBDEV_NAME_ERR), fb_name, max_depth); ErrorAlert(str); - return false; + return; } - int width = DisplayWidth(x_display, screen); - int height = DisplayHeight(x_display, screen); - depth = fb_depth; // max_depth - - // Set relative mouse mode - ADBSetRelMouseMode(false); - // Create window XSetWindowAttributes wattr; wattr.event_mask = eventmask = dga_eventmask; @@ -612,93 +1083,117 @@ static bool init_fbdev_dga(char *in_fb_n wattr.override_redirect = True; wattr.colormap = cmap[0]; - the_win = XCreateWindow(x_display, rootwin, + w = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, InputOutput, vis, - CWEventMask | CWBackPixel | CWOverrideRedirect | (depth == 8 ? CWColormap : 0), + CWEventMask | CWBackPixel | CWOverrideRedirect | (fb_depth <= 8 ? CWColormap : 0), &wattr); // Set window name/class - set_window_name(the_win, STR_WINDOW_TITLE); + set_window_name(w, STR_WINDOW_TITLE); // Indicate that we want keyboard input - set_window_focus(the_win); + set_window_focus(w); // Show window - XMapRaised(x_display, the_win); - wait_mapped(the_win); + XMapRaised(x_display, w); + wait_mapped(w); // Grab mouse and keyboard - XGrabKeyboard(x_display, the_win, True, + XGrabKeyboard(x_display, w, True, GrabModeAsync, GrabModeAsync, CurrentTime); - XGrabPointer(x_display, the_win, True, + XGrabPointer(x_display, w, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, - GrabModeAsync, GrabModeAsync, the_win, None, CurrentTime); + GrabModeAsync, GrabModeAsync, w, None, CurrentTime); + disable_mouse_accel(); - // Set VideoMonitor - int bytes_per_row = width; - switch (depth) { - case 1: - bytes_per_row = ((width | 7) & ~7) >> 3; - break; - case 15: - case 16: - bytes_per_row *= 2; - break; - case 24: - case 32: - bytes_per_row *= 4; - break; - } + // Calculate bytes per row + int bytes_per_row = TrivialBytesPerRow(mode.x, mode.depth); - if ((the_buffer = (uint8 *) mmap(NULL, height * bytes_per_row, PROT_READ | PROT_WRITE, MAP_PRIVATE, fbdev_fd, fb_offset)) == MAP_FAILED) { - if ((the_buffer = (uint8 *) mmap(NULL, height * bytes_per_row, PROT_READ | PROT_WRITE, MAP_SHARED, fbdev_fd, fb_offset)) == MAP_FAILED) { + // Map frame buffer + the_buffer_size = height * bytes_per_row; + if ((the_buffer = (uint8 *) mmap(NULL, the_buffer_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fbdev_fd, fb_offset)) == MAP_FAILED) { + if ((the_buffer = (uint8 *) mmap(NULL, the_buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, fbdev_fd, fb_offset)) == MAP_FAILED) { char str[256]; sprintf(str, GetString(STR_FBDEV_MMAP_ERR), strerror(errno)); ErrorAlert(str); - return false; + return; } } #if ENABLE_VOSF #if REAL_ADDRESSING || DIRECT_ADDRESSING - // If the blit function is null, i.e. just a copy of the buffer, - // we first try to avoid the allocation of a temporary frame buffer - use_vosf = true; - do_update_framebuffer = GET_FBCOPY_FUNC(depth, true, DISPLAY_DGA); - if (do_update_framebuffer == FBCOPY_FUNC(fbcopy_raw)) - use_vosf = false; + // Screen_blitter_init() returns TRUE if VOSF is mandatory + // i.e. the framebuffer update function is not Blit_Copy_Raw + use_vosf = Screen_blitter_init(visualFormat, true, mode.depth); if (use_vosf) { - the_host_buffer = the_buffer; - the_buffer_size = align_on_page_boundary((height + 2) * bytes_per_row); - the_buffer_copy = (uint8 *)malloc(the_buffer_size); - memset(the_buffer_copy, 0, the_buffer_size); - the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size); - memset(the_buffer, 0, the_buffer_size); + // Allocate memory for frame buffer (SIZE is extended to page-boundary) + the_host_buffer = the_buffer; + the_buffer_size = page_extend((height + 2) * bytes_per_row); + the_buffer_copy = (uint8 *)malloc(the_buffer_size); + the_buffer = (uint8 *)vm_acquire_mac(the_buffer_size); } #else use_vosf = false; #endif #endif - set_video_monitor(width, height, bytes_per_row, true); -#if REAL_ADDRESSING || DIRECT_ADDRESSING - VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer); -#else - VideoMonitor.mac_frame_base = MacFrameBaseMac; -#endif - return true; -#else - ErrorAlert("Basilisk II has been compiled with fbdev DGA support disabled."); - return false; + // Set frame buffer base + const_cast(&mode)->bytes_per_row = bytes_per_row; + const_cast(&mode)->depth = DepthModeForPixelDepth(fb_depth); + set_mac_frame_buffer(monitor, mode.depth, true); + + // Everything went well + init_ok = true; +} + +// Close display +driver_fbdev::~driver_fbdev() +{ + if (!use_vosf) { + if (the_buffer != MAP_FAILED) { + // don't free() the screen buffer in driver_base dtor + munmap(the_buffer, the_buffer_size); + the_buffer = NULL; + } + } +#ifdef ENABLE_VOSF + else { + if (the_host_buffer != MAP_FAILED) { + // don't free() the screen buffer in driver_base dtor + munmap(the_host_buffer, the_buffer_size); + the_host_buffer = NULL; + } + } #endif } +#endif + -// Init XF86 DGA display -static bool init_xf86_dga(int width, int height) -{ #ifdef ENABLE_XF86_DGA +/* + * XFree86 DGA display driver + */ + +class driver_xf86dga : public driver_dga { +public: + driver_xf86dga(X11_monitor_desc &monitor); + ~driver_xf86dga(); + + void update_palette(void); + void resume(void); + +private: + int current_dga_cmap; // Number (0 or 1) of currently installed DGA colormap +}; + +// Open display +driver_xf86dga::driver_xf86dga(X11_monitor_desc &m) + : driver_dga(m), current_dga_cmap(0) +{ + int width = mode.x, height = mode.y; + // Set relative mouse mode ADBSetRelMouseMode(true); @@ -722,25 +1217,28 @@ static bool init_xf86_dga(int width, int XSetWindowAttributes wattr; wattr.event_mask = eventmask = dga_eventmask; wattr.override_redirect = True; + wattr.colormap = (mode.depth == VDEPTH_1BIT ? DefaultColormap(x_display, screen) : cmap[0]); - the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, - InputOutput, vis, CWEventMask | CWOverrideRedirect, &wattr); + w = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, + InputOutput, vis, CWEventMask | CWOverrideRedirect | + (color_class == DirectColor ? CWColormap : 0), &wattr); // Set window name/class - set_window_name(the_win, STR_WINDOW_TITLE); + set_window_name(w, STR_WINDOW_TITLE); // Indicate that we want keyboard input - set_window_focus(the_win); + set_window_focus(w); // Show window - XMapRaised(x_display, the_win); - wait_mapped(the_win); + XMapRaised(x_display, w); + wait_mapped(w); // Establish direct screen connection - XMoveResizeWindow(x_display, the_win, 0, 0, width, height); + XMoveResizeWindow(x_display, w, 0, 0, width, height); XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0); XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime); XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); + disable_mouse_accel(); int v_width, v_bank, v_size; XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size); @@ -749,63 +1247,89 @@ static bool init_xf86_dga(int width, int XF86DGASetVidPage(x_display, screen, 0); // Set colormap - if (depth == 8) { - XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]); + if (!IsDirectMode(mode)) { + XSetWindowColormap(x_display, w, cmap[current_dga_cmap = 0]); XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); } XSync(x_display, false); - // Set VideoMonitor - int bytes_per_row = (v_width + 7) & ~7; - switch (depth) { - case 1: - bytes_per_row /= 8; - break; - case 15: - case 16: - bytes_per_row *= 2; - break; - case 24: - case 32: - bytes_per_row *= 4; - break; - } - + // Init blitting routines + int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, mode.depth); +#if ENABLE_VOSF + bool native_byte_order; +#ifdef WORDS_BIGENDIAN + native_byte_order = (XImageByteOrder(x_display) == MSBFirst); +#else + native_byte_order = (XImageByteOrder(x_display) == LSBFirst); +#endif #if REAL_ADDRESSING || DIRECT_ADDRESSING - // If the blit function is null, i.e. just a copy of the buffer, - // we first try to avoid the allocation of a temporary frame buffer - use_vosf = true; - do_update_framebuffer = GET_FBCOPY_FUNC(depth, true, DISPLAY_DGA); - if (do_update_framebuffer == FBCOPY_FUNC(fbcopy_raw)) - use_vosf = false; + // Screen_blitter_init() returns TRUE if VOSF is mandatory + // i.e. the framebuffer update function is not Blit_Copy_Raw + use_vosf = Screen_blitter_init(visualFormat, native_byte_order, depth_of_video_mode(mode)); if (use_vosf) { - the_host_buffer = the_buffer; - the_buffer_size = align_on_page_boundary((height + 2) * bytes_per_row); - the_buffer_copy = (uint8 *)malloc(the_buffer_size); - memset(the_buffer_copy, 0, the_buffer_size); - the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size); - memset(the_buffer, 0, the_buffer_size); + // Allocate memory for frame buffer (SIZE is extended to page-boundary) + the_host_buffer = the_buffer; + the_buffer_size = page_extend((height + 2) * bytes_per_row); + the_buffer_copy = (uint8 *)malloc(the_buffer_size); + the_buffer = (uint8 *)vm_acquire_mac(the_buffer_size); } -#elif defined(ENABLE_VOSF) - // The UAE memory handlers will already handle color conversion, if needed. +#else use_vosf = false; #endif +#endif - set_video_monitor(width, height, bytes_per_row, true); -#if REAL_ADDRESSING || DIRECT_ADDRESSING - VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer); -// MacFrameLayout = FLAYOUT_DIRECT; -#else - VideoMonitor.mac_frame_base = MacFrameBaseMac; + // Set frame buffer base + const_cast(&mode)->bytes_per_row = bytes_per_row; + set_mac_frame_buffer(monitor, mode.depth, true); + + // Everything went well + init_ok = true; +} + +// Close display +driver_xf86dga::~driver_xf86dga() +{ + XF86DGADirectVideo(x_display, screen, 0); + if (!use_vosf) { + // don't free() the screen buffer in driver_base dtor + the_buffer = NULL; + } +#ifdef ENABLE_VOSF + else { + // don't free() the screen buffer in driver_base dtor + the_host_buffer = NULL; + } #endif - return true; -#else - ErrorAlert("Basilisk II has been compiled with XF86 DGA support disabled."); - return false; +#ifdef ENABLE_XF86_VIDMODE + if (has_vidmode) + XF86VidModeSwitchToMode(x_display, screen, x_video_modes[0]); #endif } +// Palette has changed +void driver_xf86dga::update_palette(void) +{ + driver_dga::update_palette(); + current_dga_cmap ^= 1; + if (!IsDirectMode(monitor.get_current_mode()) && cmap[current_dga_cmap]) + XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); +} + +// Resume emulation +void driver_xf86dga::resume(void) +{ + driver_dga::resume(); + if (!IsDirectMode(monitor.get_current_mode())) + XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); +} +#endif + + +/* + * Initialization + */ + // Init keycode translation table static void keycode_init(void) { @@ -830,6 +1354,10 @@ static void keycode_init(void) // Search for server vendor string, then read keycodes const char *vendor = ServerVendor(x_display); + // Force use of MacX mappings on MacOS X with Apple's X server + int dummy; + if (XQueryExtension(x_display, "Apple-DRI", &dummy, &dummy, &dummy)) + vendor = "MacX"; bool vendor_found = false; char line[256]; while (fgets(line, 255, f)) { @@ -871,79 +1399,152 @@ static void keycode_init(void) } } -bool VideoInitBuffer() +// Open display for current mode +bool X11_monitor_desc::video_open(void) { -#ifdef ENABLE_VOSF - if (use_vosf) { - const uint32 page_size = getpagesize(); - const uint32 page_mask = page_size - 1; - - mainBuffer.memBase = (uint32) the_buffer; - // Align the frame buffer on page boundary - mainBuffer.memStart = (uint32)((((unsigned long) the_buffer) + page_mask) & ~page_mask); - mainBuffer.memLength = the_buffer_size; - mainBuffer.memEnd = mainBuffer.memStart + mainBuffer.memLength; + D(bug("video_open()\n")); + const video_mode &mode = get_current_mode(); - mainBuffer.pageSize = page_size; - mainBuffer.pageCount = (mainBuffer.memLength + page_mask)/mainBuffer.pageSize; - mainBuffer.pageBits = log_base_2(mainBuffer.pageSize); + // Find best available X visual + if (!find_visual_for_depth(mode.depth)) { + ErrorAlert(STR_NO_XVISUAL_ERR); + return false; + } - if (mainBuffer.dirtyPages != 0) - free(mainBuffer.dirtyPages); + // Build up visualFormat structure + visualFormat.depth = visualInfo.depth; + visualFormat.Rmask = visualInfo.red_mask; + visualFormat.Gmask = visualInfo.green_mask; + visualFormat.Bmask = visualInfo.blue_mask; - mainBuffer.dirtyPages = (uint8 *) malloc(mainBuffer.pageCount); + // Create color maps + if (color_class == PseudoColor || color_class == DirectColor) { + cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll); + cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll); + } else { + cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocNone); + cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocNone); + } - if (mainBuffer.pageInfo != 0) - free(mainBuffer.pageInfo); + // Find pixel format of direct modes + if (color_class == DirectColor || color_class == TrueColor) { + rshift = gshift = bshift = 0; + rloss = gloss = bloss = 8; + uint32 mask; + for (mask=vis->red_mask; !(mask&1); mask>>=1) + ++rshift; + for (; mask&1; mask>>=1) + --rloss; + for (mask=vis->green_mask; !(mask&1); mask>>=1) + ++gshift; + for (; mask&1; mask>>=1) + --gloss; + for (mask=vis->blue_mask; !(mask&1); mask>>=1) + ++bshift; + for (; mask&1; mask>>=1) + --bloss; + } + + // Preset palette pixel values for CLUT or gamma table + if (color_class == DirectColor) { + int num = vis->map_entries; + for (int i=0; imap_entries : 256); + for (int i=0; i16/32 expand map + if (!IsDirectMode(mode) && xdepth > 8) + for (int i=0; i<256; i++) + ExpandMap[i] = map_rgb(i, i, i); +#endif - PFLAG_CLEAR_ALL; + // Create display driver object of requested type + switch (display_type) { + case DISPLAY_WINDOW: + drv = new driver_window(*this); + break; +#ifdef ENABLE_FBDEV_DGA + case DISPLAY_DGA: + drv = new driver_fbdev(*this); + break; +#endif +#ifdef ENABLE_XF86_DGA + case DISPLAY_DGA: + drv = new driver_xf86dga(*this); + break; +#endif + } + if (drv == NULL) + return false; + if (!drv->init_ok) { + delete drv; + drv = NULL; + return false; + } - uint32 a = 0; - for (int i = 0; i < mainBuffer.pageCount; i++) { - int y1 = a / VideoMonitor.bytes_per_row; - if (y1 >= VideoMonitor.y) - y1 = VideoMonitor.y - 1; - - int y2 = (a + mainBuffer.pageSize) / VideoMonitor.bytes_per_row; - if (y2 >= VideoMonitor.y) - y2 = VideoMonitor.y - 1; - - mainBuffer.pageInfo[i].top = y1; - mainBuffer.pageInfo[i].bottom = y2; - - a += mainBuffer.pageSize; - if (a > mainBuffer.memLength) - a = mainBuffer.memLength; +#ifdef ENABLE_VOSF + if (use_vosf) { + // Initialize the VOSF system + if (!video_vosf_init(*this)) { + ErrorAlert(STR_VOSF_INIT_ERR); + return false; } - - // We can now write-protect the frame buffer - if (mprotect((caddr_t)mainBuffer.memStart, mainBuffer.memLength, PROT_READ) != 0) - return false; } #endif + + // Initialize VideoRefresh function + VideoRefreshInit(); + + // Lock down frame buffer + XSync(x_display, false); + LOCK_FRAME_BUFFER; + + // Start redraw/input thread +#ifdef HAVE_PTHREADS + redraw_thread_cancel = false; + Set_pthread_attr(&redraw_thread_attr, 0); + redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0); + if (!redraw_thread_active) { + printf("FATAL: cannot create redraw thread\n"); + return false; + } +#else + redraw_thread_active = true; +#endif + return true; } bool VideoInit(bool classic) { + classic_mode = classic; + #ifdef ENABLE_VOSF - // Open /dev/zero - zero_fd = open("/dev/zero", O_RDWR); - if (zero_fd < 0) { - char str[256]; - sprintf(str, GetString(STR_NO_DEV_ZERO_ERR), strerror(errno)); - ErrorAlert(str); - return false; - } - // Zero the mainBuffer structure - mainBuffer.dirtyPages = 0; - mainBuffer.pageInfo = 0; + mainBuffer.dirtyPages = NULL; + mainBuffer.pageInfo = NULL; #endif // Check if X server runs on local machine @@ -954,21 +1555,27 @@ bool VideoInit(bool classic) keycode_init(); // Read prefs - mouse_wheel_mode = PrefsFindInt16("mousewheelmode"); - mouse_wheel_lines = PrefsFindInt16("mousewheellines"); + frame_skip = PrefsFindInt32("frameskip"); + mouse_wheel_mode = PrefsFindInt32("mousewheelmode"); + mouse_wheel_lines = PrefsFindInt32("mousewheellines"); // Find screen and root window screen = XDefaultScreen(x_display); rootwin = XRootWindow(x_display, screen); - - // Get screen depth - xdepth = DefaultDepth(x_display, screen); + + // Get sorted list of available depths + avail_depths = XListDepths(x_display, screen, &num_depths); + if (avail_depths == NULL) { + ErrorAlert(STR_UNSUPP_DEPTH_ERR); + return false; + } + std::sort(avail_depths, avail_depths + num_depths); #ifdef ENABLE_FBDEV_DGA // Frame buffer name char fb_name[20]; - // Could do fbdev dga ? + // Could do fbdev DGA? if ((fbdev_fd = open(FBDEVICE_FILE_NAME, O_RDWR)) != -1) has_dga = true; else @@ -1002,141 +1609,102 @@ bool VideoInit(bool classic) black_pixel = BlackPixel(x_display, screen); white_pixel = WhitePixel(x_display, screen); - // Get appropriate visual - int color_class; - switch (xdepth) { - case 1: - color_class = StaticGray; - break; - case 8: - color_class = PseudoColor; - break; - case 15: - case 16: - case 24: - case 32: - color_class = TrueColor; - break; - default: - ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR)); - return false; - } - if (!XMatchVisualInfo(x_display, screen, xdepth, color_class, &visualInfo)) { - ErrorAlert(GetString(STR_NO_XVISUAL_ERR)); - return false; - } - if (visualInfo.depth != xdepth) { - ErrorAlert(GetString(STR_NO_XVISUAL_ERR)); - return false; - } - vis = visualInfo.visual; - - // Mac screen depth is always 1 bit in Classic mode, but follows X depth otherwise - classic_mode = classic; - if (classic) - depth = 1; - else - depth = xdepth; - - // Create color maps for 8 bit mode - if (depth == 8) { - cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll); - cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll); - XInstallColormap(x_display, cmap[0]); - XInstallColormap(x_display, cmap[1]); - } - // Get screen mode from preferences const char *mode_str; - if (classic) + if (classic_mode) mode_str = "win/512/342"; else mode_str = PrefsFindString("screen"); - // Determine type and mode - int width = 512, height = 384; + // Determine display type and default dimensions + int default_width = 512, default_height = 384; display_type = DISPLAY_WINDOW; if (mode_str) { - if (sscanf(mode_str, "win/%d/%d", &width, &height) == 2) + if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2) { display_type = DISPLAY_WINDOW; #ifdef ENABLE_FBDEV_DGA - else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) { -#else - else if (has_dga && sscanf(mode_str, "dga/%d/%d", &width, &height) == 2) { + } else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) { + display_type = DISPLAY_DGA; + default_width = -1; default_height = -1; // use entire screen #endif +#ifdef ENABLE_XF86_DGA + } else if (has_dga && sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2) { display_type = DISPLAY_DGA; - if (width > DisplayWidth(x_display, screen)) - width = DisplayWidth(x_display, screen); - if (height > DisplayHeight(x_display, screen)) - height = DisplayHeight(x_display, screen); - } - if (width <= 0) - width = DisplayWidth(x_display, screen); - if (height <= 0) - height = DisplayHeight(x_display, screen); +#endif + } } - - // Initialize according to display type - switch (display_type) { - case DISPLAY_WINDOW: - if (!init_window(width, height)) - return false; + if (default_width <= 0) + default_width = DisplayWidth(x_display, screen); + else if (default_width > DisplayWidth(x_display, screen)) + default_width = DisplayWidth(x_display, screen); + if (default_height <= 0) + default_height = DisplayHeight(x_display, screen); + else if (default_height > DisplayHeight(x_display, screen)) + default_height = DisplayHeight(x_display, screen); + + // Mac screen depth follows X depth + video_depth default_depth = VDEPTH_1BIT; + switch (DefaultDepth(x_display, screen)) { + case 8: + default_depth = VDEPTH_8BIT; break; - case DISPLAY_DGA: -#ifdef ENABLE_FBDEV_DGA - if (!init_fbdev_dga(fb_name)) -#else - if (!init_xf86_dga(width, height)) -#endif - return false; + case 15: case 16: + default_depth = VDEPTH_16BIT; + break; + case 24: case 32: + default_depth = VDEPTH_32BIT; break; } - // Lock down frame buffer - LOCK_FRAME_BUFFER; - -#if !REAL_ADDRESSING && !DIRECT_ADDRESSING - // Set variables for UAE memory mapping - MacFrameBaseHost = the_buffer; - MacFrameSize = VideoMonitor.bytes_per_row * VideoMonitor.y; - - // No special frame buffer in Classic mode (frame buffer is in Mac RAM) - if (classic) - MacFrameLayout = FLAYOUT_NONE; -#endif - -#ifdef ENABLE_VOSF - if (use_vosf) { - // Initialize the mainBuffer structure - if (!VideoInitBuffer()) { - // TODO: STR_VOSF_INIT_ERR ? - ErrorAlert("Could not initialize Video on SEGV signals"); - return false; + // Construct list of supported modes + if (display_type == DISPLAY_WINDOW) { + if (classic) + add_mode(512, 342, 0x80, 64, VDEPTH_1BIT); + else { + for (unsigned d=VDEPTH_1BIT; d<=VDEPTH_32BIT; d++) { + if (find_visual_for_depth(video_depth(d))) + add_window_modes(video_depth(d)); + } } + } else + add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, default_depth), default_depth); + if (VideoModes.empty()) { + ErrorAlert(STR_NO_XVISUAL_ERR); + return false; + } - // Initialize the handler for SIGSEGV - if (!Screen_fault_handler_init()) { - // TODO: STR_VOSF_INIT_ERR ? - ErrorAlert("Could not initialize Video on SEGV signals"); - return false; + // Find requested default mode with specified dimensions + uint32 default_id; + std::vector::const_iterator i, end = VideoModes.end(); + for (i = VideoModes.begin(); i != end; ++i) { + if (i->x == default_width && i->y == default_height && i->depth == default_depth) { + default_id = i->resolution_id; + break; } } -#endif - - // Initialize VideoRefresh function - VideoRefreshInit(); - - XSync(x_display, false); + if (i == end) { // not found, use first available mode + default_depth = VideoModes[0].depth; + default_id = VideoModes[0].resolution_id; + } -#ifdef HAVE_PTHREADS - // Start redraw/input thread - redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0); - if (!redraw_thread_active) { - printf("FATAL: cannot create redraw thread\n"); - return false; +#if DEBUG + D(bug("Available video modes:\n")); + for (i = VideoModes.begin(); i != end; ++i) { + int bits = 1 << i->depth; + if (bits == 16) + bits = 15; + else if (bits == 32) + bits = 24; + D(bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits)); } #endif - return true; + + // Create X11_monitor_desc for this (the only) display + X11_monitor_desc *monitor = new X11_monitor_desc(VideoModes, default_depth, default_id); + VideoMonitors.push_back(monitor); + + // Open display + return monitor->video_open(); } @@ -1144,99 +1712,77 @@ bool VideoInit(bool classic) * Deinitialization */ -void VideoExit(void) +// Close display +void X11_monitor_desc::video_close(void) { -#ifdef HAVE_PTHREADS + D(bug("video_close()\n")); + // Stop redraw thread +#ifdef HAVE_PTHREADS if (redraw_thread_active) { redraw_thread_cancel = true; -#ifdef HAVE_PTHREAD_CANCEL - pthread_cancel(redraw_thread); -#endif + redraw_thread_cancel_ack = false; pthread_join(redraw_thread, NULL); - redraw_thread_active = false; + while (!redraw_thread_cancel_ack) ; } #endif + redraw_thread_active = false; // Unlock frame buffer UNLOCK_FRAME_BUFFER; + XSync(x_display, false); + D(bug(" frame buffer unlocked\n")); - // Close window and server connection - if (x_display != NULL) { - XSync(x_display, false); - -#ifdef ENABLE_XF86_DGA - if (display_type == DISPLAY_DGA) { - XF86DGADirectVideo(x_display, screen, 0); - XUngrabPointer(x_display, CurrentTime); - XUngrabKeyboard(x_display, CurrentTime); - } +#ifdef ENABLE_VOSF + if (use_vosf) { + // Deinitialize VOSF + video_vosf_exit(); + } #endif -#ifdef ENABLE_XF86_VIDMODE - if (has_vidmode && display_type == DISPLAY_DGA) - XF86VidModeSwitchToMode(x_display, screen, x_video_modes[0]); -#endif + // Close display + delete drv; + drv = NULL; -#ifdef ENABLE_FBDEV_DGA - if (display_type == DISPLAY_DGA) { - XUngrabPointer(x_display, CurrentTime); - XUngrabKeyboard(x_display, CurrentTime); - close(fbdev_fd); - } -#endif + // Free colormaps + if (cmap[0]) { + XFreeColormap(x_display, cmap[0]); + cmap[0] = 0; + } + if (cmap[1]) { + XFreeColormap(x_display, cmap[1]); + cmap[1] = 0; + } +} - XFlush(x_display); - XSync(x_display, false); - if (depth == 8) { - XFreeColormap(x_display, cmap[0]); - XFreeColormap(x_display, cmap[1]); - } - - if (!use_vosf) { - if (the_buffer) { - free(the_buffer); - the_buffer = NULL; - } +void VideoExit(void) +{ + // Close displays + vector::iterator i, end = VideoMonitors.end(); + for (i = VideoMonitors.begin(); i != end; ++i) + dynamic_cast(*i)->video_close(); - if (!have_shm && the_buffer_copy) { - free(the_buffer_copy); - the_buffer_copy = NULL; - } - } -#ifdef ENABLE_VOSF - else { - if (the_buffer != (uint8 *)MAP_FAILED) { - munmap((caddr_t)the_buffer, the_buffer_size); - the_buffer = 0; - } - - if (the_buffer_copy != (uint8 *)MAP_FAILED) { - munmap((caddr_t)the_buffer_copy, the_buffer_size); - the_buffer_copy = 0; - } - } -#endif +#ifdef ENABLE_XF86_VIDMODE + // Free video mode list + if (x_video_modes) { + XFree(x_video_modes); + x_video_modes = NULL; } - -#ifdef ENABLE_VOSF - if (use_vosf) { - // Clear mainBuffer data - if (mainBuffer.pageInfo) { - free(mainBuffer.pageInfo); - mainBuffer.pageInfo = 0; - } +#endif - if (mainBuffer.dirtyPages) { - free(mainBuffer.dirtyPages); - mainBuffer.dirtyPages = 0; - } +#ifdef ENABLE_FBDEV_DGA + // Close framebuffer device + if (fbdev_fd >= 0) { + close(fbdev_fd); + fbdev_fd = -1; } - - // Close /dev/zero - if (zero_fd > 0) - close(zero_fd); #endif + + // Free depth list + if (avail_depths) { + XFree(avail_depths); + avail_depths = NULL; + } } @@ -1247,8 +1793,7 @@ void VideoExit(void) void VideoQuitFullScreen(void) { D(bug("VideoQuitFullScreen()\n")); - if (display_type == DISPLAY_DGA) - quit_full_screen = true; + quit_full_screen = true; } @@ -1273,127 +1818,75 @@ void VideoInterrupt(void) * Set palette */ -void video_set_palette(uint8 *pal) +void X11_monitor_desc::set_palette(uint8 *pal, int num_in) { + const video_mode &mode = get_current_mode(); + LOCK_PALETTE; // Convert colors to XColor array - for (int i=0; i<256; i++) { - palette[i].pixel = i; - palette[i].red = pal[i*3] * 0x0101; - palette[i].green = pal[i*3+1] * 0x0101; - palette[i].blue = pal[i*3+2] * 0x0101; - palette[i].flags = DoRed | DoGreen | DoBlue; + int num_out = 256; + bool stretch = false; + if (IsDirectMode(mode)) { + // If X is in 565 mode we have to stretch the gamma table from 32 to 64 entries + num_out = vis->map_entries; + stretch = true; + } + XColor *p = x_palette; + for (int i=0; ired = pal[c*3 + 0] * 0x0101; + p->green = pal[c*3 + 1] * 0x0101; + p->blue = pal[c*3 + 2] * 0x0101; + p++; + } + +#ifdef ENABLE_VOSF + // Recalculate pixel color expansion map + if (!IsDirectMode(mode) && xdepth > 8) { + for (int i=0; i<256; i++) { + int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier) + ExpandMap[i] = map_rgb(pal[c*3+0], pal[c*3+1], pal[c*3+2]); + } + + // We have to redraw everything because the interpretation of pixel values changed + LOCK_VOSF; + PFLAG_SET_ALL; + UNLOCK_VOSF; + memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y); } +#endif // Tell redraw thread to change palette - palette_changed = true; + x_palette_changed = true; UNLOCK_PALETTE; } /* - * Suspend/resume emulator + * Switch video mode */ -#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) -static void suspend_emul(void) +void X11_monitor_desc::switch_to_current_mode(void) { - if (display_type == DISPLAY_DGA) { - // Release ctrl key - ADBKeyUp(0x36); - ctrl_down = false; - - // Lock frame buffer (this will stop the MacOS thread) - LOCK_FRAME_BUFFER; - - // Save frame buffer - fb_save = malloc(VideoMonitor.y * VideoMonitor.bytes_per_row); - if (fb_save) - memcpy(fb_save, the_buffer, VideoMonitor.y * VideoMonitor.bytes_per_row); + // Close and reopen display + video_close(); + video_open(); - // Close full screen display -#ifdef ENABLE_XF86_DGA - XF86DGADirectVideo(x_display, screen, 0); -#endif - XUngrabPointer(x_display, CurrentTime); - XUngrabKeyboard(x_display, CurrentTime); - XUnmapWindow(x_display, the_win); - wait_unmapped(the_win); - - // Open "suspend" window - XSetWindowAttributes wattr; - wattr.event_mask = KeyPressMask; - wattr.background_pixel = black_pixel; - - suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth, - InputOutput, vis, CWEventMask | CWBackPixel, &wattr); - set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE); - set_window_focus(suspend_win); - XMapWindow(x_display, suspend_win); - emul_suspended = true; - } -} - -static void resume_emul(void) -{ - // Close "suspend" window - XDestroyWindow(x_display, suspend_win); - XSync(x_display, false); - - // Reopen full screen display - XMapRaised(x_display, the_win); - wait_mapped(the_win); - XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0); - XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime); - XGrabPointer(x_display, rootwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); -#ifdef ENABLE_XF86_DGA - XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse); - XF86DGASetViewPort(x_display, screen, 0, 0); -#endif - XSync(x_display, false); - - // the_buffer already contains the data to restore. i.e. since a temporary - // frame buffer is used when VOSF is actually used, fb_save is therefore - // not necessary. -#ifdef ENABLE_VOSF - if (use_vosf) { - LOCK_VOSF; - PFLAG_SET_ALL; - UNLOCK_VOSF; - memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y); - } -#endif - - // Restore frame buffer - if (fb_save) { -#ifdef ENABLE_VOSF - // Don't copy fb_save to the temporary frame buffer in VOSF mode - if (!use_vosf) -#endif - memcpy(the_buffer, fb_save, VideoMonitor.y * VideoMonitor.bytes_per_row); - free(fb_save); - fb_save = NULL; + if (drv == NULL) { + ErrorAlert(STR_OPEN_WINDOW_ERR); + QuitEmulator(); } - -#ifdef ENABLE_XF86_DGA - if (depth == 8) - XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); -#endif - - // Unlock frame buffer (and continue MacOS thread) - UNLOCK_FRAME_BUFFER; - emul_suspended = false; } -#endif /* - * Translate key event to Mac keycode + * Translate key event to Mac keycode, returns -1 if no keycode was found + * and -2 if the key was recognized as a hotkey */ -static int kc_decode(KeySym ks) +static int kc_decode(KeySym ks, bool key_down) { switch (ks) { case XK_A: case XK_a: return 0x00; @@ -1446,11 +1939,7 @@ static int kc_decode(KeySym ks) case XK_period: case XK_greater: return 0x2f; case XK_slash: case XK_question: return 0x2c; -#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) - case XK_Tab: if (ctrl_down) {suspend_emul(); return -1;} else return 0x30; -#else - case XK_Tab: return 0x30; -#endif + case XK_Tab: if (ctrl_down) {if (key_down) drv->suspend(); return -2;} else return 0x30; case XK_Return: return 0x24; case XK_space: return 0x31; case XK_BackSpace: return 0x33; @@ -1484,13 +1973,13 @@ static int kc_decode(KeySym ks) case XK_Left: return 0x3b; case XK_Right: return 0x3c; - case XK_Escape: if (ctrl_down) {quit_full_screen = true; emerg_quit = true; return -1;} else return 0x35; + case XK_Escape: if (ctrl_down) {if (key_down) { quit_full_screen = true; emerg_quit = true; } return -2;} else return 0x35; - case XK_F1: if (ctrl_down) {SysMountFirstFloppy(); return -1;} else return 0x7a; + case XK_F1: if (ctrl_down) {if (key_down) SysMountFirstFloppy(); return -2;} else return 0x7a; case XK_F2: return 0x78; case XK_F3: return 0x63; case XK_F4: return 0x76; - case XK_F5: return 0x60; + case XK_F5: if (ctrl_down) {if (key_down) drv->toggle_mouse_grab(); return -2;} else return 0x60; case XK_F6: return 0x61; case XK_F7: return 0x62; case XK_F8: return 0x64; @@ -1538,16 +2027,17 @@ static int kc_decode(KeySym ks) return -1; } -static int event2keycode(XKeyEvent &ev) +static int event2keycode(XKeyEvent &ev, bool key_down) { KeySym ks; - int as; int i = 0; do { ks = XLookupKeysym(&ev, i++); - as = kc_decode(ks); - if (as != -1) + int as = kc_decode(ks, key_down); + if (as >= 0) + return as; + if (as == -2) return as; } while (ks != NoSymbol); @@ -1561,11 +2051,30 @@ static int event2keycode(XKeyEvent &ev) static void handle_events(void) { - while (XPending(x_display)) { + for (;;) { XEvent event; - XNextEvent(x_display, &event); + XDisplayLock(); + + if (!XCheckMaskEvent(x_display, eventmask, &event)) { + // Handle clipboard events + if (XCheckTypedEvent(x_display, SelectionRequest, &event)) + ClipboardSelectionRequest(&event.xselectionrequest); + else if (XCheckTypedEvent(x_display, SelectionClear, &event)) + ClipboardSelectionClear(&event.xselectionclear); + // Window "close" widget clicked + else if (XCheckTypedEvent(x_display, ClientMessage, &event)) { + if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) { + ADBKeyDown(0x7f); // Power key + ADBKeyUp(0x7f); + } + } + XDisplayUnlock(); + break; + } + switch (event.type) { + // Mouse button case ButtonPress: { unsigned int button = event.xbutton.button; @@ -1594,20 +2103,25 @@ static void handle_events(void) } // Mouse moved - case EnterNotify: case MotionNotify: - ADBMouseMoved(event.xmotion.x, event.xmotion.y); + drv->mouse_moved(event.xmotion.x, event.xmotion.y); + break; + + // Mouse entered window + case EnterNotify: + if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab) + drv->mouse_moved(event.xmotion.x, event.xmotion.y); break; // Keyboard case KeyPress: { - int code; + int code = -1; if (use_keycodes) { - event2keycode(event.xkey); // This is called to process the hotkeys - code = keycode_table[event.xkey.keycode & 0xff]; + if (event2keycode(event.xkey, true) != -2) // This is called to process the hotkeys + code = keycode_table[event.xkey.keycode & 0xff]; } else - code = event2keycode(event.xkey); - if (code != -1) { + code = event2keycode(event.xkey, true); + if (code >= 0) { if (!emul_suspended) { if (code == 0x39) { // Caps Lock pressed if (caps_on) { @@ -1622,22 +2136,20 @@ static void handle_events(void) if (code == 0x36) ctrl_down = true; } else { -#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) if (code == 0x31) - resume_emul(); // Space wakes us up -#endif + drv->resume(); // Space wakes us up } } break; } case KeyRelease: { - int code; + int code = -1; if (use_keycodes) { - event2keycode(event.xkey); // This is called to process the hotkeys - code = keycode_table[event.xkey.keycode & 0xff]; + if (event2keycode(event.xkey, false) != -2) // This is called to process the hotkeys + code = keycode_table[event.xkey.keycode & 0xff]; } else - code = event2keycode(event.xkey); - if (code != -1 && code != 0x39) { // Don't propagate Caps Lock releases + code = event2keycode(event.xkey, false); + if (code >= 0 && code != 0x39) { // Don't propagate Caps Lock releases ADBKeyUp(code); if (code == 0x36) ctrl_down = false; @@ -1648,12 +2160,13 @@ static void handle_events(void) // Hidden parts exposed, force complete refresh of window case Expose: if (display_type == DISPLAY_WINDOW) { + const video_mode &mode = VideoMonitors[0]->get_current_mode(); #ifdef ENABLE_VOSF if (use_vosf) { // VOSF refresh LOCK_VOSF; PFLAG_SET_ALL; UNLOCK_VOSF; - memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y); + memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y); } else #endif @@ -1664,18 +2177,12 @@ static void handle_events(void) updt_box[x1][y1] = true; nr_boxes = 16 * 16; } else // Static refresh - memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y); - } - break; - - // Window "close" widget clicked - case ClientMessage: - if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) { - ADBKeyDown(0x7f); // Power key - ADBKeyUp(0x7f); + memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y); } break; } + + XDisplayUnlock(); } } @@ -1685,15 +2192,16 @@ static void handle_events(void) */ // Dynamic display update (variable frame rate for each box) -static void update_display_dynamic(int ticker) +static void update_display_dynamic(int ticker, driver_window *drv) { int y1, y2, y2s, y2a, i, x1, xm, xmo, ymo, yo, yi, yil, xi; int xil = 0; int rxm = 0, rxmo = 0; - int bytes_per_row = VideoMonitor.bytes_per_row; - int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x; - int rx = VideoMonitor.bytes_per_row / 16; - int ry = VideoMonitor.y / 16; + const video_mode &mode = drv->monitor.get_current_mode(); + int bytes_per_row = mode.bytes_per_row; + int bytes_per_pixel = mode.bytes_per_row / mode.x; + int rx = mode.bytes_per_row / 16; + int ry = mode.y / 16; int max_box; y2s = sm_uptd[ticker % 8]; @@ -1719,6 +2227,7 @@ static void update_display_dynamic(int t } } + XDisplayLock(); if ((nr_boxes <= max_box) && (nr_boxes)) { for (y1=0; y1<16; y1++) { for (x1=0; x1<16; x1++) { @@ -1747,16 +2256,16 @@ static void update_display_dynamic(int t i = (yi * bytes_per_row) + xi; for (y2=0; y2 < yil; y2++, i += bytes_per_row) memcpy(&the_buffer_copy[i], &the_buffer[i], xil); - if (depth == 1) { - if (have_shm) - XShmPutImage(x_display, the_win, the_gc, img, xi * 8, yi, xi * 8, yi, xil * 8, yil, 0); + if (mode.depth == VDEPTH_1BIT) { + if (drv->have_shm) + XShmPutImage(x_display, drv->w, drv->gc, drv->img, xi * 8, yi, xi * 8, yi, xil * 8, yil, 0); else - XPutImage(x_display, the_win, the_gc, img, xi * 8, yi, xi * 8, yi, xil * 8, yil); + XPutImage(x_display, drv->w, drv->gc, drv->img, xi * 8, yi, xi * 8, yi, xil * 8, yil); } else { - if (have_shm) - XShmPutImage(x_display, the_win, the_gc, img, xi / bytes_per_pixel, yi, xi / bytes_per_pixel, yi, xil / bytes_per_pixel, yil, 0); + if (drv->have_shm) + XShmPutImage(x_display, drv->w, drv->gc, drv->img, xi / bytes_per_pixel, yi, xi / bytes_per_pixel, yi, xil / bytes_per_pixel, yil, 0); else - XPutImage(x_display, the_win, the_gc, img, xi / bytes_per_pixel, yi, xi / bytes_per_pixel, yi, xil / bytes_per_pixel, yil); + XPutImage(x_display, drv->w, drv->gc, drv->img, xi / bytes_per_pixel, yi, xi / bytes_per_pixel, yi, xil / bytes_per_pixel, yil); } xil = 0; } @@ -1772,27 +2281,29 @@ static void update_display_dynamic(int t } nr_boxes = 0; } + XDisplayUnlock(); } // Static display update (fixed frame rate, but incremental) -static void update_display_static(void) +static void update_display_static(driver_window *drv) { // Incremental update code - int wide = 0, high = 0, x1, x2, y1, y2, i, j; - int bytes_per_row = VideoMonitor.bytes_per_row; - int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x; + unsigned wide = 0, high = 0, x1, x2, y1, y2, i, j; + const video_mode &mode = drv->monitor.get_current_mode(); + int bytes_per_row = mode.bytes_per_row; + int bytes_per_pixel = mode.bytes_per_row / mode.x; uint8 *p, *p2; // Check for first line from top and first line from bottom that have changed y1 = 0; - for (j=0; j=y1; j--) { + for (j=mode.y-1; j>=y1; j--) { if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) { y2 = j; break; @@ -1802,8 +2313,8 @@ static void update_display_static(void) // Check for first column from left and first column from right that have changed if (high) { - if (depth == 1) { - x1 = VideoMonitor.x - 1; + if (mode.depth == VDEPTH_1BIT) { + x1 = mode.x - 1; for (j=y1; j<=y2; j++) { p = &the_buffer[j * bytes_per_row]; p2 = &the_buffer_copy[j * bytes_per_row]; @@ -1821,7 +2332,7 @@ static void update_display_static(void) p2 = &the_buffer_copy[j * bytes_per_row]; p += bytes_per_row; p2 += bytes_per_row; - for (i=(VideoMonitor.x>>3); i>(x2>>3); i--) { + for (i=(mode.x>>3); i>(x2>>3); i--) { p--; p2--; if (*p != *p2) { x2 = (i << 3) + 7; @@ -1840,7 +2351,7 @@ static void update_display_static(void) } } else { - x1 = VideoMonitor.x; + x1 = mode.x; for (j=y1; j<=y2; j++) { p = &the_buffer[j * bytes_per_row]; p2 = &the_buffer_copy[j * bytes_per_row]; @@ -1858,7 +2369,7 @@ static void update_display_static(void) p2 = &the_buffer_copy[j * bytes_per_row]; p += bytes_per_row; p2 += bytes_per_row; - for (i=VideoMonitor.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) { + for (i=mode.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) { p--; p2--; if (*p != *p2) { @@ -1880,12 +2391,14 @@ static void update_display_static(void) } // Refresh display + XDisplayLock(); if (high && wide) { - if (have_shm) - XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high, 0); + if (drv->have_shm) + XShmPutImage(x_display, drv->w, drv->gc, drv->img, x1, y1, x1, y1, wide, high, 0); else - XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high); + XPutImage(x_display, drv->w, drv->gc, drv->img, x1, y1, x1, y1, wide, high); } + XDisplayUnlock(); } @@ -1893,60 +2406,43 @@ static void update_display_static(void) * Screen refresh functions */ -// The specialisations hereunder are meant to enable VOSF with DGA in direct -// addressing mode in case the address spaces (RAM, ROM, FrameBuffer) could -// not get mapped correctly with respect to the predetermined host frame -// buffer base address. -// -// Hmm, in other words, when in direct addressing mode and DGA is requested, -// we first try to "triple allocate" the address spaces according to the real -// host frame buffer address. Then, if it fails, we will use a temporary -// frame buffer thus making the real host frame buffer updated when pages -// of the temp frame buffer are altered. -// -// As a side effect, a little speed gain in screen updates could be noticed -// for other modes than DGA. -// -// The following two functions below are inline so that a clever compiler -// could specialise the code according to the current screen depth and -// display type. A more clever compiler would the job by itself though... -// (update_display_vosf is inlined as well) +// We suggest the compiler to inline the next two functions so that it +// may specialise the code according to the current screen depth and +// display type. A clever compiler would do that job by itself though... + +// NOTE: update_display_vosf is inlined too static inline void possibly_quit_dga_mode() { -#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA) - // Quit DGA mode if requested + // Quit DGA mode if requested (something terrible has happened and we + // want to give control back to the user) if (quit_full_screen) { quit_full_screen = false; -#ifdef ENABLE_XF86_DGA - XF86DGADirectVideo(x_display, screen, 0); -#endif - XUngrabPointer(x_display, CurrentTime); - XUngrabKeyboard(x_display, CurrentTime); - XUnmapWindow(x_display, the_win); - XSync(x_display, false); + delete drv; + drv = NULL; } -#endif } -static inline void handle_palette_changes(int depth, int display_type) +static inline void possibly_ungrab_mouse() +{ + // Ungrab mouse if requested (something terrible has happened and we + // want to give control back to the user) + if (quit_full_screen) { + quit_full_screen = false; + if (drv) + drv->ungrab_mouse(); + } +} + +static inline void handle_palette_changes(void) { LOCK_PALETTE; - if (palette_changed) { - palette_changed = false; - if (depth == 8) { - XStoreColors(x_display, cmap[0], palette, 256); - XStoreColors(x_display, cmap[1], palette, 256); - XSync(x_display, false); - -#ifdef ENABLE_XF86_DGA - if (display_type == DISPLAY_DGA) { - current_dga_cmap ^= 1; - XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); - } -#endif - } + if (x_palette_changed) { + x_palette_changed = false; + XDisplayLock(); + drv->update_palette(); + XDisplayUnlock(); } UNLOCK_PALETTE; @@ -1956,12 +2452,6 @@ static void video_refresh_dga(void) { // Quit DGA mode if requested possibly_quit_dga_mode(); - - // Handle X events - handle_events(); - - // Handle palette changes - handle_palette_changes(depth, DISPLAY_DGA); } #ifdef ENABLE_VOSF @@ -1971,73 +2461,62 @@ static void video_refresh_dga_vosf(void) // Quit DGA mode if requested possibly_quit_dga_mode(); - // Handle X events - handle_events(); - - // Handle palette changes - handle_palette_changes(depth, DISPLAY_DGA); - // Update display (VOSF variant) static int tick_counter = 0; if (++tick_counter >= frame_skip) { tick_counter = 0; - LOCK_VOSF; - update_display_dga_vosf(); - UNLOCK_VOSF; + if (mainBuffer.dirty) { + LOCK_VOSF; + update_display_dga_vosf(); + UNLOCK_VOSF; + } } } #endif static void video_refresh_window_vosf(void) { - // Quit DGA mode if requested - possibly_quit_dga_mode(); - - // Handle X events - handle_events(); - - // Handle palette changes - handle_palette_changes(depth, DISPLAY_WINDOW); + // Ungrab mouse if requested + possibly_ungrab_mouse(); // Update display (VOSF variant) static int tick_counter = 0; if (++tick_counter >= frame_skip) { tick_counter = 0; - LOCK_VOSF; - update_display_window_vosf(); - UNLOCK_VOSF; + if (mainBuffer.dirty) { + XDisplayLock(); + LOCK_VOSF; + update_display_window_vosf(static_cast(drv)); + UNLOCK_VOSF; + XSync(x_display, false); // Let the server catch up + XDisplayUnlock(); + } } } #endif // def ENABLE_VOSF static void video_refresh_window_static(void) { - // Handle X events - handle_events(); - - // Handle_palette changes - handle_palette_changes(depth, DISPLAY_WINDOW); - + // Ungrab mouse if requested + possibly_ungrab_mouse(); + // Update display (static variant) static int tick_counter = 0; if (++tick_counter >= frame_skip) { tick_counter = 0; - update_display_static(); + update_display_static(static_cast(drv)); } } static void video_refresh_window_dynamic(void) { - // Handle X events - handle_events(); - - // Handle_palette changes - handle_palette_changes(depth, DISPLAY_WINDOW); - + // Ungrab mouse if requested + possibly_ungrab_mouse(); + // Update display (dynamic variant) static int tick_counter = 0; tick_counter++; - update_display_dynamic(tick_counter); + update_display_dynamic(tick_counter, static_cast(drv)); } @@ -2045,7 +2524,7 @@ static void video_refresh_window_dynamic * Thread for screen refresh, input handling etc. */ -void VideoRefreshInit(void) +static void VideoRefreshInit(void) { // TODO: set up specialised 8bpp VideoRefresh handlers ? if (display_type == DISPLAY_DGA) { @@ -2069,30 +2548,71 @@ void VideoRefreshInit(void) } } +// This function is called on non-threaded platforms from a timer interrupt void VideoRefresh(void) { - // TODO: make main_unix/VideoRefresh call directly video_refresh() ? + // We need to check redraw_thread_active to inhibit refreshed during + // mode changes on non-threaded platforms + if (!redraw_thread_active) + return; + + // Handle X events + handle_events(); + + // Handle palette changes + handle_palette_changes(); + + // Update display video_refresh(); } +const int VIDEO_REFRESH_HZ = 60; +const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ; + #ifdef HAVE_PTHREADS static void *redraw_func(void *arg) { + int fd = ConnectionNumber(x_display); + uint64 start = GetTicks_usec(); int64 ticks = 0; - uint64 next = GetTicks_usec(); + uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY; + while (!redraw_thread_cancel) { - video_refresh(); - next += 16667; + int64 delay = next - GetTicks_usec(); - if (delay > 0) - Delay_usec(delay); - else if (delay < -16667) + if (delay < -VIDEO_REFRESH_DELAY) { + + // We are lagging far behind, so we reset the delay mechanism next = GetTicks_usec(); - ticks++; + + } else if (delay <= 0) { + + // Delay expired, refresh display + handle_events(); + handle_palette_changes(); + video_refresh(); + next += VIDEO_REFRESH_DELAY; + ticks++; + + } else { + + // No display refresh pending, check for X events + fd_set readfds; + FD_ZERO(&readfds); + FD_SET(fd, &readfds); + struct timeval timeout; + timeout.tv_sec = 0; + timeout.tv_usec = delay; + if (select(fd+1, &readfds, NULL, NULL, &timeout) > 0) + handle_events(); + } } + uint64 end = GetTicks_usec(); - printf("%Ld ticks in %Ld usec = %Ld ticks/sec\n", ticks, end - start, (end - start) / ticks); + D(bug("%Ld refreshes in %Ld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start))); + + redraw_thread_cancel_ack = true; return NULL; } #endif