src/Unix/video_vosf.h

/*
 *  video_vosf.h - Video/graphics emulation, video on SEGV signals support
 *
 *  Basilisk II (C) 1997-2000 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef VIDEO_VOSF_H
#define VIDEO_VOSF_H

// Note: this file is #include'd in video_x.cpp
#ifdef ENABLE_VOSF

/*
 *  Page-aligned memory allocation
 */

// Align on page boundaries
static uintptr align_on_page_boundary(uintptr size)
{
        const uint32 page_size = getpagesize();
        const uint32 page_mask = page_size - 1;
        return (size + page_mask) & ~page_mask;
}

// Allocate memory on page boundary
static void * allocate_framebuffer(uint32 size, uint8 * hint = 0)
{
        // Remind that the system can allocate at 0x00000000...
        return mmap((caddr_t)hint, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, zero_fd, 0);
}


/*
 *      Screen depth identification
 */

enum {
        ID_DEPTH_UNKNOWN = -1,
        ID_DEPTH_1,
        ID_DEPTH_8,
        ID_DEPTH_15,
        ID_DEPTH_16,
        ID_DEPTH_24,
        ID_DEPTH_32 = ID_DEPTH_24,
        ID_DEPTH_COUNT
};

static int depth_id(int depth)
{
        int id;
        switch (depth) {
                case 1  : id = ID_DEPTH_1;      break;
                case 8  : id = ID_DEPTH_8;      break;
                case 15 : id = ID_DEPTH_15;     break;
                case 16 : id = ID_DEPTH_16;     break;
                case 24 : id = ID_DEPTH_24;     break;
                case 32 : id = ID_DEPTH_32;     break;
                default : id = ID_DEPTH_UNKNOWN;
        }
        return id;
}


/*
 *      Frame buffer copy function templates
 */

// No conversion required

#define MEMCPY_PROFITABLE
#ifdef MEMCPY_PROFITABLE
static void do_fbcopy_raw(uint8 * dest, const uint8 * source, uint32 length)
{
        memcpy(dest, source, length);
}
#else
#define FB_BLIT_1(dst, src)     (dst = (src))
#define FB_BLIT_2(dst, src)     (dst = (src))
#define FB_DEPTH                        0
#define FB_FUNC_NAME            do_fbcopy_raw
#include "video_blit.h"
#endif


// RGB 555

#ifdef WORDS_BIGENDIAN
# define FB_FUNC_NAME do_fbcopy_15_obo
#else
# define FB_FUNC_NAME do_fbcopy_15_nbo
#endif

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 8) & 0xff) | (((src) & 0xff) << 8))
        
#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 8) & 0x00ff00ff) | (((src) & 0x00ff00ff) << 8))

#define FB_DEPTH 15
#include "video_blit.h"


// RGB 565

#ifdef WORDS_BIGENDIAN

// native byte order

#define FB_BLIT_1(dst, src) \
        (dst = (((src) & 0x1f) | (((src) << 1) & 0xffc0)))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) & 0x001f001f) | (((src) << 1) & 0xffc0ffc0)))

#define FB_DEPTH 16
#define FB_FUNC_NAME do_fbcopy_16_nbo
#include "video_blit.h"

// opposite byte order

#define FB_BLIT_1(dst, src) \
        (dst = ((((src) >> 7) & 0xff) | (((src) << 9) & 0xc000) | (((src) << 8) & 0x1f00)))

#define FB_BLIT_2(dst, src) \
        (dst = ((((src) >> 7) & 0x00ff00ff) | (((src) << 9) & 0xc000c000) | (((src) << 8) & 0x1f001f00)))

#define FB_DEPTH 16
#define FB_FUNC_NAME do_fbcopy_16_obo
#include "video_blit.h"

#else

// native byte order

#define FB_BLIT_1(dst, src) \
        (dst = (((src) >> 8) & 0x001f) | (((src) << 9) & 0xfe00) | (((src) >> 7) & 0x01c0))
        
#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 8) & 0x001f001f) | (((src) << 9) & 0xfe00fe00) | (((src) >> 7) & 0x01c001c0))

#define FB_DEPTH 16
#define FB_FUNC_NAME do_fbcopy_16_nbo
#include "video_blit.h"

// opposite byte order (untested)

#define FB_BLIT_1(dst, src) \
        (dst = (((src) & 0x1f00) | (((src) << 1) & 0xe0fe) | (((src) >> 15) & 1)))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) & 0x1f001f00) | (((src) << 1) & 0xe0fee0fe) | (((src) >> 15) & 0x10001)))

#define FB_DEPTH 16
#define FB_FUNC_NAME do_fbcopy_16_obo
#include "video_blit.h"

#endif

// RGB 888

#ifdef WORDS_BIGENDIAN
# define FB_FUNC_NAME do_fbcopy_24_obo
#else
# define FB_FUNC_NAME do_fbcopy_24_nbo
#endif

#define FB_BLIT_1(dst, src) \
        (dst = (src))

