[ViewVC] Diff of: cebix/BasiliskII/src/Unix/video

Comparing BasiliskII/src/Unix/video_x.cpp (file contents):
Revision 1.26 by cebix, 2000-10-27T17:01:40Z vs.
Revision 1.43 by gbeauche, 2001-06-28T22:06:18Z

#	Line 1 \| Line 1
1		/*
2		* video_x.cpp - Video/graphics emulation, X11 specific stuff
3		*
4	<	* Basilisk II (C) 1997-2000 Christian Bauer
4	>	* Basilisk II (C) 1997-2001 Christian Bauer
5		*
6		* This program is free software; you can redistribute it and/or modify
7		* it under the terms of the GNU General Public License as published by
#	Line 52 \| Line 52
52		# include <sys/mman.h>
53		#endif
54
55	–	#ifdef ENABLE_VOSF
56	–	# include <unistd.h>
57	–	# include <signal.h>
58	–	# include <fcntl.h>
59	–	# include <sys/mman.h>
60	–	#endif
61	–
55		#include "cpu_emulation.h"
56		#include "main.h"
57		#include "adb.h"
#	Line 93 \| Line 86 \| *static uint8 the_buffer; // Mac f**
86
87		#ifdef HAVE_PTHREADS
88		static bool redraw_thread_active = false; // Flag: Redraw thread installed
89	<	static volatile bool redraw_thread_cancel = false; // Flag: Cancel Redraw thread
89	>	static volatile bool redraw_thread_cancel; // Flag: Cancel Redraw thread
90		static pthread_t redraw_thread; // Redraw thread
91		#endif
92
#	Line 114 \| Line 107 \| static int keycode_table[256]; // X
107		// X11 variables
108		static int screen; // Screen number
109		static int xdepth; // Depth of X screen
117	–	static int depth; // Depth of Mac frame buffer
110		static Window rootwin, the_win; // Root window and our window
111		static XVisualInfo visualInfo;
112		static Visual *vis;
113		static Colormap cmap[2]; // Two colormaps (DGA) for 8-bit mode
114	+	static bool cmap_allocated = false;
115		static XColor black, white;
116		static unsigned long black_pixel, white_pixel;
117		static int eventmask;
118	<	static const int win_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask \| EnterWindowMask \| FocusChangeMask \| ExposureMask;
119	<	static const int dga_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask;
118	>	static const int win_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask \| EnterWindowMask \| ExposureMask \| StructureNotifyMask;
119	>	static const int dga_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask \| StructureNotifyMask;
120	>	static Atom WM_DELETE_WINDOW = (Atom)0;
121
122		static XColor palette[256]; // Color palette for 8-bit mode
123		static bool palette_changed = false; // Flag: Palette changed, redraw thread must set new colors
124		#ifdef HAVE_PTHREADS
125		static pthread_mutex_t palette_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect palette
126	+	#define LOCK_PALETTE pthread_mutex_lock(&palette_lock)
127	+	#define UNLOCK_PALETTE pthread_mutex_unlock(&palette_lock)
128	+	#else
129	+	#define LOCK_PALETTE
130	+	#define UNLOCK_PALETTE
131		#endif
132
133		// Variables for window mode
#	Line 149 \| Line 148 \| static Window suspend_win; // "Sus
148		static void *fb_save = NULL; // Saved frame buffer for suspend
149		#ifdef HAVE_PTHREADS
150		static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect frame buffer
151	+	#define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock);
152	+	#define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock);
153	+	#else
154	+	#define LOCK_FRAME_BUFFER
155	+	#define UNLOCK_FRAME_BUFFER
156		#endif
157
158		// Variables for fbdev DGA mode
#	Line 167 \| Line 171 \| static bool use_vosf = true; // Fla
171		static const bool use_vosf = false; // Flag: VOSF enabled
172		#endif
173
170	–	#ifdef ENABLE_VOSF
171	–	static uint8 * the_host_buffer; // Host frame buffer in VOSF mode
172	–	static uint32 the_buffer_size; // Size of allocated the_buffer
173	–	#endif
174	–
175	–	#ifdef ENABLE_VOSF
176	–	// Variables for Video on SEGV support (taken from the Win32 port)
177	–	struct ScreenPageInfo {
178	–	int top, bottom; // Mapping between this virtual page and Mac scanlines
179	–	};
180	–
181	–	struct ScreenInfo {
182	–	uint32 memBase; // Real start address
183	–	uint32 memStart; // Start address aligned to page boundary
184	–	uint32 memEnd; // Address of one-past-the-end of the screen
185	–	uint32 memLength; // Length of the memory addressed by the screen pages
186	–
187	–	uint32 pageSize; // Size of a page
188	–	int pageBits; // Shift count to get the page number
189	–	uint32 pageCount; // Number of pages allocated to the screen
190	–
191	–	uint8 * dirtyPages; // Table of flags set if page was altered
192	–	ScreenPageInfo * pageInfo; // Table of mappings page -> Mac scanlines
193	–	};
194	–
195	–	static ScreenInfo mainBuffer;
196	–
197	–	#define PFLAG_SET(page) mainBuffer.dirtyPages[page] = 1
198	–	#define PFLAG_CLEAR(page) mainBuffer.dirtyPages[page] = 0
199	–	#define PFLAG_ISSET(page) mainBuffer.dirtyPages[page]
200	–	#define PFLAG_ISCLEAR(page) (mainBuffer.dirtyPages[page] == 0)
201	–	#ifdef UNALIGNED_PROFITABLE
202	–	# define PFLAG_ISCLEAR_4(page) (((uint32 )(mainBuffer.dirtyPages + page)) == 0)
203	–	#else
204	–	# define PFLAG_ISCLEAR_4(page) \
205	–	(mainBuffer.dirtyPages[page ] == 0) \
206	–	&& (mainBuffer.dirtyPages[page+1] == 0) \
207	–	&& (mainBuffer.dirtyPages[page+2] == 0) \
208	–	&& (mainBuffer.dirtyPages[page+3] == 0)
209	–	#endif
210	–	#define PFLAG_CLEAR_ALL memset(mainBuffer.dirtyPages, 0, mainBuffer.pageCount)
211	–	#define PFLAG_SET_ALL memset(mainBuffer.dirtyPages, 1, mainBuffer.pageCount)
212	–
213	–	static int zero_fd = -1;
214	–	static bool Screen_fault_handler_init();
215	–	static struct sigaction vosf_sa;
216	–
217	–	#ifdef HAVE_PTHREADS
218	–	static pthread_mutex_t Screen_draw_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect frame buffer (dirtyPages in fact)
219	–	#endif
220	–
221	–	static int log_base_2(uint32 x)
222	–	{
223	–	uint32 mask = 0x80000000;
224	–	int l = 31;
225	–	while (l >= 0 && (x & mask) == 0) {
226	–	mask >>= 1;
227	–	l--;
228	–	}
229	–	return l;
230	–	}
231	–
232	–	#endif
233	–
174		// VideoRefresh function
175	<	void VideoRefreshInit(void);
175	>	static void VideoRefreshInit(void);
176		static void (*video_refresh)(void);
177
178		// Prototypes
179		static void redraw_func(void arg);
180	<	static int event2keycode(XKeyEvent *ev);
241	<
180	>	static int event2keycode(XKeyEvent &ev);
181
182		// From main_unix.cpp
183		extern char *x_display_name;
#	Line 247 \| Line 186 \| *extern Display x_display;**
186		// From sys_unix.cpp
187		extern void SysMountFirstFloppy(void);
188
189	+
190		#ifdef ENABLE_VOSF
191		# include "video_vosf.h"
192		#endif
#	Line 256 \| Line 196 \| extern void SysMountFirstFloppy(void);
196		* Initialization
197		*/
198
199	<	// Set VideoMonitor according to video mode
200	<	void set_video_monitor(int width, int height, int bytes_per_row, bool native_byte_order)
199	>	// Add mode to list of supported modes
200	>	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth)
201	>	{
202	>	video_mode mode;
203	>	mode.x = width;
204	>	mode.y = height;
205	>	mode.resolution_id = resolution_id;
206	>	mode.bytes_per_row = bytes_per_row;
207	>	mode.depth = depth;
208	>	VideoModes.push_back(mode);
209	>	}
210	>
211	>	// Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
212	>	static void set_mac_frame_buffer(video_depth depth, bool native_byte_order)
213		{
214		#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
215		int layout = FLAYOUT_DIRECT;
216	<	switch (depth) {
217	<	case 1:
218	<	layout = FLAYOUT_DIRECT;
219	<	break;
268	<	case 8:
269	<	layout = FLAYOUT_DIRECT;
270	<	break;
271	<	case 15:
272	<	layout = FLAYOUT_HOST_555;
273	<	break;
274	<	case 16:
275	<	layout = FLAYOUT_HOST_565;
276	<	break;
277	<	case 24:
278	<	case 32:
279	<	layout = FLAYOUT_HOST_888;
280	<	break;
281	<	}
216	>	if (depth == VDEPTH_16BIT)
217	>	layout = (xdepth == 15) ? FLAYOUT_HOST_555 : FLAYOUT_HOST_565;
218	>	else if (depth == VDEPTH_32BIT)
219	>	layour = (xdepth == 24) ? FLAYOUT_HOST_888 : FLAYOUT_DIRECT;
220		if (native_byte_order)
221		MacFrameLayout = layout;
222		else
223		MacFrameLayout = FLAYOUT_DIRECT;
224	+	VideoMonitor.mac_frame_base = MacFrameBaseMac;
225	+	#else
226	+	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
227	+	D(bug("Host frame buffer = %p, ", the_buffer));
228		#endif
229	<	switch (depth) {
230	<	case 1:
231	<	VideoMonitor.mode = VMODE_1BIT;
232	<	break;
233	<	case 8:
234	<	VideoMonitor.mode = VMODE_8BIT;
235	<	break;
236	<	case 15:
237	<	VideoMonitor.mode = VMODE_16BIT;
238	<	break;
239	<	case 16:
240	<	VideoMonitor.mode = VMODE_16BIT;
241	<	break;
242	<	case 24:
243	<	case 32:
244	<	VideoMonitor.mode = VMODE_32BIT;
245	<	break;
229	>	D(bug("VideoMonitor.mac_frame_base = %08x\n", VideoMonitor.mac_frame_base));
230	>	}
231	>
232	>	// Set window name and class
233	>	static void set_window_name(Window w, int name)
234	>	{
235	>	const char *str = GetString(name);
236	>	XStoreName(x_display, w, str);
237	>	XSetIconName(x_display, w, str);
238	>
239	>	XClassHint *hints;
240	>	hints = XAllocClassHint();
241	>	if (hints) {
242	>	hints->res_name = "BasiliskII";
243	>	hints->res_class = "BasiliskII";
244	>	XSetClassHint(x_display, w, hints);
245	>	XFree(hints);
246	>	}
247	>	}
248	>
249	>	// Set window input focus flag
250	>	static void set_window_focus(Window w)
251	>	{
252	>	XWMHints *hints = XAllocWMHints();
253	>	if (hints) {
254	>	hints->input = True;
255	>	hints->initial_state = NormalState;
256	>	hints->flags = InputHint \| StateHint;
257	>	XSetWMHints(x_display, w, hints);
258	>	XFree(hints);
259		}
260	<	VideoMonitor.x = width;
261	<	VideoMonitor.y = height;
262	<	VideoMonitor.bytes_per_row = bytes_per_row;
260	>	}
261	>
262	>	// Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
263	>	static void set_window_delete_protocol(Window w)
264	>	{
265	>	WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
266	>	XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
267	>	}
268	>
269	>	// Wait until window is mapped/unmapped
270	>	void wait_mapped(Window w)
271	>	{
272	>	XEvent e;
273	>	do {
274	>	XMaskEvent(x_display, StructureNotifyMask, &e);
275	>	} while ((e.type != MapNotify) \|\| (e.xmap.event != w));
276	>	}
277	>
278	>	void wait_unmapped(Window w)
279	>	{
280	>	XEvent e;
281	>	do {
282	>	XMaskEvent(x_display, StructureNotifyMask, &e);
283	>	} while ((e.type != UnmapNotify) \|\| (e.xmap.event != w));
284		}
285
286		// Trap SHM errors
#	Line 321 \| Line 297 \| *static int error_handler(Display d, XEr**
297		}
298
299		// Init window mode
300	<	static bool init_window(int width, int height)
300	>	static bool init_window(const video_mode &mode)
301		{
302	+	int width = mode.x, height = mode.y;
303		int aligned_width = (width + 15) & ~15;
304		int aligned_height = (height + 15) & ~15;
305
#	Line 336 \| Line 313 \| static bool init_window(int width, int h
313		XSetWindowAttributes wattr;
314		wattr.event_mask = eventmask = win_eventmask;
315		wattr.background_pixel = black_pixel;
316	<	wattr.border_pixel = black_pixel;
340	<	wattr.backing_store = NotUseful;
341	<	wattr.save_under = false;
342	<	wattr.backing_planes = xdepth;
316	>	wattr.colormap = cmap[0];
317
344	–	XSync(x_display, false);
318		the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
319	<	InputOutput, vis, CWEventMask \| CWBackPixel \| CWBorderPixel \|
320	<	CWBackingStore \| CWBackingPlanes, &wattr);
319	>	InputOutput, vis, CWEventMask \| CWBackPixel \| ((IsDirectMode(mode) \|\| mode.depth == VDEPTH_1BIT) ? 0 : CWColormap), &wattr);
320	>
321	>	// Set window name/class
322	>	set_window_name(the_win, STR_WINDOW_TITLE);
323
324		// Indicate that we want keyboard input
325	<	{
326	<	XWMHints *hints = XAllocWMHints();
327	<	if (hints) {
328	<	hints->input = True;
354	<	hints->flags = InputHint;
355	<	XSetWMHints(x_display, the_win, hints);
356	<	XFree((char *)hints);
357	<	}
358	<	}
325	>	set_window_focus(the_win);
326	>
327	>	// Set delete protocol property
328	>	set_window_delete_protocol(the_win);
329
330		// Make window unresizable
331		{
#	Line 367 \| Line 337 \| static bool init_window(int width, int h
337		hints->max_height = height;
338		hints->flags = PMinSize \| PMaxSize;
339		XSetWMNormalHints(x_display, the_win, hints);
340	<	XFree((char *)hints);
340	>	XFree(hints);
341		}
342		}
343
374	–	// Set window title
375	–	{
376	–	XTextProperty title_prop;
377	–	const char *title = GetString(STR_WINDOW_TITLE);
378	–	XStringListToTextProperty((char **)&title, 1, &title_prop);
379	–	XSetWMName(x_display, the_win, &title_prop);
380	–	XFree(title_prop.value);
381	–	}
382	–
383	–	// Set window class
384	–	{
385	–	XClassHint *hints;
386	–	hints = XAllocClassHint();
387	–	if (hints) {
388	–	hints->res_name = "BasiliskII";
389	–	hints->res_class = "BasiliskII";
390	–	XSetClassHint(x_display, the_win, hints);
391	–	XFree((char *)hints);
392	–	}
393	–	}
394	–
344		// Show window
345	<	XSync(x_display, false);
346	<	XMapRaised(x_display, the_win);
398	<	XFlush(x_display);
399	<
400	<	// Set colormap
401	<	if (depth == 8)
402	<	XSetWindowColormap(x_display, the_win, cmap[0]);
345	>	XMapWindow(x_display, the_win);
346	>	wait_mapped(the_win);
347
348		// Try to create and attach SHM image
349		have_shm = false;
350	<	if (depth != 1 && local_X11 && XShmQueryExtension(x_display)) {
350	>	if (mode.depth != VDEPTH_1BIT && local_X11 && XShmQueryExtension(x_display)) {
351
352		// Create SHM image ("height + 2" for safety)
353	<	img = XShmCreateImage(x_display, vis, depth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
353	>	img = XShmCreateImage(x_display, vis, mode.depth == VDEPTH_1BIT ? 1 : xdepth, mode.depth == VDEPTH_1BIT ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
354		shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT \| 0777);
355		the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0);
356		shminfo.shmaddr = img->data = (char *)the_buffer_copy;
#	Line 430 \| Line 374 \| static bool init_window(int width, int h
374
375		// Create normal X image if SHM doesn't work ("height + 2" for safety)
376		if (!have_shm) {
377	<	int bytes_per_row = aligned_width;
434	<	switch (depth) {
435	<	case 1:
436	<	bytes_per_row /= 8;
437	<	break;
438	<	case 15:
439	<	case 16:
440	<	bytes_per_row *= 2;
441	<	break;
442	<	case 24:
443	<	case 32:
444	<	bytes_per_row *= 4;
445	<	break;
446	<	}
377	>	int bytes_per_row = TrivialBytesPerRow(aligned_width, mode.depth);
378		the_buffer_copy = (uint8 )malloc((aligned_height + 2) bytes_per_row);
379	<	img = XCreateImage(x_display, vis, depth, depth == 1 ? XYBitmap : ZPixmap, 0, (char *)the_buffer_copy, aligned_width, aligned_height, 32, bytes_per_row);
379	>	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);
380		}
381
382		// 1-Bit mode is big-endian
383	<	if (depth == 1) {
383	>	if (mode.depth == VDEPTH_1BIT) {
384		img->byte_order = MSBFirst;
385		img->bitmap_bit_order = MSBFirst;
386		}
387
388		#ifdef ENABLE_VOSF
389	<	// Allocate a page-aligned chunk of memory for frame buffer
459	<	the_buffer_size = align_on_page_boundary((aligned_height + 2) * img->bytes_per_line);
389	>	// Allocate memory for frame buffer (SIZE is extended to page-boundary)
390		the_host_buffer = the_buffer_copy;
391	<
392	<	the_buffer_copy = (uint8 *)allocate_framebuffer(the_buffer_size);
393	<	memset(the_buffer_copy, 0, the_buffer_size);
464	<
465	<	the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size);
466	<	memset(the_buffer, 0, the_buffer_size);
391	>	the_buffer_size = page_extend((aligned_height + 2) * img->bytes_per_line);
392	>	the_buffer_copy = (uint8 *)vm_acquire(the_buffer_size);
393	>	the_buffer = (uint8 *)vm_acquire(the_buffer_size);
394		#else
395		// Allocate memory for frame buffer
396		the_buffer = (uint8 )malloc((aligned_height + 2) img->bytes_per_line);
#	Line 480 \| Line 407 \| static bool init_window(int width, int h
407		&black, &white, 0, 0);
408		XDefineCursor(x_display, the_win, mac_cursor);
409
410	<	// Set VideoMonitor
410	>	// Add resolution and set VideoMonitor
411		bool native_byte_order;
412		#ifdef WORDS_BIGENDIAN
413	<	native_byte_order = (img->bitmap_bit_order == MSBFirst);
413	>	native_byte_order = (XImageByteOrder(x_display) == MSBFirst);
414		#else
415	<	native_byte_order = (img->bitmap_bit_order == LSBFirst);
415	>	native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
416		#endif
417		#ifdef ENABLE_VOSF
418	<	do_update_framebuffer = GET_FBCOPY_FUNC(depth, native_byte_order, DISPLAY_WINDOW);
492	<	#endif
493	<	set_video_monitor(width, height, img->bytes_per_line, native_byte_order);
494	<
495	<	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
496	<	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
497	<	#else
498	<	VideoMonitor.mac_frame_base = MacFrameBaseMac;
418	>	Screen_blitter_init(&visualInfo, native_byte_order);
419		#endif
420	+	VideoMonitor.mode = mode;
421	+	set_mac_frame_buffer(mode.depth, native_byte_order);
422		return true;
423		}
424
425		// Init fbdev DGA display
426	<	static bool init_fbdev_dga(char *in_fb_name)
426	>	static bool init_fbdev_dga(const video_mode &mode)
427		{
428		#ifdef ENABLE_FBDEV_DGA
429	+	int width = mode.x, height = mode.y;
430	+
431		// Find the maximum depth available
432		int ndepths, max_depth(0);
433		int *depths = XListDepths(x_display, screen, &ndepths);
#	Line 546 \| Line 470 \| *static bool init_fbdev_dga(char in_fb_n**
470		continue;
471
472		if ((sscanf(line, "%19s %d %x", &fb_name, &fb_depth, &fb_offset) == 3)
473	<	&& (strcmp(fb_name, in_fb_name) == 0) && (fb_depth == max_depth)) {
473	>	&& (strcmp(fb_name, fb_name) == 0) && (fb_depth == max_depth)) {
474		device_found = true;
475		break;
476		}
#	Line 558 \| Line 482 \| *static bool init_fbdev_dga(char in_fb_n**
482		// Frame buffer name not found ? Then, display warning
483		if (!device_found) {
484		char str[256];
485	<	sprintf(str, GetString(STR_FBDEV_NAME_ERR), in_fb_name, max_depth);
485	>	sprintf(str, GetString(STR_FBDEV_NAME_ERR), fb_name, max_depth);
486		ErrorAlert(str);
487		return false;
488		}
489
490	<	int width = DisplayWidth(x_display, screen);
567	<	int height = DisplayHeight(x_display, screen);
568	<	depth = fb_depth; // max_depth
490	>	depth = fb_depth;
491
492		// Set relative mouse mode
493		ADBSetRelMouseMode(false);
494
495		// Create window
496		XSetWindowAttributes wattr;
497	<	wattr.override_redirect = True;
498	<	wattr.backing_store = NotUseful;
499	<	wattr.background_pixel = white_pixel;
500	<	wattr.border_pixel = black_pixel;
579	<	wattr.event_mask = eventmask = dga_eventmask;
497	>	wattr.event_mask = eventmask = dga_eventmask;
498	>	wattr.background_pixel = white_pixel;
499	>	wattr.override_redirect = True;
500	>	wattr.colormap = cmap[0];
501
581	–	XSync(x_display, false);
502		the_win = XCreateWindow(x_display, rootwin,
503		0, 0, width, height,
504		0, xdepth, InputOutput, vis,
505	<	CWEventMask\|CWBackPixel\|CWBorderPixel\|CWOverrideRedirect\|CWBackingStore,
505	>	CWEventMask \| CWBackPixel \| CWOverrideRedirect \| (depth == 8 ? CWColormap : 0),
506		&wattr);
507	<	XSync(x_display, false);
507	>
508	>	// Set window name/class
509	>	set_window_name(the_win, STR_WINDOW_TITLE);
510	>
511	>	// Indicate that we want keyboard input
512	>	set_window_focus(the_win);
513	>
514	>	// Show window
515		XMapRaised(x_display, the_win);
516	<	XSync(x_display, false);
516	>	wait_mapped(the_win);
517
518		// Grab mouse and keyboard
519		XGrabKeyboard(x_display, the_win, True,
#	Line 595 \| Line 522 \| *static bool init_fbdev_dga(char in_fb_n**
522		PointerMotionMask \| ButtonPressMask \| ButtonReleaseMask,
523		GrabModeAsync, GrabModeAsync, the_win, None, CurrentTime);
524
525	<	// Set colormap
526	<	if (depth == 8)
600	<	XSetWindowColormap(x_display, the_win, cmap[0]);
601	<
602	<	// Set VideoMonitor
603	<	int bytes_per_row = width;
604	<	switch (depth) {
605	<	case 1:
606	<	bytes_per_row = ((width \| 7) & ~7) >> 3;
607	<	break;
608	<	case 15:
609	<	case 16:
610	<	bytes_per_row *= 2;
611	<	break;
612	<	case 24:
613	<	case 32:
614	<	bytes_per_row *= 4;
615	<	break;
616	<	}
525	>	// Calculate bytes per row
526	>	int bytes_per_row = TrivialBytesPerRow(mode.x, mode.depth);
527
528	+	// Map frame buffer
529		if ((the_buffer = (uint8 ) mmap(NULL, height bytes_per_row, PROT_READ \| PROT_WRITE, MAP_PRIVATE, fbdev_fd, fb_offset)) == MAP_FAILED) {
530		if ((the_buffer = (uint8 ) mmap(NULL, height bytes_per_row, PROT_READ \| PROT_WRITE, MAP_SHARED, fbdev_fd, fb_offset)) == MAP_FAILED) {
531		char str[256];
#	Line 626 \| Line 537 \| *static bool init_fbdev_dga(char in_fb_n**
537
538		#if ENABLE_VOSF
539		#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
540	<	// If the blit function is null, i.e. just a copy of the buffer,
541	<	// we first try to avoid the allocation of a temporary frame buffer
542	<	use_vosf = true;
632	<	do_update_framebuffer = GET_FBCOPY_FUNC(depth, true, DISPLAY_DGA);
633	<	if (do_update_framebuffer == FBCOPY_FUNC(fbcopy_raw))
634	<	use_vosf = false;
540	>	// Screen_blitter_init() returns TRUE if VOSF is mandatory
541	>	// i.e. the framebuffer update function is not Blit_Copy_Raw
542	>	use_vosf = Screen_blitter_init(&visualInfo, true);
543
544		if (use_vosf) {
545	<	the_host_buffer = the_buffer;
546	<	the_buffer_size = align_on_page_boundary((height + 2) * bytes_per_row);
547	<	the_buffer_copy = (uint8 *)malloc(the_buffer_size);
548	<	memset(the_buffer_copy, 0, the_buffer_size);
549	<	the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size);
642	<	memset(the_buffer, 0, the_buffer_size);
545	>	// Allocate memory for frame buffer (SIZE is extended to page-boundary)
546	>	the_host_buffer = the_buffer;
547	>	the_buffer_size = page_extend((height + 2) * bytes_per_row);
548	>	the_buffer_copy = (uint8 *)vm_acquire(the_buffer_size);
549	>	the_buffer = (uint8 *)vm_acquire(the_buffer_size);
550		}
551		#else
552		use_vosf = false;
553		#endif
554		#endif
555
556	<	set_video_monitor(width, height, bytes_per_row, true);
557	<	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
558	<	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
652	<	#else
653	<	VideoMonitor.mac_frame_base = MacFrameBaseMac;
654	<	#endif
556	>	// Set VideoMonitor
557	>	VideoMonitor.mode = mode;
558	>	set_mac_frame_buffer(mode.depth, true);
559		return true;
560		#else
561		ErrorAlert("Basilisk II has been compiled with fbdev DGA support disabled.");
#	Line 660 \| Line 564 \| *static bool init_fbdev_dga(char in_fb_n**
564		}
565
566		// Init XF86 DGA display
567	<	static bool init_xf86_dga(int width, int height)
567	>	static bool init_xf86_dga(const video_mode &mode)
568		{
569	+	int width = mode.x, height = mode.y;
570	+
571		#ifdef ENABLE_XF86_DGA
572		// Set relative mouse mode
573		ADBSetRelMouseMode(true);
#	Line 678 \| Line 584 \| static bool init_xf86_dga(int width, int
584		}
585		XF86VidModeSwitchToMode(x_display, screen, x_video_modes[best]);
586		XF86VidModeSetViewPort(x_display, screen, 0, 0);
587	+	XSync(x_display, false);
588		}
589		#endif
590
591		// Create window
592		XSetWindowAttributes wattr;
593		wattr.event_mask = eventmask = dga_eventmask;
687	–	wattr.border_pixel = black_pixel;
594		wattr.override_redirect = True;
595
690	–	XSync(x_display, false);
596		the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
597	<	InputOutput, vis, CWEventMask \| CWBorderPixel \| CWOverrideRedirect, &wattr);
598	<	XSync(x_display, false);
599	<	XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
597	>	InputOutput, vis, CWEventMask \| CWOverrideRedirect, &wattr);
598	>
599	>	// Set window name/class
600	>	set_window_name(the_win, STR_WINDOW_TITLE);
601	>
602	>	// Indicate that we want keyboard input
603	>	set_window_focus(the_win);
604	>
605	>	// Show window
606		XMapRaised(x_display, the_win);
607	<	XSync(x_display, false);
607	>	wait_mapped(the_win);
608
609		// Establish direct screen connection
610		XMoveResizeWindow(x_display, the_win, 0, 0, width, height);
#	Line 708 \| Line 619 \| static bool init_xf86_dga(int width, int
619		XF86DGASetVidPage(x_display, screen, 0);
620
621		// Set colormap
622	<	if (depth == 8) {
622	>	if (!IsDirectMode(mode)) {
623		XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]);
624		XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
625		}
626	+	XSync(x_display, false);
627
628		// Set VideoMonitor
629	<	int bytes_per_row = (v_width + 7) & ~7;
630	<	switch (depth) {
631	<	case 1:
720	<	bytes_per_row /= 8;
721	<	break;
722	<	case 15:
723	<	case 16:
724	<	bytes_per_row *= 2;
725	<	break;
726	<	case 24:
727	<	case 32:
728	<	bytes_per_row *= 4;
729	<	break;
730	<	}
731	<
629	>	int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, mode.depth);
630	>
631	>	#ifdef VIDEO_VOSF
632		#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
633	<	// If the blit function is null, i.e. just a copy of the buffer,
634	<	// we first try to avoid the allocation of a temporary frame buffer
635	<	use_vosf = true;
736	<	do_update_framebuffer = GET_FBCOPY_FUNC(depth, true, DISPLAY_DGA);
737	<	if (do_update_framebuffer == FBCOPY_FUNC(fbcopy_raw))
738	<	use_vosf = false;
633	>	// Screen_blitter_init() returns TRUE if VOSF is mandatory
634	>	// i.e. the framebuffer update function is not Blit_Copy_Raw
635	>	use_vosf = Screen_blitter_init(&visualInfo, true);
636
637		if (use_vosf) {
638	<	the_host_buffer = the_buffer;
639	<	the_buffer_size = align_on_page_boundary((height + 2) * bytes_per_row);
640	<	the_buffer_copy = (uint8 *)malloc(the_buffer_size);
641	<	memset(the_buffer_copy, 0, the_buffer_size);
642	<	the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size);
746	<	memset(the_buffer, 0, the_buffer_size);
638	>	// Allocate memory for frame buffer (SIZE is extended to page-boundary)
639	>	the_host_buffer = the_buffer;
640	>	the_buffer_size = page_extend((height + 2) * bytes_per_row);
641	>	the_buffer_copy = (uint8 *)vm_acquire(the_buffer_size);
642	>	the_buffer = (uint8 *)vm_acquire(the_buffer_size);
643		}
644	<	#elif defined(ENABLE_VOSF)
749	<	// The UAE memory handlers will already handle color conversion, if needed.
644	>	#else
645		use_vosf = false;
646		#endif
752	–
753	–	set_video_monitor(width, height, bytes_per_row, true);
754	–	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
755	–	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
756	–	// MacFrameLayout = FLAYOUT_DIRECT;
757	–	#else
758	–	VideoMonitor.mac_frame_base = MacFrameBaseMac;
647		#endif
648	+
649	+	const_cast<video_mode *>(&mode)->bytes_per_row = bytes_per_row;
650	+	VideoMonitor.mode = mode;
651	+	set_mac_frame_buffer(mode.depth, true);
652		return true;
653		#else
654		ErrorAlert("Basilisk II has been compiled with XF86 DGA support disabled.");
#	Line 829 \| Line 721 \| static void keycode_init(void)
721		}
722		}
723
724	<	bool VideoInitBuffer()
724	>	// Open display for specified mode
725	>	static bool video_open(const video_mode &mode)
726		{
727	<	#ifdef ENABLE_VOSF
728	<	if (use_vosf) {
729	<	const uint32 page_size = getpagesize();
730	<	const uint32 page_mask = page_size - 1;
731	<
732	<	mainBuffer.memBase = (uint32) the_buffer;
733	<	// Align the frame buffer on page boundary
734	<	mainBuffer.memStart = (uint32)((((unsigned long) the_buffer) + page_mask) & ~page_mask);
842	<	mainBuffer.memLength = the_buffer_size;
843	<	mainBuffer.memEnd = mainBuffer.memStart + mainBuffer.memLength;
844	<
845	<	mainBuffer.pageSize = page_size;
846	<	mainBuffer.pageCount = (mainBuffer.memLength + page_mask)/mainBuffer.pageSize;
847	<	mainBuffer.pageBits = log_base_2(mainBuffer.pageSize);
848	<
849	<	if (mainBuffer.dirtyPages != 0)
850	<	free(mainBuffer.dirtyPages);
727	>	// Create color maps for 8 bit mode
728	>	if (!IsDirectMode(mode)) {
729	>	cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
730	>	cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
731	>	cmap_allocated = true;
732	>	XInstallColormap(x_display, cmap[0]);
733	>	XInstallColormap(x_display, cmap[1]);
734	>	}
735
736	<	mainBuffer.dirtyPages = (uint8 *) malloc(mainBuffer.pageCount);
736	>	// Initialize according to display type
737	>	switch (display_type) {
738	>	case DISPLAY_WINDOW:
739	>	if (!init_window(mode))
740	>	return false;
741	>	break;
742	>	case DISPLAY_DGA:
743	>	#ifdef ENABLE_FBDEV_DGA
744	>	if (!init_fbdev_dga(mode))
745	>	#else
746	>	if (!init_xf86_dga(mode))
747	>	#endif
748	>	return false;
749	>	break;
750	>	}
751
752	<	if (mainBuffer.pageInfo != 0)
753	<	free(mainBuffer.pageInfo);
752	>	// Lock down frame buffer
753	>	LOCK_FRAME_BUFFER;
754
755	<	mainBuffer.pageInfo = (ScreenPageInfo ) malloc(mainBuffer.pageCount sizeof(ScreenPageInfo));
755	>	#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
756	>	// Set variables for UAE memory mapping
757	>	MacFrameBaseHost = the_buffer;
758	>	MacFrameSize = VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y;
759
760	<	if ((mainBuffer.dirtyPages == 0) \|\| (mainBuffer.pageInfo == 0))
761	<	return false;
760	>	// No special frame buffer in Classic mode (frame buffer is in Mac RAM)
761	>	if (classic)
762	>	MacFrameLayout = FLAYOUT_NONE;
763	>	#endif
764
765	<	PFLAG_CLEAR_ALL;
765	>	InitFrameBufferMapping();
766
767	<	uint32 a = 0;
768	<	for (int i = 0; i < mainBuffer.pageCount; i++) {
769	<	int y1 = a / VideoMonitor.bytes_per_row;
770	<	if (y1 >= VideoMonitor.y)
771	<	y1 = VideoMonitor.y - 1;
772	<
870	<	int y2 = (a + mainBuffer.pageSize) / VideoMonitor.bytes_per_row;
871	<	if (y2 >= VideoMonitor.y)
872	<	y2 = VideoMonitor.y - 1;
873	<
874	<	mainBuffer.pageInfo[i].top = y1;
875	<	mainBuffer.pageInfo[i].bottom = y2;
876	<
877	<	a += mainBuffer.pageSize;
878	<	if (a > mainBuffer.memLength)
879	<	a = mainBuffer.memLength;
767	>	#ifdef ENABLE_VOSF
768	>	if (use_vosf) {
769	>	// Initialize the mainBuffer structure
770	>	if (!video_init_buffer()) {
771	>	ErrorAlert(GetString(STR_VOSF_INIT_ERR));
772	>	return false;
773		}
774	<
775	<	// We can now write-protect the frame buffer
776	<	if (mprotect((caddr_t)mainBuffer.memStart, mainBuffer.memLength, PROT_READ) != 0)
774	>
775	>	// Initialize the handler for SIGSEGV
776	>	if (!sigsegv_install_handler(screen_fault_handler)) {
777	>	ErrorAlert("Could not initialize Video on SEGV signals");
778		return false;
779	+	}
780	+	}
781	+	#endif
782	+
783	+	// Initialize VideoRefresh function
784	+	VideoRefreshInit();
785	+
786	+	XSync(x_display, false);
787	+
788	+	#ifdef HAVE_PTHREADS
789	+	// Start redraw/input thread
790	+	redraw_thread_cancel = false;
791	+	redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0);
792	+	if (!redraw_thread_active) {
793	+	printf("FATAL: cannot create redraw thread\n");
794	+	return false;
795		}
796		#endif
797	+
798		return true;
799		}
800
801		bool VideoInit(bool classic)
802		{
803	+	classic_mode = classic;
804	+
805		#ifdef ENABLE_VOSF
893	–	// Open /dev/zero
894	–	zero_fd = open("/dev/zero", O_RDWR);
895	–	if (zero_fd < 0) {
896	–	char str[256];
897	–	sprintf(str, GetString(STR_NO_DEV_ZERO_ERR), strerror(errno));
898	–	ErrorAlert(str);
899	–	return false;
900	–	}
901	–
806		// Zero the mainBuffer structure
807		mainBuffer.dirtyPages = 0;
808		mainBuffer.pageInfo = 0;
#	Line 912 \| Line 816 \| bool VideoInit(bool classic)
816		keycode_init();
817
818		// Read prefs
819	<	mouse_wheel_mode = PrefsFindInt16("mousewheelmode");
820	<	mouse_wheel_lines = PrefsFindInt16("mousewheellines");
819	>	mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
820	>	mouse_wheel_lines = PrefsFindInt32("mousewheellines");
821
822		// Find screen and root window
823		screen = XDefaultScreen(x_display);
#	Line 989 \| Line 893 \| bool VideoInit(bool classic)
893		}
894		vis = visualInfo.visual;
895
992	–	// Mac screen depth is always 1 bit in Classic mode, but follows X depth otherwise
993	–	classic_mode = classic;
994	–	if (classic)
995	–	depth = 1;
996	–	else
997	–	depth = xdepth;
998	–
999	–	// Create color maps for 8 bit mode
1000	–	if (depth == 8) {
1001	–	cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1002	–	cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1003	–	XInstallColormap(x_display, cmap[0]);
1004	–	XInstallColormap(x_display, cmap[1]);
1005	–	}
1006	–
896		// Get screen mode from preferences
897		const char *mode_str;
898	<	if (classic)
898	>	if (classic_mode)
899		mode_str = "win/512/342";
900		else
901		mode_str = PrefsFindString("screen");
902
903	<	// Determine type and mode
904	<	int width = 512, height = 384;
903	>	// Determine display type and default dimensions
904	>	int default_width = 512, default_height = 384;
905		display_type = DISPLAY_WINDOW;
906		if (mode_str) {
907	<	if (sscanf(mode_str, "win/%d/%d", &width, &height) == 2)
907	>	if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2) {
908		display_type = DISPLAY_WINDOW;
909		#ifdef ENABLE_FBDEV_DGA
910	<	else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) {
1022	<	#else
1023	<	else if (has_dga && sscanf(mode_str, "dga/%d/%d", &width, &height) == 2) {
1024	<	#endif
910	>	} else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) {
911		display_type = DISPLAY_DGA;
912	<	if (width > DisplayWidth(x_display, screen))
1027	<	width = DisplayWidth(x_display, screen);
1028	<	if (height > DisplayHeight(x_display, screen))
1029	<	height = DisplayHeight(x_display, screen);
1030	<	}
1031	<	if (width <= 0)
1032	<	width = DisplayWidth(x_display, screen);
1033	<	if (height <= 0)
1034	<	height = DisplayHeight(x_display, screen);
1035	<	}
1036	<
1037	<	// Initialize according to display type
1038	<	switch (display_type) {
1039	<	case DISPLAY_WINDOW:
1040	<	if (!init_window(width, height))
1041	<	return false;
1042	<	break;
1043	<	case DISPLAY_DGA:
1044	<	#ifdef ENABLE_FBDEV_DGA
1045	<	if (!init_fbdev_dga(fb_name))
912	>	default_width = -1; default_height = -1;
913		#else
914	<	if (!init_xf86_dga(width, height))
914	>	} else if (has_dga && sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2) {
915	>	display_type = DISPLAY_DGA;
916		#endif
917	<	return false;
1050	<	break;
917	>	}
918		}
919	+	if (default_width <= 0)
920	+	default_width = DisplayWidth(x_display, screen);
921	+	else if (default_width > DisplayWidth(x_display, screen))
922	+	default_width = DisplayWidth(x_display, screen);
923	+	if (default_height <= 0)
924	+	default_height = DisplayHeight(x_display, screen);
925	+	else if (default_height > DisplayHeight(x_display, screen))
926	+	default_height = DisplayHeight(x_display, screen);
927
928	<	#ifdef HAVE_PTHREADS
929	<	// Lock down frame buffer
930	<	pthread_mutex_lock(&frame_buffer_lock);
1056	<	#endif
1057	<
1058	<	#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
1059	<	// Set variables for UAE memory mapping
1060	<	MacFrameBaseHost = the_buffer;
1061	<	MacFrameSize = VideoMonitor.bytes_per_row * VideoMonitor.y;
1062	<
1063	<	// No special frame buffer in Classic mode (frame buffer is in Mac RAM)
1064	<	if (classic)
1065	<	MacFrameLayout = FLAYOUT_NONE;
1066	<	#endif
928	>	// Mac screen depth is always 1 bit in Classic mode, but follows X depth otherwise
929	>	int depth = (classic_mode ? 1 : xdepth);
930	>	video_depth depth_mode = DepthModeForPixelDepth(depth);
931
932	<	#ifdef ENABLE_VOSF
933	<	if (use_vosf) {
934	<	// Initialize the mainBuffer structure
935	<	if (!VideoInitBuffer()) {
936	<	// TODO: STR_VOSF_INIT_ERR ?
937	<	ErrorAlert("Could not initialize Video on SEGV signals");
938	<	return false;
932	>	// Construct list of supported modes
933	>	if (display_type == DISPLAY_WINDOW) {
934	>	if (classic)
935	>	add_mode(512, 342, 0x80, 64, depth_mode);
936	>	else {
937	>	add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth_mode), depth_mode);
938	>	add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth_mode), depth_mode);
939	>	add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth_mode), depth_mode);
940	>	add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth_mode), depth_mode);
941	>	add_mode(1280, 1024, 0x84, TrivialBytesPerRow(1280, depth_mode), depth_mode);
942		}
943	+	} else
944	+	add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, depth_mode), depth_mode);
945
946	<	// Initialize the handler for SIGSEGV
947	<	if (!Screen_fault_handler_init()) {
948	<	// TODO: STR_VOSF_INIT_ERR ?
949	<	ErrorAlert("Could not initialize Video on SEGV signals");
950	<	return false;
946	>	// Find requested default mode and open display
947	>	if (VideoModes.size() == 1)
948	>	return video_open(VideoModes[0]);
949	>	else {
950	>	// Find mode with specified dimensions
951	>	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
952	>	while (i != end) {
953	>	if (i->x == default_width && i->y == default_height)
954	>	return video_open(*i);
955	>	++i;
956		}
957	+	return video_open(VideoModes[0]);
958		}
1084	–	#endif
1085	–
1086	–	// Initialize VideoRefresh function
1087	–	VideoRefreshInit();
1088	–
1089	–	XSync(x_display, false);
1090	–
1091	–	#ifdef HAVE_PTHREADS
1092	–	// Start redraw/input thread
1093	–	redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0);
1094	–	if (!redraw_thread_active) {
1095	–	printf("FATAL: cannot create redraw thread\n");
1096	–	return false;
1097	–	}
1098	–	#endif
1099	–	return true;
959		}
960
961
#	Line 1104 \| Line 963 \| bool VideoInit(bool classic)
963		* Deinitialization
964		*/
965
966	<	void VideoExit(void)
966	>	// Close display
967	>	static void video_close(void)
968		{
969		#ifdef HAVE_PTHREADS
970		// Stop redraw thread
#	Line 1118 \| Line 978 \| void VideoExit(void)
978		}
979		#endif
980
1121	–	#ifdef HAVE_PTHREADS
981		// Unlock frame buffer
982	<	pthread_mutex_unlock(&frame_buffer_lock);
1124	<	#endif
982	>	UNLOCK_FRAME_BUFFER;
983
984		// Close window and server connection
985		if (x_display != NULL) {
#	Line 1150 \| Line 1008 \| void VideoExit(void)
1008
1009		XFlush(x_display);
1010		XSync(x_display, false);
1011	<	if (depth == 8) {
1011	>	XUnmapWindow(x_display, the_win);
1012	>	wait_unmapped(the_win);
1013	>	XDestroyWindow(x_display, the_win);
1014	>
1015	>	if (have_shm) {
1016	>	XDestroyImage(img);
1017	>	XShmDetach(x_display, &shminfo);
1018	>	have_shm = false;
1019	>	} else {
1020	>	//!! free img
1021	>	}
1022	>	//!! free the_gc
1023	>
1024	>	if (cmap_allocated) {
1025		XFreeColormap(x_display, cmap[0]);
1026		XFreeColormap(x_display, cmap[1]);
1027	+	cmap_allocated = false;
1028		}
1029
1030		if (!use_vosf) {
#	Line 1168 \| Line 1040 \| void VideoExit(void)
1040		}
1041		#ifdef ENABLE_VOSF
1042		else {
1043	<	if (the_buffer != (uint8 *)MAP_FAILED) {
1044	<	munmap((caddr_t)the_buffer, the_buffer_size);
1043	>	//!! uninstall SEGV handler?
1044	>
1045	>	if (the_buffer != (uint8 *)VM_MAP_FAILED) {
1046	>	vm_release(the_buffer, the_buffer_size);
1047		the_buffer = 0;
1048		}
1049
1050	<	if (the_buffer_copy != (uint8 *)MAP_FAILED) {
1051	<	munmap((caddr_t)the_buffer_copy, the_buffer_size);
1050	>	if (the_buffer_copy != (uint8 *)VM_MAP_FAILED) {
1051	>	vm_release(the_buffer_copy, the_buffer_size);
1052		the_buffer_copy = 0;
1053		}
1054		}
#	Line 1194 \| Line 1068 \| void VideoExit(void)
1068		mainBuffer.dirtyPages = 0;
1069		}
1070		}
1197	–
1198	–	// Close /dev/zero
1199	–	if (zero_fd > 0)
1200	–	close(zero_fd);
1071		#endif
1072		}
1073
1074	+	void VideoExit(void)
1075	+	{
1076	+	video_close();
1077	+	}
1078	+
1079
1080		/*
1081		* Close down full-screen mode (if bringing up error alerts is unsafe while in full-screen mode)
#	Line 1224 \| Line 1099 \| void VideoInterrupt(void)
1099		if (emerg_quit)
1100		QuitEmulator();
1101
1227	–	#ifdef HAVE_PTHREADS
1102		// Temporarily give up frame buffer lock (this is the point where
1103		// we are suspended when the user presses Ctrl-Tab)
1104	<	pthread_mutex_unlock(&frame_buffer_lock);
1105	<	pthread_mutex_lock(&frame_buffer_lock);
1232	<	#endif
1104	>	UNLOCK_FRAME_BUFFER;
1105	>	LOCK_FRAME_BUFFER;
1106		}
1107
1108
#	Line 1239 \| Line 1112 \| void VideoInterrupt(void)
1112
1113		void video_set_palette(uint8 *pal)
1114		{
1115	<	#ifdef HAVE_PTHREDS
1243	<	pthread_mutex_lock(&palette_lock);
1244	<	#endif
1115	>	LOCK_PALETTE;
1116
1117		// Convert colors to XColor array
1118		for (int i=0; i<256; i++) {
#	Line 1255 \| Line 1126 \| *void video_set_palette(uint8 pal)**
1126		// Tell redraw thread to change palette
1127		palette_changed = true;
1128
1129	<	#ifdef HAVE_PTHREADS
1130	<	pthread_mutex_unlock(&palette_lock);
1131	<	#endif
1129	>	UNLOCK_PALETTE;
1130	>	}
1131	>
1132	>
1133	>	/*
1134	>	* Switch video mode
1135	>	*/
1136	>
1137	>	void video_switch_to_mode(const video_mode &mode)
1138	>	{
1139	>	video_close();
1140	>	video_open(mode);
1141		}
1142
1143
#	Line 1273 \| Line 1153 \| static void suspend_emul(void)
1153		ADBKeyUp(0x36);
1154		ctrl_down = false;
1155
1276	–	#ifdef HAVE_PTHREADS
1156		// Lock frame buffer (this will stop the MacOS thread)
1157	<	pthread_mutex_lock(&frame_buffer_lock);
1279	<	#endif
1157	>	LOCK_FRAME_BUFFER;
1158
1159		// Save frame buffer
1160	<	fb_save = malloc(VideoMonitor.y * VideoMonitor.bytes_per_row);
1160	>	fb_save = malloc(VideoMonitor.mode.y * VideoMonitor.mode.bytes_per_row);
1161		if (fb_save)
1162	<	memcpy(fb_save, the_buffer, VideoMonitor.y * VideoMonitor.bytes_per_row);
1162	>	memcpy(fb_save, the_buffer, VideoMonitor.mode.y * VideoMonitor.mode.bytes_per_row);
1163
1164		// Close full screen display
1165		#ifdef ENABLE_XF86_DGA
#	Line 1290 \| Line 1168 \| static void suspend_emul(void)
1168		XUngrabPointer(x_display, CurrentTime);
1169		XUngrabKeyboard(x_display, CurrentTime);
1170		XUnmapWindow(x_display, the_win);
1171	<	XSync(x_display, false);
1171	>	wait_unmapped(the_win);
1172
1173		// Open "suspend" window
1174		XSetWindowAttributes wattr;
1175		wattr.event_mask = KeyPressMask;
1176		wattr.background_pixel = black_pixel;
1299	–	wattr.border_pixel = black_pixel;
1300	–	wattr.backing_store = Always;
1301	–	wattr.backing_planes = xdepth;
1302	–	wattr.colormap = DefaultColormap(x_display, screen);
1177
1304	–	XSync(x_display, false);
1178		suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth,
1179	<	InputOutput, vis, CWEventMask \| CWBackPixel \| CWBorderPixel \|
1180	<	CWBackingStore \| CWBackingPlanes \| (xdepth == 8 ? CWColormap : 0), &wattr);
1181	<	XSync(x_display, false);
1182	<	XStoreName(x_display, suspend_win, GetString(STR_SUSPEND_WINDOW_TITLE));
1310	<	XMapRaised(x_display, suspend_win);
1311	<	XSync(x_display, false);
1179	>	InputOutput, vis, CWEventMask \| CWBackPixel, &wattr);
1180	>	set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE);
1181	>	set_window_focus(suspend_win);
1182	>	XMapWindow(x_display, suspend_win);
1183		emul_suspended = true;
1184		}
1185		}
#	Line 1321 \| Line 1192 \| static void resume_emul(void)
1192
1193		// Reopen full screen display
1194		XMapRaised(x_display, the_win);
1195	+	wait_mapped(the_win);
1196		XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
1325	–	XSync(x_display, false);
1197		XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime);
1198		XGrabPointer(x_display, rootwin, 1, PointerMotionMask \| ButtonPressMask \| ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
1199		#ifdef ENABLE_XF86_DGA
#	Line 1336 \| Line 1207 \| static void resume_emul(void)
1207		// not necessary.
1208		#ifdef ENABLE_VOSF
1209		if (use_vosf) {
1210	<	#ifdef HAVE_PTHREADS
1340	<	pthread_mutex_lock(&Screen_draw_lock);
1341	<	#endif
1210	>	LOCK_VOSF;
1211		PFLAG_SET_ALL;
1212	<	#ifdef HAVE_PTHREADS
1213	<	pthread_mutex_unlock(&Screen_draw_lock);
1345	<	#endif
1346	<	memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1212	>	UNLOCK_VOSF;
1213	>	memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
1214		}
1215		#endif
1216
#	Line 1353 \| Line 1220 \| static void resume_emul(void)
1220		// Don't copy fb_save to the temporary frame buffer in VOSF mode
1221		if (!use_vosf)
1222		#endif
1223	<	memcpy(the_buffer, fb_save, VideoMonitor.y * VideoMonitor.bytes_per_row);
1223	>	memcpy(the_buffer, fb_save, VideoMonitor.mode.y * VideoMonitor.mode.bytes_per_row);
1224		free(fb_save);
1225		fb_save = NULL;
1226		}
1227
1228		#ifdef ENABLE_XF86_DGA
1229	<	if (depth == 8)
1229	>	if (!IsDirectMode(VideoMonitor.mode))
1230		XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1231		#endif
1232
1366	–	#ifdef HAVE_PTHREADS
1233		// Unlock frame buffer (and continue MacOS thread)
1234	<	pthread_mutex_unlock(&frame_buffer_lock);
1234	>	UNLOCK_FRAME_BUFFER;
1235		emul_suspended = false;
1370	–	#endif
1236		}
1237		#endif
1238
#	Line 1521 \| Line 1386 \| static int kc_decode(KeySym ks)
1386		return -1;
1387		}
1388
1389	<	static int event2keycode(XKeyEvent *ev)
1389	>	static int event2keycode(XKeyEvent &ev)
1390		{
1391		KeySym ks;
1392		int as;
1393		int i = 0;
1394
1395		do {
1396	<	ks = XLookupKeysym(ev, i++);
1396	>	ks = XLookupKeysym(&ev, i++);
1397		as = kc_decode(ks);
1398		if (as != -1)
1399		return as;
#	Line 1544 \| Line 1409 \| *static int event2keycode(XKeyEvent ev)**
1409
1410		static void handle_events(void)
1411		{
1412	<	XEvent event;
1413	<	for (;;) {
1414	<	if (!XCheckMaskEvent(x_display, eventmask, &event))
1550	<	break;
1412	>	while (XPending(x_display)) {
1413	>	XEvent event;
1414	>	XNextEvent(x_display, &event);
1415
1416		switch (event.type) {
1417		// Mouse button
1418		case ButtonPress: {
1419	<	unsigned int button = ((XButtonEvent *)&event)->button;
1419	>	unsigned int button = event.xbutton.button;
1420		if (button < 4)
1421		ADBMouseDown(button - 1);
1422		else if (button < 6) { // Wheel mouse
#	Line 1571 \| Line 1435 \| static void handle_events(void)
1435		break;
1436		}
1437		case ButtonRelease: {
1438	<	unsigned int button = ((XButtonEvent *)&event)->button;
1438	>	unsigned int button = event.xbutton.button;
1439		if (button < 4)
1440		ADBMouseUp(button - 1);
1441		break;
#	Line 1579 \| Line 1443 \| static void handle_events(void)
1443
1444		// Mouse moved
1445		case EnterNotify:
1582	–	ADBMouseMoved(((XMotionEvent )&event)->x, ((XMotionEvent )&event)->y);
1583	–	break;
1446		case MotionNotify:
1447	<	ADBMouseMoved(((XMotionEvent )&event)->x, ((XMotionEvent )&event)->y);
1447	>	ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1448		break;
1449
1450		// Keyboard
1451		case KeyPress: {
1452		int code;
1453		if (use_keycodes) {
1454	<	event2keycode((XKeyEvent *)&event); // This is called to process the hotkeys
1455	<	code = keycode_table[((XKeyEvent *)&event)->keycode & 0xff];
1454	>	event2keycode(event.xkey); // This is called to process the hotkeys
1455	>	code = keycode_table[event.xkey.keycode & 0xff];
1456		} else
1457	<	code = event2keycode((XKeyEvent *)&event);
1457	>	code = event2keycode(event.xkey);
1458		if (code != -1) {
1459		if (!emul_suspended) {
1460		if (code == 0x39) { // Caps Lock pressed
#	Line 1619 \| Line 1481 \| static void handle_events(void)
1481		case KeyRelease: {
1482		int code;
1483		if (use_keycodes) {
1484	<	event2keycode((XKeyEvent *)&event); // This is called to process the hotkeys
1485	<	code = keycode_table[((XKeyEvent *)&event)->keycode & 0xff];
1484	>	event2keycode(event.xkey); // This is called to process the hotkeys
1485	>	code = keycode_table[event.xkey.keycode & 0xff];
1486		} else
1487	<	code = event2keycode((XKeyEvent *)&event);
1487	>	code = event2keycode(event.xkey);
1488		if (code != -1 && code != 0x39) { // Don't propagate Caps Lock releases
1489		ADBKeyUp(code);
1490		if (code == 0x36)
#	Line 1636 \| Line 1498 \| static void handle_events(void)
1498		if (display_type == DISPLAY_WINDOW) {
1499		#ifdef ENABLE_VOSF
1500		if (use_vosf) { // VOSF refresh
1501	<	#ifdef HAVE_PTHREADS
1640	<	pthread_mutex_lock(&Screen_draw_lock);
1641	<	#endif
1501	>	LOCK_VOSF;
1502		PFLAG_SET_ALL;
1503	<	#ifdef HAVE_PTHREADS
1504	<	pthread_mutex_unlock(&Screen_draw_lock);
1645	<	#endif
1646	<	memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1503	>	UNLOCK_VOSF;
1504	>	memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
1505		}
1506		else
1507		#endif
#	Line 1654 \| Line 1512 \| static void handle_events(void)
1512		updt_box[x1][y1] = true;
1513		nr_boxes = 16 * 16;
1514		} else // Static refresh
1515	<	memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1515	>	memset(the_buffer_copy, 0, VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y);
1516		}
1517		break;
1518
1519	<	case FocusIn:
1520	<	case FocusOut:
1519	>	// Window "close" widget clicked
1520	>	case ClientMessage:
1521	>	if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) {
1522	>	ADBKeyDown(0x7f); // Power key
1523	>	ADBKeyUp(0x7f);
1524	>	}
1525		break;
1526		}
1527		}
#	Line 1676 \| Line 1538 \| static void update_display_dynamic(int t
1538		int y1, y2, y2s, y2a, i, x1, xm, xmo, ymo, yo, yi, yil, xi;
1539		int xil = 0;
1540		int rxm = 0, rxmo = 0;
1541	<	int bytes_per_row = VideoMonitor.bytes_per_row;
1542	<	int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x;
1543	<	int rx = VideoMonitor.bytes_per_row / 16;
1544	<	int ry = VideoMonitor.y / 16;
1541	>	int bytes_per_row = VideoMonitor.mode.bytes_per_row;
1542	>	int bytes_per_pixel = VideoMonitor.mode.bytes_per_row / VideoMonitor.mode.x;
1543	>	int rx = VideoMonitor.mode.bytes_per_row / 16;
1544	>	int ry = VideoMonitor.mode.y / 16;
1545		int max_box;
1546
1547		y2s = sm_uptd[ticker % 8];
#	Line 1733 \| Line 1595 \| static void update_display_dynamic(int t
1595		i = (yi * bytes_per_row) + xi;
1596		for (y2=0; y2 < yil; y2++, i += bytes_per_row)
1597		memcpy(&the_buffer_copy[i], &the_buffer[i], xil);
1598	<	if (depth == 1) {
1598	>	if (VideoMonitor.mode.depth == VDEPTH_1BIT) {
1599		if (have_shm)
1600		XShmPutImage(x_display, the_win, the_gc, img, xi * 8, yi, xi * 8, yi, xil * 8, yil, 0);
1601		else
#	Line 1765 \| Line 1627 \| static void update_display_static(void)
1627		{
1628		// Incremental update code
1629		int wide = 0, high = 0, x1, x2, y1, y2, i, j;
1630	<	int bytes_per_row = VideoMonitor.bytes_per_row;
1631	<	int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x;
1630	>	int bytes_per_row = VideoMonitor.mode.bytes_per_row;
1631	>	int bytes_per_pixel = VideoMonitor.mode.bytes_per_row / VideoMonitor.mode.x;
1632		uint8 p, p2;
1633
1634		// Check for first line from top and first line from bottom that have changed
1635		y1 = 0;
1636	<	for (j=0; j<VideoMonitor.y; j++) {
1636	>	for (j=0; j<VideoMonitor.mode.y; j++) {
1637		if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1638		y1 = j;
1639		break;
1640		}
1641		}
1642		y2 = y1 - 1;
1643	<	for (j=VideoMonitor.y-1; j>=y1; j--) {
1643	>	for (j=VideoMonitor.mode.y-1; j>=y1; j--) {
1644		if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1645		y2 = j;
1646		break;
#	Line 1788 \| Line 1650 \| static void update_display_static(void)
1650
1651		// Check for first column from left and first column from right that have changed
1652		if (high) {
1653	<	if (depth == 1) {
1654	<	x1 = VideoMonitor.x - 1;
1653	>	if (VideoMonitor.mode.depth == VDEPTH_1BIT) {
1654	>	x1 = VideoMonitor.mode.x - 1;
1655		for (j=y1; j<=y2; j++) {
1656		p = &the_buffer[j * bytes_per_row];
1657		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1807 \| Line 1669 \| static void update_display_static(void)
1669		p2 = &the_buffer_copy[j * bytes_per_row];
1670		p += bytes_per_row;
1671		p2 += bytes_per_row;
1672	<	for (i=(VideoMonitor.x>>3); i>(x2>>3); i--) {
1672	>	for (i=(VideoMonitor.mode.x>>3); i>(x2>>3); i--) {
1673		p--; p2--;
1674		if (p != p2) {
1675		x2 = (i << 3) + 7;
#	Line 1826 \| Line 1688 \| static void update_display_static(void)
1688		}
1689
1690		} else {
1691	<	x1 = VideoMonitor.x;
1691	>	x1 = VideoMonitor.mode.x;
1692		for (j=y1; j<=y2; j++) {
1693		p = &the_buffer[j * bytes_per_row];
1694		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1844 \| Line 1706 \| static void update_display_static(void)
1706		p2 = &the_buffer_copy[j * bytes_per_row];
1707		p += bytes_per_row;
1708		p2 += bytes_per_row;
1709	<	for (i=VideoMonitor.xbytes_per_pixel; i>x2bytes_per_pixel; i--) {
1709	>	for (i=VideoMonitor.mode.xbytes_per_pixel; i>x2bytes_per_pixel; i--) {
1710		p--;
1711		p2--;
1712		if (p != p2) {
#	Line 1879 \| Line 1741 \| static void update_display_static(void)
1741		* Screen refresh functions
1742		*/
1743
1744	<	// The specialisations hereunder are meant to enable VOSF with DGA in direct
1745	<	// addressing mode in case the address spaces (RAM, ROM, FrameBuffer) could
1746	<	// not get mapped correctly with respect to the predetermined host frame
1747	<	// buffer base address.
1748	<	//
1887	<	// Hmm, in other words, when in direct addressing mode and DGA is requested,
1888	<	// we first try to "triple allocate" the address spaces according to the real
1889	<	// host frame buffer address. Then, if it fails, we will use a temporary
1890	<	// frame buffer thus making the real host frame buffer updated when pages
1891	<	// of the temp frame buffer are altered.
1892	<	//
1893	<	// As a side effect, a little speed gain in screen updates could be noticed
1894	<	// for other modes than DGA.
1895	<	//
1896	<	// The following two functions below are inline so that a clever compiler
1897	<	// could specialise the code according to the current screen depth and
1898	<	// display type. A more clever compiler would the job by itself though...
1899	<	// (update_display_vosf is inlined as well)
1744	>	// We suggest the compiler to inline the next two functions so that it
1745	>	// may specialise the code according to the current screen depth and
1746	>	// display type. A clever compiler would do that job by itself though...
1747	>
1748	>	// NOTE: update_display_vosf is inlined too
1749
1750		static inline void possibly_quit_dga_mode()
1751		{
#	Line 1910 \| Line 1759 \| static inline void possibly_quit_dga_mod
1759		XUngrabPointer(x_display, CurrentTime);
1760		XUngrabKeyboard(x_display, CurrentTime);
1761		XUnmapWindow(x_display, the_win);
1762	<	XSync(x_display, false);
1762	>	wait_unmapped(the_win);
1763		}
1764		#endif
1765		}
1766
1767	<	static inline void handle_palette_changes(int depth, int display_type)
1767	>	static inline void handle_palette_changes(int display_type)
1768		{
1769	<	#ifdef HAVE_PTHREADS
1770	<	pthread_mutex_lock(&palette_lock);
1922	<	#endif
1769	>	LOCK_PALETTE;
1770	>
1771		if (palette_changed) {
1772		palette_changed = false;
1773	<	if (depth == 8) {
1773	>	if (!IsDirectMode(VideoMonitor.mode)) {
1774		XStoreColors(x_display, cmap[0], palette, 256);
1775		XStoreColors(x_display, cmap[1], palette, 256);
1776	+	XSync(x_display, false);
1777
1778		#ifdef ENABLE_XF86_DGA
1779		if (display_type == DISPLAY_DGA) {
#	Line 1934 \| Line 1783 \| static inline void handle_palette_change
1783		#endif
1784		}
1785		}
1786	<	#ifdef HAVE_PTHREADS
1787	<	pthread_mutex_unlock(&palette_lock);
1939	<	#endif
1786	>
1787	>	UNLOCK_PALETTE;
1788		}
1789
1790		static void video_refresh_dga(void)
#	Line 1948 \| Line 1796 \| static void video_refresh_dga(void)
1796		handle_events();
1797
1798		// Handle palette changes
1799	<	handle_palette_changes(depth, DISPLAY_DGA);
1799	>	handle_palette_changes(DISPLAY_DGA);
1800		}
1801
1802		#ifdef ENABLE_VOSF
#	Line 1962 \| Line 1810 \| static void video_refresh_dga_vosf(void)
1810		handle_events();
1811
1812		// Handle palette changes
1813	<	handle_palette_changes(depth, DISPLAY_DGA);
1813	>	handle_palette_changes(DISPLAY_DGA);
1814
1815		// Update display (VOSF variant)
1816		static int tick_counter = 0;
1817		if (++tick_counter >= frame_skip) {
1818		tick_counter = 0;
1819	<	#ifdef HAVE_PTHREADS
1820	<	pthread_mutex_lock(&Screen_draw_lock);
1821	<	#endif
1822	<	update_display_dga_vosf();
1823	<	#ifdef HAVE_PTHREADS
1976	<	pthread_mutex_unlock(&Screen_draw_lock);
1977	<	#endif
1819	>	if (mainBuffer.dirty) {
1820	>	LOCK_VOSF;
1821	>	update_display_dga_vosf();
1822	>	UNLOCK_VOSF;
1823	>	}
1824		}
1825		}
1826		#endif
#	Line 1988 \| Line 1834 \| static void video_refresh_window_vosf(vo
1834		handle_events();
1835
1836		// Handle palette changes
1837	<	handle_palette_changes(depth, DISPLAY_WINDOW);
1837	>	handle_palette_changes(DISPLAY_WINDOW);
1838
1839		// Update display (VOSF variant)
1840		static int tick_counter = 0;
1841		if (++tick_counter >= frame_skip) {
1842		tick_counter = 0;
1843	<	#ifdef HAVE_PTHREADS
1844	<	pthread_mutex_lock(&Screen_draw_lock);
1845	<	#endif
1846	<	update_display_window_vosf();
1847	<	#ifdef HAVE_PTHREADS
1848	<	pthread_mutex_unlock(&Screen_draw_lock);
2003	<	#endif
1843	>	if (mainBuffer.dirty) {
1844	>	LOCK_VOSF;
1845	>	update_display_window_vosf();
1846	>	UNLOCK_VOSF;
1847	>	XSync(x_display, false); // Let the server catch up
1848	>	}
1849		}
1850		}
1851		#endif // def ENABLE_VOSF
#	Line 2011 \| Line 1856 \| static void video_refresh_window_static(
1856		handle_events();
1857
1858		// Handle_palette changes
1859	<	handle_palette_changes(depth, DISPLAY_WINDOW);
1859	>	handle_palette_changes(DISPLAY_WINDOW);
1860
1861		// Update display (static variant)
1862		static int tick_counter = 0;
#	Line 2027 \| Line 1872 \| static void video_refresh_window_dynamic
1872		handle_events();
1873
1874		// Handle_palette changes
1875	<	handle_palette_changes(depth, DISPLAY_WINDOW);
1875	>	handle_palette_changes(DISPLAY_WINDOW);
1876
1877		// Update display (dynamic variant)
1878		static int tick_counter = 0;
#	Line 2040 \| Line 1885 \| static void video_refresh_window_dynamic
1885		* Thread for screen refresh, input handling etc.
1886		*/
1887
1888	<	void VideoRefreshInit(void)
1888	>	static void VideoRefreshInit(void)
1889		{
1890		// TODO: set up specialised 8bpp VideoRefresh handlers ?
1891		if (display_type == DISPLAY_DGA) {
#	Line 2070 \| Line 1915 \| void VideoRefresh(void)
1915		video_refresh();
1916		}
1917
2073	–	#if 0
2074	–	void VideoRefresh(void)
2075	–	{
2076	–	#if defined(ENABLE_XF86_DGA) \|\| defined(ENABLE_FBDEV_DGA)
2077	–	// Quit DGA mode if requested
2078	–	if (quit_full_screen) {
2079	–	quit_full_screen = false;
2080	–	if (display_type == DISPLAY_DGA) {
2081	–	#ifdef ENABLE_XF86_DGA
2082	–	XF86DGADirectVideo(x_display, screen, 0);
2083	–	#endif
2084	–	XUngrabPointer(x_display, CurrentTime);
2085	–	XUngrabKeyboard(x_display, CurrentTime);
2086	–	XUnmapWindow(x_display, the_win);
2087	–	XSync(x_display, false);
2088	–	}
2089	–	}
2090	–	#endif
2091	–
2092	–	// Handle X events
2093	–	handle_events();
2094	–
2095	–	// Handle palette changes
2096	–	#ifdef HAVE_PTHREADS
2097	–	pthread_mutex_lock(&palette_lock);
2098	–	#endif
2099	–	if (palette_changed) {
2100	–	palette_changed = false;
2101	–	if (depth == 8) {
2102	–	XStoreColors(x_display, cmap[0], palette, 256);
2103	–	XStoreColors(x_display, cmap[1], palette, 256);
2104	–
2105	–	#ifdef ENABLE_XF86_DGA
2106	–	if (display_type == DISPLAY_DGA) {
2107	–	current_dga_cmap ^= 1;
2108	–	XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
2109	–	}
2110	–	#endif
2111	–	}
2112	–	}
2113	–	#ifdef HAVE_PTHREADS
2114	–	pthread_mutex_unlock(&palette_lock);
2115	–	#endif
2116	–
2117	–	// In window mode, update display
2118	–	static int tick_counter = 0;
2119	–	if (display_type == DISPLAY_WINDOW) {
2120	–	tick_counter++;
2121	–	if (frame_skip == 0)
2122	–	update_display_dynamic(tick_counter);
2123	–	else if (tick_counter >= frame_skip) {
2124	–	tick_counter = 0;
2125	–	update_display_static();
2126	–	}
2127	–	}
2128	–	}
2129	–	#endif
2130	–
1918		#ifdef HAVE_PTHREADS
1919		static void redraw_func(void arg)
1920		{
#	Line 2135 \| Line 1922 \| *static void redraw_func(void arg)*
1922		int64 ticks = 0;
1923		uint64 next = GetTicks_usec();
1924		while (!redraw_thread_cancel) {
2138	–	// VideoRefresh();
1925		video_refresh();
1926		next += 16667;
1927		int64 delay = next - GetTicks_usec();
#	Line 2146 \| Line 1932 \| *static void redraw_func(void arg)*
1932		ticks++;
1933		}
1934		uint64 end = GetTicks_usec();
1935	<	printf("%Ld ticks in %Ld usec = %Ld ticks/sec\n", ticks, end - start, (end - start) / ticks);
1935	>	// printf("%Ld ticks in %Ld usec = %Ld ticks/sec\n", ticks, end - start, ticks * 1000000 / (end - start));
1936		return NULL;
1937		}
1938		#endif

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing BasiliskII/src/Unix/video_x.cpp (file contents): Revision 1.26 by cebix, 2000-10-27T17:01:40Z vs. Revision 1.43 by gbeauche, 2001-06-28T22:06:18Z

Diff Legend

Comparing BasiliskII/src/Unix/video_x.cpp (file contents):
Revision 1.26 by cebix, 2000-10-27T17:01:40Z vs.
Revision 1.43 by gbeauche, 2001-06-28T22:06:18Z