--- SheepShaver/src/Unix/video_x.cpp 2003/12/31 11:37:26 1.9 +++ SheepShaver/src/Unix/video_x.cpp 2004/04/18 23:17:54 1.17 @@ -1,7 +1,7 @@ /* * video_x.cpp - Video/graphics emulation, X11 specific stuff * - * SheepShaver (C) 1997-2003 Marc Hellwig and Christian Bauer + * SheepShaver (C) 1997-2004 Marc Hellwig and 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 @@ -29,8 +29,10 @@ #include #include +#include + #ifdef ENABLE_XF86_DGA -#include +# include #endif #ifdef ENABLE_XF86_VIDMODE @@ -48,6 +50,10 @@ #define DEBUG 0 #include "debug.h" +#ifndef NO_STD_NAMESPACE +using std::sort; +#endif + // Constants const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes"; @@ -57,6 +63,7 @@ static int32 frame_skip; static int16 mouse_wheel_mode; static int16 mouse_wheel_lines; static bool redraw_thread_active = false; // Flag: Redraw thread installed +static pthread_attr_t redraw_thread_attr; // Redraw thread attributes static pthread_t redraw_thread; // Redraw thread static bool local_X11; // Flag: X server running on local machine? @@ -89,14 +96,20 @@ static int screen; // Screen numbe 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 int num_depths = 0; // Number of available X depths +static int *avail_depths = NULL; // List of available X depths static XVisualInfo visualInfo; static Visual *vis; +static int color_class; +static int rshift, rloss, gshift, gloss, bshift, bloss; // Pixel format of DirectColor/TrueColor modes static Colormap cmap[2]; // Two colormaps (DGA) for 8-bit mode +static XColor x_palette[256]; // Color palette to be used as CLUT and gamma table + 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; -static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask; +static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask; +static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask; // Variables for window mode static GC the_gc; @@ -113,8 +126,6 @@ static uint8 *the_buffer_copy = NULL; / static uint32 the_buffer_size; // Size of allocated the_buffer // Variables for DGA mode -static char *dga_screen_base; -static int dga_fb_width; static int current_dga_cmap; #ifdef ENABLE_XF86_VIDMODE @@ -123,6 +134,20 @@ static XF86VidModeModeInfo **x_video_mod static int num_x_video_modes; #endif +// Mutex to protect palette +#ifdef HAVE_SPINLOCKS +static spinlock_t x_palette_lock = SPIN_LOCK_UNLOCKED; +#define LOCK_PALETTE spin_lock(&x_palette_lock) +#define UNLOCK_PALETTE spin_unlock(&x_palette_lock) +#elif defined(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 +#define LOCK_PALETTE +#define UNLOCK_PALETTE +#endif + // Prototypes static void *redraw_func(void *arg); @@ -138,7 +163,6 @@ extern void SysMountFirstFloppy(void); // From clip_unix.cpp extern void ClipboardSelectionClear(XSelectionClearEvent *); extern void ClipboardSelectionRequest(XSelectionRequestEvent *); -extern void ClipboardSelectionNotify(XSelectionEvent *req); // Video acceleration through SIGSEGV @@ -148,9 +172,218 @@ extern void ClipboardSelectionNotify(XSe /* + * Utility functions + */ + +// Get current video mode +static inline int get_current_mode(void) +{ + return VModes[cur_mode].viAppleMode; +} + +// Find palette size for given color depth +static int palette_size(int mode) +{ + switch (mode) { + case APPLE_1_BIT: return 2; + case APPLE_2_BIT: return 4; + case APPLE_4_BIT: return 16; + case APPLE_8_BIT: return 256; + case APPLE_16_BIT: return 32; + case APPLE_32_BIT: return 256; + default: return 0; + } +} + +// Return bits per pixel for requested depth +static inline int bytes_per_pixel(int depth) +{ + int bpp; + switch (depth) { + case 8: + bpp = 1; + break; + case 15: case 16: + bpp = 2; + break; + case 24: case 32: + bpp = 4; + break; + default: + abort(); + } + return bpp; +} + +// Map video_mode depth ID to numerical depth value +static inline int depth_of_video_mode(int mode) +{ + int depth; + switch (mode) { + case APPLE_1_BIT: + depth = 1; + break; + case APPLE_2_BIT: + depth = 2; + break; + case APPLE_4_BIT: + depth = 4; + break; + case APPLE_8_BIT: + depth = 8; + break; + case APPLE_16_BIT: + depth = 16; + break; + case APPLE_32_BIT: + 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(int depth) +{ + D(bug("have_visual_for_depth(%d)\n", depth_of_video_mode(depth))); + + // 1-bit works always and uses default visual + if (depth == APPLE_1_BIT) { + 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) { +#ifdef ENABLE_VOSF + case APPLE_2_BIT: + case APPLE_4_BIT: // VOSF blitters can convert 2/4/8-bit -> 8/16/32-bit + case APPLE_8_BIT: + min_depth = 8; + max_depth = 32; + break; +#else + case APPLE_2_BIT: + case APPLE_4_BIT: // 2/4-bit requires VOSF blitters + return false; + case APPLE_8_BIT: // 8-bit without VOSF requires an 8-bit visual + min_depth = 8; + max_depth = 8; + break; +#endif + case APPLE_16_BIT: // 16-bit requires a 15/16-bit visual + min_depth = 15; + max_depth = 16; + break; + case APPLE_32_BIT: // 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; +} + + +/* * Open display (window or fullscreen) */ +// 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); + XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1); +} + +// Wait until window is mapped/unmapped +static void wait_mapped(Window w) +{ + XEvent e; + do { + XMaskEvent(x_display, StructureNotifyMask, &e); + } while ((e.type != MapNotify) || (e.xmap.event != w)); +} + +static void wait_unmapped(Window w) +{ + XEvent e; + do { + XMaskEvent(x_display, StructureNotifyMask, &e); + } while ((e.type != UnmapNotify) || (e.xmap.event != w)); +} + // Trap SHM errors static bool shm_error = false; static int (*old_error_handler)(Display *, XErrorEvent *); @@ -176,23 +409,18 @@ static bool open_window(int width, int h // Create window XSetWindowAttributes wattr; wattr.event_mask = eventmask = win_eventmask; - wattr.background_pixel = black_pixel; - wattr.border_pixel = black_pixel; + wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0); + wattr.border_pixel = 0; wattr.backing_store = NotUseful; - - XSync(x_display, false); + wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]); the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, - InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore, &wattr); - XSync(x_display, false); + InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap, &wattr); + + // Set window name XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE)); - XMapRaised(x_display, the_win); - XSync(x_display, false); - // Set colormap - if (depth == 8) { - XSetWindowColormap(x_display, the_win, cmap[0]); - XSetWMColormapWindows(x_display, the_win, &the_win, 1); - } + // Set delete protocol property + set_window_delete_protocol(the_win); // Make window unresizable XSizeHints *hints; @@ -206,6 +434,10 @@ static bool open_window(int width, int h XFree((char *)hints); } + // Show window + XMapWindow(x_display, the_win); + wait_mapped(the_win); + // 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 = (depth == 1 && XImageByteOrder(x_display) == LSBFirst); @@ -216,7 +448,8 @@ static bool open_window(int width, int h // Create SHM image ("height + 2" for safety) img = XShmCreateImage(x_display, vis, depth == 1 ? 1 : xdepth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height); - shminfo.shmid = shmget(IPC_PRIVATE, (height + 2) * img->bytes_per_line, IPC_CREAT | 0777); + shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT | 0777); + D(bug(" shm image created\n")); the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0); shminfo.shmaddr = img->data = (char *)the_buffer_copy; shminfo.readOnly = False; @@ -235,30 +468,19 @@ static bool open_window(int width, int h 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 = depth == 1 ? 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 == 1 ? 1 : xdepth, depth == 1 ? 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; } @@ -280,7 +502,7 @@ static bool open_window(int width, int h // Create GC the_gc = XCreateGC(x_display, the_win, 0, 0); - XSetForeground(x_display, the_gc, black_pixel); + XSetState(x_display, the_gc, black_pixel, white_pixel, GXcopy, AllPlanes); // Create cursor cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2); @@ -308,7 +530,6 @@ static bool open_window(int width, int h #endif // Set bytes per row - VModes[cur_mode].viRowBytes = img->bytes_per_line; XSync(x_display, false); return true; } @@ -320,6 +541,19 @@ static bool open_dga(int width, int heig // Set relative mouse mode ADBSetRelMouseMode(true); + // Create window + XSetWindowAttributes wattr; + wattr.event_mask = eventmask = dga_eventmask; + wattr.override_redirect = True; + wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]); + the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, + InputOutput, vis, CWEventMask | CWOverrideRedirect | + (color_class == DirectColor ? CWColormap : 0), &wattr); + + // Show window + XMapRaised(x_display, the_win); + wait_mapped(the_win); + #ifdef ENABLE_XF86_VIDMODE // Switch to best mode if (has_vidmode) { @@ -336,29 +570,26 @@ static bool open_dga(int width, int heig #endif // Establish direct screen connection + XMoveResizeWindow(x_display, the_win, 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); + + int v_width, v_bank, v_size; + XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size); XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse); XF86DGASetViewPort(x_display, screen, 0, 0); XF86DGASetVidPage(x_display, screen, 0); // Set colormap - if (depth == 8) + if (!IsDirectMode(get_current_mode())) { + XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]); XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); - - // Set bytes per row - int bytes_per_row = (dga_fb_width + 7) & ~7; - switch (depth) { - case 15: - case 16: - bytes_per_row *= 2; - break; - case 24: - case 32: - bytes_per_row *= 4; - break; } + XSync(x_display, false); + // Init blitting routines + int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, DepthModeForPixelDepth(depth)); #if ENABLE_VOSF bool native_byte_order; #ifdef WORDS_BIGENDIAN @@ -377,16 +608,17 @@ static bool open_dga(int width, int heig the_buffer_size = page_extend((height + 2) * bytes_per_row); the_buffer_copy = (uint8 *)malloc(the_buffer_size); the_buffer = (uint8 *)vm_acquire(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 use_vosf = false; - the_buffer = dga_screen_base; #endif #endif - screen_base = (uint32)the_buffer; + // Set frame buffer base + D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf)); + screen_base = (uint32)the_buffer; VModes[cur_mode].viRowBytes = bytes_per_row; - XSync(x_display, false); return true; #else ErrorAlert("SheepShaver has been compiled with DGA support disabled."); @@ -396,28 +628,82 @@ static bool open_dga(int width, int heig static bool open_display(void) { - display_type = VModes[cur_mode].viType; - switch (VModes[cur_mode].viAppleMode) { - case APPLE_1_BIT: - depth = 1; - break; - case APPLE_2_BIT: - depth = 2; - break; - case APPLE_4_BIT: - depth = 4; - break; - case APPLE_8_BIT: - depth = 8; - break; - case APPLE_16_BIT: - depth = xdepth == 15 ? 15 : 16; - break; - case APPLE_32_BIT: - depth = 32; - break; + D(bug("open_display()\n")); + const VideoInfo &mode = VModes[cur_mode]; + + // Find best available X visual + if (!find_visual_for_depth(mode.viAppleMode)) { + ErrorAlert(GetString(STR_NO_XVISUAL_ERR)); + return false; + } + + // 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); + } + + // 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(get_current_mode()) && xdepth > 8) + for (int i=0; i<256; i++) + ExpandMap[i] = map_rgb(i, i, i); +#endif + + // Create display of requested type + display_type = mode.viType; + depth = depth_of_video_mode(mode.viAppleMode); + bool display_open = false; if (display_type == DIS_SCREEN) display_open = open_dga(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize); @@ -465,8 +751,8 @@ static void close_window(void) if (the_gc) XFreeGC(x_display, the_gc); - // Close window - XDestroyWindow(x_display, the_win); + XFlush(x_display); + XSync(x_display, false); } // Close DGA mode @@ -502,6 +788,23 @@ static void close_display(void) else if (display_type == DIS_WINDOW) close_window(); + // Close window + if (the_win) { + XUnmapWindow(x_display, the_win); + wait_unmapped(the_win); + XDestroyWindow(x_display, the_win); + } + + // Free colormaps + if (cmap[0]) { + XFreeColormap(x_display, cmap[0]); + cmap[0] = 0; + } + if (cmap[1]) { + XFreeColormap(x_display, cmap[1]); + cmap[1] = 0; + } + #ifdef ENABLE_VOSF if (use_vosf) { // Deinitialize VOSF @@ -608,7 +911,41 @@ static void keycode_init(void) } } -static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, long apple_mode, long apple_id, int type) +// Find Apple mode matching best specified dimensions +static int find_apple_resolution(int xsize, int ysize) +{ + int apple_id; + if (xsize < 800) + apple_id = APPLE_640x480; + else if (xsize < 1024) + apple_id = APPLE_800x600; + else if (xsize < 1152) + apple_id = APPLE_1024x768; + else if (xsize < 1280) { + if (ysize < 900) + apple_id = APPLE_1152x768; + else + apple_id = APPLE_1152x900; + } + else if (xsize < 1600) + apple_id = APPLE_1280x1024; + else + apple_id = APPLE_1600x1200; + return apple_id; +} + +// Find mode in list of supported modes +static int find_mode(int apple_mode, int apple_id, int type) +{ + for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) { + if (p->viType == type && p->viAppleID == apple_id && p->viAppleMode == apple_mode) + return p - VModes; + } + return -1; +} + +// Add mode to list of supported modes +static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, int apple_mode, int apple_id, int type) { if (allow & test) { p->viType = type; @@ -627,6 +964,10 @@ static void add_mode(VideoInfo *&p, uint p->viXsize = 1024; p->viYsize = 768; break; + case APPLE_1152x768: + p->viXsize = 1152; + p->viYsize = 768; + break; case APPLE_1152x900: p->viXsize = 1152; p->viYsize = 900; @@ -640,23 +981,20 @@ static void add_mode(VideoInfo *&p, uint p->viYsize = 1200; break; } - switch (apple_mode) { - case APPLE_8_BIT: - p->viRowBytes = p->viXsize; - break; - case APPLE_16_BIT: - p->viRowBytes = p->viXsize * 2; - break; - case APPLE_32_BIT: - p->viRowBytes = p->viXsize * 4; - break; - } + p->viRowBytes = TrivialBytesPerRow(p->viXsize, apple_mode); p->viAppleMode = apple_mode; p->viAppleID = apple_id; p++; } } +// Add standard list of windowed modes for given color depth +static void add_window_modes(VideoInfo *&p, int window_modes, int mode) +{ + add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW); + add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW); +} + static bool has_mode(int x, int y) { #ifdef ENABLE_XF86_VIDMODE @@ -695,13 +1033,20 @@ bool VideoInit(void) // Init variables private_data = NULL; - cur_mode = 0; // Window 640x480 video_activated = true; // Find screen and root window screen = XDefaultScreen(x_display); rootwin = XRootWindow(x_display, screen); + // Get sorted list of available depths + avail_depths = XListDepths(x_display, screen, &num_depths); + if (avail_depths == NULL) { + ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR)); + return false; + } + sort(avail_depths, avail_depths + num_depths); + // Get screen depth xdepth = DefaultDepth(x_display, screen); @@ -732,72 +1077,24 @@ bool VideoInit(void) black_pixel = BlackPixel(x_display, screen); white_pixel = WhitePixel(x_display, screen); - // Get appropriate visual - int color_class; - switch (xdepth) { -#if 0 - case 1: - color_class = StaticGray; - break; -#endif - 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 follows X depth (for now) - 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]); + int default_mode = APPLE_8_BIT; + switch (DefaultDepth(x_display, screen)) { + case 1: + default_mode = APPLE_1_BIT; + break; + case 8: + default_mode = APPLE_8_BIT; + break; + case 15: case 16: + default_mode = APPLE_16_BIT; + break; + case 24: case 32: + default_mode = APPLE_32_BIT; + break; } // Construct video mode table - int mode = APPLE_8_BIT; - int bpr_mult = 8; - switch (depth) { - case 1: - mode = APPLE_1_BIT; - bpr_mult = 1; - break; - case 8: - mode = APPLE_8_BIT; - bpr_mult = 8; - break; - case 15: - case 16: - mode = APPLE_16_BIT; - bpr_mult = 16; - break; - case 24: - case 32: - mode = APPLE_32_BIT; - bpr_mult = 32; - break; - } - uint32 window_modes = PrefsFindInt32("windowmodes"); uint32 screen_modes = PrefsFindInt32("screenmodes"); if (!has_dga) @@ -806,42 +1103,34 @@ bool VideoInit(void) window_modes |= 3; // Allow at least 640x480 and 800x600 window modes VideoInfo *p = VModes; - add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW); - add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW); + for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++) + if (find_visual_for_depth(d)) + add_window_modes(p, window_modes, d); + if (has_vidmode) { if (has_mode(640, 480)) - add_mode(p, screen_modes, 1, mode, APPLE_640x480, DIS_SCREEN); + add_mode(p, screen_modes, 1, default_mode, APPLE_640x480, DIS_SCREEN); if (has_mode(800, 600)) - add_mode(p, screen_modes, 2, mode, APPLE_800x600, DIS_SCREEN); + add_mode(p, screen_modes, 2, default_mode, APPLE_800x600, DIS_SCREEN); if (has_mode(1024, 768)) - add_mode(p, screen_modes, 4, mode, APPLE_1024x768, DIS_SCREEN); + add_mode(p, screen_modes, 4, default_mode, APPLE_1024x768, DIS_SCREEN); + if (has_mode(1152, 768)) + add_mode(p, screen_modes, 64, default_mode, APPLE_1152x768, DIS_SCREEN); if (has_mode(1152, 900)) - add_mode(p, screen_modes, 8, mode, APPLE_1152x900, DIS_SCREEN); + add_mode(p, screen_modes, 8, default_mode, APPLE_1152x900, DIS_SCREEN); if (has_mode(1280, 1024)) - add_mode(p, screen_modes, 16, mode, APPLE_1280x1024, DIS_SCREEN); + add_mode(p, screen_modes, 16, default_mode, APPLE_1280x1024, DIS_SCREEN); if (has_mode(1600, 1200)) - add_mode(p, screen_modes, 32, mode, APPLE_1600x1200, DIS_SCREEN); + add_mode(p, screen_modes, 32, default_mode, APPLE_1600x1200, DIS_SCREEN); } else if (screen_modes) { int xsize = DisplayWidth(x_display, screen); int ysize = DisplayHeight(x_display, screen); - int apple_id; - if (xsize < 800) - apple_id = APPLE_640x480; - else if (xsize < 1024) - apple_id = APPLE_800x600; - else if (xsize < 1152) - apple_id = APPLE_1024x768; - else if (xsize < 1280) - apple_id = APPLE_1152x900; - else if (xsize < 1600) - apple_id = APPLE_1280x1024; - else - apple_id = APPLE_1600x1200; + int apple_id = find_apple_resolution(xsize, ysize); p->viType = DIS_SCREEN; p->viRowBytes = 0; p->viXsize = xsize; p->viYsize = ysize; - p->viAppleMode = mode; + p->viAppleMode = default_mode; p->viAppleID = apple_id; p++; } @@ -851,11 +1140,24 @@ bool VideoInit(void) p->viAppleMode = 0; p->viAppleID = 0; -#ifdef ENABLE_XF86_DGA + // Find default mode (window 640x480) + cur_mode = -1; if (has_dga && screen_modes) { - int v_bank, v_size; - XF86DGAGetVideo(x_display, screen, &dga_screen_base, &dga_fb_width, &v_bank, &v_size); - D(bug("DGA screen_base %p, v_width %d\n", dga_screen_base, dga_fb_width)); + int screen_width = DisplayWidth(x_display, screen); + int screen_height = DisplayHeight(x_display, screen); + int apple_id = find_apple_resolution(screen_width, screen_height); + if (apple_id != -1) + cur_mode = find_mode(default_mode, apple_id, DIS_SCREEN); + } + if (cur_mode == -1) + cur_mode = find_mode(default_mode, APPLE_W_640x480, DIS_WINDOW); + assert(cur_mode != -1); + +#if DEBUG + D(bug("Available video modes:\n")); + for (p = VModes; p->viType != DIS_INVALID; p++) { + int bits = depth_of_video_mode(p->viAppleMode); + D(bug(" %dx%d (ID %02x), %d colors\n", p->viXsize, p->viYsize, p->viAppleID, 1 << bits)); } #endif @@ -870,7 +1172,8 @@ bool VideoInit(void) // Start periodic thread XSync(x_display, false); - redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0); + Set_pthread_attr(&redraw_thread_attr, 0); + redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0); D(bug("Redraw thread installed (%ld)\n", redraw_thread)); return true; } @@ -902,10 +1205,6 @@ void VideoExit(void) close_display(); XFlush(x_display); XSync(x_display, false); - if (depth == 8) { - XFreeColormap(x_display, cmap[0]); - XFreeColormap(x_display, cmap[1]); - } } } @@ -969,8 +1268,10 @@ static void resume_emul(void) // Reopen full screen display 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 @@ -1186,16 +1487,26 @@ static void handle_events(void) for (;;) { XEvent 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); - else if (XCheckTypedEvent(x_display, SelectionNotify, &event)) - ClipboardSelectionNotify(&event.xselection); + + // 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; } + XDisplayUnlock(); switch (event.type) { // Mouse button @@ -1225,12 +1536,15 @@ static void handle_events(void) break; } - // Mouse moved + // Mouse entered window case EnterNotify: - ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y); + if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab) + ADBMouseMoved(event.xmotion.x, event.xmotion.y); break; + + // Mouse moved case MotionNotify: - ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y); + ADBMouseMoved(event.xmotion.x, event.xmotion.y); break; // Keyboard @@ -1298,44 +1612,6 @@ void VideoVBL(void) */ #if 0 -// Rectangle blitting -static void accl_bitblt(accl_params *p) -{ - D(bug("accl_bitblt\n")); - - // Get blitting parameters - int16 src_X = p->src_rect[1] - p->src_bounds[1]; - int16 src_Y = p->src_rect[0] - p->src_bounds[0]; - int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; - int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; - int16 width = p->dest_rect[3] - p->dest_rect[1] - 1; - int16 height = p->dest_rect[2] - p->dest_rect[0] - 1; - D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y)); - D(bug(" width %d, height %d\n", width, height)); - - // And perform the blit - bitblt_hook(src_X, src_Y, dest_X, dest_Y, width, height); -} - -static bool accl_bitblt_hook(accl_params *p) -{ - D(bug("accl_draw_hook %p\n", p)); - - // Check if we can accelerate this bitblt - if (p->src_base_addr == screen_base && p->dest_base_addr == screen_base && - display_type == DIS_SCREEN && bitblt_hook != NULL && - ((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 && - ((uint32 *)p)[0x130 >> 2] == 0 && - p->transfer_mode == 0 && - p->src_row_bytes > 0 && ((uint32 *)p)[0x15c >> 2] > 0) { - - // Yes, set function pointer - p->draw_proc = accl_bitblt; - return true; - } - return false; -} - // Rectangle filling/inversion static void accl_fillrect8(accl_params *p) { @@ -1413,25 +1689,97 @@ static bool accl_fillrect_hook(accl_para return false; } +static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT}; +#endif + +// Rectangle blitting +// TODO: optimize for VOSF and target pixmap == screen +void NQD_bitblt(uint32 arg) +{ + D(bug("accl_bitblt %08x\n", arg)); + accl_params *p = (accl_params *)arg; + + // Get blitting parameters + int16 src_X = p->src_rect[1] - p->src_bounds[1]; + int16 src_Y = p->src_rect[0] - p->src_bounds[0]; + int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; + int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; + int16 width = p->dest_rect[3] - p->dest_rect[1]; + int16 height = p->dest_rect[2] - p->dest_rect[0]; + D(bug(" src addr %08x, dest addr %08x\n", p->src_base_addr, p->dest_base_addr)); + D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y)); + D(bug(" width %d, height %d\n", width, height)); + + // And perform the blit + const int bpp = bytes_per_pixel(p->src_pixel_size); + width *= bpp; + if (p->src_row_bytes > 0) { + const int src_row_bytes = p->src_row_bytes; + const int dst_row_bytes = p->dest_row_bytes; + uint8 *src = (uint8 *)p->src_base_addr + (src_Y * src_row_bytes) + (src_X * bpp); + uint8 *dst = (uint8 *)p->dest_base_addr + (dest_Y * dst_row_bytes) + (dest_X * bpp); + for (int i = 0; i < height; i++) { + memcpy(dst, src, width); + src += src_row_bytes; + dst += dst_row_bytes; + } + } + else { + const int src_row_bytes = -p->src_row_bytes; + const int dst_row_bytes = -p->dest_row_bytes; + uint8 *src = (uint8 *)p->src_base_addr + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp); + uint8 *dst = (uint8 *)p->dest_base_addr + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp); + for (int i = height - 1; i >= 0; i--) { + memcpy(dst, src, width); + src -= src_row_bytes; + dst -= dst_row_bytes; + } + } +} + +bool NQD_bitblt_hook(uint32 arg) +{ + D(bug("accl_draw_hook %08x\n", arg)); + accl_params *p = (accl_params *)arg; + + // Check if we can accelerate this bitblt + if (((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 && + ((uint32 *)p)[0x130 >> 2] == 0 && + p->src_pixel_size >= 8 && p->src_pixel_size == p->dest_pixel_size && + ((p->src_row_bytes ^ p->dest_row_bytes) >> 31) == 0 && + p->transfer_mode == 0 && + ((uint32 *)p)[0x15c >> 2] > 0) { + + // Yes, set function pointer + p->draw_proc = NativeTVECT(NATIVE_BITBLT); + return true; + } + return false; +} + // Wait for graphics operation to finish -static bool accl_sync_hook(void *arg) +bool NQD_sync_hook(uint32 arg) { - D(bug("accl_sync_hook %p\n", arg)); - if (sync_hook != NULL) - sync_hook(); + D(bug("accl_sync_hook %08x\n", arg)); return true; } -static struct accl_hook_info bitblt_hook_info = {accl_bitblt_hook, accl_sync_hook, ACCL_BITBLT}; -static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT}; -#endif - void VideoInstallAccel(void) { // Install acceleration hooks if (PrefsFindBool("gfxaccel")) { D(bug("Video: Installing acceleration hooks\n")); -//!! NQDMisc(6, &bitblt_hook_info); + uint32 base; + + SheepVar bitblt_hook_info(sizeof(accl_hook_info)); + base = bitblt_hook_info.addr(); + WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK)); + WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK)); + WriteMacInt32(base + 8, ACCL_BITBLT); +#if defined(__powerpc__) // Temporary hack until it's fixed for e.g. little-endian & 64-bit platforms + NQDMisc(6, bitblt_hook_info.ptr()); +#endif + // NQDMisc(6, &fillrect_hook_info); } } @@ -1495,7 +1843,47 @@ int16 video_mode_change(VidLocals *csSav void video_set_palette(void) { + LOCK_PALETTE; + + // Convert colors to XColor array + int mode = get_current_mode(); + int num_in = palette_size(mode); + 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 = mac_pal[c].red * 0x0101; + p->green = mac_pal[c].green * 0x0101; + p->blue = mac_pal[c].blue * 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(mac_pal[c].red, mac_pal[c].green, mac_pal[c].blue); + } + + // We have to redraw everything because the interpretation of pixel values changed + LOCK_VOSF; + PFLAG_SET_ALL; + UNLOCK_VOSF; + memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize); + } +#endif + + // Tell redraw thread to change palette palette_changed = true; + + UNLOCK_PALETTE; } @@ -1622,114 +2010,170 @@ static void update_display(void) // Refresh display if (high && wide) { + XDisplayLock(); if (have_shm) XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high, 0); else XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high); + XDisplayUnlock(); + } +} + +const int VIDEO_REFRESH_HZ = 60; +const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ; + +static void handle_palette_changes(void) +{ + LOCK_PALETTE; + + if (palette_changed && !emul_suspended) { + palette_changed = false; + + int mode = get_current_mode(); + if (color_class == PseudoColor || color_class == DirectColor) { + int num = vis->map_entries; + bool set_clut = true; + if (!IsDirectMode(mode) && color_class == DirectColor) { + if (display_type == DIS_WINDOW) + set_clut = false; // Indexed mode on true color screen, don't set CLUT + } + + if (set_clut) { + XDisplayLock(); + XStoreColors(x_display, cmap[0], x_palette, num); + XStoreColors(x_display, cmap[1], x_palette, num); + XSync(x_display, false); + XDisplayUnlock(); + } + } + +#ifdef ENABLE_XF86_DGA + if (display_type == DIS_SCREEN) { + current_dga_cmap ^= 1; + if (!IsDirectMode(mode) && cmap[current_dga_cmap]) + XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); + } +#endif } + + UNLOCK_PALETTE; } static void *redraw_func(void *arg) { - int tick_counter = 0; - struct timespec req = {0, 16666667}; + int fd = ConnectionNumber(x_display); - for (;;) { + uint64 start = GetTicks_usec(); + int64 ticks = 0; + uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY; - // Wait - nanosleep(&req, NULL); + for (;;) { // Pause if requested (during video mode switches) while (thread_stop_req) thread_stop_ack = true; - // Handle X11 events - handle_events(); + int64 delay = next - GetTicks_usec(); + if (delay < -VIDEO_REFRESH_DELAY) { - // Quit DGA mode if requested - if (quit_full_screen) { - quit_full_screen = false; - if (display_type == DIS_SCREEN) { + // We are lagging far behind, so we reset the delay mechanism + next = GetTicks_usec(); + + } else if (delay <= 0) { + + // Delay expired, refresh display + next += VIDEO_REFRESH_DELAY; + ticks++; + + // Handle X11 events + handle_events(); + + // Quit DGA mode if requested + if (quit_full_screen) { + quit_full_screen = false; + if (display_type == DIS_SCREEN) { + XDisplayLock(); #ifdef ENABLE_XF86_DGA - XF86DGADirectVideo(x_display, screen, 0); - XUngrabPointer(x_display, CurrentTime); - XUngrabKeyboard(x_display, CurrentTime); -#endif - XSync(x_display, false); - quit_full_screen_ack = true; - return NULL; + XF86DGADirectVideo(x_display, screen, 0); + XUngrabPointer(x_display, CurrentTime); + XUngrabKeyboard(x_display, CurrentTime); + XUnmapWindow(x_display, the_win); + wait_unmapped(the_win); + XDestroyWindow(x_display, the_win); +#endif + XSync(x_display, false); + XDisplayUnlock(); + quit_full_screen_ack = true; + return NULL; + } } - } - // Refresh display and set cursor image in window mode - if (display_type == DIS_WINDOW) { - tick_counter++; - if (tick_counter >= frame_skip) { - tick_counter = 0; + // Refresh display and set cursor image in window mode + static int tick_counter = 0; + if (display_type == DIS_WINDOW) { + tick_counter++; + if (tick_counter >= frame_skip) { + tick_counter = 0; - // Update display + // Update display #ifdef ENABLE_VOSF - if (use_vosf) { - if (mainBuffer.dirty) { - LOCK_VOSF; - update_display_window_vosf(); - UNLOCK_VOSF; - XSync(x_display, false); // Let the server catch up + if (use_vosf) { + XDisplayLock(); + if (mainBuffer.dirty) { + LOCK_VOSF; + update_display_window_vosf(); + UNLOCK_VOSF; + XSync(x_display, false); // Let the server catch up + } + XDisplayUnlock(); } - } - else + else #endif - update_display(); + update_display(); - // Set new cursor image if it was changed - if (cursor_changed) { - cursor_changed = false; - memcpy(cursor_image->data, MacCursor + 4, 32); - memcpy(cursor_mask_image->data, MacCursor + 36, 32); - XFreeCursor(x_display, mac_cursor); - XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16); - XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16); - mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]); - XDefineCursor(x_display, the_win, mac_cursor); + // Set new cursor image if it was changed + if (cursor_changed) { + cursor_changed = false; + memcpy(cursor_image->data, MacCursor + 4, 32); + memcpy(cursor_mask_image->data, MacCursor + 36, 32); + XDisplayLock(); + XFreeCursor(x_display, mac_cursor); + XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16); + XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16); + mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]); + XDefineCursor(x_display, the_win, mac_cursor); + XDisplayUnlock(); + } } } - } #ifdef ENABLE_VOSF - else if (use_vosf) { - // Update display (VOSF variant) - static int tick_counter = 0; - if (++tick_counter >= frame_skip) { - tick_counter = 0; - if (mainBuffer.dirty) { - LOCK_VOSF; - update_display_dga_vosf(); - UNLOCK_VOSF; + else if (use_vosf) { + // Update display (VOSF variant) + if (++tick_counter >= frame_skip) { + tick_counter = 0; + if (mainBuffer.dirty) { + LOCK_VOSF; + update_display_dga_vosf(); + UNLOCK_VOSF; + } } } - } #endif - // Set new palette if it was changed - if (palette_changed && !emul_suspended) { - palette_changed = false; - XColor c[256]; - for (int i=0; i<256; i++) { - c[i].pixel = i; - c[i].red = mac_pal[i].red * 0x0101; - c[i].green = mac_pal[i].green * 0x0101; - c[i].blue = mac_pal[i].blue * 0x0101; - c[i].flags = DoRed | DoGreen | DoBlue; - } - if (depth == 8) { - XStoreColors(x_display, cmap[0], c, 256); - XStoreColors(x_display, cmap[1], c, 256); -#ifdef ENABLE_XF86_DGA - if (display_type == DIS_SCREEN) { - current_dga_cmap ^= 1; - XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); - } -#endif - } + // Set new palette if it was changed + handle_palette_changes(); + + } 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(); } } return NULL;