#define FB_BLIT_2(dst, src) \
        (dst = (((src) >> 24) & 0xff) | (((src) >> 8) & 0xff00) | (((src) & 0xff00) << 8) | (((src) & 0xff) << 24))

#define FB_DEPTH 24
#include "video_blit.h"


/*
 *      Frame buffer copy functions map table
 */

typedef void (*fbcopy_func)(uint8 *, const uint8 *, uint32);
static fbcopy_func do_update_framebuffer;

#define FBCOPY_FUNC(aHandler) do_ ## aHandler

#if REAL_ADDRESSING || DIRECT_ADDRESSING
#define WD(X) { FBCOPY_FUNC(X), FBCOPY_FUNC(X) }
#else
#define WD(X) { FBCOPY_FUNC(fbcopy_raw), FBCOPY_FUNC(fbcopy_raw) }
#endif

// fb_copy_funcs[depth_id][native_byte_order][dga_mode]
// NT  : not tested
// OK  : has been successfully tested
// NBO : native byte order (X server vs. client)
// OBO : opposite byte order (X server vs. client)
static fbcopy_func fbcopy_funcs[ID_DEPTH_COUNT][2][2] = {
#ifdef WORDS_BIGENDIAN
                                /*      opposite byte order             native byte order       */
/*  1 bpp */    {       WD(fbcopy_raw)          ,       WD(fbcopy_raw)          },      // NT
/*  8 bpp */    {       WD(fbcopy_raw)          ,       WD(fbcopy_raw)          },      // OK (NBO)
/* 15 bpp */    {       WD(fbcopy_15_obo)       ,       WD(fbcopy_raw)          },      // OK (OBO)
/* 16 bpp */    {       WD(fbcopy_16_obo)       ,       WD(fbcopy_16_nbo)       },      // OK (OBO)
/* 24 bpp */    {       WD(fbcopy_24_obo)       ,       WD(fbcopy_raw)          }       // OK (OBO)
#else
                                /*      opposite byte order             native byte order       */
/*  1 bpp */    {       WD(fbcopy_raw)          ,       WD(fbcopy_raw)          },      // NT
/*  8 bpp */    {       WD(fbcopy_raw)          ,       WD(fbcopy_raw)          },      // OK (NBO)
/* 15 bpp */    {       WD(fbcopy_raw)          ,       WD(fbcopy_15_nbo)       },      // OK (NBO)
/* 16 bpp */    {       WD(fbcopy_16_obo)       ,       WD(fbcopy_16_nbo)       },      // OK (NBO)
/* 24 bpp */    {       WD(fbcopy_raw)          ,       WD(fbcopy_24_nbo)       }       // OK (NBO)
#endif
};

#undef WD

#define FBCOPY_FUNC_ERROR \
        ErrorAlert("Invalid screen depth")

#define GET_FBCOPY_FUNC(aDepth, aNativeByteOrder, aDisplay) \
        ((depth_id(aDepth) == ID_DEPTH_UNKNOWN) ? ( FBCOPY_FUNC_ERROR, (fbcopy_func)0 ) : \
        fbcopy_funcs[depth_id(aDepth)][(aNativeByteOrder)][(aDisplay) == DISPLAY_DGA ? 1 : 0])


/*
 *      Screen fault handler
 */

static inline void do_handle_screen_fault(uintptr addr)
{
        if ((addr < mainBuffer.memStart) || (addr >= mainBuffer.memEnd)) {
                fprintf(stderr, "Segmentation fault at 0x%08X\n", addr);
                abort();
        }
        
        const int page  = (addr - mainBuffer.memStart) >> mainBuffer.pageBits;
        caddr_t page_ad = (caddr_t)(addr & ~(mainBuffer.pageSize - 1));
        LOCK_VOSF;
        PFLAG_SET(page);
        mprotect(page_ad, mainBuffer.pageSize, PROT_READ | PROT_WRITE);
        UNLOCK_VOSF;
}

#if defined(HAVE_SIGINFO_T)

static void Screen_fault_handler(int, siginfo_t * sip, void *)
{
        D(bug("Screen_fault_handler: ADDR=0x%08X\n", sip->si_addr));
        do_handle_screen_fault((uintptr)sip->si_addr);
}

#elif defined(HAVE_SIGCONTEXT_SUBTERFUGE)

# if defined(__i386__) && defined(__linux__)
static void Screen_fault_handler(int, struct sigcontext scs)
{
        D(bug("Screen_fault_handler: ADDR=0x%08X from IP=0x%08X\n", scs.cr2, scs.eip));
        do_handle_screen_fault((uintptr)scs.cr2);
}

# elif defined(__m68k__) && defined(__NetBSD__)

# include <m68k/frame.h>
static void Screen_fault_handler(int, int code, struct sigcontext *scp)
{
        D(bug("Screen_fault_handler: ADDR=0x%08X\n", code));
        struct sigstate {
                int ss_flags;
                struct frame ss_frame;
        };
        struct sigstate *state = (struct sigstate *)scp->sc_ap;
        uintptr fault_addr;
        switch (state->ss_frame.f_format) {
                case 7:         // 68040 access error
                        // "code" is sometimes unreliable (i.e. contains NULL or a bogus address), reason unknown
                        fault_addr = state->ss_frame.f_fmt7.f_fa;
                        break;
                default:
                        fault_addr = (uintptr)code;
                        break;
        }
        do_handle_screen_fault(fault_addr);
}

