ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/Unix/video_x.cpp

Comparing BasiliskII/src/Unix/video_x.cpp (file contents):
Revision 1.41 by cebix, 2001-06-27T20:05:30Z vs.
Revision 1.42 by cebix, 2001-06-28T21:20:00Z

#	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	–	# include "vm_alloc.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;
#	Line 178 | Line 171 | static bool use_vosf = true;                                           // Fla
171		static const bool use_vosf = false;                                     // Flag: VOSF enabled
172		#endif
173
181	–	#ifdef ENABLE_VOSF
182	–	// Variables for Video on SEGV support (taken from the Win32 port)
183	–	static uint8 *the_host_buffer;                                          // Host frame buffer in VOSF mode
184	–	static uint32 the_buffer_size;                                          // Size of allocated the_buffer
185	–
186	–	struct ScreenPageInfo {
187	–	int top, bottom;                    // Mapping between this virtual page and Mac scanlines
188	–	};
189	–
190	–	struct ScreenInfo {
191	–	uintptr memBase;                    // Real start address
192	–	uintptr memStart;                   // Start address aligned to page boundary
193	–	uintptr memEnd;                             // Address of one-past-the-end of the screen
194	–	uint32 memLength;                   // Length of the memory addressed by the screen pages
195	–
196	–	uint32 pageSize;                    // Size of a page
197	–	int pageBits;                               // Shift count to get the page number
198	–	uint32 pageCount;                   // Number of pages allocated to the screen
199	–
200	–	bool dirty;                                     // Flag: set if the frame buffer was touched
201	–	char * dirtyPages;                  // Table of flags set if page was altered
202	–	ScreenPageInfo * pageInfo;  // Table of mappings page -> Mac scanlines
203	–	};
204	–
205	–	static ScreenInfo mainBuffer;
206	–
207	–	#define PFLAG_SET_VALUE                 0x00
208	–	#define PFLAG_CLEAR_VALUE               0x01
209	–	#define PFLAG_SET_VALUE_4               0x00000000
210	–	#define PFLAG_CLEAR_VALUE_4             0x01010101
211	–	#define PFLAG_SET(page)                 mainBuffer.dirtyPages[page] = PFLAG_SET_VALUE
212	–	#define PFLAG_CLEAR(page)               mainBuffer.dirtyPages[page] = PFLAG_CLEAR_VALUE
213	–	#define PFLAG_ISSET(page)               (mainBuffer.dirtyPages[page] == PFLAG_SET_VALUE)
214	–	#define PFLAG_ISCLEAR(page)             (mainBuffer.dirtyPages[page] != PFLAG_SET_VALUE)
215	–
216	–	#ifdef UNALIGNED_PROFITABLE
217	–	# define PFLAG_ISSET_4(page)    (*((uint32 *)(mainBuffer.dirtyPages + (page))) == PFLAG_SET_VALUE_4)
218	–	# define PFLAG_ISCLEAR_4(page)  (*((uint32 *)(mainBuffer.dirtyPages + (page))) == PFLAG_CLEAR_VALUE_4)
219	–	#else
220	–	# define PFLAG_ISSET_4(page) \
221	–	PFLAG_ISSET(page  ) && PFLAG_ISSET(page+1) \
222	–	&&      PFLAG_ISSET(page+2) && PFLAG_ISSET(page+3)
223	–	# define PFLAG_ISCLEAR_4(page) \
224	–	PFLAG_ISCLEAR(page  ) && PFLAG_ISCLEAR(page+1) \
225	–	&&      PFLAG_ISCLEAR(page+2) && PFLAG_ISCLEAR(page+3)
226	–	#endif
227	–
228	–	// Set the selected page range [ first_page, last_page [ into the SET state
229	–	#define PFLAG_SET_RANGE(first_page, last_page) \
230	–	memset(mainBuffer.dirtyPages + (first_page), PFLAG_SET_VALUE, \
231	–	(last_page) - (first_page))
232	–
233	–	// Set the selected page range [ first_page, last_page [ into the CLEAR state
234	–	#define PFLAG_CLEAR_RANGE(first_page, last_page) \
235	–	memset(mainBuffer.dirtyPages + (first_page), PFLAG_CLEAR_VALUE, \
236	–	(last_page) - (first_page))
237	–
238	–	#define PFLAG_SET_ALL do { \
239	–	PFLAG_SET_RANGE(0, mainBuffer.pageCount); \
240	–	mainBuffer.dirty = true; \
241	–	} while (0)
242	–
243	–	#define PFLAG_CLEAR_ALL do { \
244	–	PFLAG_CLEAR_RANGE(0, mainBuffer.pageCount); \
245	–	mainBuffer.dirty = false; \
246	–	} while (0)
247	–
248	–	// Set the following macro definition to 1 if your system
249	–	// provides a really fast strchr() implementation
250	–	//#define HAVE_FAST_STRCHR 0
251	–
252	–	static inline int find_next_page_set(int page)
253	–	{
254	–	#if HAVE_FAST_STRCHR
255	–	char *match = strchr(mainBuffer.dirtyPages + page, PFLAG_SET_VALUE);
256	–	return match ? match - mainBuffer.dirtyPages : mainBuffer.pageCount;
257	–	#else
258	–	while (PFLAG_ISCLEAR_4(page))
259	–	page += 4;
260	–	while (PFLAG_ISCLEAR(page))
261	–	page++;
262	–	return page;
263	–	#endif
264	–	}
265	–
266	–	static inline int find_next_page_clear(int page)
267	–	{
268	–	#if HAVE_FAST_STRCHR
269	–	char *match = strchr(mainBuffer.dirtyPages + page, PFLAG_CLEAR_VALUE);
270	–	return match ? match - mainBuffer.dirtyPages : mainBuffer.pageCount;
271	–	#else
272	–	while (PFLAG_ISSET_4(page))
273	–	page += 4;
274	–	while (PFLAG_ISSET(page))
275	–	page++;
276	–	return page;
277	–	#endif
278	–	}
279	–
280	–	static int zero_fd = -1;
281	–
282	–	#ifdef HAVE_PTHREADS
283	–	static pthread_mutex_t vosf_lock = PTHREAD_MUTEX_INITIALIZER;   // Mutex to protect frame buffer (dirtyPages in fact)
284	–	#define LOCK_VOSF pthread_mutex_lock(&vosf_lock);
285	–	#define UNLOCK_VOSF pthread_mutex_unlock(&vosf_lock);
286	–	#else
287	–	#define LOCK_VOSF
288	–	#define UNLOCK_VOSF
289	–	#endif
290	–
291	–	static int log_base_2(uint32 x)
292	–	{
293	–	uint32 mask = 0x80000000;
294	–	int l = 31;
295	–	while (l >= 0 && (x & mask) == 0) {
296	–	mask >>= 1;
297	–	l--;
298	–	}
299	–	return l;
300	–	}
301	–	#endif /* ENABLE_VOSF */
302	–
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);
181
311	–
182		// From main_unix.cpp
183		extern char *x_display_name;
184		extern Display *x_display;
#	Line 316 | 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 325 | Line 196 | extern void SysMountFirstFloppy(void);
196		*  Initialization
197		*/
198
199	<	// Add resolution to list of supported modes and set VideoMonitor
200	<	static void set_video_monitor(uint32 width, uint32 height, uint32 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;
338	<	case 8:
339	<	layout = FLAYOUT_DIRECT;
340	<	break;
341	<	case 15:
342	<	layout = FLAYOUT_HOST_555;
343	<	break;
344	<	case 16:
345	<	layout = FLAYOUT_HOST_565;
346	<	break;
347	<	case 24:
348	<	case 32:
349	<	layout = FLAYOUT_HOST_888;
350	<	break;
351	<	}
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	<
358	<	mode.x = width;
359	<	mode.y = height;
360	<	mode.resolution_id = 0x80;
361	<	mode.bytes_per_row = bytes_per_row;
362	<
363	<	switch (depth) {
364	<	case 1:
365	<	mode.depth = VDEPTH_1BIT;
366	<	break;
367	<	case 2:
368	<	mode.depth = VDEPTH_2BIT;
369	<	break;
370	<	case 4:
371	<	mode.depth = VDEPTH_4BIT;
372	<	break;
373	<	case 8:
374	<	mode.depth = VDEPTH_8BIT;
375	<	break;
376	<	case 15:
377	<	mode.depth = VDEPTH_16BIT;
378	<	break;
379	<	case 16:
380	<	mode.depth = VDEPTH_16BIT;
381	<	break;
382	<	case 24:
383	<	case 32:
384	<	mode.depth = VDEPTH_32BIT;
385	<	break;
386	<	}
387	<
388	<	VideoModes.push_back(mode);
389	<	VideoMonitor.mode = mode;
229	>	D(bug("VideoMonitor.mac_frame_base = %08x\n", VideoMonitor.mac_frame_base));
230		}
231
232		// Set window name and class
#	Line 457 | 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 475 | Line 316 | static bool init_window(int width, int h
316		wattr.colormap = cmap[0];
317
318		the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
319	<	InputOutput, vis, CWEventMask | CWBackPixel | (depth == 8 ? CWColormap : 0), &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);
#	Line 506 | Line 347 | static bool init_window(int width, int h
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 533 | 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;
537	<	switch (depth) {
538	<	case 1:
539	<	bytes_per_row /= 8;
540	<	break;
541	<	case 15:
542	<	case 16:
543	<	bytes_per_row *= 2;
544	<	break;
545	<	case 24:
546	<	case 32:
547	<	bytes_per_row *= 4;
548	<	break;
549	<	}
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		}
#	Line 589 | Line 417 | static bool init_window(int width, int h
417		#ifdef ENABLE_VOSF
418		Screen_blitter_init(&visualInfo, native_byte_order);
419		#endif
420	<	set_video_monitor(width, height, img->bytes_per_line, native_byte_order);
421	<
594	<	#if REAL_ADDRESSING || DIRECT_ADDRESSING
595	<	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
596	<	#else
597	<	VideoMonitor.mac_frame_base = MacFrameBaseMac;
598	<	#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 645 | 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 657 | 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);
666	<	int height = DisplayHeight(x_display, screen);
667	<	depth = fb_depth; // max_depth
490	>	depth = fb_depth;
491
492		// Set relative mouse mode
493		ADBSetRelMouseMode(false);
#	Line 699 | 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 VideoMonitor
526	<	int bytes_per_row = width;
704	<	switch (depth) {
705	<	case 1:
706	<	bytes_per_row = ((width | 7) & ~7) >> 3;
707	<	break;
708	<	case 15:
709	<	case 16:
710	<	bytes_per_row *= 2;
711	<	break;
712	<	case 24:
713	<	case 32:
714	<	bytes_per_row *= 4;
715	<	break;
716	<	}
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 742 | Line 553 | static bool init_fbdev_dga(char *in_fb_n
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);
748	<	#else
749	<	VideoMonitor.mac_frame_base = MacFrameBaseMac;
750	<	#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 756 | 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 809 | 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;
820	<	switch (depth) {
821	<	case 1:
822	<	bytes_per_row /= 8;
823	<	break;
824	<	case 15:
825	<	case 16:
826	<	bytes_per_row *= 2;
827	<	break;
828	<	case 24:
829	<	case 32:
830	<	bytes_per_row *= 4;
831	<	break;
832	<	}
629	>	int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, mode.depth);
630
631		#ifdef VIDEO_VOSF
632		#if REAL_ADDRESSING || DIRECT_ADDRESSING
#	Line 849 | Line 646 | static bool init_xf86_dga(int width, int
646		#endif
647		#endif
648
649	<	set_video_monitor(width, height, bytes_per_row, true);
650	<	#if REAL_ADDRESSING || DIRECT_ADDRESSING
651	<	VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
855	<	//      MacFrameLayout = FLAYOUT_DIRECT;
856	<	#else
857	<	VideoMonitor.mac_frame_base = MacFrameBaseMac;
858	<	#endif
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 928 | 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      = (uintptr) the_buffer;
733	<	// Align the frame buffer on page boundary
734	<	mainBuffer.memStart             = (uintptr)((((unsigned long) the_buffer) + page_mask) & ~page_mask);
941	<	mainBuffer.memLength    = the_buffer_size;
942	<	mainBuffer.memEnd       = mainBuffer.memStart + mainBuffer.memLength;
943	<
944	<	mainBuffer.pageSize     = page_size;
945	<	mainBuffer.pageCount    = (mainBuffer.memLength + page_mask)/mainBuffer.pageSize;
946	<	mainBuffer.pageBits     = log_base_2(mainBuffer.pageSize);
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	<	if (mainBuffer.dirtyPages != 0)
737	<	free(mainBuffer.dirtyPages);
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	<	mainBuffer.dirtyPages = (char *) malloc(mainBuffer.pageCount + 2);
752	>	// Lock down frame buffer
753	>	LOCK_FRAME_BUFFER;
754
755	<	if (mainBuffer.pageInfo != 0)
756	<	free(mainBuffer.pageInfo);
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	<	mainBuffer.pageInfo = (ScreenPageInfo *) malloc(mainBuffer.pageCount * sizeof(ScreenPageInfo));
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	<	if ((mainBuffer.dirtyPages == 0) || (mainBuffer.pageInfo == 0))
959	<	return false;
960	<
961	<	mainBuffer.dirty = false;
765	>	InitFrameBufferMapping();
766
767	<	PFLAG_CLEAR_ALL;
768	<	// Safety net to insure the loops in the update routines will terminate
769	<	// See a discussion in <video_vosf.h> for further details
770	<	PFLAG_CLEAR(mainBuffer.pageCount);
771	<	PFLAG_SET(mainBuffer.pageCount+1);
772	<
969	<	uint32 a = 0;
970	<	for (int i = 0; i < mainBuffer.pageCount; i++) {
971	<	int y1 = a / VideoMonitor.mode.bytes_per_row;
972	<	if (y1 >= VideoMonitor.mode.y)
973	<	y1 = VideoMonitor.mode.y - 1;
974	<
975	<	int y2 = (a + mainBuffer.pageSize) / VideoMonitor.mode.bytes_per_row;
976	<	if (y2 >= VideoMonitor.mode.y)
977	<	y2 = VideoMonitor.mode.y - 1;
978	<
979	<	mainBuffer.pageInfo[i].top = y1;
980	<	mainBuffer.pageInfo[i].bottom = y2;
981	<
982	<	a += mainBuffer.pageSize;
983	<	if (a > mainBuffer.memLength)
984	<	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 (vm_protect((char *)mainBuffer.memStart, mainBuffer.memLength, VM_PAGE_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
806		// Open /dev/zero
807		zero_fd = open("/dev/zero", O_RDWR);
#	Line 1094 | Line 902 | bool VideoInit(bool classic)
902		}
903		vis = visualInfo.visual;
904
1097	–	// Mac screen depth is always 1 bit in Classic mode, but follows X depth otherwise
1098	–	classic_mode = classic;
1099	–	if (classic)
1100	–	depth = 1;
1101	–	else
1102	–	depth = xdepth;
1103	–
1104	–	// Create color maps for 8 bit mode
1105	–	if (depth == 8) {
1106	–	cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1107	–	cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1108	–	XInstallColormap(x_display, cmap[0]);
1109	–	XInstallColormap(x_display, cmap[1]);
1110	–	}
1111	–
905		// Get screen mode from preferences
906		const char *mode_str;
907	<	if (classic)
907	>	if (classic_mode)
908		mode_str = "win/512/342";
909		else
910		mode_str = PrefsFindString("screen");
911
912	<	// Determine type and mode
913	<	int width = 512, height = 384;
912	>	// Determine display type and default dimensions
913	>	int default_width = 512, default_height = 384;
914		display_type = DISPLAY_WINDOW;
915		if (mode_str) {
916	<	if (sscanf(mode_str, "win/%d/%d", &width, &height) == 2)
916	>	if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2) {
917		display_type = DISPLAY_WINDOW;
918		#ifdef ENABLE_FBDEV_DGA
919	<	else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) {
1127	<	#else
1128	<	else if (has_dga && sscanf(mode_str, "dga/%d/%d", &width, &height) == 2) {
1129	<	#endif
919	>	} else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) {
920		display_type = DISPLAY_DGA;
921	<	if (width > DisplayWidth(x_display, screen))
1132	<	width = DisplayWidth(x_display, screen);
1133	<	if (height > DisplayHeight(x_display, screen))
1134	<	height = DisplayHeight(x_display, screen);
1135	<	}
1136	<	if (width <= 0)
1137	<	width = DisplayWidth(x_display, screen);
1138	<	if (height <= 0)
1139	<	height = DisplayHeight(x_display, screen);
1140	<	}
1141	<
1142	<	// Initialize according to display type
1143	<	switch (display_type) {
1144	<	case DISPLAY_WINDOW:
1145	<	if (!init_window(width, height))
1146	<	return false;
1147	<	break;
1148	<	case DISPLAY_DGA:
1149	<	#ifdef ENABLE_FBDEV_DGA
1150	<	if (!init_fbdev_dga(fb_name))
921	>	default_width = -1; default_height = -1;
922		#else
923	<	if (!init_xf86_dga(width, height))
923	>	} else if (has_dga && sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2) {
924	>	display_type = DISPLAY_DGA;
925		#endif
926	<	return false;
1155	<	break;
926	>	}
927		}
928	+	if (default_width <= 0)
929	+	default_width = DisplayWidth(x_display, screen);
930	+	else if (default_width > DisplayWidth(x_display, screen))
931	+	default_width = DisplayWidth(x_display, screen);
932	+	if (default_height <= 0)
933	+	default_height = DisplayHeight(x_display, screen);
934	+	else if (default_height > DisplayHeight(x_display, screen))
935	+	default_height = DisplayHeight(x_display, screen);
936
937	<	// Lock down frame buffer
938	<	LOCK_FRAME_BUFFER;
939	<
1161	<	#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
1162	<	// Set variables for UAE memory mapping
1163	<	MacFrameBaseHost = the_buffer;
1164	<	MacFrameSize = VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y;
1165	<
1166	<	// No special frame buffer in Classic mode (frame buffer is in Mac RAM)
1167	<	if (classic)
1168	<	MacFrameLayout = FLAYOUT_NONE;
1169	<	#endif
937	>	// Mac screen depth is always 1 bit in Classic mode, but follows X depth otherwise
938	>	int depth = (classic_mode ? 1 : xdepth);
939	>	video_depth depth_mode = DepthModeForPixelDepth(depth);
940
941	<	#ifdef ENABLE_VOSF
942	<	if (use_vosf) {
943	<	// Initialize the mainBuffer structure
944	<	if (!VideoInitBuffer()) {
945	<	// TODO: STR_VOSF_INIT_ERR ?
946	<	ErrorAlert("Could not initialize Video on SEGV signals");
947	<	return false;
941	>	// Construct list of supported modes
942	>	if (display_type == DISPLAY_WINDOW) {
943	>	if (classic)
944	>	add_mode(512, 342, 0x80, 64, depth_mode);
945	>	else {
946	>	add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth_mode), depth_mode);
947	>	add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth_mode), depth_mode);
948	>	add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth_mode), depth_mode);
949	>	add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth_mode), depth_mode);
950	>	add_mode(1280, 1024, 0x84, TrivialBytesPerRow(1280, depth_mode), depth_mode);
951		}
952	+	} else
953	+	add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, depth_mode), depth_mode);
954
955	<	// Initialize the handler for SIGSEGV
956	<	if (!sigsegv_install_handler(screen_fault_handler)) {
957	<	// TODO: STR_VOSF_INIT_ERR ?
958	<	ErrorAlert("Could not initialize Video on SEGV signals");
959	<	return false;
955	>	// Find requested default mode and open display
956	>	if (VideoModes.size() == 1)
957	>	return video_open(VideoModes[0]);
958	>	else {
959	>	// Find mode with specified dimensions
960	>	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
961	>	while (i != end) {
962	>	if (i->x == default_width && i->y == default_height)
963	>	return video_open(*i);
964	>	++i;
965		}
966	+	return video_open(VideoModes[0]);
967		}
1187	–	#endif
1188	–
1189	–	// Initialize VideoRefresh function
1190	–	VideoRefreshInit();
1191	–
1192	–	XSync(x_display, false);
1193	–
1194	–	#ifdef HAVE_PTHREADS
1195	–	// Start redraw/input thread
1196	–	redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0);
1197	–	if (!redraw_thread_active) {
1198	–	printf("FATAL: cannot create redraw thread\n");
1199	–	return false;
1200	–	}
1201	–	#endif
1202	–	return true;
968		}
969
970
#	Line 1207 | Line 972 | bool VideoInit(bool classic)
972		*  Deinitialization
973		*/
974
975	<	void VideoExit(void)
975	>	// Close display
976	>	static void video_close(void)
977		{
978		#ifdef HAVE_PTHREADS
979		// Stop redraw thread
#	Line 1251 | Line 1017 | void VideoExit(void)
1017
1018		XFlush(x_display);
1019		XSync(x_display, false);
1020	<	if (depth == 8) {
1020	>	XUnmapWindow(x_display, the_win);
1021	>	wait_unmapped(the_win);
1022	>	XDestroyWindow(x_display, the_win);
1023	>
1024	>	if (have_shm) {
1025	>	XDestroyImage(img);
1026	>	XShmDetach(x_display, &shminfo);
1027	>	have_shm = false;
1028	>	} else {
1029	>	//!! free img
1030	>	}
1031	>	//!! free the_gc
1032	>
1033	>	if (cmap_allocated) {
1034		XFreeColormap(x_display, cmap[0]);
1035		XFreeColormap(x_display, cmap[1]);
1036	+	cmap_allocated = false;
1037		}
1038
1039		if (!use_vosf) {
#	Line 1269 | Line 1049 | void VideoExit(void)
1049		}
1050		#ifdef ENABLE_VOSF
1051		else {
1052	+	//!! uninstall SEGV handler?
1053	+
1054		if (the_buffer != (uint8 *)VM_MAP_FAILED) {
1055		vm_release(the_buffer, the_buffer_size);
1056		the_buffer = 0;
#	Line 1295 | Line 1077 | void VideoExit(void)
1077		mainBuffer.dirtyPages = 0;
1078		}
1079		}
1080	+	#endif
1081	+	}
1082	+
1083	+	void VideoExit(void)
1084	+	{
1085	+	video_close();
1086
1087	+	#ifdef ENABLE_VOSF
1088		// Close /dev/zero
1089		if (zero_fd > 0)
1090		close(zero_fd);
#	Line 1362 | Line 1151 | void video_set_palette(uint8 *pal)
1151
1152		void video_switch_to_mode(const video_mode &mode)
1153		{
1154	+	video_close();
1155	+	video_open(mode);
1156		}
1157
1158
#	Line 1450 | Line 1241 | static void resume_emul(void)
1241		}
1242
1243		#ifdef ENABLE_XF86_DGA
1244	<	if (depth == 8)
1244	>	if (!IsDirectMode(VideoMonitor.mode))
1245		XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1246		#endif
1247
#	Line 1819 | Line 1610 | static void update_display_dynamic(int t
1610		i = (yi * bytes_per_row) + xi;
1611		for (y2=0; y2 < yil; y2++, i += bytes_per_row)
1612		memcpy(&the_buffer_copy[i], &the_buffer[i], xil);
1613	<	if (depth == 1) {
1613	>	if (VideoMonitor.mode.depth == VDEPTH_1BIT) {
1614		if (have_shm)
1615		XShmPutImage(x_display, the_win, the_gc, img, xi * 8, yi, xi * 8, yi, xil * 8, yil, 0);
1616		else
#	Line 1874 | Line 1665 | static void update_display_static(void)
1665
1666		// Check for first column from left and first column from right that have changed
1667		if (high) {
1668	<	if (depth == 1) {
1668	>	if (VideoMonitor.mode.depth == VDEPTH_1BIT) {
1669		x1 = VideoMonitor.mode.x - 1;
1670		for (j=y1; j<=y2; j++) {
1671		p = &the_buffer[j * bytes_per_row];
#	Line 1983 | Line 1774 | static inline void possibly_quit_dga_mod
1774		XUngrabPointer(x_display, CurrentTime);
1775		XUngrabKeyboard(x_display, CurrentTime);
1776		XUnmapWindow(x_display, the_win);
1777	<	XSync(x_display, false);
1777	>	wait_unmapped(the_win);
1778		}
1779		#endif
1780		}
1781
1782	<	static inline void handle_palette_changes(int depth, int display_type)
1782	>	static inline void handle_palette_changes(int display_type)
1783		{
1784		LOCK_PALETTE;
1785
1786		if (palette_changed) {
1787		palette_changed = false;
1788	<	if (depth == 8) {
1788	>	if (!IsDirectMode(VideoMonitor.mode)) {
1789		XStoreColors(x_display, cmap[0], palette, 256);
1790		XStoreColors(x_display, cmap[1], palette, 256);
1791		XSync(x_display, false);
#	Line 2020 | Line 1811 | static void video_refresh_dga(void)
1811		handle_events();
1812
1813		// Handle palette changes
1814	<	handle_palette_changes(depth, DISPLAY_DGA);
1814	>	handle_palette_changes(DISPLAY_DGA);
1815		}
1816
1817		#ifdef ENABLE_VOSF
#	Line 2034 | Line 1825 | static void video_refresh_dga_vosf(void)
1825		handle_events();
1826
1827		// Handle palette changes
1828	<	handle_palette_changes(depth, DISPLAY_DGA);
1828	>	handle_palette_changes(DISPLAY_DGA);
1829
1830		// Update display (VOSF variant)
1831		static int tick_counter = 0;
#	Line 2058 | Line 1849 | static void video_refresh_window_vosf(vo
1849		handle_events();
1850
1851		// Handle palette changes
1852	<	handle_palette_changes(depth, DISPLAY_WINDOW);
1852	>	handle_palette_changes(DISPLAY_WINDOW);
1853
1854		// Update display (VOSF variant)
1855		static int tick_counter = 0;
#	Line 2080 | Line 1871 | static void video_refresh_window_static(
1871		handle_events();
1872
1873		// Handle_palette changes
1874	<	handle_palette_changes(depth, DISPLAY_WINDOW);
1874	>	handle_palette_changes(DISPLAY_WINDOW);
1875
1876		// Update display (static variant)
1877		static int tick_counter = 0;
#	Line 2096 | Line 1887 | static void video_refresh_window_dynamic
1887		handle_events();
1888
1889		// Handle_palette changes
1890	<	handle_palette_changes(depth, DISPLAY_WINDOW);
1890	>	handle_palette_changes(DISPLAY_WINDOW);
1891
1892		// Update display (dynamic variant)
1893		static int tick_counter = 0;
#	Line 2109 | Line 1900 | static void video_refresh_window_dynamic
1900		*  Thread for screen refresh, input handling etc.
1901		*/
1902
1903	<	void VideoRefreshInit(void)
1903	>	static void VideoRefreshInit(void)
1904		{
1905		// TODO: set up specialised 8bpp VideoRefresh handlers ?
1906		if (display_type == DISPLAY_DGA) {

Diff Legend

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