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

Comparing BasiliskII/src/Unix/video_x.cpp (file contents):
Revision 1.18 by cebix, 2000-07-22T18:12:35Z vs.
Revision 1.38 by gbeauche, 2001-05-20T20:31:50Z

#	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 <fcntl.h>
57	+	# include <sys/mman.h>
58	+	# include "sigsegv.h"
59	+	#endif
60	+
61		#include "cpu_emulation.h"
62		#include "main.h"
63		#include "adb.h"
#	Line 115 \| Line 121 \| static Colormap cmap[2]; // Two co
121		static XColor black, white;
122		static unsigned long black_pixel, white_pixel;
123		static int eventmask;
124	<	static const int win_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask \| EnterWindowMask \| ExposureMask;
125	<	static const int dga_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask;
124	>	static const int win_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask \| EnterWindowMask \| ExposureMask \| StructureNotifyMask;
125	>	static const int dga_eventmask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask \| StructureNotifyMask;
126	>	static Atom WM_DELETE_WINDOW = (Atom)0;
127
128		static XColor palette[256]; // Color palette for 8-bit mode
129		static bool palette_changed = false; // Flag: Palette changed, redraw thread must set new colors
130		#ifdef HAVE_PTHREADS
131		static pthread_mutex_t palette_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect palette
132	+	#define LOCK_PALETTE pthread_mutex_lock(&palette_lock)
133	+	#define UNLOCK_PALETTE pthread_mutex_unlock(&palette_lock)
134	+	#else
135	+	#define LOCK_PALETTE
136	+	#define UNLOCK_PALETTE
137		#endif
138
139		// Variables for window mode
#	Line 142 \| Line 154 \| static Window suspend_win; // "Sus
154		static void *fb_save = NULL; // Saved frame buffer for suspend
155		#ifdef HAVE_PTHREADS
156		static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect frame buffer
157	+	#define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock);
158	+	#define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock);
159	+	#else
160	+	#define LOCK_FRAME_BUFFER
161	+	#define UNLOCK_FRAME_BUFFER
162		#endif
163
164		// Variables for fbdev DGA mode
#	Line 154 \| Line 171 \| static XF86VidModeModeInfo x_video_mod**
171		static int num_x_video_modes;
172		#endif
173
174	+	#ifdef ENABLE_VOSF
175	+	static bool use_vosf = true; // Flag: VOSF enabled
176	+	#else
177	+	static const bool use_vosf = false; // Flag: VOSF enabled
178	+	#endif
179	+
180	+	#ifdef ENABLE_VOSF
181	+	// Variables for Video on SEGV support (taken from the Win32 port)
182	+	static uint8 *the_host_buffer; // Host frame buffer in VOSF mode
183	+	static uint32 the_buffer_size; // Size of allocated the_buffer
184	+
185	+	struct ScreenPageInfo {
186	+	int top, bottom; // Mapping between this virtual page and Mac scanlines
187	+	};
188	+
189	+	struct ScreenInfo {
190	+	uint32 memBase; // Real start address
191	+	uint32 memStart; // Start address aligned to page boundary
192	+	uint32 memEnd; // Address of one-past-the-end of the screen
193	+	uint32 memLength; // Length of the memory addressed by the screen pages
194	+
195	+	uint32 pageSize; // Size of a page
196	+	int pageBits; // Shift count to get the page number
197	+	uint32 pageCount; // Number of pages allocated to the screen
198	+
199	+	bool dirty; // Flag: set if the frame buffer was touched
200	+	char * dirtyPages; // Table of flags set if page was altered
201	+	ScreenPageInfo * pageInfo; // Table of mappings page -> Mac scanlines
202	+	};
203	+
204	+	static ScreenInfo mainBuffer;
205	+
206	+	#define PFLAG_SET_VALUE 0x00
207	+	#define PFLAG_CLEAR_VALUE 0x01
208	+	#define PFLAG_SET_VALUE_4 0x00000000
209	+	#define PFLAG_CLEAR_VALUE_4 0x01010101
210	+	#define PFLAG_SET(page) mainBuffer.dirtyPages[page] = PFLAG_SET_VALUE
211	+	#define PFLAG_CLEAR(page) mainBuffer.dirtyPages[page] = PFLAG_CLEAR_VALUE
212	+	#define PFLAG_ISSET(page) (mainBuffer.dirtyPages[page] == PFLAG_SET_VALUE)
213	+	#define PFLAG_ISCLEAR(page) (mainBuffer.dirtyPages[page] != PFLAG_SET_VALUE)
214	+
215	+	#ifdef UNALIGNED_PROFITABLE
216	+	# define PFLAG_ISSET_4(page) (((uint32 )(mainBuffer.dirtyPages + (page))) == PFLAG_SET_VALUE_4)
217	+	# define PFLAG_ISCLEAR_4(page) (((uint32 )(mainBuffer.dirtyPages + (page))) == PFLAG_CLEAR_VALUE_4)
218	+	#else
219	+	# define PFLAG_ISSET_4(page) \
220	+	PFLAG_ISSET(page ) && PFLAG_ISSET(page+1) \
221	+	&& PFLAG_ISSET(page+2) && PFLAG_ISSET(page+3)
222	+	# define PFLAG_ISCLEAR_4(page) \
223	+	PFLAG_ISCLEAR(page ) && PFLAG_ISCLEAR(page+1) \
224	+	&& PFLAG_ISCLEAR(page+2) && PFLAG_ISCLEAR(page+3)
225	+	#endif
226	+
227	+	// Set the selected page range [ first_page, last_page [ into the SET state
228	+	#define PFLAG_SET_RANGE(first_page, last_page) \
229	+	memset(mainBuffer.dirtyPages + (first_page), PFLAG_SET_VALUE, \
230	+	(last_page) - (first_page))
231	+
232	+	// Set the selected page range [ first_page, last_page [ into the CLEAR state
233	+	#define PFLAG_CLEAR_RANGE(first_page, last_page) \
234	+	memset(mainBuffer.dirtyPages + (first_page), PFLAG_CLEAR_VALUE, \
235	+	(last_page) - (first_page))
236	+
237	+	#define PFLAG_SET_ALL do { \
238	+	PFLAG_SET_RANGE(0, mainBuffer.pageCount); \
239	+	mainBuffer.dirty = true; \
240	+	} while (0)
241	+
242	+	#define PFLAG_CLEAR_ALL do { \
243	+	PFLAG_CLEAR_RANGE(0, mainBuffer.pageCount); \
244	+	mainBuffer.dirty = false; \
245	+	} while (0)
246	+
247	+	// Set the following macro definition to 1 if your system
248	+	// provides a really fast strchr() implementation
249	+	//#define HAVE_FAST_STRCHR 0
250	+
251	+	static inline int find_next_page_set(int page)
252	+	{
253	+	#if HAVE_FAST_STRCHR
254	+	char *match = strchr(mainBuffer.dirtyPages + page, PFLAG_SET_VALUE);
255	+	return match ? match - mainBuffer.dirtyPages : mainBuffer.pageCount;
256	+	#else
257	+	while (PFLAG_ISCLEAR_4(page))
258	+	page += 4;
259	+	while (PFLAG_ISCLEAR(page))
260	+	page++;
261	+	return page;
262	+	#endif
263	+	}
264	+
265	+	static inline int find_next_page_clear(int page)
266	+	{
267	+	#if HAVE_FAST_STRCHR
268	+	char *match = strchr(mainBuffer.dirtyPages + page, PFLAG_CLEAR_VALUE);
269	+	return match ? match - mainBuffer.dirtyPages : mainBuffer.pageCount;
270	+	#else
271	+	while (PFLAG_ISSET_4(page))
272	+	page += 4;
273	+	while (PFLAG_ISSET(page))
274	+	page++;
275	+	return page;
276	+	#endif
277	+	}
278	+
279	+	static int zero_fd = -1;
280	+
281	+	#ifdef HAVE_PTHREADS
282	+	static pthread_mutex_t vosf_lock = PTHREAD_MUTEX_INITIALIZER; // Mutex to protect frame buffer (dirtyPages in fact)
283	+	#define LOCK_VOSF pthread_mutex_lock(&vosf_lock);
284	+	#define UNLOCK_VOSF pthread_mutex_unlock(&vosf_lock);
285	+	#else
286	+	#define LOCK_VOSF
287	+	#define UNLOCK_VOSF
288	+	#endif
289	+
290	+	static int log_base_2(uint32 x)
291	+	{
292	+	uint32 mask = 0x80000000;
293	+	int l = 31;
294	+	while (l >= 0 && (x & mask) == 0) {
295	+	mask >>= 1;
296	+	l--;
297	+	}
298	+	return l;
299	+	}
300	+	#endif /* ENABLE_VOSF */
301	+
302	+	// VideoRefresh function
303	+	void VideoRefreshInit(void);
304	+	static void (*video_refresh)(void);
305
306		// Prototypes
307		static void redraw_func(void arg);
308	<	static int event2keycode(XKeyEvent *ev);
308	>	static int event2keycode(XKeyEvent &ev);
309
310
311		// From main_unix.cpp
#	Line 167 \| Line 315 \| *extern Display x_display;**
315		// From sys_unix.cpp
316		extern void SysMountFirstFloppy(void);
317
318	+	#ifdef ENABLE_VOSF
319	+	# include "video_vosf.h"
320	+	#endif
321	+
322
323		/*
324		* Initialization
#	Line 175 \| Line 327 \| extern void SysMountFirstFloppy(void);
327		// Set VideoMonitor according to video mode
328		void set_video_monitor(int width, int height, int bytes_per_row, bool native_byte_order)
329		{
330	<	#if !REAL_ADDRESSING
330	>	#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
331		int layout = FLAYOUT_DIRECT;
332		switch (depth) {
333		case 1:
#	Line 223 \| Line 375 \| void set_video_monitor(int width, int he
375		VideoMonitor.bytes_per_row = bytes_per_row;
376		}
377
378	+	// Set window name and class
379	+	static void set_window_name(Window w, int name)
380	+	{
381	+	const char *str = GetString(name);
382	+	XStoreName(x_display, w, str);
383	+	XSetIconName(x_display, w, str);
384	+
385	+	XClassHint *hints;
386	+	hints = XAllocClassHint();
387	+	if (hints) {
388	+	hints->res_name = "BasiliskII";
389	+	hints->res_class = "BasiliskII";
390	+	XSetClassHint(x_display, w, hints);
391	+	XFree(hints);
392	+	}
393	+	}
394	+
395	+	// Set window input focus flag
396	+	static void set_window_focus(Window w)
397	+	{
398	+	XWMHints *hints = XAllocWMHints();
399	+	if (hints) {
400	+	hints->input = True;
401	+	hints->initial_state = NormalState;
402	+	hints->flags = InputHint \| StateHint;
403	+	XSetWMHints(x_display, w, hints);
404	+	XFree(hints);
405	+	}
406	+	}
407	+
408	+	// Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
409	+	static void set_window_delete_protocol(Window w)
410	+	{
411	+	WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
412	+	XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
413	+	}
414	+
415	+	// Wait until window is mapped/unmapped
416	+	void wait_mapped(Window w)
417	+	{
418	+	XEvent e;
419	+	do {
420	+	XMaskEvent(x_display, StructureNotifyMask, &e);
421	+	} while ((e.type != MapNotify) \|\| (e.xmap.event != w));
422	+	}
423	+
424	+	void wait_unmapped(Window w)
425	+	{
426	+	XEvent e;
427	+	do {
428	+	XMaskEvent(x_display, StructureNotifyMask, &e);
429	+	} while ((e.type != UnmapNotify) \|\| (e.xmap.event != w));
430	+	}
431	+
432		// Trap SHM errors
433		static bool shm_error = false;
434		static int (old_error_handler)(Display , XErrorEvent *);
#	Line 252 \| Line 458 \| static bool init_window(int width, int h
458		XSetWindowAttributes wattr;
459		wattr.event_mask = eventmask = win_eventmask;
460		wattr.background_pixel = black_pixel;
461	<	wattr.border_pixel = black_pixel;
256	<	wattr.backing_store = NotUseful;
257	<	wattr.save_under = false;
258	<	wattr.backing_planes = xdepth;
461	>	wattr.colormap = cmap[0];
462
260	–	XSync(x_display, false);
463		the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
464	<	InputOutput, vis, CWEventMask \| CWBackPixel \| CWBorderPixel \|
263	<	CWBackingStore \| CWBackingPlanes, &wattr);
264	<	XSync(x_display, false);
265	<	XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
266	<	XMapRaised(x_display, the_win);
267	<	XSync(x_display, false);
464	>	InputOutput, vis, CWEventMask \| CWBackPixel \| (depth == 8 ? CWColormap : 0), &wattr);
465
466	<	// Set colormap
467	<	if (depth == 8) {
468	<	XSetWindowColormap(x_display, the_win, cmap[0]);
469	<	XSetWMColormapWindows(x_display, the_win, &the_win, 1);
470	<	}
466	>	// Set window name/class
467	>	set_window_name(the_win, STR_WINDOW_TITLE);
468	>
469	>	// Indicate that we want keyboard input
470	>	set_window_focus(the_win);
471	>
472	>	// Set delete protocol property
473	>	set_window_delete_protocol(the_win);
474
475		// Make window unresizable
476	<	XSizeHints *hints;
477	<	if ((hints = XAllocSizeHints()) != NULL) {
478	<	hints->min_width = width;
479	<	hints->max_width = width;
480	<	hints->min_height = height;
481	<	hints->max_height = height;
482	<	hints->flags = PMinSize \| PMaxSize;
483	<	XSetWMNormalHints(x_display, the_win, hints);
484	<	XFree((char *)hints);
476	>	{
477	>	XSizeHints *hints = XAllocSizeHints();
478	>	if (hints) {
479	>	hints->min_width = width;
480	>	hints->max_width = width;
481	>	hints->min_height = height;
482	>	hints->max_height = height;
483	>	hints->flags = PMinSize \| PMaxSize;
484	>	XSetWMNormalHints(x_display, the_win, hints);
485	>	XFree(hints);
486	>	}
487		}
488
489	+	// Show window
490	+	XMapWindow(x_display, the_win);
491	+	wait_mapped(the_win);
492	+
493		// Try to create and attach SHM image
494		have_shm = false;
495		if (depth != 1 && local_X11 && XShmQueryExtension(x_display)) {
#	Line 337 \| Line 543 \| static bool init_window(int width, int h
543		img->bitmap_bit_order = MSBFirst;
544		}
545
546	+	#ifdef ENABLE_VOSF
547	+	// Allocate a page-aligned chunk of memory for frame buffer
548	+	the_buffer_size = align_on_page_boundary((aligned_height + 2) * img->bytes_per_line);
549	+	the_host_buffer = the_buffer_copy;
550	+
551	+	the_buffer_copy = (uint8 *)allocate_framebuffer(the_buffer_size);
552	+	memset(the_buffer_copy, 0, the_buffer_size);
553	+
554	+	the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size);
555	+	memset(the_buffer, 0, the_buffer_size);
556	+	#else
557		// Allocate memory for frame buffer
558		the_buffer = (uint8 )malloc((aligned_height + 2) img->bytes_per_line);
559	+	#endif
560
561		// Create GC
562		the_gc = XCreateGC(x_display, the_win, 0, 0);
#	Line 352 \| Line 570 \| static bool init_window(int width, int h
570		XDefineCursor(x_display, the_win, mac_cursor);
571
572		// Set VideoMonitor
573	+	bool native_byte_order;
574		#ifdef WORDS_BIGENDIAN
575	<	set_video_monitor(width, height, img->bytes_per_line, img->bitmap_bit_order == MSBFirst);
575	>	native_byte_order = (XImageByteOrder(x_display) == MSBFirst);
576		#else
577	<	set_video_monitor(width, height, img->bytes_per_line, img->bitmap_bit_order == LSBFirst);
577	>	native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
578	>	#endif
579	>	#ifdef ENABLE_VOSF
580	>	Screen_blitter_init(&visualInfo, native_byte_order);
581		#endif
582	+	set_video_monitor(width, height, img->bytes_per_line, native_byte_order);
583
584	<	#if REAL_ADDRESSING
585	<	VideoMonitor.mac_frame_base = (uint32)the_buffer;
584	>	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
585	>	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
586		#else
587		VideoMonitor.mac_frame_base = MacFrameBaseMac;
588		#endif
#	Line 438 \| Line 661 \| *static bool init_fbdev_dga(char in_fb_n**
661
662		// Create window
663		XSetWindowAttributes wattr;
664	<	wattr.override_redirect = True;
665	<	wattr.backing_store = NotUseful;
666	<	wattr.background_pixel = white_pixel;
667	<	wattr.border_pixel = black_pixel;
445	<	wattr.event_mask = eventmask = dga_eventmask;
664	>	wattr.event_mask = eventmask = dga_eventmask;
665	>	wattr.background_pixel = white_pixel;
666	>	wattr.override_redirect = True;
667	>	wattr.colormap = cmap[0];
668
447	–	XSync(x_display, false);
669		the_win = XCreateWindow(x_display, rootwin,
670		0, 0, width, height,
671		0, xdepth, InputOutput, vis,
672	<	CWEventMask\|CWBackPixel\|CWBorderPixel\|CWOverrideRedirect\|CWBackingStore,
672	>	CWEventMask \| CWBackPixel \| CWOverrideRedirect \| (depth == 8 ? CWColormap : 0),
673		&wattr);
674	<	XSync(x_display, false);
674	>
675	>	// Set window name/class
676	>	set_window_name(the_win, STR_WINDOW_TITLE);
677	>
678	>	// Indicate that we want keyboard input
679	>	set_window_focus(the_win);
680	>
681	>	// Show window
682		XMapRaised(x_display, the_win);
683	<	XSync(x_display, false);
683	>	wait_mapped(the_win);
684
685		// Grab mouse and keyboard
686		XGrabKeyboard(x_display, the_win, True,
#	Line 461 \| Line 689 \| *static bool init_fbdev_dga(char in_fb_n**
689		PointerMotionMask \| ButtonPressMask \| ButtonReleaseMask,
690		GrabModeAsync, GrabModeAsync, the_win, None, CurrentTime);
691
464	–	// Set colormap
465	–	if (depth == 8) {
466	–	XSetWindowColormap(x_display, the_win, cmap[0]);
467	–	XSetWMColormapWindows(x_display, the_win, &the_win, 1);
468	–	}
469	–
692		// Set VideoMonitor
693		int bytes_per_row = width;
694		switch (depth) {
#	Line 492 \| Line 714 \| *static bool init_fbdev_dga(char in_fb_n**
714		}
715		}
716
717	+	#if ENABLE_VOSF
718	+	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
719	+	// Screen_blitter_init() returns TRUE if VOSF is mandatory
720	+	// i.e. the framebuffer update function is not Blit_Copy_Raw
721	+	use_vosf = Screen_blitter_init(&visualInfo, true);
722	+
723	+	if (use_vosf) {
724	+	the_host_buffer = the_buffer;
725	+	the_buffer_size = align_on_page_boundary((height + 2) * bytes_per_row);
726	+	the_buffer_copy = (uint8 *)malloc(the_buffer_size);
727	+	memset(the_buffer_copy, 0, the_buffer_size);
728	+	the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size);
729	+	memset(the_buffer, 0, the_buffer_size);
730	+	}
731	+	#else
732	+	use_vosf = false;
733	+	#endif
734	+	#endif
735	+
736		set_video_monitor(width, height, bytes_per_row, true);
737	<	#if REAL_ADDRESSING
738	<	VideoMonitor.mac_frame_base = (uint32)the_buffer;
737	>	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
738	>	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
739		#else
740		VideoMonitor.mac_frame_base = MacFrameBaseMac;
741		#endif
#	Line 524 \| Line 765 \| static bool init_xf86_dga(int width, int
765		}
766		XF86VidModeSwitchToMode(x_display, screen, x_video_modes[best]);
767		XF86VidModeSetViewPort(x_display, screen, 0, 0);
768	+	XSync(x_display, false);
769		}
770		#endif
771
772		// Create window
773		XSetWindowAttributes wattr;
774		wattr.event_mask = eventmask = dga_eventmask;
533	–	wattr.border_pixel = black_pixel;
775		wattr.override_redirect = True;
776
536	–	XSync(x_display, false);
777		the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
778	<	InputOutput, vis, CWEventMask \| CWBorderPixel \| CWOverrideRedirect, &wattr);
779	<	XSync(x_display, false);
780	<	XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
778	>	InputOutput, vis, CWEventMask \| CWOverrideRedirect, &wattr);
779	>
780	>	// Set window name/class
781	>	set_window_name(the_win, STR_WINDOW_TITLE);
782	>
783	>	// Indicate that we want keyboard input
784	>	set_window_focus(the_win);
785	>
786	>	// Show window
787		XMapRaised(x_display, the_win);
788	<	XSync(x_display, false);
788	>	wait_mapped(the_win);
789
790		// Establish direct screen connection
791		XMoveResizeWindow(x_display, the_win, 0, 0, width, height);
#	Line 556 \| Line 802 \| static bool init_xf86_dga(int width, int
802		// Set colormap
803		if (depth == 8) {
804		XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]);
559	–	XSetWMColormapWindows(x_display, the_win, &the_win, 1);
805		XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
806		}
807	+	XSync(x_display, false);
808
809		// Set VideoMonitor
810		int bytes_per_row = (v_width + 7) & ~7;
#	Line 575 \| Line 821 \| static bool init_xf86_dga(int width, int
821		bytes_per_row *= 4;
822		break;
823		}
824	+
825	+	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
826	+	// Screen_blitter_init() returns TRUE if VOSF is mandatory
827	+	// i.e. the framebuffer update function is not Blit_Copy_Raw
828	+	use_vosf = Screen_blitter_init(&visualInfo, true);
829	+
830	+	if (use_vosf) {
831	+	the_host_buffer = the_buffer;
832	+	the_buffer_size = align_on_page_boundary((height + 2) * bytes_per_row);
833	+	the_buffer_copy = (uint8 *)malloc(the_buffer_size);
834	+	memset(the_buffer_copy, 0, the_buffer_size);
835	+	the_buffer = (uint8 *)allocate_framebuffer(the_buffer_size);
836	+	memset(the_buffer, 0, the_buffer_size);
837	+	}
838	+	#elif defined(ENABLE_VOSF)
839	+	// The UAE memory handlers will already handle color conversion, if needed.
840	+	use_vosf = false;
841	+	#endif
842	+
843		set_video_monitor(width, height, bytes_per_row, true);
844	<	#if REAL_ADDRESSING
845	<	VideoMonitor.mac_frame_base = (uint32)the_buffer;
846	<	MacFrameLayout = FLAYOUT_DIRECT;
844	>	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
845	>	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
846	>	// MacFrameLayout = FLAYOUT_DIRECT;
847		#else
848		VideoMonitor.mac_frame_base = MacFrameBaseMac;
849		#endif
#	Line 654 \| Line 919 \| static void keycode_init(void)
919		}
920		}
921
922	+	bool VideoInitBuffer()
923	+	{
924	+	#ifdef ENABLE_VOSF
925	+	if (use_vosf) {
926	+	const uint32 page_size = getpagesize();
927	+	const uint32 page_mask = page_size - 1;
928	+
929	+	mainBuffer.memBase = (uint32) the_buffer;
930	+	// Align the frame buffer on page boundary
931	+	mainBuffer.memStart = (uint32)((((unsigned long) the_buffer) + page_mask) & ~page_mask);
932	+	mainBuffer.memLength = the_buffer_size;
933	+	mainBuffer.memEnd = mainBuffer.memStart + mainBuffer.memLength;
934	+
935	+	mainBuffer.pageSize = page_size;
936	+	mainBuffer.pageCount = (mainBuffer.memLength + page_mask)/mainBuffer.pageSize;
937	+	mainBuffer.pageBits = log_base_2(mainBuffer.pageSize);
938	+
939	+	if (mainBuffer.dirtyPages != 0)
940	+	free(mainBuffer.dirtyPages);
941	+
942	+	mainBuffer.dirtyPages = (char *) malloc(mainBuffer.pageCount + 2);
943	+
944	+	if (mainBuffer.pageInfo != 0)
945	+	free(mainBuffer.pageInfo);
946	+
947	+	mainBuffer.pageInfo = (ScreenPageInfo ) malloc(mainBuffer.pageCount sizeof(ScreenPageInfo));
948	+
949	+	if ((mainBuffer.dirtyPages == 0) \|\| (mainBuffer.pageInfo == 0))
950	+	return false;
951	+
952	+	mainBuffer.dirty = false;
953	+
954	+	PFLAG_CLEAR_ALL;
955	+	// Safety net to insure the loops in the update routines will terminate
956	+	// See a discussion in <video_vosf.h> for further details
957	+	PFLAG_CLEAR(mainBuffer.pageCount);
958	+	PFLAG_SET(mainBuffer.pageCount+1);
959	+
960	+	uint32 a = 0;
961	+	for (int i = 0; i < mainBuffer.pageCount; i++) {
962	+	int y1 = a / VideoMonitor.bytes_per_row;
963	+	if (y1 >= VideoMonitor.y)
964	+	y1 = VideoMonitor.y - 1;
965	+
966	+	int y2 = (a + mainBuffer.pageSize) / VideoMonitor.bytes_per_row;
967	+	if (y2 >= VideoMonitor.y)
968	+	y2 = VideoMonitor.y - 1;
969	+
970	+	mainBuffer.pageInfo[i].top = y1;
971	+	mainBuffer.pageInfo[i].bottom = y2;
972	+
973	+	a += mainBuffer.pageSize;
974	+	if (a > mainBuffer.memLength)
975	+	a = mainBuffer.memLength;
976	+	}
977	+
978	+	// We can now write-protect the frame buffer
979	+	if (mprotect((caddr_t)mainBuffer.memStart, mainBuffer.memLength, PROT_READ) != 0)
980	+	return false;
981	+	}
982	+	#endif
983	+	return true;
984	+	}
985	+
986		bool VideoInit(bool classic)
987		{
988	+	#ifdef ENABLE_VOSF
989	+	// Open /dev/zero
990	+	zero_fd = open("/dev/zero", O_RDWR);
991	+	if (zero_fd < 0) {
992	+	char str[256];
993	+	sprintf(str, GetString(STR_NO_DEV_ZERO_ERR), strerror(errno));
994	+	ErrorAlert(str);
995	+	return false;
996	+	}
997	+
998	+	// Zero the mainBuffer structure
999	+	mainBuffer.dirtyPages = 0;
1000	+	mainBuffer.pageInfo = 0;
1001	+	#endif
1002	+
1003		// Check if X server runs on local machine
1004		local_X11 = (strncmp(XDisplayName(x_display_name), ":", 1) == 0)
1005		\|\| (strncmp(XDisplayName(x_display_name), "unix:", 5) == 0);
#	Line 664 \| Line 1008 \| bool VideoInit(bool classic)
1008		keycode_init();
1009
1010		// Read prefs
1011	<	mouse_wheel_mode = PrefsFindInt16("mousewheelmode");
1012	<	mouse_wheel_lines = PrefsFindInt16("mousewheellines");
1011	>	mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
1012	>	mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1013
1014		// Find screen and root window
1015		screen = XDefaultScreen(x_display);
#	Line 802 \| Line 1146 \| bool VideoInit(bool classic)
1146		break;
1147		}
1148
805	–	#ifdef HAVE_PTHREADS
1149		// Lock down frame buffer
1150	<	pthread_mutex_lock(&frame_buffer_lock);
808	<	#endif
1150	>	LOCK_FRAME_BUFFER;
1151
1152	<	#if !REAL_ADDRESSING
1152	>	#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
1153		// Set variables for UAE memory mapping
1154		MacFrameBaseHost = the_buffer;
1155		MacFrameSize = VideoMonitor.bytes_per_row * VideoMonitor.y;
#	Line 817 \| Line 1159 \| bool VideoInit(bool classic)
1159		MacFrameLayout = FLAYOUT_NONE;
1160		#endif
1161
1162	+	#ifdef ENABLE_VOSF
1163	+	if (use_vosf) {
1164	+	// Initialize the mainBuffer structure
1165	+	if (!VideoInitBuffer()) {
1166	+	// TODO: STR_VOSF_INIT_ERR ?
1167	+	ErrorAlert("Could not initialize Video on SEGV signals");
1168	+	return false;
1169	+	}
1170	+
1171	+	// Initialize the handler for SIGSEGV
1172	+	if (!sigsegv_install_handler(screen_fault_handler)) {
1173	+	// TODO: STR_VOSF_INIT_ERR ?
1174	+	ErrorAlert("Could not initialize Video on SEGV signals");
1175	+	return false;
1176	+	}
1177	+	}
1178	+	#endif
1179	+
1180	+	// Initialize VideoRefresh function
1181	+	VideoRefreshInit();
1182	+
1183		XSync(x_display, false);
1184
1185		#ifdef HAVE_PTHREADS
#	Line 849 \| Line 1212 \| void VideoExit(void)
1212		}
1213		#endif
1214
852	–	#ifdef HAVE_PTHREADS
1215		// Unlock frame buffer
1216	<	pthread_mutex_unlock(&frame_buffer_lock);
855	<	#endif
1216	>	UNLOCK_FRAME_BUFFER;
1217
1218		// Close window and server connection
1219		if (x_display != NULL) {
#	Line 885 \| Line 1246 \| void VideoExit(void)
1246		XFreeColormap(x_display, cmap[0]);
1247		XFreeColormap(x_display, cmap[1]);
1248		}
1249	+
1250	+	if (!use_vosf) {
1251	+	if (the_buffer) {
1252	+	free(the_buffer);
1253	+	the_buffer = NULL;
1254	+	}
1255
1256	<	if (the_buffer) {
1257	<	free(the_buffer);
1258	<	the_buffer = NULL;
1256	>	if (!have_shm && the_buffer_copy) {
1257	>	free(the_buffer_copy);
1258	>	the_buffer_copy = NULL;
1259	>	}
1260	>	}
1261	>	#ifdef ENABLE_VOSF
1262	>	else {
1263	>	if (the_buffer != (uint8 *)MAP_FAILED) {
1264	>	munmap((caddr_t)the_buffer, the_buffer_size);
1265	>	the_buffer = 0;
1266	>	}
1267	>
1268	>	if (the_buffer_copy != (uint8 *)MAP_FAILED) {
1269	>	munmap((caddr_t)the_buffer_copy, the_buffer_size);
1270	>	the_buffer_copy = 0;
1271	>	}
1272	>	}
1273	>	#endif
1274	>	}
1275	>
1276	>	#ifdef ENABLE_VOSF
1277	>	if (use_vosf) {
1278	>	// Clear mainBuffer data
1279	>	if (mainBuffer.pageInfo) {
1280	>	free(mainBuffer.pageInfo);
1281	>	mainBuffer.pageInfo = 0;
1282		}
1283
1284	<	if (!have_shm && the_buffer_copy) {
1285	<	free(the_buffer_copy);
1286	<	the_buffer_copy = NULL;
1284	>	if (mainBuffer.dirtyPages) {
1285	>	free(mainBuffer.dirtyPages);
1286	>	mainBuffer.dirtyPages = 0;
1287		}
1288		}
1289	+
1290	+	// Close /dev/zero
1291	+	if (zero_fd > 0)
1292	+	close(zero_fd);
1293	+	#endif
1294		}
1295
1296
#	Line 921 \| Line 1316 \| void VideoInterrupt(void)
1316		if (emerg_quit)
1317		QuitEmulator();
1318
924	–	#ifdef HAVE_PTHREADS
1319		// Temporarily give up frame buffer lock (this is the point where
1320		// we are suspended when the user presses Ctrl-Tab)
1321	<	pthread_mutex_unlock(&frame_buffer_lock);
1322	<	pthread_mutex_lock(&frame_buffer_lock);
929	<	#endif
1321	>	UNLOCK_FRAME_BUFFER;
1322	>	LOCK_FRAME_BUFFER;
1323		}
1324
1325
#	Line 936 \| Line 1329 \| void VideoInterrupt(void)
1329
1330		void video_set_palette(uint8 *pal)
1331		{
1332	<	#ifdef HAVE_PTHREDS
940	<	pthread_mutex_lock(&palette_lock);
941	<	#endif
1332	>	LOCK_PALETTE;
1333
1334		// Convert colors to XColor array
1335		for (int i=0; i<256; i++) {
#	Line 952 \| Line 1343 \| *void video_set_palette(uint8 pal)**
1343		// Tell redraw thread to change palette
1344		palette_changed = true;
1345
1346	<	#ifdef HAVE_PTHREADS
956	<	pthread_mutex_unlock(&palette_lock);
957	<	#endif
1346	>	UNLOCK_PALETTE;
1347		}
1348
1349
#	Line 970 \| Line 1359 \| static void suspend_emul(void)
1359		ADBKeyUp(0x36);
1360		ctrl_down = false;
1361
973	–	#ifdef HAVE_PTHREADS
1362		// Lock frame buffer (this will stop the MacOS thread)
1363	<	pthread_mutex_lock(&frame_buffer_lock);
976	<	#endif
1363	>	LOCK_FRAME_BUFFER;
1364
1365		// Save frame buffer
1366		fb_save = malloc(VideoMonitor.y * VideoMonitor.bytes_per_row);
#	Line 987 \| Line 1374 \| static void suspend_emul(void)
1374		XUngrabPointer(x_display, CurrentTime);
1375		XUngrabKeyboard(x_display, CurrentTime);
1376		XUnmapWindow(x_display, the_win);
1377	<	XSync(x_display, false);
1377	>	wait_unmapped(the_win);
1378
1379		// Open "suspend" window
1380		XSetWindowAttributes wattr;
1381		wattr.event_mask = KeyPressMask;
1382		wattr.background_pixel = black_pixel;
996	–	wattr.border_pixel = black_pixel;
997	–	wattr.backing_store = Always;
998	–	wattr.backing_planes = xdepth;
999	–	wattr.colormap = DefaultColormap(x_display, screen);
1383
1001	–	XSync(x_display, false);
1384		suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth,
1385	<	InputOutput, vis, CWEventMask \| CWBackPixel \| CWBorderPixel \|
1386	<	CWBackingStore \| CWBackingPlanes \| (xdepth == 8 ? CWColormap : 0), &wattr);
1387	<	XSync(x_display, false);
1388	<	XStoreName(x_display, suspend_win, GetString(STR_SUSPEND_WINDOW_TITLE));
1007	<	XMapRaised(x_display, suspend_win);
1008	<	XSync(x_display, false);
1385	>	InputOutput, vis, CWEventMask \| CWBackPixel, &wattr);
1386	>	set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE);
1387	>	set_window_focus(suspend_win);
1388	>	XMapWindow(x_display, suspend_win);
1389		emul_suspended = true;
1390		}
1391		}
#	Line 1018 \| Line 1398 \| static void resume_emul(void)
1398
1399		// Reopen full screen display
1400		XMapRaised(x_display, the_win);
1401	+	wait_mapped(the_win);
1402		XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
1022	–	XSync(x_display, false);
1403		XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime);
1404		XGrabPointer(x_display, rootwin, 1, PointerMotionMask \| ButtonPressMask \| ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
1405		#ifdef ENABLE_XF86_DGA
#	Line 1027 \| Line 1407 \| static void resume_emul(void)
1407		XF86DGASetViewPort(x_display, screen, 0, 0);
1408		#endif
1409		XSync(x_display, false);
1410	<
1410	>
1411	>	// the_buffer already contains the data to restore. i.e. since a temporary
1412	>	// frame buffer is used when VOSF is actually used, fb_save is therefore
1413	>	// not necessary.
1414	>	#ifdef ENABLE_VOSF
1415	>	if (use_vosf) {
1416	>	LOCK_VOSF;
1417	>	PFLAG_SET_ALL;
1418	>	UNLOCK_VOSF;
1419	>	memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1420	>	}
1421	>	#endif
1422	>
1423		// Restore frame buffer
1424		if (fb_save) {
1425	+	#ifdef ENABLE_VOSF
1426	+	// Don't copy fb_save to the temporary frame buffer in VOSF mode
1427	+	if (!use_vosf)
1428	+	#endif
1429		memcpy(the_buffer, fb_save, VideoMonitor.y * VideoMonitor.bytes_per_row);
1430		free(fb_save);
1431		fb_save = NULL;
#	Line 1040 \| Line 1436 \| static void resume_emul(void)
1436		XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1437		#endif
1438
1043	–	#ifdef HAVE_PTHREADS
1439		// Unlock frame buffer (and continue MacOS thread)
1440	<	pthread_mutex_unlock(&frame_buffer_lock);
1440	>	UNLOCK_FRAME_BUFFER;
1441		emul_suspended = false;
1047	–	#endif
1442		}
1443		#endif
1444
#	Line 1198 \| Line 1592 \| static int kc_decode(KeySym ks)
1592		return -1;
1593		}
1594
1595	<	static int event2keycode(XKeyEvent *ev)
1595	>	static int event2keycode(XKeyEvent &ev)
1596		{
1597		KeySym ks;
1598		int as;
1599		int i = 0;
1600
1601		do {
1602	<	ks = XLookupKeysym(ev, i++);
1602	>	ks = XLookupKeysym(&ev, i++);
1603		as = kc_decode(ks);
1604		if (as != -1)
1605		return as;
#	Line 1221 \| Line 1615 \| *static int event2keycode(XKeyEvent ev)**
1615
1616		static void handle_events(void)
1617		{
1618	<	XEvent event;
1619	<	for (;;) {
1620	<	if (!XCheckMaskEvent(x_display, eventmask, &event))
1227	<	break;
1618	>	while (XPending(x_display)) {
1619	>	XEvent event;
1620	>	XNextEvent(x_display, &event);
1621
1622		switch (event.type) {
1623		// Mouse button
1624		case ButtonPress: {
1625	<	unsigned int button = ((XButtonEvent *)&event)->button;
1625	>	unsigned int button = event.xbutton.button;
1626		if (button < 4)
1627		ADBMouseDown(button - 1);
1628		else if (button < 6) { // Wheel mouse
#	Line 1248 \| Line 1641 \| static void handle_events(void)
1641		break;
1642		}
1643		case ButtonRelease: {
1644	<	unsigned int button = ((XButtonEvent *)&event)->button;
1644	>	unsigned int button = event.xbutton.button;
1645		if (button < 4)
1646		ADBMouseUp(button - 1);
1647		break;
#	Line 1256 \| Line 1649 \| static void handle_events(void)
1649
1650		// Mouse moved
1651		case EnterNotify:
1259	–	ADBMouseMoved(((XMotionEvent )&event)->x, ((XMotionEvent )&event)->y);
1260	–	break;
1652		case MotionNotify:
1653	<	ADBMouseMoved(((XMotionEvent )&event)->x, ((XMotionEvent )&event)->y);
1653	>	ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1654		break;
1655
1656		// Keyboard
1657		case KeyPress: {
1658		int code;
1659		if (use_keycodes) {
1660	<	event2keycode((XKeyEvent *)&event); // This is called to process the hotkeys
1661	<	code = keycode_table[((XKeyEvent *)&event)->keycode & 0xff];
1660	>	event2keycode(event.xkey); // This is called to process the hotkeys
1661	>	code = keycode_table[event.xkey.keycode & 0xff];
1662		} else
1663	<	code = event2keycode((XKeyEvent *)&event);
1663	>	code = event2keycode(event.xkey);
1664		if (code != -1) {
1665		if (!emul_suspended) {
1666		if (code == 0x39) { // Caps Lock pressed
#	Line 1296 \| Line 1687 \| static void handle_events(void)
1687		case KeyRelease: {
1688		int code;
1689		if (use_keycodes) {
1690	<	event2keycode((XKeyEvent *)&event); // This is called to process the hotkeys
1691	<	code = keycode_table[((XKeyEvent *)&event)->keycode & 0xff];
1690	>	event2keycode(event.xkey); // This is called to process the hotkeys
1691	>	code = keycode_table[event.xkey.keycode & 0xff];
1692		} else
1693	<	code = event2keycode((XKeyEvent *)&event);
1693	>	code = event2keycode(event.xkey);
1694		if (code != -1 && code != 0x39) { // Don't propagate Caps Lock releases
1695		ADBKeyUp(code);
1696		if (code == 0x36)
#	Line 1311 \| Line 1702 \| static void handle_events(void)
1702		// Hidden parts exposed, force complete refresh of window
1703		case Expose:
1704		if (display_type == DISPLAY_WINDOW) {
1705	+	#ifdef ENABLE_VOSF
1706	+	if (use_vosf) { // VOSF refresh
1707	+	LOCK_VOSF;
1708	+	PFLAG_SET_ALL;
1709	+	UNLOCK_VOSF;
1710	+	memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1711	+	}
1712	+	else
1713	+	#endif
1714		if (frame_skip == 0) { // Dynamic refresh
1715		int x1, y1;
1716		for (y1=0; y1<16; y1++)
1717		for (x1=0; x1<16; x1++)
1718		updt_box[x1][y1] = true;
1719		nr_boxes = 16 * 16;
1720	<	} else
1720	>	} else // Static refresh
1721		memset(the_buffer_copy, 0, VideoMonitor.bytes_per_row * VideoMonitor.y);
1722		}
1723		break;
1724	+
1725	+	// Window "close" widget clicked
1726	+	case ClientMessage:
1727	+	if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) {
1728	+	ADBKeyDown(0x7f); // Power key
1729	+	ADBKeyUp(0x7f);
1730	+	}
1731	+	break;
1732		}
1733		}
1734		}
#	Line 1449 \| Line 1857 \| static void update_display_static(void)
1857		// Check for first column from left and first column from right that have changed
1858		if (high) {
1859		if (depth == 1) {
1860	<	x1 = VideoMonitor.x;
1860	>	x1 = VideoMonitor.x - 1;
1861		for (j=y1; j<=y2; j++) {
1862		p = &the_buffer[j * bytes_per_row];
1863		p2 = &the_buffer_copy[j * bytes_per_row];
#	Line 1470 \| Line 1878 \| static void update_display_static(void)
1878		for (i=(VideoMonitor.x>>3); i>(x2>>3); i--) {
1879		p--; p2--;
1880		if (p != p2) {
1881	<	x2 = i << 3;
1881	>	x2 = (i << 3) + 7;
1882		break;
1883		}
1884		}
1885		}
1886	<	wide = x2 - x1;
1886	>	wide = x2 - x1 + 1;
1887
1888		// Update copy of the_buffer
1889		if (high && wide) {
#	Line 1536 \| Line 1944 \| static void update_display_static(void)
1944
1945
1946		/*
1947	<	* Thread for screen refresh, input handling etc.
1947	>	* Screen refresh functions
1948		*/
1949
1950	<	void VideoRefresh(void)
1950	>	// We suggest the compiler to inline the next two functions so that it
1951	>	// may specialise the code according to the current screen depth and
1952	>	// display type. A clever compiler would do that job by itself though...
1953	>
1954	>	// NOTE: update_display_vosf is inlined too
1955	>
1956	>	static inline void possibly_quit_dga_mode()
1957		{
1958		#if defined(ENABLE_XF86_DGA) \|\| defined(ENABLE_FBDEV_DGA)
1959		// Quit DGA mode if requested
1960		if (quit_full_screen) {
1961		quit_full_screen = false;
1548	–	if (display_type == DISPLAY_DGA) {
1962		#ifdef ENABLE_XF86_DGA
1963	<	XF86DGADirectVideo(x_display, screen, 0);
1963	>	XF86DGADirectVideo(x_display, screen, 0);
1964		#endif
1965	<	XUngrabPointer(x_display, CurrentTime);
1966	<	XUngrabKeyboard(x_display, CurrentTime);
1967	<	XUnmapWindow(x_display, the_win);
1968	<	XSync(x_display, false);
1556	<	}
1965	>	XUngrabPointer(x_display, CurrentTime);
1966	>	XUngrabKeyboard(x_display, CurrentTime);
1967	>	XUnmapWindow(x_display, the_win);
1968	>	XSync(x_display, false);
1969		}
1970		#endif
1971	+	}
1972
1973	<	// Handle X events
1974	<	handle_events();
1973	>	static inline void handle_palette_changes(int depth, int display_type)
1974	>	{
1975	>	LOCK_PALETTE;
1976
1563	–	// Handle palette changes
1564	–	#ifdef HAVE_PTHREADS
1565	–	pthread_mutex_lock(&palette_lock);
1566	–	#endif
1977		if (palette_changed) {
1978		palette_changed = false;
1979		if (depth == 8) {
1980		XStoreColors(x_display, cmap[0], palette, 256);
1981		XStoreColors(x_display, cmap[1], palette, 256);
1982	+	XSync(x_display, false);
1983
1984		#ifdef ENABLE_XF86_DGA
1985		if (display_type == DISPLAY_DGA) {
#	Line 1578 \| Line 1989 \| void VideoRefresh(void)
1989		#endif
1990		}
1991		}
1992	<	#ifdef HAVE_PTHREADS
1993	<	pthread_mutex_unlock(&palette_lock);
1992	>
1993	>	UNLOCK_PALETTE;
1994	>	}
1995	>
1996	>	static void video_refresh_dga(void)
1997	>	{
1998	>	// Quit DGA mode if requested
1999	>	possibly_quit_dga_mode();
2000	>
2001	>	// Handle X events
2002	>	handle_events();
2003	>
2004	>	// Handle palette changes
2005	>	handle_palette_changes(depth, DISPLAY_DGA);
2006	>	}
2007	>
2008	>	#ifdef ENABLE_VOSF
2009	>	#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
2010	>	static void video_refresh_dga_vosf(void)
2011	>	{
2012	>	// Quit DGA mode if requested
2013	>	possibly_quit_dga_mode();
2014	>
2015	>	// Handle X events
2016	>	handle_events();
2017	>
2018	>	// Handle palette changes
2019	>	handle_palette_changes(depth, DISPLAY_DGA);
2020	>
2021	>	// Update display (VOSF variant)
2022	>	static int tick_counter = 0;
2023	>	if (++tick_counter >= frame_skip) {
2024	>	tick_counter = 0;
2025	>	if (mainBuffer.dirty) {
2026	>	LOCK_VOSF;
2027	>	update_display_dga_vosf();
2028	>	UNLOCK_VOSF;
2029	>	}
2030	>	}
2031	>	}
2032		#endif
2033
2034	<	// In window mode, update display
2034	>	static void video_refresh_window_vosf(void)
2035	>	{
2036	>	// Quit DGA mode if requested
2037	>	possibly_quit_dga_mode();
2038	>
2039	>	// Handle X events
2040	>	handle_events();
2041	>
2042	>	// Handle palette changes
2043	>	handle_palette_changes(depth, DISPLAY_WINDOW);
2044	>
2045	>	// Update display (VOSF variant)
2046		static int tick_counter = 0;
2047	<	if (display_type == DISPLAY_WINDOW) {
2048	<	tick_counter++;
2049	<	if (frame_skip == 0)
2050	<	update_display_dynamic(tick_counter);
2051	<	else if (tick_counter >= frame_skip) {
2052	<	tick_counter = 0;
2053	<	update_display_static();
2047	>	if (++tick_counter >= frame_skip) {
2048	>	tick_counter = 0;
2049	>	if (mainBuffer.dirty) {
2050	>	LOCK_VOSF;
2051	>	update_display_window_vosf();
2052	>	UNLOCK_VOSF;
2053	>	XSync(x_display, false); // Let the server catch up
2054		}
2055		}
2056		}
2057	+	#endif // def ENABLE_VOSF
2058	+
2059	+	static void video_refresh_window_static(void)
2060	+	{
2061	+	// Handle X events
2062	+	handle_events();
2063	+
2064	+	// Handle_palette changes
2065	+	handle_palette_changes(depth, DISPLAY_WINDOW);
2066	+
2067	+	// Update display (static variant)
2068	+	static int tick_counter = 0;
2069	+	if (++tick_counter >= frame_skip) {
2070	+	tick_counter = 0;
2071	+	update_display_static();
2072	+	}
2073	+	}
2074	+
2075	+	static void video_refresh_window_dynamic(void)
2076	+	{
2077	+	// Handle X events
2078	+	handle_events();
2079	+
2080	+	// Handle_palette changes
2081	+	handle_palette_changes(depth, DISPLAY_WINDOW);
2082	+
2083	+	// Update display (dynamic variant)
2084	+	static int tick_counter = 0;
2085	+	tick_counter++;
2086	+	update_display_dynamic(tick_counter);
2087	+	}
2088	+
2089	+
2090	+	/*
2091	+	* Thread for screen refresh, input handling etc.
2092	+	*/
2093	+
2094	+	void VideoRefreshInit(void)
2095	+	{
2096	+	// TODO: set up specialised 8bpp VideoRefresh handlers ?
2097	+	if (display_type == DISPLAY_DGA) {
2098	+	#if ENABLE_VOSF && (REAL_ADDRESSING \|\| DIRECT_ADDRESSING)
2099	+	if (use_vosf)
2100	+	video_refresh = video_refresh_dga_vosf;
2101	+	else
2102	+	#endif
2103	+	video_refresh = video_refresh_dga;
2104	+	}
2105	+	else {
2106	+	#ifdef ENABLE_VOSF
2107	+	if (use_vosf)
2108	+	video_refresh = video_refresh_window_vosf;
2109	+	else
2110	+	#endif
2111	+	if (frame_skip == 0)
2112	+	video_refresh = video_refresh_window_dynamic;
2113	+	else
2114	+	video_refresh = video_refresh_window_static;
2115	+	}
2116	+	}
2117	+
2118	+	void VideoRefresh(void)
2119	+	{
2120	+	// TODO: make main_unix/VideoRefresh call directly video_refresh() ?
2121	+	video_refresh();
2122	+	}
2123
2124		#ifdef HAVE_PTHREADS
2125		static void redraw_func(void arg)
2126		{
2127	<	uint64 start = GetTicks_usec();
2128	<	int64 ticks = 0;
2127	>	uint64 start = GetTicks_usec();
2128	>	int64 ticks = 0;
2129		uint64 next = GetTicks_usec();
2130		while (!redraw_thread_cancel) {
2131	<	VideoRefresh();
2131	>	video_refresh();
2132		next += 16667;
2133		int64 delay = next - GetTicks_usec();
2134		if (delay > 0)
2135		Delay_usec(delay);
2136		else if (delay < -16667)
2137		next = GetTicks_usec();
2138	<	ticks++;
2138	>	ticks++;
2139		}
2140	<	uint64 end = GetTicks_usec();
2141	<	printf("%Ld ticks in %Ld usec = %Ld ticks/sec\n", ticks, end - start, (end - start) / ticks);
2140	>	uint64 end = GetTicks_usec();
2141	>	// printf("%Ld ticks in %Ld usec = %Ld ticks/sec\n", ticks, end - start, ticks * 1000000 / (end - start));
2142		return NULL;
2143		}
2144		#endif

Diff Legend

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

Comparing BasiliskII/src/Unix/video_x.cpp (file contents): Revision 1.18 by cebix, 2000-07-22T18:12:35Z vs. Revision 1.38 by gbeauche, 2001-05-20T20:31:50Z

Diff Legend

Comparing BasiliskII/src/Unix/video_x.cpp (file contents):
Revision 1.18 by cebix, 2000-07-22T18:12:35Z vs.
Revision 1.38 by gbeauche, 2001-05-20T20:31:50Z