# else
#  error "No suitable subterfuge for Video on SEGV signals"
# endif
#else
# error "Can't do Video on SEGV signals"
#endif


/*
 *      Screen fault handler initialization
 */

#if defined(HAVE_SIGINFO_T)
static bool Screen_fault_handler_init()
{
        // Setup SIGSEGV handler to process writes to frame buffer
        sigemptyset(&vosf_sa.sa_mask);
        vosf_sa.sa_sigaction = Screen_fault_handler;
        vosf_sa.sa_flags = SA_SIGINFO;
        return (sigaction(SIGSEGV, &vosf_sa, NULL) == 0);
}
#elif defined(HAVE_SIGCONTEXT_SUBTERFUGE)
static bool Screen_fault_handler_init()
{
        // Setup SIGSEGV handler to process writes to frame buffer
        sigemptyset(&vosf_sa.sa_mask);
        vosf_sa.sa_handler = (void (*)(int)) Screen_fault_handler;
#if !EMULATED_68K && defined(__NetBSD__)
        sigaddset(&vosf_sa.sa_mask, SIGALRM);
        vosf_sa.sa_flags = SA_ONSTACK;
#else
        vosf_sa.sa_flags = 0;
#endif
        return (sigaction(SIGSEGV, &vosf_sa, NULL) == 0);
}
#endif


/*
 *      Update display for Windowed mode and VOSF
 */

static inline void update_display_window_vosf(void)
{
        int page = 0;
        for (;;) {
                while (PFLAG_ISCLEAR_4(page))
                        page += 4;
                
                while (PFLAG_ISCLEAR(page))
                        page++;
                
                if (page >= mainBuffer.pageCount)
                        break;
                
                const int first_page = page;
                while ((page < mainBuffer.pageCount) && PFLAG_ISSET(page)) {
                        PFLAG_CLEAR(page);
                        ++page;
                }

                // Make the dirty pages read-only again
                const int32 offset  = first_page << mainBuffer.pageBits;
                const uint32 length = (page - first_page) << mainBuffer.pageBits;
                mprotect((caddr_t)(mainBuffer.memStart + offset), length, PROT_READ);
                
                // There is at least one line to update
                const int y1 = mainBuffer.pageInfo[first_page].top;
                const int y2 = mainBuffer.pageInfo[page - 1].bottom;
                const int height = y2 - y1 + 1;
                
                const int bytes_per_row = VideoMonitor.bytes_per_row;
                const int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x;
                int i, j;
                
                // Check for first column from left and first column
                // from right that have changed
                int x1, x2, width;
                if (depth == 1) {

                        x1 = VideoMonitor.x - 1;
                        for (j = y1; j <= y2; j++) {
                                uint8 * const p1 = &the_buffer[j * bytes_per_row];
                                uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
                                for (i = 0; i < (x1>>3); i++) {
                                        if (p1[i] != p2[i]) {
                                                x1 = i << 3;
                                                break;
                                        }
                                }
                        }

                        x2 = x1;
                        for (j = y2; j >= y1; j--) {
                                uint8 * const p1 = &the_buffer[j * bytes_per_row];
                                uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
                                for (i = (VideoMonitor.x>>3) - 1; i > (x2>>3); i--) {
                                        if (p1[i] != p2[i]) {
                                                x2 = (i << 3) + 7;
                                                break;
                                        }
                                }
                        }
                        width = x2 - x1 + 1;

                        // Update the_host_buffer and copy of the_buffer
                        i = y1 * bytes_per_row + (x1 >> 3);
                        for (j = y1; j <= y2; j++) {
                                do_update_framebuffer(the_host_buffer + i, the_buffer + i, width >> 3);
                                memcpy(the_buffer_copy + i, the_buffer + i, width >> 3);
                                i += bytes_per_row;
                        }

                } else {

                        x1 = VideoMonitor.x * bytes_per_pixel - 1;
                        for (j = y1; j <= y2; j++) {
                                uint8 * const p1 = &the_buffer[j * bytes_per_row];
                                uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
                                for (i = 0; i < x1; i++) {
                                        if (p1[i] != p2[i]) {
                                                x1 = i;
                                                break;
                                        }
                                }
                        }
                        x1 /= bytes_per_pixel;
                
                        x2 = x1 * bytes_per_pixel;
                        for (j = y2; j >= y1; j--) {
                                uint8 * const p1 = &the_buffer[j * bytes_per_row];
                                uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
                                for (i = VideoMonitor.x * bytes_per_pixel - 1; i > x2; i--) {
                                        if (p1[i] != p2[i]) {
                                                x2 = i;
                                                break;
                                        }
                                }
                        }
                        x2 /= bytes_per_pixel;
                        width = x2 - x1 + 1;

                        // Update the_host_buffer and copy of the_buffer
                        i = y1 * bytes_per_row + x1 * bytes_per_pixel;
                        for (j = y1; j <= y2; j++) {
                                do_update_framebuffer(the_host_buffer + i, the_buffer + i, bytes_per_pixel * width);
                                memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * width);
                                i += bytes_per_row;
                        }
                }
                
                if (have_shm)
                        XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, width, height, 0);
                else
                        XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, width, height);
        }
}


/*
 *      Update display for DGA mode and VOSF
 *      (only in Direct Addressing mode)
 */

#if REAL_ADDRESSING || DIRECT_ADDRESSING
static inline void update_display_dga_vosf(void)
{
        int page = 0;
        for (;;) {
                while (PFLAG_ISCLEAR_4(page))
                        page += 4;
                
                while (PFLAG_ISCLEAR(page))
                        page++;
                
                if (page >= mainBuffer.pageCount)
                        break;
                
                const int first_page = page;
                while ((page < mainBuffer.pageCount) && PFLAG_ISSET(page)) {
                        PFLAG_CLEAR(page);
                        ++page;
                }
                
                // Make the dirty pages read-only again
                const int32 offset  = first_page << mainBuffer.pageBits;
                const uint32 length = (page - first_page) << mainBuffer.pageBits;
                mprotect((caddr_t)(mainBuffer.memStart + offset), length, PROT_READ);
                
                // I am sure that y2 >= y1 and depth != 1
                const int y1 = mainBuffer.pageInfo[first_page].top;
                const int y2 = mainBuffer.pageInfo[page - 1].bottom;
                
                const int bytes_per_row = VideoMonitor.bytes_per_row;
                const int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x;
                int i, j;
                
                // Check for first column from left and first column
                // from right that have changed
                int x1 = VideoMonitor.x * bytes_per_pixel - 1;
                for (j = y1; j <= y2; j++) {
                        uint8 * const p1 = &the_buffer[j * bytes_per_row];
                        uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
                        for (i = 0; i < x1; i++) {
                                if (p1[i] != p2[i]) {
                                        x1 = i;
                                        break;
                                }
                        }
                }
                x1 /= bytes_per_pixel;
                
                int x2 = x1 * bytes_per_pixel;
                for (j = y2; j >= y1; j--) {
                        uint8 * const p1 = &the_buffer[j * bytes_per_row];
                        uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
                        for (i = VideoMonitor.x * bytes_per_pixel - 1; i > x2; i--) {
                                if (p1[i] != p2[i]) {
                                        x2 = i;
                                        break;
                                }
                        }
                }
                x2 /= bytes_per_pixel;
                
                // Update the_host_buffer and copy of the_buffer
                // There should be at least one pixel to copy
                const int width = x2 - x1 + 1;
                i = y1 * bytes_per_row + x1 * bytes_per_pixel;
                for (j = y1; j <= y2; j++) {
                        do_update_framebuffer(the_host_buffer + i, the_buffer + i, bytes_per_pixel * width);
                        memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * width);
                        i += bytes_per_row;
                }
        }
}
#endif

#endif /* ENABLE_VOSF */

#endif /* VIDEO_VOSF_H */
Revision:	1.10
Committed:	2000-11-30T16:20:52Z (24 years ago) by cebix
Content type:	text/plain
Branch:	MAIN
Changes since 1.9:	+5 -5 lines
Log Message:	- removed USE_MAPPED_MEMORY (unused) - fixed Delay_usec() on Solaris
#	User	Rev	Content
1	gbeauche	1.1	/*
2			* video_vosf.h - Video/graphics emulation, video on SEGV signals support
3			*
4			* Basilisk II (C) 1997-2000 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
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifndef VIDEO_VOSF_H
22			#define VIDEO_VOSF_H
23
24			// Note: this file is #include'd in video_x.cpp
25			#ifdef ENABLE_VOSF
26
27			/*
28			* Page-aligned memory allocation
29			*/
30
31			// Align on page boundaries
32	gbeauche	1.4	static uintptr align_on_page_boundary(uintptr size)
33	gbeauche	1.1	{
34			const uint32 page_size = getpagesize();
35			const uint32 page_mask = page_size - 1;
36			return (size + page_mask) & ~page_mask;
37			}
38
39			// Allocate memory on page boundary
40			static void * allocate_framebuffer(uint32 size, uint8 * hint = 0)
41			{
42			// Remind that the system can allocate at 0x00000000...
43			return mmap((caddr_t)hint, size, PROT_READ \| PROT_WRITE, MAP_PRIVATE, zero_fd, 0);
44			}
45
46
47			/*
48			* Screen depth identification
49			*/
50
51			enum {
52			ID_DEPTH_UNKNOWN = -1,
53			ID_DEPTH_1,
54			ID_DEPTH_8,
55			ID_DEPTH_15,
56			ID_DEPTH_16,
57			ID_DEPTH_24,
58			ID_DEPTH_32 = ID_DEPTH_24,
59			ID_DEPTH_COUNT
60			};
61
62			static int depth_id(int depth)
63			{
64			int id;
65			switch (depth) {
66			case 1 : id = ID_DEPTH_1; break;
67			case 8 : id = ID_DEPTH_8; break;
68			case 15 : id = ID_DEPTH_15; break;
69			case 16 : id = ID_DEPTH_16; break;
70			case 24 : id = ID_DEPTH_24; break;
71			case 32 : id = ID_DEPTH_32; break;
72			default : id = ID_DEPTH_UNKNOWN;
73			}
74			return id;
75			}
76
77
78			/*
79			* Frame buffer copy function templates
80			*/
81
82			// No conversion required
83
84			#define MEMCPY_PROFITABLE
85			#ifdef MEMCPY_PROFITABLE
86			static void do_fbcopy_raw(uint8 * dest, const uint8 * source, uint32 length)
87			{
88			memcpy(dest, source, length);
89			}
90			#else
91			#define FB_BLIT_1(dst, src) (dst = (src))
92			#define FB_BLIT_2(dst, src) (dst = (src))
93	gbeauche	1.2	#define FB_DEPTH 0
94	gbeauche	1.1	#define FB_FUNC_NAME do_fbcopy_raw
95			#include "video_blit.h"
96			#endif
97
98
99			// RGB 555
100
101	gbeauche	1.2	#ifdef WORDS_BIGENDIAN
102			# define FB_FUNC_NAME do_fbcopy_15_obo
103			#else
104			# define FB_FUNC_NAME do_fbcopy_15_nbo
105			#endif
106
107	gbeauche	1.1	#define FB_BLIT_1(dst, src) \
108			(dst = (((src) >> 8) & 0xff) \| (((src) & 0xff) << 8))
109
110			#define FB_BLIT_2(dst, src) \
111			(dst = (((src) >> 8) & 0x00ff00ff) \| (((src) & 0x00ff00ff) << 8))
112
113			#define FB_DEPTH 15
114			#include "video_blit.h"
115
116
117			// RGB 565
118
119	gbeauche	1.2	#ifdef WORDS_BIGENDIAN
120
121			// native byte order
122
123			#define FB_BLIT_1(dst, src) \
124			(dst = (((src) & 0x1f) \| (((src) << 1) & 0xffc0)))
125
126			#define FB_BLIT_2(dst, src) \
127			(dst = (((src) & 0x001f001f) \| (((src) << 1) & 0xffc0ffc0)))
128
129			#define FB_DEPTH 16
130			#define FB_FUNC_NAME do_fbcopy_16_nbo
131			#include "video_blit.h"
132
133	cebix	1.9	// opposite byte order
134	gbeauche	1.2
135			#define FB_BLIT_1(dst, src) \
136	cebix	1.9	(dst = ((((src) >> 7) & 0xff) \| (((src) << 9) & 0xc000) \| (((src) << 8) & 0x1f00)))
137	gbeauche	1.2
138			#define FB_BLIT_2(dst, src) \
139	cebix	1.9	(dst = ((((src) >> 7) & 0x00ff00ff) \| (((src) << 9) & 0xc000c000) \| (((src) << 8) & 0x1f001f00)))
140	gbeauche	1.2
141			#define FB_DEPTH 16
142			#define FB_FUNC_NAME do_fbcopy_16_obo
143			#include "video_blit.h"
144
145			#else
146
147			// native byte order
148
149	gbeauche	1.1	#define FB_BLIT_1(dst, src) \
150			(dst = (((src) >> 8) & 0x001f) \| (((src) << 9) & 0xfe00) \| (((src) >> 7) & 0x01c0))
151
152			#define FB_BLIT_2(dst, src) \
153			(dst = (((src) >> 8) & 0x001f001f) \| (((src) << 9) & 0xfe00fe00) \| (((src) >> 7) & 0x01c001c0))
154
155			#define FB_DEPTH 16
156	gbeauche	1.2	#define FB_FUNC_NAME do_fbcopy_16_nbo
157	gbeauche	1.1	#include "video_blit.h"
158
159	gbeauche	1.2	// opposite byte order (untested)
160
161			#define FB_BLIT_1(dst, src) \
162			(dst = (((src) & 0x1f00) \| (((src) << 1) & 0xe0fe) \| (((src) >> 15) & 1)))
163
164			#define FB_BLIT_2(dst, src) \
165			(dst = (((src) & 0x1f001f00) \| (((src) << 1) & 0xe0fee0fe) \| (((src) >> 15) & 0x10001)))
166
167			#define FB_DEPTH 16
168			#define FB_FUNC_NAME do_fbcopy_16_obo
169			#include "video_blit.h"
170
171			#endif
172	gbeauche	1.1
173			// RGB 888
174
175	gbeauche	1.2	#ifdef WORDS_BIGENDIAN
176			# define FB_FUNC_NAME do_fbcopy_24_obo
177			#else
178			# define FB_FUNC_NAME do_fbcopy_24_nbo
179			#endif
180
181	gbeauche	1.1	#define FB_BLIT_1(dst, src) \
182			(dst = (src))
183
184			#define FB_BLIT_2(dst, src) \
185	gbeauche	1.4	(dst = (((src) >> 24) & 0xff) \| (((src) >> 8) & 0xff00) \| (((src) & 0xff00) << 8) \| (((src) & 0xff) << 24))
186	gbeauche	1.1
187			#define FB_DEPTH 24
188			#include "video_blit.h"
189
190
191			/*
192			* Frame buffer copy functions map table
193			*/
194
195			typedef void (fbcopy_func)(uint8 , const uint8 *, uint32);
196			static fbcopy_func do_update_framebuffer;
197
198			#define FBCOPY_FUNC(aHandler) do_ ## aHandler
199
200			#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
201			#define WD(X) { FBCOPY_FUNC(X), FBCOPY_FUNC(X) }
202			#else
203			#define WD(X) { FBCOPY_FUNC(fbcopy_raw), FBCOPY_FUNC(fbcopy_raw) }
204			#endif
205
206			// fb_copy_funcs[depth_id][native_byte_order][dga_mode]
207			// NT : not tested
208			// OK : has been successfully tested
209	cebix	1.10	// NBO : native byte order (X server vs. client)
210			// OBO : opposite byte order (X server vs. client)
211	gbeauche	1.1	static fbcopy_func fbcopy_funcs[ID_DEPTH_COUNT][2][2] = {
212			#ifdef WORDS_BIGENDIAN
213	gbeauche	1.2	/* opposite byte order native byte order */
214			/* 1 bpp */ { WD(fbcopy_raw) , WD(fbcopy_raw) }, // NT
215			/* 8 bpp */ { WD(fbcopy_raw) , WD(fbcopy_raw) }, // OK (NBO)
216	cebix	1.10	/* 15 bpp */ { WD(fbcopy_15_obo) , WD(fbcopy_raw) }, // OK (OBO)
217	cebix	1.9	/* 16 bpp */ { WD(fbcopy_16_obo) , WD(fbcopy_16_nbo) }, // OK (OBO)
218	cebix	1.10	/* 24 bpp */ { WD(fbcopy_24_obo) , WD(fbcopy_raw) } // OK (OBO)
219	gbeauche	1.1	#else
220	gbeauche	1.2	/* opposite byte order native byte order */
221			/* 1 bpp */ { WD(fbcopy_raw) , WD(fbcopy_raw) }, // NT
222			/* 8 bpp */ { WD(fbcopy_raw) , WD(fbcopy_raw) }, // OK (NBO)
223			/* 15 bpp */ { WD(fbcopy_raw) , WD(fbcopy_15_nbo) }, // OK (NBO)
224			/* 16 bpp */ { WD(fbcopy_16_obo) , WD(fbcopy_16_nbo) }, // OK (NBO)
225	cebix	1.10	/* 24 bpp */ { WD(fbcopy_raw) , WD(fbcopy_24_nbo) } // OK (NBO)
226	gbeauche	1.1	#endif
227			};
228
229			#undef WD
230
231			#define FBCOPY_FUNC_ERROR \
232			ErrorAlert("Invalid screen depth")
233
234			#define GET_FBCOPY_FUNC(aDepth, aNativeByteOrder, aDisplay) \
235			((depth_id(aDepth) == ID_DEPTH_UNKNOWN) ? ( FBCOPY_FUNC_ERROR, (fbcopy_func)0 ) : \
236			fbcopy_funcs[depth_id(aDepth)][(aNativeByteOrder)][(aDisplay) == DISPLAY_DGA ? 1 : 0])
237
238
239			/*
240			* Screen fault handler
241			*/
242
243	gbeauche	1.4	static inline void do_handle_screen_fault(uintptr addr)
244	gbeauche	1.1	{
245			if ((addr < mainBuffer.memStart) \|\| (addr >= mainBuffer.memEnd)) {
246			fprintf(stderr, "Segmentation fault at 0x%08X\n", addr);
247			abort();
248			}
249
250			const int page = (addr - mainBuffer.memStart) >> mainBuffer.pageBits;
251			caddr_t page_ad = (caddr_t)(addr & ~(mainBuffer.pageSize - 1));
252	cebix	1.8	LOCK_VOSF;
253	gbeauche	1.1	PFLAG_SET(page);
254			mprotect(page_ad, mainBuffer.pageSize, PROT_READ \| PROT_WRITE);
255	cebix	1.8	UNLOCK_VOSF;
256	gbeauche	1.1	}
257
258			#if defined(HAVE_SIGINFO_T)
259	cebix	1.6
260	gbeauche	1.1	static void Screen_fault_handler(int, siginfo_t * sip, void *)
261			{
262			D(bug("Screen_fault_handler: ADDR=0x%08X\n", sip->si_addr));
263	gbeauche	1.4	do_handle_screen_fault((uintptr)sip->si_addr);
264	gbeauche	1.1	}
265	cebix	1.6
266	gbeauche	1.1	#elif defined(HAVE_SIGCONTEXT_SUBTERFUGE)
267	cebix	1.6
268	gbeauche	1.1	# if defined(__i386__) && defined(__linux__)
269			static void Screen_fault_handler(int, struct sigcontext scs)
270			{
271			D(bug("Screen_fault_handler: ADDR=0x%08X from IP=0x%08X\n", scs.cr2, scs.eip));
272	gbeauche	1.4	do_handle_screen_fault((uintptr)scs.cr2);
273	gbeauche	1.1	}
274	cebix	1.6
275			# elif defined(__m68k__) && defined(__NetBSD__)
276
277			# include <m68k/frame.h>
278			static void Screen_fault_handler(int, int code, struct sigcontext *scp)
279			{
280			D(bug("Screen_fault_handler: ADDR=0x%08X\n", code));
281			struct sigstate {
282			int ss_flags;
283			struct frame ss_frame;
284			};
285			struct sigstate state = (struct sigstate )scp->sc_ap;
286			uintptr fault_addr;
287			switch (state->ss_frame.f_format) {
288			case 7: // 68040 access error
289			// "code" is sometimes unreliable (i.e. contains NULL or a bogus address), reason unknown
290			fault_addr = state->ss_frame.f_fmt7.f_fa;
291			break;
292			default:
293			fault_addr = (uintptr)code;
294			break;
295			}
296			do_handle_screen_fault(fault_addr);
297			}
298
299	gbeauche	1.1	# else
300			# error "No suitable subterfuge for Video on SEGV signals"
301			# endif
302			#else
303			# error "Can't do Video on SEGV signals"
304			#endif
305
306
307			/*
308			* Screen fault handler initialization
309			*/
310
311			#if defined(HAVE_SIGINFO_T)
312			static bool Screen_fault_handler_init()
313			{
314			// Setup SIGSEGV handler to process writes to frame buffer
315			sigemptyset(&vosf_sa.sa_mask);
316			vosf_sa.sa_sigaction = Screen_fault_handler;
317	cebix	1.5	vosf_sa.sa_flags = SA_SIGINFO;
318	gbeauche	1.1	return (sigaction(SIGSEGV, &vosf_sa, NULL) == 0);
319			}
320			#elif defined(HAVE_SIGCONTEXT_SUBTERFUGE)
321			static bool Screen_fault_handler_init()
322			{
323			// Setup SIGSEGV handler to process writes to frame buffer
324			sigemptyset(&vosf_sa.sa_mask);
325			vosf_sa.sa_handler = (void (*)(int)) Screen_fault_handler;
326	cebix	1.7	#if !EMULATED_68K && defined(__NetBSD__)
327			sigaddset(&vosf_sa.sa_mask, SIGALRM);
328			vosf_sa.sa_flags = SA_ONSTACK;
329			#else
330	gbeauche	1.1	vosf_sa.sa_flags = 0;
331	cebix	1.7	#endif
332	gbeauche	1.1	return (sigaction(SIGSEGV, &vosf_sa, NULL) == 0);
333			}
334			#endif
335
336
337			/*
338			* Update display for Windowed mode and VOSF
339			*/
340
341			static inline void update_display_window_vosf(void)
342			{
343			int page = 0;
344			for (;;) {
345			while (PFLAG_ISCLEAR_4(page))
346			page += 4;
347
348			while (PFLAG_ISCLEAR(page))
349			page++;
350
351			if (page >= mainBuffer.pageCount)
352			break;
353
354			const int first_page = page;
355	gbeauche	1.4	while ((page < mainBuffer.pageCount) && PFLAG_ISSET(page)) {
356	gbeauche	1.1	PFLAG_CLEAR(page);
357	gbeauche	1.4	++page;
358			}
359	cebix	1.7
360	gbeauche	1.1	// Make the dirty pages read-only again
361			const int32 offset = first_page << mainBuffer.pageBits;
362			const uint32 length = (page - first_page) << mainBuffer.pageBits;
363			mprotect((caddr_t)(mainBuffer.memStart + offset), length, PROT_READ);
364
365			// There is at least one line to update
366			const int y1 = mainBuffer.pageInfo[first_page].top;
367			const int y2 = mainBuffer.pageInfo[page - 1].bottom;
368			const int height = y2 - y1 + 1;
369
370			const int bytes_per_row = VideoMonitor.bytes_per_row;
371			const int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x;
372			int i, j;
373
374			// Check for first column from left and first column
375			// from right that have changed
376	cebix	1.6	int x1, x2, width;
377			if (depth == 1) {
378
379			x1 = VideoMonitor.x - 1;
380			for (j = y1; j <= y2; j++) {
381			uint8 * const p1 = &the_buffer[j * bytes_per_row];
382			uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
383			for (i = 0; i < (x1>>3); i++) {
384			if (p1[i] != p2[i]) {
385			x1 = i << 3;
386			break;
387			}
388	gbeauche	1.1	}
389			}
390	cebix	1.6
391			x2 = x1;
392			for (j = y2; j >= y1; j--) {
393			uint8 * const p1 = &the_buffer[j * bytes_per_row];
394			uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
395			for (i = (VideoMonitor.x>>3) - 1; i > (x2>>3); i--) {
396			if (p1[i] != p2[i]) {
397	cebix	1.7	x2 = (i << 3) + 7;
398	cebix	1.6	break;
399			}
400			}
401			}
402			width = x2 - x1 + 1;
403
404			// Update the_host_buffer and copy of the_buffer
405			i = y1 * bytes_per_row + (x1 >> 3);
406			for (j = y1; j <= y2; j++) {
407			do_update_framebuffer(the_host_buffer + i, the_buffer + i, width >> 3);
408			memcpy(the_buffer_copy + i, the_buffer + i, width >> 3);
409			i += bytes_per_row;
410			}
411
412			} else {
413
414			x1 = VideoMonitor.x * bytes_per_pixel - 1;
415			for (j = y1; j <= y2; j++) {
416			uint8 * const p1 = &the_buffer[j * bytes_per_row];
417			uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
418			for (i = 0; i < x1; i++) {
419			if (p1[i] != p2[i]) {
420			x1 = i;
421			break;
422			}
423			}
424			}
425			x1 /= bytes_per_pixel;
426	gbeauche	1.1
427	cebix	1.6	x2 = x1 * bytes_per_pixel;
428			for (j = y2; j >= y1; j--) {
429			uint8 * const p1 = &the_buffer[j * bytes_per_row];
430			uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
431			for (i = VideoMonitor.x * bytes_per_pixel - 1; i > x2; i--) {
432			if (p1[i] != p2[i]) {
433			x2 = i;
434			break;
435			}
436	gbeauche	1.1	}
437			}
438	cebix	1.6	x2 /= bytes_per_pixel;
439			width = x2 - x1 + 1;
440
441			// Update the_host_buffer and copy of the_buffer
442			i = y1 * bytes_per_row + x1 * bytes_per_pixel;
443			for (j = y1; j <= y2; j++) {
444			do_update_framebuffer(the_host_buffer + i, the_buffer + i, bytes_per_pixel * width);
445			memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * width);
446			i += bytes_per_row;
447			}
448	gbeauche	1.1	}
449
450			if (have_shm)
451			XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, width, height, 0);
452			else
453			XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, width, height);
454			}
455			}
456
457
458			/*
459			* Update display for DGA mode and VOSF
460			* (only in Direct Addressing mode)
461			*/
462
463			#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
464			static inline void update_display_dga_vosf(void)
465			{
466			int page = 0;
467			for (;;) {
468			while (PFLAG_ISCLEAR_4(page))
469			page += 4;
470
471			while (PFLAG_ISCLEAR(page))
472			page++;
473
474			if (page >= mainBuffer.pageCount)
475			break;
476
477			const int first_page = page;
478	gbeauche	1.4	while ((page < mainBuffer.pageCount) && PFLAG_ISSET(page)) {
479	gbeauche	1.1	PFLAG_CLEAR(page);
480	gbeauche	1.4	++page;
481			}
482	gbeauche	1.1
483			// Make the dirty pages read-only again
484			const int32 offset = first_page << mainBuffer.pageBits;
485			const uint32 length = (page - first_page) << mainBuffer.pageBits;
486			mprotect((caddr_t)(mainBuffer.memStart + offset), length, PROT_READ);
487
488			// I am sure that y2 >= y1 and depth != 1
489			const int y1 = mainBuffer.pageInfo[first_page].top;
490			const int y2 = mainBuffer.pageInfo[page - 1].bottom;
491
492			const int bytes_per_row = VideoMonitor.bytes_per_row;
493			const int bytes_per_pixel = VideoMonitor.bytes_per_row / VideoMonitor.x;
494			int i, j;
495
496			// Check for first column from left and first column
497			// from right that have changed
498			int x1 = VideoMonitor.x * bytes_per_pixel - 1;
499			for (j = y1; j <= y2; j++) {
500			uint8 * const p1 = &the_buffer[j * bytes_per_row];
501			uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
502			for (i = 0; i < x1; i++) {
503			if (p1[i] != p2[i]) {
504			x1 = i;
505			break;
506			}
507			}
508			}
509			x1 /= bytes_per_pixel;
510
511			int x2 = x1 * bytes_per_pixel;
512			for (j = y2; j >= y1; j--) {
513			uint8 * const p1 = &the_buffer[j * bytes_per_row];
514			uint8 * const p2 = &the_buffer_copy[j * bytes_per_row];
515			for (i = VideoMonitor.x * bytes_per_pixel - 1; i > x2; i--) {
516			if (p1[i] != p2[i]) {
517			x2 = i;
518			break;
519			}
520			}
521			}
522			x2 /= bytes_per_pixel;
523
524			// Update the_host_buffer and copy of the_buffer
525			// There should be at least one pixel to copy
526			const int width = x2 - x1 + 1;
527			i = y1 * bytes_per_row + x1 * bytes_per_pixel;
528			for (j = y1; j <= y2; j++) {
529			do_update_framebuffer(the_host_buffer + i, the_buffer + i, bytes_per_pixel * width);
530			memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * width);
531			i += bytes_per_row;
532			}
533			}
534			}
535			#endif
536
537			#endif /* ENABLE_VOSF */
538
539			#endif /* VIDEO_VOSF_H */