DMesa now uses OSMesa as a back-end.

13 files changed, 1672 insertions, 2393 deletions

diff --git a/src/mesa/drivers/dos/blit.S b/src/mesa/drivers/dos/blit.S
index f5888c7e39..02dc8400d8 100644
--- a/src/mesa/drivers/dos/blit.S
+++ b/src/mesa/drivers/dos/blit.S
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.3 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@yahoo.com
  *  Web   : http://www.geocities.com/dborca
  */
@@ -197,3 +197,844 @@ _vesa_l_dump_virtual_mmx:
 		emms
 #endif
 		ret
+
+
+
+#define CVT_32_TO_16(s, tmp)			\
+    /* SRC = bbbbbbbbggggggggrrrrrrrr******** */\
+		movl	%e##s##x, %tmp		;\
+    /* TMP = bbbbbbbbggggggggrrrrrrrr******** */\
+		shrb	$2, %s##h		;\
+    /* SRC = bbbbbbbbgggggg00rrrrrrrr******** */\
+		andl	$0xF80000, %tmp		;\
+    /* TMP = 0000000000000000000rrrrr00000000 */\
+		shrw	$3, %s##x		;\
+    /* SRC = bbbbbgggggg00000rrrrrrrr******** */\
+		shrl	$8, %tmp		;\
+    /* TMP = 00000000000rrrrr0000000000000000 */\
+		orl	%tmp, %e##s##x		;\
+    /* SRC = bbbbbggggggrrrrrrrrrrrrr******** */
+
+#define CVT_32_TO_15(s, tmp)			\
+    /* SRC = bbbbbbbbggggggggrrrrrrrr******** */\
+		movl	%e##s##x, %tmp		;\
+    /* TMP = bbbbbbbbggggggggrrrrrrrr******** */\
+		shrb	$3, %s##h		;\
+    /* SRC = bbbbbbbbgggggg00rrrrrrrr******** */\
+		andl	$0xF80000, %tmp		;\
+    /* TMP = 0000000000000000000rrrrr00000000 */\
+		shrw	$3, %s##x		;\
+    /* SRC = bbbbbgggggg00000rrrrrrrr******** */\
+		shrl	$9, %tmp		;\
+    /* TMP = 00000000000rrrrr0000000000000000 */\
+		orl	%tmp, %e##s##x		;\
+    /* SRC = bbbbbggggggrrrrrrrrrrrrr******** */
+
+#define CVT_16_TO_15(src, tmp)			\
+    /* SRC = bbbbbggggggrrrrrBBBBBGGGGGGRRRRR */\
+		movl	%src, %tmp		;\
+    /* TMP = bbbbbggggggrrrrrBBBBBGGGGGGRRRRR */\
+		andl	$0x1F001F, %src		;\
+    /* SRC = bbbbb00000000000BBBBB00000000000 */\
+		andl	$0xFFC0FFC0, %tmp	;\
+    /* TMP = 000000gggggrrrrr000000GGGGGRRRRR */\
+		shrl	%tmp			;\
+    /* TMP = 00000gggggrrrrr000000GGGGGRRRRR0 */\
+		orl	%tmp, %src		;\
+    /* SRC = bbbbbgggggrrrrr0BBBBBGGGGGRRRRR0 */\
+
+
+
+/* transform BGRA to BGR */
+		.p2align 5,,31
+		.global	_vesa_l_dump_32_to_24
+_vesa_l_dump_32_to_24:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%ecx
+	1:
+		movl	(%esi), %eax
+		addl	$4, %esi
+		movw	%ax, %fs:(%edi)
+		shrl	$16, %eax
+		movb	%al, %fs:2(%edi)
+		addl	$3, %edi
+		subl	$3, %ecx
+		jnz	1b
+		popl	%ecx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+/* transform BGRA to B5G6R5 */
+		.p2align 5,,31
+		.global	_vesa_l_dump_32_to_16
+_vesa_l_dump_32_to_16:
+		pushl	%ebp
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%ecx
+	1:
+		movl	(%esi), %eax
+		addl	$4, %esi
+		CVT_32_TO_16(a, ebp)
+		movw	%ax, %fs:(%edi)
+		addl	$2, %edi
+		subl	$2, %ecx
+		jnz	1b
+		popl	%ecx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		popl	%ebp
+		ret
+
+/* transform BGRA to B5G5R5 */
+		.p2align 5,,31
+		.global	_vesa_l_dump_32_to_15
+_vesa_l_dump_32_to_15:
+		pushl	%ebp
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%ecx
+	1:
+		movl	(%esi), %eax
+		addl	$4, %esi
+		CVT_32_TO_15(a, ebp)
+		movw	%ax, %fs:(%edi)
+		addl	$2, %edi
+		subl	$2, %ecx
+		jnz	1b
+		popl	%ecx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		popl	%ebp
+		ret
+
+/* transform BGRA to fake8 */
+		.p2align 5,,31
+		.global	_vesa_l_dump_32_to_8
+_vesa_l_dump_32_to_8:
+		pushl	%ebp
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%edx
+		pushl	%ecx
+		pushl	%ebx
+	1:
+		movl	(%esi), %eax
+		addl	$4, %esi
+#if 1
+		xorl	%ebx, %ebx
+		movl	%eax, %edx
+		movb	%ah, %bl
+		shrl	$16, %edx
+		andl	$0xFF, %edx
+		andl	$0xFF, %eax
+
+		movb	_array_b(%eax), %al
+		movb	_array_r(%edx), %dl
+		movb	_array_g(%ebx), %bl
+
+		imull	$36, %eax
+		imull	$6, %ebx
+		addl	%edx, %eax
+		addl	%ebx, %eax
+#endif
+		movb	%al, %fs:(%edi)
+		incl	%edi
+		decl	%ecx
+		jnz	1b
+		popl	%ebx
+		popl	%ecx
+		popl	%edx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		popl	%ebp
+		ret
+
+/* transform BGR to BGRx */
+		.p2align 5,,31
+		.global	_vesa_l_dump_24_to_32
+_vesa_l_dump_24_to_32:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%ecx
+	1:
+		movl	(%esi), %eax
+		addl	$3, %esi
+		movl	%eax, %fs:(%edi)
+		addl	$4, %edi
+		subl	$4, %ecx
+		jnz	1b
+		popl	%ecx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+/* transform BGR to fake8 */
+		.p2align 5,,31
+		.global	_vesa_l_dump_24_to_8
+_vesa_l_dump_24_to_8:
+		pushl	%ebp
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%edx
+		pushl	%ecx
+		pushl	%ebx
+	1:
+		movl	(%esi), %eax
+		addl	$3, %esi
+#if 1
+		xorl	%ebx, %ebx
+		movl	%eax, %edx
+		movb	%ah, %bl
+		shrl	$16, %edx
+		andl	$0xFF, %edx
+		andl	$0xFF, %eax
+
+		movb	_array_b(%eax), %al
+		movb	_array_r(%edx), %dl
+		movb	_array_g(%ebx), %bl
+
+		imull	$36, %eax
+		imull	$6, %ebx
+		addl	%edx, %eax
+		addl	%ebx, %eax
+#endif
+		movb	%al, %fs:(%edi)
+		incl	%edi
+		decl	%ecx
+		jnz	1b
+		popl	%ebx
+		popl	%ecx
+		popl	%edx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		popl	%ebp
+		ret
+
+/* transform B5G6R5 to B5G5R5 */
+		.p2align 5,,31
+		.global	_vesa_l_dump_16_to_15
+_vesa_l_dump_16_to_15:
+		pushl	%ebp
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%ecx
+	1:
+		movl	(%esi), %eax
+		addl	$4, %esi
+		CVT_16_TO_15(eax, ebp)
+		movl	%eax, %fs:(%edi)
+		addl	$4, %edi
+		subl	$4, %ecx
+		jnz	1b
+		popl	%ecx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		popl	%ebp
+		ret
+
+/* transform B5G6R5 to fake8 */
+		.p2align 5,,31
+		.global	_vesa_l_dump_16_to_8
+_vesa_l_dump_16_to_8:
+		pushl	%ebp
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %edx
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%ecx
+		pushl	%ebx
+	1:
+		movl	(%esi), %eax
+		addl	$4, %esi
+#if 1
+		movl	%eax, %ebx
+		andl	$0xFFFF, %eax
+		shrl	$16, %ebx
+		movb	_tab_16_8(%eax), %al
+		movb	_tab_16_8(%ebx), %ah
+#endif
+		movw	%ax, %fs:(%edi)
+		addl	$2, %edi
+		subl	$2, %ecx
+		jnz	1b
+		popl	%ebx
+		popl	%ecx
+		addl	%ebx, %edi
+		decl	%edx
+		jnz	0b
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		popl	%ebp
+		ret
+
+
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_32_to_24
+_vesa_b_dump_32_to_24:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		movl	$0x00FFFFFF, %ebx
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		pushl	%ebx
+		incl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		popl	%ebx
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movb	(%esi), %al	/* XXX too many accesses */
+		incl	%esi
+		rorl	$8, %ebx
+		jnc	2b
+		movb	%al, %fs:(%edi)
+		incl	%edi
+		decl	%ecx
+		jnz	1b
+		popl	%ecx
+		popl	%eax
+		addl	_vl_current_delta, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_32_to_16
+_vesa_b_dump_32_to_16:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		incl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movl	(%esi), %eax
+		addl	$4, %esi
+		CVT_32_TO_16(a, ebx)
+		movw	%ax, %fs:(%edi)
+		addl	$2, %edi
+		subl	$2, %ecx
+		jnz	1b
+		popl	%ecx
+		popl	%eax
+		addl	_vl_current_delta, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_32_to_15
+_vesa_b_dump_32_to_15:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		incl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movl	(%esi), %eax
+		addl	$4, %esi
+		CVT_32_TO_15(a, ebx)
+		movw	%ax, %fs:(%edi)
+		addl	$2, %edi
+		subl	$2, %ecx
+		jnz	1b
+		popl	%ecx
+		popl	%eax
+		addl	_vl_current_delta, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_32_to_8
+_vesa_b_dump_32_to_8:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		pushl	%edx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		popl	%edx
+		incl	%edx
+		pushl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movl	(%esi), %eax
+		addl	$4, %esi
+#if 1
+		xorl	%ebx, %ebx
+		movl	%eax, %edx
+		movb	%ah, %bl
+		shrl	$16, %edx
+		andl	$0xFF, %edx
+		andl	$0xFF, %eax
+
+		movb	_array_b(%eax), %al
+		movb	_array_r(%edx), %dl
+		movb	_array_g(%ebx), %bl
+
+		imull	$36, %eax
+		imull	$6, %ebx
+		addl	%edx, %eax
+		addl	%ebx, %eax
+#endif
+		movb	%al, %fs:(%edi)
+		incl	%edi
+		decl	%ecx
+		jnz	1b
+		popl	%edx
+		popl	%ecx
+		popl	%eax
+		addl	_vl_current_delta, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_24_to_32
+_vesa_b_dump_24_to_32:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		pushl	%ebx
+		incl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		popl	%ebx
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movl	(%esi), %eax
+		addl	$3, %esi
+		movl	%eax, %fs:(%edi)
+		addl	$4, %edi
+		subl	$4, %ecx
+		jnz	1b
+		popl	%ecx
+		popl	%eax
+		addl	%ebx, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_24_to_8
+_vesa_b_dump_24_to_8:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		pushl	%edx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		popl	%edx
+		incl	%edx
+		pushl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movl	(%esi), %eax
+		addl	$3, %esi
+#if 1
+		xorl	%ebx, %ebx
+		movl	%eax, %edx
+		movb	%ah, %bl
+		shrl	$16, %edx
+		andl	$0xFF, %edx
+		andl	$0xFF, %eax
+
+		movb	_array_b(%eax), %al
+		movb	_array_r(%edx), %dl
+		movb	_array_g(%ebx), %bl
+
+		imull	$36, %eax
+		imull	$6, %ebx
+		addl	%edx, %eax
+		addl	%ebx, %eax
+#endif
+		movb	%al, %fs:(%edi)
+		incl	%edi
+		decl	%ecx
+		jnz	1b
+		popl	%edx
+		popl	%ecx
+		popl	%eax
+		addl	_vl_current_delta, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_16_to_15
+_vesa_b_dump_16_to_15:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		incl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movw	(%esi), %ax
+		addl	$2, %esi
+		CVT_16_TO_15(eax, ebx)
+		movw	%ax, %fs:(%edi)
+		addl	$2, %edi
+		subl	$2, %ecx
+		jnz	1b
+		popl	%ecx
+		popl	%eax
+		addl	_vl_current_delta, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
+
+		.p2align 5,,31
+		.global	_vesa_b_dump_16_to_8
+_vesa_b_dump_16_to_8:
+		pushl	%ebx
+		pushl	%esi
+		pushl	%edi
+		pushl	%ebp
+		movl	_vl_video_selector, %fs
+		movl	_vl_current_draw_buffer, %esi
+		movl	_vl_current_offset, %edi
+		movl	_vesa_gran_shift, %ecx
+		movl	_vesa_gran_mask, %ebp
+		movl	%edi, %edx
+		xorl	%ebx, %ebx
+		andl	%ebp, %edi
+		shrl	%cl, %edx
+		incl	%ebp
+		call	*_vesa_swbank
+		movl	_vl_current_stride, %ecx
+		movl	_vl_current_height, %eax
+		movl	_vl_current_delta, %ebx
+		.balign	4
+	0:
+		pushl	%eax
+		pushl	%ecx
+		.balign	4
+	1:
+		cmpl	%ebp, %edi
+		jb	2f
+		pushl	%ebx
+		incl	%edx
+		xorl	%ebx, %ebx
+		call	*_vesa_swbank
+		popl	%ebx
+		subl	%ebp, %edi
+		.balign	4
+	2:
+		movw	(%esi), %ax
+		addl	$2, %esi
+#if 1
+		andl	$0xFFFF, %eax
+		movb	_tab_16_8(%eax), %al
+#endif
+		movb	%al, %fs:(%edi)
+		addl	$1, %edi
+		subl	$1, %ecx
+		jnz	1b
+		popl	%ecx
+		popl	%eax
+		addl	%ebx, %edi
+		decl	%eax
+		jnz	0b
+		popl	%ebp
+		popl	%edi
+		popl	%esi
+		popl	%ebx
+		ret
diff --git a/src/mesa/drivers/dos/dmesa.c b/src/mesa/drivers/dos/dmesa.c
index 719f4ec54d..ee87e63852 100644
--- a/src/mesa/drivers/dos/dmesa.c
+++ b/src/mesa/drivers/dos/dmesa.c
@@ -23,922 +23,60 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.7 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (c) 2003 - Daniel Borca
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  */
 
 
-#include "glheader.h"
 #include "context.h"
 #include "imports.h"
-#ifndef FX
-#include "bufferobj.h"
-#include "buffers.h"
-#include "extensions.h"
-#include "macros.h"
-#include "matrix.h"
 #include "mtypes.h"
-#include "texformat.h"
-#include "teximage.h"
-#include "texstore.h"
-#include "array_cache/acache.h"
-#include "swrast/s_context.h"
-#include "swrast/s_depth.h"
-#include "swrast/s_lines.h"
-#include "swrast/s_triangle.h"
-#include "swrast/swrast.h"
-#include "swrast_setup/swrast_setup.h"
-#include "tnl/tnl.h"
-#include "tnl/t_context.h"
-#include "tnl/t_pipeline.h"
-#include "drivers/common/driverfuncs.h"
+
 #include "video.h"
-#else  /* FX */
-#include "GL/fxmesa.h"
-#endif /* FX */
 
+#include "GL/osmesa.h"
 #include "GL/dmesa.h"
 
 
-#define SWTC 0 /* SW texture compression */
-
-
 /*
- * In C++ terms, this class derives from the GLvisual class.
- * Add system-specific fields to it.
+ * This has nothing to do with Mesa Visual structure.
+ * We keep this one around for backwards compatibility,
+ * and to store video mode data for DMesaCreateContext.
  */
 struct dmesa_visual {
-   GLvisual gl_visual;
-   GLboolean sw_alpha;          /* use Mesa's alpha buffer? */
-   int z_buffer;                /* Z=buffer: 0=no, 1=SW, -1=HW */
+    GLenum format;		/* OSMesa framebuffer format */
+    GLint depthBits;
+    GLint stencilBits;
+    GLint accumBits;
 };
 
 /*
- * In C++ terms, this class derives from the GLframebuffer class.
- * Add system-specific fields to it.
+ * This has nothing to do with Mesa Buffer structure.
+ * We keep this one around for backwards compatibility,
+ * and to store various data.
  */
 struct dmesa_buffer {
-   GLframebuffer gl_buffer;     /* The depth, stencil, accum, etc buffers */
-   void *the_window;            /* your window handle, etc */
-
-   int xpos, ypos;              /* position */
-   int width, height;           /* size in pixels */
+    int xpos, ypos;              /* position */
+    int width, height;           /* size in pixels */
+    GLenum type;
+    void *the_window;            /* your window handle, etc */
 };
 
 /*
- * In C++ terms, this class derives from the GLcontext class.
- * Add system-specific fields to it.
+ * This has nothing to do with Mesa Context structure.
+ * We keep this one around for backwards compatibility,
+ * and to store real off-screen context.
  */
 struct dmesa_context {
-   GLcontext gl_ctx;            /* the core library context */
-   DMesaVisual visual;
-   DMesaBuffer buffer;
-   GLuint ClearColor;
-   GLuint ClearIndex;
-   /* etc... */
+    OSMesaContext osmesa;
+    DMesaBuffer buffer;
 };
 
 
-/*
- * SPAN FUNCTIONS
- * XXX: These need to be updated to take the new gl_renderbuffer parameter
- * introduced in Mesa 6.3.  That parameter will indicate whether the front
- * or back color buffer is to be read/written.
- */
-
-#ifndef FX
-/****************************************************************************
- * Read/Write pixels
- ***************************************************************************/
-#define FLIP(y)  (dmesa->buffer->height - (y) - 1)
-#define FLIP2(y) (_b_ - (y))
-
-#define DSTRIDE dmesa->buffer->width
-
-/****************************************************************************
- * RGB[A]
- ***************************************************************************/
-static void
-write_rgba_span (const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                 const GLubyte rgba[][4], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++, offset++) {
-         if (mask[i]) {
-            vl_putpixel(offset, vl_mixrgba(rgba[i]));
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++, offset++) {
-         vl_putpixel(offset, vl_mixrgba(rgba[i]));
-      }
-   }
-}
-
-
-static void
-write_rgb_span (const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                const GLubyte rgb[][3], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++, offset++) {
-         if (mask[i]) {
-            vl_putpixel(offset, vl_mixrgb(rgb[i]));
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++, offset++) {
-         vl_putpixel(offset, vl_mixrgb(rgb[i]));
-      }
-   }
-}
-
-
-static void
-write_mono_rgba_span (const GLcontext *ctx,
-                      GLuint n, GLint x, GLint y,
-                      const GLchan color[4], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset, rgba = vl_mixrgba(color);
-
-   offset = DSTRIDE * FLIP(y) + x;
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++, offset++) {
-         if (mask[i]) {
-            vl_putpixel(offset, rgba);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++, offset++) {
-         vl_putpixel(offset, rgba);
-      }
-   }
-}
-
-
-static void
-read_rgba_span (const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                GLubyte rgba[][4])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   /* read all pixels */
-   for (i = 0; i < n; i++, offset++) {
-      vl_getrgba(offset, rgba[i]);
-   }
-}
-
-
-static void
-write_rgba_pixels (const GLcontext *ctx,
-                   GLuint n, const GLint x[], const GLint y[],
-                   const GLubyte rgba[][4], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, _w_ = DSTRIDE, _b_ = dmesa->buffer->height - 1;
-
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            vl_putpixel(FLIP2(y[i])*_w_ + x[i], vl_mixrgba(rgba[i]));
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++) {
-         vl_putpixel(FLIP2(y[i])*_w_ + x[i], vl_mixrgba(rgba[i]));
-      }
-   }
-}
-
-
-static void
-write_mono_rgba_pixels (const GLcontext *ctx,
-                        GLuint n, const GLint x[], const GLint y[],
-                                    const GLchan color[4], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, _w_ = DSTRIDE, _b_ = dmesa->buffer->height - 1, rgba = vl_mixrgba(color);
-
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            vl_putpixel(FLIP2(y[i])*_w_ + x[i], rgba);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++) {
-         vl_putpixel(FLIP2(y[i])*_w_ + x[i], rgba);
-      }
-   }
-}
-
-
-static void
-read_rgba_pixels (const GLcontext *ctx,
-                  GLuint n, const GLint x[], const GLint y[],
-                  GLubyte rgba[][4], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, _w_ = DSTRIDE, _b_ = dmesa->buffer->height - 1;
-
-   if (mask) {
-      /* read some pixels */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            vl_getrgba(FLIP2(y[i])*_w_ + x[i], rgba[i]);
-         }
-      }
-   } else {
-      /* read all pixels */
-      for (i = 0; i < n; i++) {
-         vl_getrgba(FLIP2(y[i])*_w_ + x[i], rgba[i]);
-      }
-   }
-}
-
-
-/****************************************************************************
- * Index
- ***************************************************************************/
-static void
-write_index_span (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                  GLuint n, GLint x, GLint y,
-                  const GLuint index[], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++, offset++) {
-         if (mask[i]) {
-            vl_putpixel(offset, index[i]);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++, offset++) {
-         vl_putpixel(offset, index[i]);
-      }
-   }
-}
-
-
-static void
-write_index8_span (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                   GLuint n, GLint x, GLint y,
-                   const GLubyte index[], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++, offset++) {
-         if (mask[i]) {
-            vl_putpixel(offset, index[i]);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++, offset++) {
-         vl_putpixel(offset, index[i]);
-      }
-   }
-}
-
-
-static void
-write_mono_index_span (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                       GLuint n, GLint x, GLint y,
-                       GLuint colorIndex, const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++, offset++) {
-         if (mask[i]) {
-            vl_putpixel(offset, colorIndex);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++, offset++) {
-         vl_putpixel(offset, colorIndex);
-      }
-   }
-}
-
-
-static void
-read_index_span (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                 GLuint n, GLint x, GLint y, GLuint index[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, offset;
-
-   offset = DSTRIDE * FLIP(y) + x;
-   /* read all pixels */
-   for (i = 0; i < n; i++, offset++) {
-      index[i] = vl_getpixel(offset);
-   }
-}
-
-
-static void
-write_index_pixels (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                    GLuint n, const GLint x[], const GLint y[],
-                    const GLuint index[], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, _w_ = DSTRIDE, _b_ = dmesa->buffer->height - 1;
-
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            vl_putpixel(FLIP2(y[i])*_w_ + x[i], index[i]);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++) {
-         vl_putpixel(FLIP2(y[i])*_w_ + x[i], index[i]);
-      }
-   }
-}
-
-
-static void
-write_mono_index_pixels (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLuint colorIndex, const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, _w_ = DSTRIDE, _b_ = dmesa->buffer->height - 1;
-
-   if (mask) {
-      /* draw some pixels */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            vl_putpixel(FLIP2(y[i])*_w_ + x[i], colorIndex);
-         }
-      }
-   } else {
-      /* draw all pixels */
-      for (i = 0; i < n; i++) {
-         vl_putpixel(FLIP2(y[i])*_w_ + x[i], colorIndex);
-      }
-   }
-}
-
-
-static void
-read_index_pixels (const GLcontext *ctx, struct gl_renderbuffer *rb,
-                   GLuint n, const GLint x[], const GLint y[],
-                   GLuint index[], const GLubyte mask[])
-{
-   const DMesaContext dmesa = (DMesaContext)ctx;
-   GLuint i, _w_ = DSTRIDE, _b_ = dmesa->buffer->height - 1;
-
-   if (mask) {
-      /* read some pixels */
-      for (i = 0; i < n; i++) {
-         if (mask[i]) {
-            index[i] = vl_getpixel(FLIP2(y[i])*_w_ + x[i]);
-         }
-      }
-   } else {
-      /* read all pixels */
-      for (i = 0; i < n; i++) {
-         index[i] = vl_getpixel(FLIP2(y[i])*_w_ + x[i]);
-      }
-   }
-}
-
-
-/****************************************************************************
- * Z-buffer
- ***************************************************************************/
-
-
-/****************************************************************************
- * Optimized triangle rendering
- ***************************************************************************/
-
-/*
- * NON-depth-buffered flat triangle.
- */
-#define NAME tri_rgb_flat
-
-#define SETUP_CODE \
-   const DMesaContext dmesa = (DMesaContext)ctx;\
-   GLuint _b_ = dmesa->buffer->height - 1;	\
-   GLuint _w_ = dmesa->buffer->width;		\
-   GLuint rgb = vl_mixrgb(v2->color);
-
-#define RENDER_SPAN(span) \
-   GLuint i, offset = FLIP2(span.y)*_w_ + span.x;\
-   for (i = 0; i < span.end; i++, offset++) {	\
-      vl_putpixel(offset, rgb);			\
-   }
-
-#include "swrast/s_tritemp.h"
-
-
-/*
- * Z-less flat triangle.
- */
-#define NAME tri_rgb_flat_zless
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-
-#define SETUP_CODE \
-   const DMesaContext dmesa = (DMesaContext)ctx; \
-   GLuint _b_ = dmesa->buffer->height - 1;	\
-   GLuint _w_ = dmesa->buffer->width;		\
-   GLuint rgb = vl_mixrgb(v2->color);
-
-#define RENDER_SPAN(span) \
-   GLuint i, offset = FLIP2(span.y)*_w_ + span.x;\
-   for (i = 0; i < span.end; i++, offset++) {	\
-      const DEPTH_TYPE z = FixedToDepth(span.z);\
-      if (z < zRow[i]) {			\
-         vl_putpixel(offset, rgb);		\
-         zRow[i] = z;				\
-      }						\
-      span.z += span.zStep;			\
-   }
-
-#include "swrast/s_tritemp.h"
-
-
-/*
- * NON-depth-buffered iterated triangle.
- */
-#define NAME tri_rgb_iter
-
-#define INTERP_RGB 1
-
-#define SETUP_CODE \
-   const DMesaContext dmesa = (DMesaContext)ctx;\
-   GLuint _b_ = dmesa->buffer->height - 1;	\
-   GLuint _w_ = dmesa->buffer->width;
-
-#define RENDER_SPAN(span) \
-   GLuint i, offset = FLIP2(span.y)*_w_ + span.x;			\
-   for (i = 0; i < span.end; i++, offset++) {				\
-      vl_putpixel(offset, vl_mixfix(span.red, span.green, span.blue));	\
-      span.red += span.redStep;						\
-      span.green += span.greenStep;					\
-      span.blue += span.blueStep;					\
-   }
-
-#include "swrast/s_tritemp.h"
-
-
-/*
- * Z-less iterated triangle.
- */
-#define NAME tri_rgb_iter_zless
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-
-#define SETUP_CODE \
-   const DMesaContext dmesa = (DMesaContext)ctx;\
-   GLuint _b_ = dmesa->buffer->height - 1;	\
-   GLuint _w_ = dmesa->buffer->width;
-
-#define RENDER_SPAN(span) \
-   GLuint i, offset = FLIP2(span.y)*_w_ + span.x;			\
-   for (i = 0; i < span.end; i++, offset++) {				\
-      const DEPTH_TYPE z = FixedToDepth(span.z);			\
-      if (z < zRow[i]) {						\
-         vl_putpixel(offset, vl_mixfix(span.red, span.green, span.blue));\
-         zRow[i] = z;							\
-      }									\
-      span.red += span.redStep;						\
-      span.green += span.greenStep;					\
-      span.blue += span.blueStep;					\
-      span.z += span.zStep;						\
-   }
-
-#include "swrast/s_tritemp.h"
-
-
-/*
- * Analyze context state to see if we can provide a fast triangle function
- * Otherwise, return NULL.
- */
-static swrast_tri_func
-dmesa_choose_tri_function (GLcontext *ctx)
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if ((ctx->RenderMode != GL_RENDER)
-       || (ctx->Polygon.SmoothFlag)
-       || (ctx->Polygon.StippleFlag)
-       || (ctx->Texture._EnabledUnits)
-       || (swrast->_RasterMask & MULTI_DRAW_BIT)
-       || (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)) {
-      return (swrast_tri_func)NULL;
-   }
-
-   if (swrast->_RasterMask==DEPTH_BIT
-       && ctx->Depth.Func==GL_LESS
-       && ctx->Depth.Mask==GL_TRUE
-       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
-      return (ctx->Light.ShadeModel==GL_SMOOTH) ? tri_rgb_iter_zless : tri_rgb_flat_zless;
-   }
-
-   if (swrast->_RasterMask==0) { /* no depth test */
-      return (ctx->Light.ShadeModel==GL_SMOOTH) ? tri_rgb_iter : tri_rgb_flat;
-   }
-
-   return (swrast_tri_func)NULL;
-}
-
-
-/* Override for the swrast triangle-selection function.  Try to use one
- * of our internal triangle functions, otherwise fall back to the
- * standard swrast functions.
- */
-static void
-dmesa_choose_tri (GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if (!(swrast->Triangle=dmesa_choose_tri_function(ctx))) {
-      _swrast_choose_triangle(ctx);
-   }
-}
-
-
-/****************************************************************************
- * Optimized line rendering
- ***************************************************************************/
-
-/*
- * NON-depth-buffered flat line.
- */
-#define NAME line_rgb_flat
-
-#define INTERP_XY 1
-#define CLIP_HACK 1
-
-#define SETUP_CODE \
-   const DMesaContext dmesa = (DMesaContext)ctx;\
-   GLuint _b_ = dmesa->buffer->height - 1;	\
-   GLuint _w_ = dmesa->buffer->width;		\
-   GLuint rgb = vl_mixrgb(vert1->color);
-
-#define PLOT(X,Y) vl_putpixel(FLIP2(Y) * _w_ + X, rgb);
-
-#include "swrast/s_linetemp.h"
-
-
-/*
- * Z-less flat line.
- */
-#define NAME line_rgb_flat_zless
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define CLIP_HACK 1
-
-#define SETUP_CODE \
-   const DMesaContext dmesa = (DMesaContext)ctx;\
-   GLuint _b_ = dmesa->buffer->height - 1;	\
-   GLuint _w_ = dmesa->buffer->width;		\
-   GLuint rgb = vl_mixrgb(vert1->color);
-
-#define PLOT(X,Y) \
-   if (Z < *zPtr) {				\
-      *zPtr = Z;				\
-      vl_putpixel(FLIP2(Y) * _w_ + X, rgb);	\
-   }
-
-#include "swrast/s_linetemp.h"
-
-
-/*
- * NON-depth-buffered iterated line.
- */
-#define line_rgb_iter NULL
-
-
-/*
- * Z-less iterated line.
- */
-#define line_rgb_iter_zless NULL
-
-
-/*
- * Analyze context state to see if we can provide a fast line function
- * Otherwise, return NULL.
- */
-static swrast_line_func
-dmesa_choose_line_function (GLcontext *ctx)
-{
-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if ((ctx->RenderMode != GL_RENDER)
-       || (ctx->Line.SmoothFlag)
-       || (ctx->Texture._EnabledUnits)
-       || (ctx->Line.StippleFlag)
-       || (swrast->_RasterMask & MULTI_DRAW_BIT)
-       || (ctx->Line.Width!=1.0F)) {
-      return (swrast_line_func)NULL;
-   }
-
-   if (swrast->_RasterMask==DEPTH_BIT
-       && ctx->Depth.Func==GL_LESS
-       && ctx->Depth.Mask==GL_TRUE
-       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
-      return (ctx->Light.ShadeModel==GL_SMOOTH) ? line_rgb_iter_zless : line_rgb_flat_zless;
-   }
-
-   if (swrast->_RasterMask==0) { /* no depth test */
-      return (ctx->Light.ShadeModel==GL_SMOOTH) ? line_rgb_iter : line_rgb_flat;
-   }
-
-   return (swrast_line_func)NULL;
-}
-
-
-/* Override for the swrast line-selection function.  Try to use one
- * of our internal line functions, otherwise fall back to the
- * standard swrast functions.
- */
-static void
-dmesa_choose_line (GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if (!(swrast->Line=dmesa_choose_line_function(ctx))) {
-      _swrast_choose_line(ctx);
-   }
-}
-
-
-/****************************************************************************
- * Miscellaneous device driver funcs
- ***************************************************************************/
-static const struct gl_texture_format *
-choose_tex_format (GLcontext *ctx, GLint internalFormat,
-                   GLenum format, GLenum type)
-{
-   switch (internalFormat) {
-      case GL_COMPRESSED_RGB_ARB:
-         return &_mesa_texformat_rgb;
-      case GL_COMPRESSED_RGBA_ARB:
-         return &_mesa_texformat_rgba;
-      default:
-         return _mesa_choose_tex_format(ctx, internalFormat, format, type);
-   }
-}
-
-
-static void
-clear_index (GLcontext *ctx, GLuint index)
-{
-   ((DMesaContext)ctx)->ClearIndex = index;
-}
-
-
-static void
-clear_color (GLcontext *ctx, const GLfloat color[4])
-{
-   GLubyte col[4];
-   CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]);
-   CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]);
-   CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]);
-   CLAMPED_FLOAT_TO_UBYTE(col[3], color[3]);
-   ((DMesaContext)ctx)->ClearColor = vl_mixrgba(col);
-}
-
-
-static void
-clear (GLcontext *ctx, GLbitfield mask, GLboolean all,
-       GLint x, GLint y, GLint width, GLint height)
-{
-   const DMesaContext c = (DMesaContext)ctx;
-   const GLuint *colorMask = (GLuint *)&ctx->Color.ColorMask;
-
-   /*
-    * Clear the specified region of the buffers indicated by 'mask'
-    * using the clear color or index as specified by one of the two
-    * functions above.
-    * If all==GL_TRUE, clear whole buffer, else just clear region defined
-    * by x,y,width,height
-    */
-
-   /* we can't handle color or index masking */
-   if ((*colorMask == 0xffffffff) && (ctx->Color.IndexMask == 0xffffffff)) {
-      if (mask & DD_BACK_LEFT_BIT) {
-         int color = ((GLvisual *)(c->visual))->rgbMode ? c->ClearColor : c->ClearIndex;
-
-         if (all) {
-            vl_clear(color);
-         } else {
-            vl_rect(x, c->buffer->height - y - height, width, height, color);
-         }
-
-         mask &= ~DD_BACK_LEFT_BIT;
-      }
-   }
-
-   if (mask) {
-      _swrast_Clear(ctx, mask, all, x, y, width, height);
-   }
-}
-
-
-/*
- * Return the width and height of the current buffer.
- * If anything special has to been done when the buffer/window is
- * resized, do it now.
- */
-static void
-get_buffer_size (GLframebuffer *buffer, GLuint *width, GLuint *height)
-{
-   DMesaBuffer b = (DMesaBuffer)buffer;
-
-   *width  = b->width;
-   *height = b->height;
-}
-
-
-static void
-viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
-{
-   /* poll for window size change and realloc software Z/stencil/etc if needed */
-   _mesa_ResizeBuffersMESA();
-}
-
-
-static const GLubyte *
-get_string (GLcontext *ctx, GLenum name)
-{
-   switch (name) {
-      case GL_RENDERER:
-         return (const GLubyte *)"Mesa DJGPP";
-      default:
-         return NULL;
-   }
-}
-
-
-static void
-finish (GLcontext *ctx)
-{
-   /*
-    * XXX todo - OPTIONAL FUNCTION: implements glFinish if possible
-    */
-}
-
-
-static void
-flush (GLcontext *ctx)
-{
-   /*
-    * XXX todo - OPTIONAL FUNCTION: implements glFlush if possible
-    */
-}
-
-
-/****************************************************************************
- * State
- ***************************************************************************/
-#define DMESA_NEW_LINE (_NEW_LINE | \
-                        _NEW_TEXTURE | \
-                        _NEW_LIGHT | \
-                        _NEW_DEPTH | \
-                        _NEW_RENDERMODE | \
-                        _SWRAST_NEW_RASTERMASK)
-
-#define DMESA_NEW_TRIANGLE (_NEW_POLYGON | \
-                            _NEW_TEXTURE | \
-                            _NEW_LIGHT | \
-                            _NEW_DEPTH | \
-                            _NEW_RENDERMODE | \
-                            _SWRAST_NEW_RASTERMASK)
-
-/* Extend the software rasterizer with our line and triangle
- * functions.
- */
-static void
-dmesa_register_swrast_functions (GLcontext *ctx)
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   swrast->choose_line = dmesa_choose_line;
-   swrast->choose_triangle = dmesa_choose_tri;
-
-   swrast->InvalidateLineMask |= DMESA_NEW_LINE;
-   swrast->InvalidateTriangleMask |= DMESA_NEW_TRIANGLE;
-}
-
-
-static void
-dmesa_update_state (GLcontext *ctx, GLuint new_state)
-{
-   /* Propagate statechange information to swrast and swrast_setup
-    * modules. The DMesa driver has no internal GL-dependent state.
-    */
-   _swrast_InvalidateState( ctx, new_state );
-   _ac_InvalidateState( ctx, new_state );
-   _tnl_InvalidateState( ctx, new_state );
-   _swsetup_InvalidateState( ctx, new_state );
-}
-
-
-/* Initialize the device driver function table with the functions
- * we implement in this driver.
- */
-static void
-dmesa_init_driver_functions (DMesaVisual visual,
-                             struct dd_function_table *driver)
-{
-   driver->UpdateState = dmesa_update_state;
-   driver->GetString = get_string;
-   driver->GetBufferSize = get_buffer_size;
-   driver->Viewport = viewport;
-   driver->Flush = flush;
-   driver->Finish = finish;
-   driver->Clear = clear;
-   driver->ClearColor = clear_color;
-   driver->ClearIndex = clear_index;
-#if SWTC
-   driver->ChooseTextureFormat = choose_tex_format;
-#endif
-}
-
-
-/* Setup pointers and other driver state that is constant for the life
- * of a context.
- */
-static void
-dmesa_init_pointers (GLcontext *ctx)
-{
-   struct swrast_device_driver *dd = _swrast_GetDeviceDriverReference(ctx);
-
-   /* The span functions should be in `dmesa_update_state', but I'm
-    * pretty sure they will never change during the life of the Visual
-    */
-
-   /* Index span/pixel functions */
-   dd->WriteCI32Span = write_index_span;
-   dd->WriteCI8Span = write_index8_span;
-   dd->WriteMonoCISpan = write_mono_index_span;
-   dd->WriteCI32Pixels = write_index_pixels;
-   dd->WriteMonoCIPixels = write_mono_index_pixels;
-   dd->ReadCI32Span = read_index_span;
-   dd->ReadCI32Pixels = read_index_pixels;
-
-   /* RGB(A) span/pixel functions */
-   dd->WriteRGBASpan = write_rgba_span;
-   dd->WriteRGBSpan = write_rgb_span;
-   dd->WriteMonoRGBASpan = write_mono_rgba_span;
-   dd->WriteRGBAPixels = write_rgba_pixels;
-   dd->WriteMonoRGBAPixels = write_mono_rgba_pixels;
-   dd->ReadRGBASpan = read_rgba_span;
-   dd->ReadRGBAPixels = read_rgba_pixels;
-}
-#endif /* FX */
+static DMesaContext ctx;
 
 
 /****************************************************************************
@@ -960,131 +98,50 @@ DMesaCreateVisual (GLint width,
                    GLint stencilSize,
                    GLint accumSize)
 {
-   DMesaVisual v;
-   GLint redBits, greenBits, blueBits, alphaBits, indexBits;
-   GLboolean sw_alpha;
-
-   alphaBits = 0;
-
-   if (!rgbFlag) {
-      indexBits = 8;
-      redBits = 0;
-      greenBits = 0;
-      blueBits = 0;
-   } else {
-      indexBits = 0;
-      switch (colDepth) {
-         case 8:
-            redBits = 8;
-            greenBits = 8;
-            blueBits = 8;
-            break;
-         case 15:
-            alphaBits = 1;
-            redBits = 5;
-            greenBits = 5;
-            blueBits = 5;
-            break;
-         case 16:
-            redBits = 5;
-            greenBits = 6;
-            blueBits = 5;
-            break;
-         case 32:
-            alphaBits = 8;
-         case 24:
-            redBits = 8;
-            greenBits = 8;
-            blueBits = 8;
-            break;
-         default:
-            return NULL;
-      }
-   }
-
-   /* Okay,
-    * `alphaBits' is what we can provide
-    * `alphaSize' is what app requests
-    *
-    * Note that alpha buffering is required only if destination alpha is used
-    * in alpha blending; alpha blending modes that do not use destination alpha
-    * can be used w/o alpha buffer.
-    *
-    * We will use whatever ALPHA app requests. Later, in `CreateBuffer' we'll
-    * instruct Mesa to use its own ALPHA buffer, by passing a non-FALSE value
-    * for ALPHA to `_mesa_initialize_framebuffer'.
-    *
-    * Basically, 32bit modes provide ALPHA storage, but can we rely on this?
-    */
-   alphaBits = alphaSize;
-   sw_alpha = (alphaBits > 0);
-
-#ifndef FX
-   if (!dbFlag) {
-      return NULL;
-   }
-   if ((colDepth=vl_video_init(width, height, colDepth, rgbFlag, refresh)) <= 0) {
-      return NULL;
-   }
-#else  /* FX */
-   if (!rgbFlag) {
-      return NULL;
-   } else {
-      char *env;
-
-      if ((env = getenv("MESA_FX_INFO")) && (env[0] == 'r')) {
-         freopen("MESA.LOG", "w", stderr);
-      }
-
-      if (refresh && (((env = getenv("FX_GLIDE_REFRESH")) == NULL) || !atoi(env))) {
-         /* if we are passed non-zero value for refresh, we need to override
-          * default refresh rate. However, if FX_GLIDE_REFRESH is already set
-          * to 0, we won't override it, because it has a special meaning for
-          * DJGPP Glide3x (switch via VESA, using BIOS default refresh).
-          */
-         char tmp[32];
-         sprintf(tmp, "FX_GLIDE_REFRESH=%u", refresh);
-         putenv(tmp);
-      }
-   }
-#endif /* FX */
-
-   if ((v=(DMesaVisual)CALLOC_STRUCT(dmesa_visual)) != NULL) {
-      /* Create core visual */
-      _mesa_initialize_visual((GLvisual *)v,
-                              rgbFlag,		/* rgb */
-                              dbFlag,
-                              GL_FALSE,		/* stereo */
-                              redBits,
-                              greenBits,
-                              blueBits,
-                              alphaBits,
-                              indexBits,		/* indexBits */
-                              depthSize,
-                              stencilSize,
-                              accumSize,		/* accumRed */
-                              accumSize,		/* accumGreen */
-                              accumSize,		/* accumBlue */
-                              alphaBits?accumSize:0,	/* accumAlpha */
-                              1);			/* numSamples */
-
-#ifndef FX
-      v->sw_alpha = sw_alpha;
-      v->z_buffer = (depthSize > 0) ? 1 : 0;
-#endif
-   }
-
-   return v;
+    DMesaVisual visual;
+    GLenum format;
+    int fbbits;
+
+    if (dbFlag) {
+	return NULL;
+    }
+
+    if (!rgbFlag) {
+	format = OSMESA_COLOR_INDEX;
+	fbbits = 8;
+    } else if (alphaSize) {
+	format = OSMESA_BGRA;
+	fbbits = 32;
+    } else if (colDepth == 15 || colDepth == 16) {
+	format = OSMESA_RGB_565;
+	fbbits = 16;
+    } else {
+	format = OSMESA_BGR;
+	fbbits = 24;
+    }
+
+    if ((visual = (DMesaVisual)CALLOC_STRUCT(dmesa_visual)) == NULL) {
+	return NULL;
+    }
+
+    if (vl_video_init(width, height, colDepth, rgbFlag, refresh, fbbits) <= 0) {
+	FREE(visual);
+	return NULL;
+    }
+
+    visual->format = format;
+    visual->depthBits = depthSize;
+    visual->stencilBits = stencilSize;
+    visual->accumBits = accumSize;
+    return visual;
 }
 
 
 void
-DMesaDestroyVisual (DMesaVisual v)
+DMesaDestroyVisual (DMesaVisual visual)
 {
-#ifndef FX
    vl_video_exit();
-#endif
-   _mesa_destroy_visual((GLvisual *)v);
+   FREE(visual);
 }
 
 
@@ -1093,248 +150,168 @@ DMesaCreateBuffer (DMesaVisual visual,
                    GLint xpos, GLint ypos,
                    GLint width, GLint height)
 {
-#ifndef FX
-   DMesaBuffer b;
-
-   if ((b=(DMesaBuffer)CALLOC_STRUCT(dmesa_buffer)) != NULL) {
-      _mesa_initialize_framebuffer((GLframebuffer *)b,
-                                   (GLvisual *)visual,
-                                   visual->z_buffer == 1,
-                                   ((GLvisual *)visual)->stencilBits > 0,
-                                   ((GLvisual *)visual)->accumRedBits > 0,
-                                   visual->sw_alpha);
-      b->xpos = xpos;
-      b->ypos = ypos;
-      b->width = width;
-      b->height = height;
-   }
-
-   return b;
-#else  /* FX */
-
-   GLvisual *v = (GLvisual *)visual;
-   int i = 0, fx_attrib[32];
-
-   if (v->doubleBufferMode) fx_attrib[i++] = FXMESA_DOUBLEBUFFER;
-   if (v->depthBits > 0) { fx_attrib[i++] = FXMESA_DEPTH_SIZE; fx_attrib[i++] = v->depthBits; }
-   if (v->stencilBits > 0) { fx_attrib[i++] = FXMESA_STENCIL_SIZE; fx_attrib[i++] = v->stencilBits; }
-   if (v->accumRedBits > 0) { fx_attrib[i++] = FXMESA_ACCUM_SIZE; fx_attrib[i++] = v->accumRedBits; }
-   if (v->alphaBits) { fx_attrib[i++] = FXMESA_ALPHA_SIZE; fx_attrib[i++] = v->alphaBits; }
-   fx_attrib[i++] = FXMESA_COLORDEPTH;
-   fx_attrib[i++] = v->redBits + v->greenBits + v->blueBits;
-   fx_attrib[i] = FXMESA_NONE;
-
-   return (DMesaBuffer)fxMesaCreateBestContext(-1, width, height, fx_attrib);
-#endif /* FX */
+    DMesaBuffer buffer;
+    GLenum type;
+    int bytesPerPixel;
+
+    switch (visual->format) {
+	case OSMESA_COLOR_INDEX:
+	    bytesPerPixel = 1;
+	    type = CHAN_TYPE;
+	    break;
+	case OSMESA_RGB_565:
+	    bytesPerPixel = 2;
+	    type = GL_UNSIGNED_SHORT_5_6_5;
+	    break;
+	case OSMESA_BGR:
+	    bytesPerPixel = 3;
+	    type = CHAN_TYPE;
+	    break;
+	default:
+	    bytesPerPixel = 4;
+	    type = CHAN_TYPE;
+    }
+
+    if ((buffer = (DMesaBuffer)CALLOC_STRUCT(dmesa_buffer)) != NULL) {
+	buffer->xpos = xpos;
+	buffer->ypos = ypos;
+	buffer->width = width;
+	buffer->height = height;
+	buffer->type = type;
+	buffer->the_window = MALLOC(width * height * bytesPerPixel + 1);
+	if (buffer->the_window == NULL) {
+	    FREE(buffer);
+	    buffer = NULL;
+	}
+    }
+
+    return buffer;
 }
 
 
 void
-DMesaDestroyBuffer (DMesaBuffer b)
+DMesaDestroyBuffer (DMesaBuffer buffer)
 {
-#ifndef FX
-   if (b->the_window != NULL) {
-      free(b->the_window);
-   }
-   _mesa_destroy_framebuffer((GLframebuffer *)b);
-#else
-   fxMesaDestroyContext((fxMesaContext)b);
-#endif
+    FREE(buffer->the_window);
+    FREE(buffer);
 }
 
 
 DMesaContext
 DMesaCreateContext (DMesaVisual visual, DMesaContext share)
 {
-   GLcontext *c;
-#ifndef FX
-   TNLcontext *tnl;
-   struct dd_function_table functions;
-
-   if ((c=(GLcontext *)CALLOC_STRUCT(dmesa_context)) != NULL) {
-      /* Initialize device driver function table */
-      _mesa_init_driver_functions(&functions);
-      /* override with our functions */
-      dmesa_init_driver_functions(visual, &functions);
-
-      _mesa_initialize_context(c,
-                               (GLvisual *)visual,
-                               (GLcontext *)share,
-                               &functions,
-                               (void *)c);
- 
-      _mesa_enable_sw_extensions(c);
-      _mesa_enable_1_3_extensions(c);
-      _mesa_enable_1_4_extensions(c);
-      _mesa_enable_1_5_extensions(c);
-      _mesa_enable_2_0_extensions(c);
-#if SWTC
-      if (c->Mesa_DXTn) {
-         _mesa_enable_extension(c, "GL_EXT_texture_compression_s3tc");
-         _mesa_enable_extension(c, "GL_S3_s3tc");
-      }
-      _mesa_enable_extension(c, "GL_3DFX_texture_compression_FXT1");
-#endif
-
-      /* you probably have to do a bunch of other initializations here. */
-      ((DMesaContext)c)->visual = visual;
-
-      /* Initialize the software rasterizer and helper modules.
-       */
-      _swrast_CreateContext(c);
-      _ac_CreateContext(c);
-      _tnl_CreateContext(c);
-      _swsetup_CreateContext(c);
-      /* tnl setup */
-      tnl = TNL_CONTEXT(c);
-      tnl->Driver.RunPipeline = _tnl_run_pipeline;
-      /* swrast setup */
-      if (((GLvisual *)visual)->rgbMode) dmesa_register_swrast_functions(c);
-      dmesa_init_pointers(c);
-      _swsetup_Wakeup(c);
-   }
-
-#else  /* FX */
-   c = (GLcontext *)0xdeadbeef;
-#endif /* FX */
-
-   return (DMesaContext)c;
+    DMesaContext dmesa;
+    if ((dmesa = (DMesaContext)CALLOC_STRUCT(dmesa_context)) != NULL) {
+	dmesa->osmesa = OSMesaCreateContextExt(
+				visual->format,
+				visual->depthBits,
+				visual->stencilBits,
+				visual->accumBits,
+				(share != NULL) ? share->osmesa : NULL);
+	if (dmesa->osmesa == NULL) {
+	    FREE(dmesa);
+	    dmesa = NULL;
+	}
+    }
+    return dmesa;
 }
 
 
 void
-DMesaDestroyContext (DMesaContext c)
+DMesaDestroyContext (DMesaContext dmesa)
 {
-#ifndef FX
-   if (c) {
-      _swsetup_DestroyContext((GLcontext *)c);
-      _swrast_DestroyContext((GLcontext *)c);
-      _tnl_DestroyContext((GLcontext *)c);
-      _ac_DestroyContext((GLcontext *)c);
-      _mesa_destroy_context((GLcontext *)c);
-   }
-#endif
+    OSMesaDestroyContext(dmesa->osmesa);
+    FREE(dmesa);
 }
 
 
 GLboolean
 DMesaMoveBuffer (GLint xpos, GLint ypos)
 {
-#ifndef FX
-   GET_CURRENT_CONTEXT(ctx);
-   DMesaBuffer b = ((DMesaContext)ctx)->buffer;
+    const DMesaContext dmesa = DMesaGetCurrentContext();
+    DMesaBuffer b = dmesa->buffer;
 
-   if (vl_sync_buffer(&b->the_window, xpos, ypos, b->width, b->height) == 0) {
-      b->xpos = xpos;
-      b->ypos = ypos;
-      return GL_TRUE;
-   }
-#endif
+    if (vl_sync_buffer(&b->the_window, xpos, ypos, b->width, b->height) == 0) {
+	b->xpos = xpos;
+	b->ypos = ypos;
+	return GL_TRUE;
+    }
 
-   return GL_FALSE;
+    return GL_FALSE;
 }
 
 
 GLboolean
 DMesaResizeBuffer (GLint width, GLint height)
 {
-#ifndef FX
-   GET_CURRENT_CONTEXT(ctx);
-   DMesaBuffer b = ((DMesaContext)ctx)->buffer;
+    const DMesaContext dmesa = DMesaGetCurrentContext();
+    DMesaBuffer b = dmesa->buffer;
 
-   if (vl_sync_buffer(&b->the_window, b->xpos, b->ypos, width, height) == 0) {
-      b->width = width;
-      b->height = height;
-      return GL_TRUE;
-   }
-#endif
+    if (vl_sync_buffer(&b->the_window, b->xpos, b->ypos, width, height) == 0) {
+	b->width = width;
+	b->height = height;
+	return GL_TRUE;
+    }
 
-   return GL_FALSE;
+    return GL_FALSE;
 }
 
 
-/*
- * Make the specified context and buffer the current one.
- */
 GLboolean
-DMesaMakeCurrent (DMesaContext c, DMesaBuffer b)
+DMesaMakeCurrent (DMesaContext dmesa, DMesaBuffer buffer)
 {
-#ifndef FX
-   if ((c != NULL) && (b != NULL)) {
-      if (vl_sync_buffer(&b->the_window, b->xpos, b->ypos, b->width, b->height) != 0) {
-         return GL_FALSE;
-      }
-
-      c->buffer = b;
-
-      _mesa_make_current((GLcontext *)c, (GLframebuffer *)b);
-   }
-   else {
-      /* Detach */
-      _mesa_make_current(NULL, NULL);
-   }
-
-#else
-   fxMesaMakeCurrent((fxMesaContext)b);
-#endif
-
-   return GL_TRUE;
+    if (dmesa == NULL || buffer == NULL) {
+	ctx = NULL;
+	return GL_TRUE;
+    }
+    if (OSMesaMakeCurrent(dmesa->osmesa, buffer->the_window,
+			  buffer->type,
+			  buffer->width, buffer->height) &&
+	vl_sync_buffer(&buffer->the_window, buffer->xpos, buffer->ypos, buffer->width, buffer->height) == 0) {
+	OSMesaPixelStore(OSMESA_Y_UP, GL_FALSE);
+	dmesa->buffer = buffer;
+	ctx = dmesa;
+	return GL_TRUE;
+    }
+    return GL_FALSE;
 }
 
 
 void
-DMesaSwapBuffers (DMesaBuffer b)
+DMesaSwapBuffers (DMesaBuffer buffer)
 {
-   /* copy/swap back buffer to front if applicable */
-#ifndef FX
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_notifySwapBuffers(ctx);
-   vl_flip();
-#else
-   fxMesaSwapBuffers();
-#endif
+    /* copy/swap back buffer to front if applicable */
+    GET_CURRENT_CONTEXT(ctx);
+    _mesa_notifySwapBuffers(ctx);
+    vl_flip();
+    (void)buffer;
 }
 
 
 void
 DMesaSetCI (int ndx, GLfloat red, GLfloat green, GLfloat blue)
 {
-#ifndef FX
-   vl_setCI(ndx, red, green, blue);
-#endif
+    vl_setCI(ndx, red, green, blue);
 }
 
 
 DMesaContext
 DMesaGetCurrentContext (void)
 {
-   GET_CURRENT_CONTEXT(ctx);
-
-#ifndef FX
-#else
-   if (ctx != NULL) {
-      ctx = (GLcontext *)0xdeadbeef;
-   }
-#endif
-
-   return (DMesaContext)ctx;
+   return ctx;
 }
 
 
 DMesaBuffer
 DMesaGetCurrentBuffer (void)
 {
-   const DMesaContext dmesa = DMesaGetCurrentContext();
+    const DMesaContext dmesa = DMesaGetCurrentContext();
 
-   if (dmesa == NULL) {
-      return NULL;
-   }
+    if (dmesa != NULL) {
+	return dmesa->buffer;
+    }
 
-#ifndef FX
-   return dmesa->buffer;
-#else
-   return (DMesaBuffer)fxMesaGetCurrentContext();
-#endif
+    return NULL;
 }
 
 
@@ -1355,61 +332,28 @@ DMesaGetProcAddress (const char *name)
 int
 DMesaGetIntegerv (GLenum pname, GLint *params)
 {
-   switch (pname) {
-      case DMESA_GET_SCREEN_SIZE:
-         #ifndef FX
-         vl_get(VL_GET_SCREEN_SIZE, params);
-         #else
-         fxGetScreenGeometry(&params[0], &params[1]);
-         #endif
-         break;
-      case DMESA_GET_DRIVER_CAPS:
-         #ifndef FX
-         params[0] = DMESA_DRIVER_SWDB_BIT;
-         #else
-         params[0] = DMESA_DRIVER_LLWO_BIT;
-         #endif
-         break;
-      case DMESA_GET_VIDEO_MODES:
-         #ifndef FX
-         return vl_get(VL_GET_VIDEO_MODES, params);
-         #else
-         return -1; /* TODO */
-         #endif
-      case DMESA_GET_BUFFER_ADDR: {
-         #ifndef FX
-         DMesaContext c = (DMesaContext)DMesaGetCurrentContext();
-         if (c != NULL) {
-            DMesaBuffer b = c->buffer;
-            if (b != NULL) {
-               params[0] = (GLint)b->the_window;
-            }
-         }
-         break;
-         #else
-         return -1;
-         #endif
-      }
-      default:
-         return -1;
-   }
-
-   return 0;
+    switch (pname) {
+	case DMESA_GET_SCREEN_SIZE:
+	    vl_get(VL_GET_SCREEN_SIZE, params);
+	    break;
+	case DMESA_GET_DRIVER_CAPS:
+	    params[0] = 0;
+	    break;
+	case DMESA_GET_VIDEO_MODES:
+	    return vl_get(VL_GET_VIDEO_MODES, params);
+	case DMESA_GET_BUFFER_ADDR: {
+	    const DMesaContext dmesa = DMesaGetCurrentContext();
+	    if (dmesa != NULL) {
+		DMesaBuffer b = dmesa->buffer;
+		if (b != NULL) {
+		    params[0] = (GLint)b->the_window;
+		}
+	    }
+	    break;
+	}
+	default:
+	    return -1;
+    }
+
+    return 0;
 }
-
-
-#if SWTC && (((__DJGPP__ << 8) | __DJGPP_MINOR__) >= 0x204)
-#include <sys/dxe.h>
-
-extern_asm(___dj_assert);
-extern_asm(_free);
-extern_asm(_malloc);
-extern_asm(_memset);
-
-DXE_EXPORT_TABLE_AUTO (___dxe_eta___dxtn)
-   DXE_EXPORT_ASM (___dj_assert)
-   DXE_EXPORT_ASM (_free)
-   DXE_EXPORT_ASM (_malloc)
-   DXE_EXPORT_ASM (_memset)
-DXE_EXPORT_END
-#endif
diff --git a/src/mesa/drivers/dos/dpmi.c b/src/mesa/drivers/dos/dpmi.c
index b2cef04ac8..bd33b8856c 100644
--- a/src/mesa/drivers/dos/dpmi.c
+++ b/src/mesa/drivers/dos/dpmi.c
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.5 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@yahoo.com
  *  Web   : http://www.geocities.com/dborca
  */
diff --git a/src/mesa/drivers/dos/internal.h b/src/mesa/drivers/dos/internal.h
index 85b94d3773..0fa7c77222 100644
--- a/src/mesa/drivers/dos/internal.h
+++ b/src/mesa/drivers/dos/internal.h
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.6 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  */
@@ -54,6 +54,8 @@ typedef unsigned long word32;
 #define _16_ *(word16 *)&
 #define _32_ *(word32 *)&
 
+typedef void (*BLTFUNC) (void);
+
 
 /*
  * video mode structure
@@ -75,7 +77,7 @@ typedef struct vl_mode {
  */
 typedef struct {
    vl_mode *(*init) (void);
-   int (*entermode) (vl_mode *p, int refresh);
+   int (*entermode) (vl_mode *p, int refresh, int fbbits);
    void (*blit) (void);
    void (*setCI_f) (int index, float red, float green, float blue);
    void (*setCI_i) (int index, int red, int green, int blue);
@@ -100,32 +102,4 @@ void _remove_selector (int *segment);
 int _can_mmx (void);
 
 
-/*
- * asm routines to deal with virtual buffering
- */
-extern void v_clear8 (int color);
-#define v_clear15 v_clear16
-extern void v_clear16 (int color);
-extern void v_clear24 (int color);
-extern void v_clear32 (int color);
-
-extern void v_clear8_mmx (int color);
-#define v_clear15_mmx v_clear16_mmx
-extern void v_clear16_mmx (int color);
-extern void v_clear24_mmx (int color);
-extern void v_clear32_mmx (int color);
-
-extern void v_rect8 (int x, int y, int width, int height, int color);
-#define v_rect15 v_rect16
-extern void v_rect16 (int x, int y, int width, int height, int color);
-extern void v_rect24 (int x, int y, int width, int height, int color);
-extern void v_rect32 (int x, int y, int width, int height, int color);
-
-extern void v_putpixel8 (unsigned int offset, int color);
-#define v_putpixel15 v_putpixel16
-extern void v_putpixel16 (unsigned int offset, int color);
-extern void v_putpixel24 (unsigned int offset, int color);
-extern void v_putpixel32 (unsigned int offset, int color);
-
-
 #endif
diff --git a/src/mesa/drivers/dos/null.c b/src/mesa/drivers/dos/null.c
index 369255a422..55846299fb 100644
--- a/src/mesa/drivers/dos/null.c
+++ b/src/mesa/drivers/dos/null.c
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.7 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  */
@@ -137,13 +137,13 @@ null_fini (void)
  * Note: -
  */
 static int
-null_entermode (vl_mode *p, int refresh)
+null_entermode (vl_mode *p, int refresh, int fbbits)
 {
    NUL.blit = null_blit_nop;
 
    return 0;
 
-   (void)(p && refresh); /* silence compiler warning */
+   (void)(p && refresh && fbbits); /* silence compiler warning */
 }
 
 
diff --git a/src/mesa/drivers/dos/null.h b/src/mesa/drivers/dos/null.h
index a38accc857..bbdc7966e0 100644
--- a/src/mesa/drivers/dos/null.h
+++ b/src/mesa/drivers/dos/null.h
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.6 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@yahoo.com
  *  Web   : http://www.geocities.com/dborca
  */
diff --git a/src/mesa/drivers/dos/vesa.c b/src/mesa/drivers/dos/vesa.c
index cd48a24bfb..3fdd3e25db 100644
--- a/src/mesa/drivers/dos/vesa.c
+++ b/src/mesa/drivers/dos/vesa.c
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.6 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  */
@@ -86,16 +86,16 @@ unsigned int vesa_gran_mask, vesa_gran_shift;
  * VESA 3.0 CRTC timings structure
  */
 typedef struct CRTCInfoBlock {
-   unsigned short HorizontalTotal;
-   unsigned short HorizontalSyncStart;
-   unsigned short HorizontalSyncEnd;
-   unsigned short VerticalTotal;
-   unsigned short VerticalSyncStart;
-   unsigned short VerticalSyncEnd;
-   unsigned char  Flags;
-   unsigned long  PixelClock;         /* units of Hz */
-   unsigned short RefreshRate;        /* units of 0.01 Hz */
-   unsigned char  reserved[40];
+    unsigned short HorizontalTotal;
+    unsigned short HorizontalSyncStart;
+    unsigned short HorizontalSyncEnd;
+    unsigned short VerticalTotal;
+    unsigned short VerticalSyncStart;
+    unsigned short VerticalSyncEnd;
+    unsigned char  Flags;
+    unsigned long  PixelClock;	/* units of Hz */
+    unsigned short RefreshRate;	/* units of 0.01 Hz */
+    unsigned char  reserved[40];
 } __PACKED__ CRTCInfoBlock;
 
 #define HNEG         (1 << 2)
@@ -113,116 +113,122 @@ typedef struct CRTCInfoBlock {
 static vl_mode *
 vesa_init (void)
 {
-   __dpmi_regs r;
-   word16 *p;
-   vl_mode *q;
-   char vesa_info[512], tmp[512];
-   int maxsize = 0;
-   word32 linearfb = 0;
-
-   if (vesa_ver) {
-      return modes;
-   }
-
-   _farpokel(_stubinfo->ds_selector, 0, 0x32454256);
-   r.x.ax = 0x4f00;
-   r.x.di = 0;
-   r.x.es = _stubinfo->ds_segment;
-   __dpmi_int(0x10, &r);
-   movedata(_stubinfo->ds_selector, 0, _my_ds(), (unsigned)vesa_info, 512);
-   if ((r.x.ax != 0x004f) || ((_32_ vesa_info[V_SIGN]) != 0x41534556)) {
-      return NULL;
-   }
-
-   p = (word16 *)(((_16_ vesa_info[V_MODE_SEG])<<4) + (_16_ vesa_info[V_MODE_OFS]));
-   q = modes;
-   do {
-      if ((q->mode=_farpeekw(__djgpp_dos_sel, (unsigned long)(p++))) == 0xffff) {
-         break;
-      }
-
-      r.x.ax = 0x4f01;
-      r.x.cx = q->mode;
-      r.x.di = 512;
-      r.x.es = _stubinfo->ds_segment;
-      __dpmi_int(0x10, &r);
-      movedata(_stubinfo->ds_selector, 512, _my_ds(), (unsigned)tmp, 256);
-      switch (tmp[M_BPP]) {
-         case 16:
-            q->bpp = tmp[M_RED] + tmp[M_GREEN] + tmp[M_BLUE];
-            break;
-         case 8:
-         case 15:
-         case 24:
-         case 32:
-            q->bpp = tmp[M_BPP];
-            break;
-         default:
-            q->bpp = 0;
-      }
-      if ((r.x.ax == 0x004f) && ((tmp[M_ATTR] & 0x11) == 0x11) && q->bpp) {
-         q->xres = _16_ tmp[M_XRES];
-         q->yres = _16_ tmp[M_YRES];
-         q->scanlen = _16_ tmp[M_SCANLEN];
-         q->gran = (_16_ tmp[M_GRAN])<<10;
-         if (tmp[M_ATTR] & 0x80) {
-            vl_mode *q1 = q + 1;
-            *q1 = *q++;
-            linearfb = _32_ tmp[M_PHYS_PTR];
-            q->mode |= 0x4000;
-         }
-         if (maxsize < (q->scanlen * q->yres)) {
-            maxsize = q->scanlen * q->yres;
-         }
-         q++;
-      }
-   } while (TRUE);
-
-   if (q == modes) {
-      return NULL;
-   }
-   if (linearfb) {
-      maxsize = (maxsize + 0xfffUL) & ~0xfffUL;
-      if (_create_selector(&linear_selector, linearfb, maxsize)) {
-         return NULL;
-      }
-   }
-   if (_create_selector(&banked_selector, 0xa0000, modes[0].gran)) {
-      _remove_selector(&linear_selector);
-      return NULL;
-   }
-
-   for (q = modes; q->mode != 0xffff; q++) {
-       q->sel = (q->mode & 0x4000) ? linear_selector : banked_selector;
-   }
-
-   if (vesa_info[V_MAJOR] >= 2) {
-      r.x.ax = 0x4f0a;
-      r.x.bx = 0;
-      __dpmi_int(0x10, &r);
-      if (r.x.ax == 0x004f) {
-         vesa_pmcode = (word16 *)malloc(r.x.cx);
-         if (vesa_pmcode != NULL) {
-            movedata(__djgpp_dos_sel, (r.x.es << 4) + r.x.di, _my_ds(), (unsigned)vesa_pmcode, r.x.cx);
-            if (vesa_pmcode[3]) {
-               p = (word16 *)((long)vesa_pmcode + vesa_pmcode[3]);
-               while (*p++ != 0xffff) {
-               }
-            } else {
-               p = NULL;
-            }
-            if (p && (*p != 0xffff)) {
-               free(vesa_pmcode);
-               vesa_pmcode = NULL;
-            } else {
-               vesa_swbank = (void *)((long)vesa_pmcode + vesa_pmcode[0]);
-            }
-         }
-      }
-   }
-
-   vesa_ver = _16_ vesa_info[V_MINOR];
-   return modes;
+    __dpmi_regs r;
+    word16 *p;
+    vl_mode *q;
+    char vesa_info[512], tmp[512];
+    int maxsize = 0;
+    word32 linearfb = 0;
+
+    if (vesa_ver) {
+	return modes;
+    }
+
+    _farpokel(_stubinfo->ds_selector, 0, 0x32454256);
+    r.x.ax = 0x4f00;
+    r.x.di = 0;
+    r.x.es = _stubinfo->ds_segment;
+    __dpmi_int(0x10, &r);
+    movedata(_stubinfo->ds_selector, 0, _my_ds(), (unsigned)vesa_info, 512);
+    if ((r.x.ax != 0x004f) || ((_32_ vesa_info[V_SIGN]) != 0x41534556)) {
+	return NULL;
+    }
+
+    p = (word16 *)(((_16_ vesa_info[V_MODE_SEG]) << 4) + (_16_ vesa_info[V_MODE_OFS]));
+    q = modes;
+    do {
+	if ((q->mode = _farpeekw(__djgpp_dos_sel, (unsigned long)(p++))) == 0xffff) {
+	    break;
+	}
+
+	r.x.ax = 0x4f01;
+	r.x.cx = q->mode;
+	r.x.di = 512;
+	r.x.es = _stubinfo->ds_segment;
+	__dpmi_int(0x10, &r);
+	movedata(_stubinfo->ds_selector, 512, _my_ds(), (unsigned)tmp, 256);
+	switch (tmp[M_BPP]) {
+	    case 16:
+		q->bpp = tmp[M_RED] + tmp[M_GREEN] + tmp[M_BLUE];
+		break;
+	    case 8:
+	    case 15:
+	    case 24:
+	    case 32:
+		q->bpp = tmp[M_BPP];
+		break;
+	    default:
+		q->bpp = 0;
+	}
+	if ((r.x.ax == 0x004f) && ((tmp[M_ATTR] & 0x11) == 0x11) && q->bpp) {
+	    q->xres = _16_ tmp[M_XRES];
+	    q->yres = _16_ tmp[M_YRES];
+	    q->scanlen = _16_ tmp[M_SCANLEN];
+	    q->gran = (_16_ tmp[M_GRAN]) << 10;
+	    if (tmp[M_ATTR] & 0x80) {
+		vl_mode *q1 = q + 1;
+		*q1 = *q++;
+		linearfb = _32_ tmp[M_PHYS_PTR];
+		q->mode |= 0x4000;
+	    }
+	    if (maxsize < (q->scanlen * q->yres)) {
+		maxsize = q->scanlen * q->yres;
+	    }
+	    q++;
+	}
+    } while (TRUE);
+
+    if (q == modes) {
+	return NULL;
+    }
+    if (_create_selector(&banked_selector, 0xa0000, modes[0].gran)) {
+	return NULL;
+    }
+    if (linearfb) {
+	maxsize = ((maxsize + 0xfffUL) & ~0xfffUL);
+	if (_create_selector(&linear_selector, linearfb, maxsize)) {
+	    linear_selector = banked_selector;
+	}
+    }
+
+    for (q = modes; q->mode != 0xffff; q++) {
+	q->sel = banked_selector;
+	if (q->mode & 0x4000) {
+	    if (linear_selector != banked_selector) {
+		q->sel = linear_selector;
+	    } else {
+		q->mode &= ~0x4000;
+	    }
+	}
+    }
+
+    if (vesa_info[V_MAJOR] >= 2) {
+	r.x.ax = 0x4f0a;
+	r.x.bx = 0;
+	__dpmi_int(0x10, &r);
+	if (r.x.ax == 0x004f) {
+	    vesa_pmcode = (word16 *)malloc(r.x.cx);
+	    if (vesa_pmcode != NULL) {
+		movedata(__djgpp_dos_sel, (r.x.es << 4) + r.x.di, _my_ds(), (unsigned)vesa_pmcode, r.x.cx);
+		if (vesa_pmcode[3]) {
+		    p = (word16 *)((long)vesa_pmcode + vesa_pmcode[3]);
+		    while (*p++ != 0xffff) {
+		    }
+		} else {
+		    p = NULL;
+		}
+		if (p && (*p != 0xffff)) {
+		    free(vesa_pmcode);
+		    vesa_pmcode = NULL;
+		} else {
+		    vesa_swbank = (void *)((long)vesa_pmcode + vesa_pmcode[0]);
+		}
+	    }
+	}
+    }
+
+    vesa_ver = _16_ vesa_info[V_MINOR];
+    return modes;
 }
 
 
@@ -236,14 +242,14 @@ vesa_init (void)
 static void
 vesa_fini (void)
 {
-   if (vesa_ver) {
-      _remove_selector(&linear_selector);
-      _remove_selector(&banked_selector);
-      if (vesa_pmcode != NULL) {
-         free(vesa_pmcode);
-         vesa_pmcode = NULL;
-      }
-   }
+    if (vesa_ver) {
+	_remove_selector(&linear_selector);
+	_remove_selector(&banked_selector);
+	if (vesa_pmcode != NULL) {
+	    free(vesa_pmcode);
+	    vesa_pmcode = NULL;
+	}
+    }
 }
 
 
@@ -257,15 +263,15 @@ vesa_fini (void)
 static unsigned long
 _closest_pixclk (int mode_no, unsigned long vclk)
 {
-   __dpmi_regs r;
+    __dpmi_regs r;
 
-   r.x.ax = 0x4F0B;
-   r.h.bl = 0;
-   r.d.ecx = vclk;
-   r.x.dx = mode_no;
-   __dpmi_int(0x10, &r);
+    r.x.ax = 0x4F0B;
+    r.h.bl = 0;
+    r.d.ecx = vclk;
+    r.x.dx = mode_no;
+    __dpmi_int(0x10, &r);
 
-   return (r.x.ax == 0x004f) ? r.d.ecx : 0;
+    return (r.x.ax == 0x004f) ? r.d.ecx : 0;
 }
 
 
@@ -279,77 +285,253 @@ _closest_pixclk (int mode_no, unsigned long vclk)
 static void
 _crtc_timing (CRTCInfoBlock *crtc, int xres, int yres, int xadjust, int yadjust)
 {
-   int HTotal, VTotal;
-   int HDisp, VDisp;
-   int HSS, VSS;
-   int HSE, VSE;
-   int HSWidth, VSWidth;
-   int SS, SE;
-   int doublescan = FALSE;
-
-   if (yres < 400) {
-      doublescan = TRUE;
-      yres *= 2;
-   }
-
-   HDisp = xres;
-   HTotal = (int)(HDisp * 1.27) & ~0x7;
-   HSWidth = (int)((HTotal - HDisp) / 5) & ~0x7;
-   HSS = HDisp + 16;
-   HSE = HSS + HSWidth;
-   VDisp = yres;
-   VTotal = VDisp * 1.07;
-   VSWidth = (VTotal / 100) + 1;
-   VSS = VDisp + ((int)(VTotal - VDisp) / 5) + 1;
-   VSE = VSS + VSWidth;
-
-   SS = HSS + xadjust;
-   SE = HSE + xadjust;
-
-   if (xadjust < 0) {
-      if (SS < (HDisp + 8)) {
-         SS = HDisp + 8;
-         SE = SS + HSWidth;
-      }
-   } else {
-      if ((HTotal - 24) < SE) {
-         SE = HTotal - 24;
-         SS = SE - HSWidth;
-      }
-   }
-
-   HSS = SS;
-   HSE = SE;
-
-   SS = VSS + yadjust;
-   SE = VSE + yadjust;
-
-   if (yadjust < 0) {
-      if (SS < (VDisp + 3)) {
-         SS = VDisp + 3;
-         SE = SS + VSWidth;
-      }
-   } else {
-      if ((VTotal - 4) < SE) {
-         SE = VTotal - 4;
-         SS = SE - VSWidth;
-      }
-   }
-
-   VSS = SS;
-   VSE = SE;
-
-   crtc->HorizontalTotal     = HTotal;
-   crtc->HorizontalSyncStart = HSS;
-   crtc->HorizontalSyncEnd   = HSE;
-   crtc->VerticalTotal       = VTotal;
-   crtc->VerticalSyncStart   = VSS;
-   crtc->VerticalSyncEnd     = VSE;
-   crtc->Flags               = HNEG | VNEG;
-
-   if (doublescan) {
-      crtc->Flags |= DOUBLESCAN;
-   }
+    int HTotal, VTotal;
+    int HDisp, VDisp;
+    int HSS, VSS;
+    int HSE, VSE;
+    int HSWidth, VSWidth;
+    int SS, SE;
+    int doublescan = FALSE;
+
+    if (yres < 400) {
+	doublescan = TRUE;
+	yres *= 2;
+    }
+
+    HDisp = xres;
+    HTotal = (int)(HDisp * 1.27) & ~0x7;
+    HSWidth = (int)((HTotal - HDisp) / 5) & ~0x7;
+    HSS = HDisp + 16;
+    HSE = HSS + HSWidth;
+    VDisp = yres;
+    VTotal = VDisp * 1.07;
+    VSWidth = (VTotal / 100) + 1;
+    VSS = VDisp + ((int)(VTotal - VDisp) / 5) + 1;
+    VSE = VSS + VSWidth;
+
+    SS = HSS + xadjust;
+    SE = HSE + xadjust;
+
+    if (xadjust < 0) {
+	if (SS < (HDisp + 8)) {
+	    SS = HDisp + 8;
+	    SE = SS + HSWidth;
+	}
+    } else {
+	if ((HTotal - 24) < SE) {
+	    SE = HTotal - 24;
+	    SS = SE - HSWidth;
+	}
+    }
+
+    HSS = SS;
+    HSE = SE;
+
+    SS = VSS + yadjust;
+    SE = VSE + yadjust;
+
+    if (yadjust < 0) {
+	if (SS < (VDisp + 3)) {
+	    SS = VDisp + 3;
+	    SE = SS + VSWidth;
+	}
+    } else {
+	if ((VTotal - 4) < SE) {
+	    SE = VTotal - 4;
+	    SS = SE - VSWidth;
+	}
+    }
+
+    VSS = SS;
+    VSE = SE;
+
+    crtc->HorizontalTotal     = HTotal;
+    crtc->HorizontalSyncStart = HSS;
+    crtc->HorizontalSyncEnd   = HSE;
+    crtc->VerticalTotal       = VTotal;
+    crtc->VerticalSyncStart   = VSS;
+    crtc->VerticalSyncEnd     = VSE;
+    crtc->Flags               = HNEG | VNEG;
+
+    if (doublescan) {
+	crtc->Flags |= DOUBLESCAN;
+    }
+}
+
+
+/* Desc: Attempts to choose a suitable blitter.
+ *
+ * In  : ptr to mode structure, software framebuffer bits
+ * Out : blitter funciton, or NULL
+ *
+ * Note: -
+ */
+static BLTFUNC
+_choose_blitter (vl_mode *p, int fbbits)
+{
+    BLTFUNC blitter;
+
+    if (p->mode & 0x4000) {
+	blitter = _can_mmx() ? vesa_l_dump_virtual_mmx : vesa_l_dump_virtual;
+	    switch (p->bpp) {
+		case 8:
+		    switch (fbbits) {
+			case 8:
+			    break;
+			case 16:
+			    blitter = vesa_l_dump_16_to_8;
+			    break;
+			case 24:
+			    blitter = vesa_l_dump_24_to_8;
+			    break;
+			case 32:
+			    blitter = vesa_l_dump_32_to_8;
+			    break;
+			case 15:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 15:
+		    switch (fbbits) {
+			case 16:
+			    blitter = vesa_l_dump_16_to_15;
+			    break;
+			case 32:
+			    blitter = vesa_l_dump_32_to_15;
+			    break;
+			case 8:
+			case 15:
+			case 24:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 16:
+		    switch (fbbits) {
+			case 16:
+			    break;
+			case 32:
+			    blitter = vesa_l_dump_32_to_16;
+			    break;
+			case 8:
+			case 15:
+			case 24:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 24:
+		    switch (fbbits) {
+			case 24:
+			    break;
+			case 32:
+			    blitter = vesa_l_dump_32_to_24;
+			    break;
+			case 8:
+			case 15:
+			case 16:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 32:
+		    switch (fbbits) {
+			case 24:
+			    blitter = vesa_l_dump_24_to_32;
+			    break;
+			case 32:
+			    break;
+			case 8:
+			case 15:
+			case 16:
+			default:
+			    return NULL;
+		    }
+		    break;
+	    }
+    } else {
+	blitter = vesa_b_dump_virtual;
+	    switch (p->bpp) {
+		case 8:
+		    switch (fbbits) {
+			case 8:
+			    break;
+			case 16:
+			    blitter = vesa_b_dump_16_to_8;
+			    break;
+			case 24:
+			    blitter = vesa_b_dump_24_to_8;
+			    break;
+			case 32:
+			    blitter = vesa_b_dump_32_to_8;
+			    break;
+			case 15:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 15:
+		    switch (fbbits) {
+			case 16:
+			    blitter = vesa_b_dump_16_to_15;
+			    break;
+			case 32:
+			    blitter = vesa_b_dump_32_to_15;
+			    break;
+			case 8:
+			case 15:
+			case 24:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 16:
+		    switch (fbbits) {
+			case 16:
+			    break;
+			case 32:
+			    blitter = vesa_b_dump_32_to_16;
+			    break;
+			case 8:
+			case 15:
+			case 24:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 24:
+		    switch (fbbits) {
+			case 24:
+			    break;
+			case 32:
+			    blitter = vesa_b_dump_32_to_24;
+			    break;
+			case 8:
+			case 15:
+			case 16:
+			default:
+			    return NULL;
+		    }
+		    break;
+		case 32:
+		    switch (fbbits) {
+			case 24:
+			    blitter = vesa_b_dump_24_to_32;
+			    break;
+			case 32:
+			    break;
+			case 8:
+			case 15:
+			case 16:
+			default:
+			    return NULL;
+		    }
+		    break;
+	    }
+    }
+
+    return blitter;
 }
 
 
@@ -361,74 +543,76 @@ _crtc_timing (CRTCInfoBlock *crtc, int xres, int yres, int xadjust, int yadjust)
  * Note: -
  */
 static int
-vesa_entermode (vl_mode *p, int refresh)
+vesa_entermode (vl_mode *p, int refresh, int fbbits)
 {
-   __dpmi_regs r;
-
-   if (p->mode & 0x4000) {
-      VESA.blit = _can_mmx() ? vesa_l_dump_virtual_mmx : vesa_l_dump_virtual;
-   } else {
-      VESA.blit = vesa_b_dump_virtual;
-      { int n; for (vesa_gran_shift=0, n=p->gran; n; vesa_gran_shift++, n>>=1) ; }
-      vesa_gran_mask = (1 << (--vesa_gran_shift)) - 1;
-      if ((unsigned)p->gran != (vesa_gran_mask+1)) {
-         return !0;
-      }
-   }
-
-   if (oldmode == -1) {
-      r.x.ax = 0x4f03;
-      __dpmi_int(0x10, &r);
-      oldmode = r.x.bx;
-   }
-
-   r.x.ax = 0x4f02;
-   r.x.bx = p->mode;
-
-   if (refresh && ((vesa_ver>>8) >= 3)) {
-      /* VESA 3.0 stuff for controlling the refresh rate */
-      CRTCInfoBlock crtc;
-      unsigned long vclk;
-      double f0;
-
-      _crtc_timing(&crtc, p->xres, p->yres, 0, 0);
-
-      vclk = (double)crtc.HorizontalTotal * crtc.VerticalTotal * refresh;
-      vclk = _closest_pixclk(p->mode, vclk);
-
-      if (vclk != 0) {
-         f0 = (double)vclk / (crtc.HorizontalTotal * crtc.VerticalTotal);
-         /*_current_refresh_rate = (int)(f0 + 0.5);*/
-
-         crtc.PixelClock  = vclk;
-         crtc.RefreshRate = refresh * 100;
-
-         movedata(_my_ds(), (unsigned)&crtc, _stubinfo->ds_selector, 0, sizeof(crtc));
-
-         r.x.di = 0;
-         r.x.es = _stubinfo->ds_segment;
-         r.x.bx |= 0x0800;
-      }
-   }
-
-   __dpmi_int(0x10, &r);
-   if (r.x.ax != 0x004f) {
-      return !0;
-   }
-
-   if (p->bpp == 8) {
-      r.x.ax = 0x4f08;
-      r.x.bx = 0x0800;
-      __dpmi_int(0x10, &r);
-      if (r.x.ax == 0x004f) {
-         r.x.ax = 0x4f08;
-         r.h.bl = 0x01;
-         __dpmi_int(0x10, &r);
-         vesa_color_precision = r.h.bh;
-      }
-   }
-
-   return 0;
+    __dpmi_regs r;
+
+    if (!(p->mode & 0x4000)) {
+	{ int n; for (vesa_gran_shift = 0, n = p->gran; n; vesa_gran_shift++, n >>= 1); }
+	vesa_gran_mask = (1 << (--vesa_gran_shift)) - 1;
+	if ((unsigned)p->gran != (vesa_gran_mask + 1)) {
+	    return !0;
+	}
+    }
+
+    VESA.blit = _choose_blitter(p, fbbits);
+    if (VESA.blit == NULL) {
+	return !0;
+    }
+
+    if (oldmode == -1) {
+	r.x.ax = 0x4f03;
+	__dpmi_int(0x10, &r);
+	oldmode = r.x.bx;
+    }
+
+    r.x.ax = 0x4f02;
+    r.x.bx = p->mode;
+
+    if (refresh && ((vesa_ver >> 8) >= 3)) {
+	/* VESA 3.0 stuff for controlling the refresh rate */
+	CRTCInfoBlock crtc;
+	unsigned long vclk;
+	double f0;
+
+	_crtc_timing(&crtc, p->xres, p->yres, 0, 0);
+
+	vclk = (double)crtc.HorizontalTotal * crtc.VerticalTotal * refresh;
+	vclk = _closest_pixclk(p->mode, vclk);
+
+	if (vclk != 0) {
+	    f0 = (double)vclk / (crtc.HorizontalTotal * crtc.VerticalTotal);
+	    /*_current_refresh_rate = (int)(f0 + 0.5);*/
+
+	    crtc.PixelClock  = vclk;
+	    crtc.RefreshRate = refresh * 100;
+
+	    movedata(_my_ds(), (unsigned)&crtc, _stubinfo->ds_selector, 0, sizeof(crtc));
+
+	    r.x.di = 0;
+	    r.x.es = _stubinfo->ds_segment;
+	    r.x.bx |= 0x0800;
+	}
+    }
+
+    __dpmi_int(0x10, &r);
+    if (r.x.ax != 0x004f) {
+	return !0;
+    }
+
+    if (p->bpp == 8) {
+	r.x.ax = 0x4f08;
+	r.x.bx = 0x0800;
+	__dpmi_int(0x10, &r);
+	if (r.x.ax == 0x004f) {
+	    r.x.ax = 0x4f08;
+	    r.h.bl = 0x01;
+	    __dpmi_int(0x10, &r);
+	    vesa_color_precision = r.h.bh;
+	}
+    }
+
+    return 0;
 }
 
 
@@ -442,14 +626,18 @@ vesa_entermode (vl_mode *p, int refresh)
 static void
 vesa_restore (void)
 {
-   __dpmi_regs r;
-
-   if (oldmode != -1) {
-      r.x.ax = 0x4f02;
-      r.x.bx = oldmode;
-      __dpmi_int(0x10, &r);
-      oldmode = -1;
-   }
+    __dpmi_regs r;
+
+    if (oldmode != -1) {
+	if (oldmode < 0x100) {
+	    __asm("int $0x10"::"a"(oldmode));
+	} else {
+	    r.x.ax = 0x4f02;
+	    r.x.bx = oldmode;
+	    __dpmi_int(0x10, &r);
+	}
+	oldmode = -1;
+    }
 }
 
 
@@ -464,17 +652,17 @@ static void
 vesa_setCI_i (int index, int red, int green, int blue)
 {
 #if 0
-   __asm("\n\
+  __asm("\n\
 		movw	$0x1010, %%ax	\n\
 		movb	%1, %%dh	\n\
 		movb	%2, %%ch	\n\
 		int	$0x10		\n\
    "::"b"(index), "m"(red), "m"(green), "c"(blue):"%eax", "%edx");
 #else
-   outportb(0x03C8, index);
-   outportb(0x03C9, red);
-   outportb(0x03C9, green);
-   outportb(0x03C9, blue);
+    outportb(0x03C8, index);
+    outportb(0x03C9, red);
+    outportb(0x03C9, green);
+    outportb(0x03C9, blue);
 #endif
 }
 
@@ -489,9 +677,9 @@ vesa_setCI_i (int index, int red, int green, int blue)
 static void
 vesa_setCI_f (int index, float red, float green, float blue)
 {
- float max = (1 << vesa_color_precision) - 1;
+    float max = (1 << vesa_color_precision) - 1;
 
- vesa_setCI_i(index, (int)(red * max), (int)(green * max), (int)(blue * max));
+    vesa_setCI_i(index, (int)(red * max), (int)(green * max), (int)(blue * max));
 }
 
 
@@ -505,14 +693,14 @@ vesa_setCI_f (int index, float red, float green, float blue)
 static int
 vesa_get (int pname, int *params)
 {
-   switch (pname) {
-      case VL_GET_CI_PREC:
-         params[0] = vesa_color_precision;
-         break;
-      default:
-         return -1;
-   }
-   return 0;
+    switch (pname) {
+	case VL_GET_CI_PREC:
+	    params[0] = vesa_color_precision;
+	    break;
+	default:
+	    return -1;
+    }
+    return 0;
 }
 
 
@@ -520,12 +708,12 @@ vesa_get (int pname, int *params)
  * the driver
  */
 vl_driver VESA = {
-   vesa_init,
-   vesa_entermode,
-   NULL,
-   vesa_setCI_f,
-   vesa_setCI_i,
-   vesa_get,
-   vesa_restore,
-   vesa_fini
+    vesa_init,
+    vesa_entermode,
+    NULL,
+    vesa_setCI_f,
+    vesa_setCI_i,
+    vesa_get,
+    vesa_restore,
+    vesa_fini
 };
diff --git a/src/mesa/drivers/dos/vesa.h b/src/mesa/drivers/dos/vesa.h
index 9287697c37..4b3c3ab832 100644
--- a/src/mesa/drivers/dos/vesa.h
+++ b/src/mesa/drivers/dos/vesa.h
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.3 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@yahoo.com
  *  Web   : http://www.geocities.com/dborca
  */
@@ -42,6 +42,24 @@ extern void vesa_b_dump_virtual (void);
 extern void vesa_l_dump_virtual (void);
 extern void vesa_l_dump_virtual_mmx (void);
 
+extern void vesa_l_dump_32_to_24 (void);
+extern void vesa_l_dump_32_to_16 (void);
+extern void vesa_l_dump_32_to_15 (void);
+extern void vesa_l_dump_32_to_8 (void);
+extern void vesa_l_dump_24_to_32 (void);
+extern void vesa_l_dump_24_to_8 (void);
+extern void vesa_l_dump_16_to_15 (void);
+extern void vesa_l_dump_16_to_8 (void);
+
+extern void vesa_b_dump_32_to_24 (void);
+extern void vesa_b_dump_32_to_16 (void);
+extern void vesa_b_dump_32_to_15 (void);
+extern void vesa_b_dump_32_to_8 (void);
+extern void vesa_b_dump_24_to_32 (void);
+extern void vesa_b_dump_24_to_8 (void);
+extern void vesa_b_dump_16_to_15 (void);
+extern void vesa_b_dump_16_to_8 (void);
+
 extern vl_driver VESA;
 
 #endif
diff --git a/src/mesa/drivers/dos/vga.c b/src/mesa/drivers/dos/vga.c
index 27758f14d2..5a6447dd87 100644
--- a/src/mesa/drivers/dos/vga.c
+++ b/src/mesa/drivers/dos/vga.c
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.7 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  */
@@ -123,6 +123,41 @@ vga_fini (void)
 }
 
 
+/* Desc: Attempts to choose a suitable blitter.
+ *
+ * In  : ptr to mode structure, software framebuffer bits
+ * Out : blitter funciton, or NULL
+ *
+ * Note: -
+ */
+static BLTFUNC
+_choose_blitter (vl_mode *p, int fbbits)
+{
+    BLTFUNC blitter;
+
+    switch (fbbits) {
+	case 8:
+	    blitter = _can_mmx() ? vesa_l_dump_virtual_mmx : vesa_l_dump_virtual;
+	    break;
+	case 16:
+	    blitter = vesa_l_dump_16_to_8;
+	    break;
+	case 24:
+	    blitter = vesa_l_dump_24_to_8;
+	    break;
+	case 32:
+	    blitter = vesa_l_dump_32_to_8;
+	    break;
+	default:
+	    return NULL;
+    }
+
+    return blitter;
+
+    (void)p;
+}
+
+
 /* Desc: Attempts to enter specified video mode.
  *
  * In  : ptr to mode structure, refresh rate
@@ -131,27 +166,31 @@ vga_fini (void)
  * Note: -
  */
 static int
-vga_entermode (vl_mode *p, int refresh)
+vga_entermode (vl_mode *p, int refresh, int fbbits)
 {
-   if (!(p->mode & 0x4000)) {
-      return -1;
-   }
-   VGA.blit = _can_mmx() ? vesa_l_dump_virtual_mmx : vesa_l_dump_virtual;
+    if (!(p->mode & 0x4000)) {
+	return -1;
+    }
 
-   if (oldmode == -1) {
-      __asm("\n\
+    VGA.blit = _choose_blitter(p, fbbits);
+    if (VGA.blit == NULL) {
+	return !0;
+    }
+
+    if (oldmode == -1) {
+	__asm("\n\
 		movb	$0x0f, %%ah	\n\
 		int	$0x10		\n\
 		andl	$0xff, %%eax	\n\
 		movl	%%eax, %0	\n\
-      ":"=g"(oldmode)::"%eax", "%ebx");
-   }
+	":"=g"(oldmode)::"%eax", "%ebx");
+    }
 
-   __asm("int $0x10"::"a"(p->mode&0xff));
+    __asm("int $0x10"::"a"(p->mode&0xff));
 
-   return 0;
+    return 0;
 
-   (void)refresh; /* silence compiler warning */
+    (void)refresh; /* silence compiler warning */
 }
 
 
diff --git a/src/mesa/drivers/dos/vga.h b/src/mesa/drivers/dos/vga.h
index aeb8faddae..7c17625a3c 100644
--- a/src/mesa/drivers/dos/vga.h
+++ b/src/mesa/drivers/dos/vga.h
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.3 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@yahoo.com
  *  Web   : http://www.geocities.com/dborca
  */
diff --git a/src/mesa/drivers/dos/video.c b/src/mesa/drivers/dos/video.c
index 60370afc8e..468207fbf6 100644
--- a/src/mesa/drivers/dos/video.c
+++ b/src/mesa/drivers/dos/video.c
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.6 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  *
@@ -53,17 +53,25 @@ int vl_current_stride, vl_current_width, vl_current_height, vl_current_bytes;
 int vl_current_offset, vl_current_delta;
 
 
-#if HUGE_LOOKUP
-/* These lookup tables are used to extract RGB values in [0,255]
- * from 15/16-bit pixel values.
- */
-static unsigned char pix15r[0x8000];
-static unsigned char pix15g[0x8000];
-static unsigned char pix15b[0x8000];
-static unsigned char pix16r[0x10000];
-static unsigned char pix16g[0x10000];
-static unsigned char pix16b[0x10000];
-#else
+void (*vl_flip) (void);
+
+
+/* FakeColor data */
+#define R_CNT 6
+#define G_CNT 6
+#define B_CNT 6
+
+#define R_BIAS 7
+#define G_BIAS 7
+#define B_BIAS 7
+
+static word32 VGAPalette[256];
+word8 array_r[256];
+word8 array_g[256];
+word8 array_b[256];
+word8 tab_16_8[0x10000];
+
+
 /* lookup table for scaling 5 bit colors up to 8 bits */
 static int _rgb_scale_5[32] = {
    0,   8,   16,  25,  33,  41,  49,  58,
@@ -71,7 +79,6 @@ static int _rgb_scale_5[32] = {
    132, 140, 148, 156, 165, 173, 181, 189,
    197, 206, 214, 222, 230, 239, 247, 255
 };
-#endif
 
 /* lookup table for scaling 6 bit colors up to 8 bits */
 static int _rgb_scale_6[64] = {
@@ -85,92 +92,6 @@ static int _rgb_scale_6[64] = {
    227, 231, 235, 239, 243, 247, 251, 255
 };
 
-/* FakeColor data */
-#define R_CNT 6
-#define G_CNT 6
-#define B_CNT 6
-
-#define R_BIAS 7
-#define G_BIAS 7
-#define B_BIAS 7
-
-static word32 VGAPalette[256];
-static word8 array_r[256];
-static word8 array_g[256];
-static word8 array_b[256];
-
-
-int (*vl_mixfix) (fixed r, fixed g, fixed b);
-int (*vl_mixrgb) (const unsigned char rgb[]);
-int (*vl_mixrgba) (const unsigned char rgba[]);
-void (*vl_getrgba) (unsigned int offset, unsigned char rgba[4]);
-int (*vl_getpixel) (unsigned int offset);
-void (*vl_clear) (int color);
-void (*vl_rect) (int x, int y, int width, int height, int color);
-void (*vl_flip) (void);
-void (*vl_putpixel) (unsigned int offset, int color);
-
-
-/* Desc: color composition (w/o ALPHA)
- *
- * In  : R, G, B
- * Out : color
- *
- * Note: -
- */
-static int
-vl_mixfix8fake (fixed r, fixed g, fixed b)
-{
-   return array_b[b>>FIXED_SHIFT]*G_CNT*R_CNT
-        + array_g[g>>FIXED_SHIFT]*R_CNT
-        + array_r[r>>FIXED_SHIFT];
-}
-#define vl_mixfix8 vl_mixfix8fake
-static int
-vl_mixfix15 (fixed r, fixed g, fixed b)
-{
-   return ((r>>(3+FIXED_SHIFT))<<10)
-         |((g>>(3+FIXED_SHIFT))<<5)
-         | (b>>(3+FIXED_SHIFT));
-}
-static int
-vl_mixfix16 (fixed r, fixed g, fixed b)
-{
-   return ((r>>(3+FIXED_SHIFT))<<11)
-         |((g>>(2+FIXED_SHIFT))<<5)
-         | (b>>(3+FIXED_SHIFT));
-}
-#define vl_mixfix24 vl_mixfix32
-static int
-vl_mixfix32 (fixed r, fixed g, fixed b)
-{
-   return ((r>>FIXED_SHIFT)<<16)
-         |((g>>FIXED_SHIFT)<<8)
-         | (b>>FIXED_SHIFT);
-}
-
-
-/* Desc: color composition (w/ ALPHA)
- *
- * In  : array of integers (R, G, B, A)
- * Out : color
- *
- * Note: -
- */
-#define vl_mixrgba8 vl_mixrgb8fake
-#define vl_mixrgba15 vl_mixrgb15
-#define vl_mixrgba16 vl_mixrgb16
-#define vl_mixrgba24 vl_mixrgb24
-static int
-vl_mixrgba32 (const unsigned char rgba[])
-{
-   /* Hack alert:
-    * currently, DMesa uses Mesa's alpha buffer;
-    * so we don't really care about alpha value here...
-    */
-   return /*(rgba[3]<<24) | */(rgba[0]<<16) | (rgba[1]<<8) | (rgba[2]);
-}
-
 
 /* Desc: color composition (w/o ALPHA)
  *
@@ -180,29 +101,12 @@ vl_mixrgba32 (const unsigned char rgba[])
  * Note: -
  */
 static int
-vl_mixrgb8fake (const unsigned char rgb[])
+v_mixrgb8fake (const unsigned char rgb[])
 {
    return array_b[rgb[2]]*G_CNT*R_CNT
         + array_g[rgb[1]]*R_CNT
         + array_r[rgb[0]];
 }
-#define vl_mixrgb8 vl_mixrgb8fake
-static int
-vl_mixrgb15 (const unsigned char rgb[])
-{
-   return ((rgb[0]>>3)<<10) | ((rgb[1]>>3)<<5) | (rgb[2]>>3);
-}
-static int
-vl_mixrgb16 (const unsigned char rgb[])
-{
-   return ((rgb[0]>>3)<<11) | ((rgb[1]>>2)<<5) | (rgb[2]>>3);
-}
-#define vl_mixrgb24 vl_mixrgb32
-static int
-vl_mixrgb32 (const unsigned char rgb[])
-{
-   return (rgb[0]<<16) | (rgb[1]<<8) | (rgb[2]);
-}
 
 
 /* Desc: color decomposition
@@ -213,102 +117,43 @@ vl_mixrgb32 (const unsigned char rgb[])
  * Note: uses current read buffer
  */
 static void
-v_getrgba8fake6 (unsigned int offset, unsigned char rgba[4])
+v_getrgb8fake6 (unsigned int offset, unsigned char rgb[])
 {
    word32 c = VGAPalette[((word8 *)vl_current_read_buffer)[offset]];
-   rgba[0] = _rgb_scale_6[(c >> 16) & 0x3F];
-   rgba[1] = _rgb_scale_6[(c >> 8)  & 0x3F];
-   rgba[2] = _rgb_scale_6[ c        & 0x3F];
-   /*rgba[3] = c >> 24;*/ /* dummy alpha; we have separate SW alpha, so ignore */
+   rgb[0] = _rgb_scale_6[(c >> 16) & 0x3F];
+   rgb[1] = _rgb_scale_6[(c >> 8)  & 0x3F];
+   rgb[2] = _rgb_scale_6[ c        & 0x3F];
 }
 static void
-v_getrgba8fake8 (unsigned int offset, unsigned char rgba[4])
+v_getrgb8fake8 (unsigned int offset, unsigned char rgb[])
 {
    word32 c = VGAPalette[((word8 *)vl_current_read_buffer)[offset]];
-   rgba[0] = c >> 16;
-   rgba[1] = c >> 8;
-   rgba[2] = c;
-   /*rgba[3] = c >> 24;*/ /* dummy alpha; we have separate SW alpha, so ignore */
-}
-#define v_getrgba8 v_getrgba8fake6
-static void
-v_getrgba15 (unsigned int offset, unsigned char rgba[4])
-{
-   word32 c = ((word16 *)vl_current_read_buffer)[offset];
-#if HUGE_LOOKUP
-   c &= 0x7fff;
-   rgba[0] = pix15r[c];
-   rgba[1] = pix15g[c];
-   rgba[2] = pix15b[c];
-#else
-   rgba[0] = _rgb_scale_5[(c >> 10) & 0x1F];
-   rgba[1] = _rgb_scale_5[(c >> 5)  & 0x1F];
-   rgba[2] = _rgb_scale_5[ c        & 0x1F];
-#endif
-   /*rgba[3] = 255;*/ /* dummy alpha; we have separate SW alpha, so ignore */
-}
-static void
-v_getrgba16 (unsigned int offset, unsigned char rgba[4])
-{
-   word32 c = ((word16 *)vl_current_read_buffer)[offset];
-#if HUGE_LOOKUP
-   rgba[0] = pix16r[c];
-   rgba[1] = pix16g[c];
-   rgba[2] = pix16b[c];
-#else
-   rgba[0] = _rgb_scale_5[(c >> 11) & 0x1F];
-   rgba[1] = _rgb_scale_6[(c >> 5)  & 0x3F];
-   rgba[2] = _rgb_scale_5[ c        & 0x1F];
-#endif
-   /*rgba[3] = 255;*/ /* dummy alpha; we have separate SW alpha, so ignore */
-}
-static void
-v_getrgba24 (unsigned int offset, unsigned char rgba[4])
-{
-   word32 c = *(word32 *)((long)vl_current_read_buffer+offset*3);
-   rgba[0] = c >> 16;
-   rgba[1] = c >> 8;
-   rgba[2] = c;
-   /*rgba[3] = 255;*/ /* dummy alpha; we have separate SW alpha, so ignore */
-}
-static void
-v_getrgba32 (unsigned int offset, unsigned char rgba[4])
-{
-   word32 c = ((word32 *)vl_current_read_buffer)[offset];
-   rgba[0] = c >> 16;
-   rgba[1] = c >> 8;
-   rgba[2] = c;
-   /*rgba[3] = c >> 24;*/ /* dummy alpha; we have separate SW alpha, so ignore */
+   rgb[0] = c >> 16;
+   rgb[1] = c >> 8;
+   rgb[2] = c;
 }
 
 
-/* Desc: pixel retrieval
+/* Desc: create R5G6B5 to FakeColor table lookup
  *
- * In  : pixel offset
- * Out : pixel value
+ * In  : -
+ * Out : -
  *
- * Note: uses current read buffer
+ * Note: -
  */
-static int
-v_getpixel8 (unsigned int offset)
-{
-   return ((word8 *)vl_current_read_buffer)[offset];
-}
-#define v_getpixel15 v_getpixel16
-static int
-v_getpixel16 (unsigned int offset)
-{
-   return ((word16 *)vl_current_read_buffer)[offset];
-}
-static int
-v_getpixel24 (unsigned int offset)
-{
-   return *(word32 *)((long)vl_current_read_buffer+offset*3);
-}
-static int
-v_getpixel32 (unsigned int offset)
+static void
+init_tab_16_8 (void)
 {
-   return ((word32 *)vl_current_read_buffer)[offset];
+    int i;
+    for (i = 0; i < 0x10000; i++) {
+	unsigned char rgb[3];
+	rgb[0] = _rgb_scale_5[(i >> 11) & 0x1F];
+	rgb[1] = _rgb_scale_6[(i >>  5) & 0x3F];
+	rgb[2] = _rgb_scale_5[ i        & 0x1F];
+	tab_16_8[i] = v_mixrgb8fake(rgb);
+    }
+    (void)v_getrgb8fake6;
+    (void)v_getrgb8fake8;
 }
 
 
@@ -379,54 +224,6 @@ fake_buildpalette (int bits)
 }
 
 
-#if HUGE_LOOKUP
-/* Desc: initialize lookup arrays
- *
- * In  : -
- * Out : -
- *
- * Note: -
- */
-void
-v_init_pixeltables (void)
-{
-   unsigned int pixel;
-
-   for (pixel = 0; pixel <= 0xffff; pixel++) {
-      unsigned int r, g, b;
-
-      if (pixel <= 0x7fff) {
-         /* 15bit */
-         r = (pixel & 0x7c00) >> 8;
-         g = (pixel & 0x03E0) >> 3;
-         b = (pixel & 0x001F) << 2;
-
-         r = (unsigned int)(((double)r * 255. / 0x7c) + 0.5);
-         g = (unsigned int)(((double)g * 255. / 0x7c) + 0.5);
-         b = (unsigned int)(((double)b * 255. / 0x7c) + 0.5);
-
-         pix15r[pixel] = r;
-         pix15g[pixel] = g;
-         pix15b[pixel] = b;
-      }
-
-      /* 16bit */
-      r = (pixel & 0xF800) >> 8;
-      g = (pixel & 0x07E0) >> 3;
-      b = (pixel & 0x001F) << 3;
-
-      r = (unsigned int)(((double)r * 255. / 0xF8) + 0.5);
-      g = (unsigned int)(((double)g * 255. / 0xFC) + 0.5);
-      b = (unsigned int)(((double)b * 255. / 0xF8) + 0.5);
-
-      pix16r[pixel] = r;
-      pix16g[pixel] = g;
-      pix16b[pixel] = b;
-   }
-}
-#endif
-
-
 /* Desc: initialize hardware
  *
  * In  : -
@@ -471,7 +268,7 @@ v_init_hw (void)
 int
 vl_sync_buffer (void **buffer, int x, int y, int width, int height)
 {
-   if ((width & 7) || (x < 0) || (y < 0) || (x+width > video_mode->xres) || (y+height > video_mode->yres)) {
+   if ((/*XXX*/width & 7) || (x < 0) || (y < 0) || (x+width > video_mode->xres) || (y+height > video_mode->yres)) {
       return -1;
    } else {
       void *newbuf = *buffer;
@@ -553,38 +350,21 @@ vl_setup_mode (vl_mode *p)
       return -1;
    }
 
-#define INITPTR(bpp) \
-   vl_putpixel = v_putpixel##bpp; \
-   vl_getrgba = v_getrgba##bpp;   \
-   vl_getpixel = v_getpixel##bpp; \
-   vl_rect = v_rect##bpp;         \
-   vl_mixfix = vl_mixfix##bpp;    \
-   vl_mixrgb = vl_mixrgb##bpp;    \
-   vl_mixrgba = vl_mixrgba##bpp;  \
-   vl_clear = _can_mmx() ? v_clear##bpp##_mmx : v_clear##bpp
-        
    switch (p->bpp) {
       case 8:
-         INITPTR(8);
          break;
       case 15:
-         INITPTR(15);
          break;
       case 16:
-         INITPTR(16);
          break;
       case 24:
-         INITPTR(24);
          break;
       case 32:
-         INITPTR(32);
          break;
       default:
          return -1;
    }
 
-#undef INITPTR
-
    video_mode = p;
    video_bypp = (p->bpp+7)/8;
    video_scanlen = p->scanlen;
@@ -618,7 +398,7 @@ vl_video_exit (void)
  * Note: -
  */
 int
-vl_video_init (int width, int height, int bpp, int rgb, int refresh)
+vl_video_init (int width, int height, int bpp, int rgb, int refresh, int fbbits)
 {
    int fake;
    vl_mode *p, *q;
@@ -630,11 +410,6 @@ vl_video_init (int width, int height, int bpp, int rgb, int refresh)
    } else if (bpp == 8) {
       fake = 1;
    }
-#if HUGE_LOOKUP
-   else if (bpp < 24) {
-      v_init_pixeltables();
-   }
-#endif
 
    /* initialize hardware */
    if ((q = v_init_hw()) == NULL) {
@@ -651,18 +426,16 @@ vl_video_init (int width, int height, int bpp, int rgb, int refresh)
       }
    }
 
-   /* setup and enter mode */
-   if ((vl_setup_mode(p) == 0) && (drv->entermode(p, refresh) == 0)) {
-      vl_flip = drv->blit;
-      if (fake) {
-         drv->get(VL_GET_CI_PREC, (int *)(&min));
-         fake_buildpalette(min);
-         if (min == 8) {
-            vl_getrgba = v_getrgba8fake8;
-         }
-      }
-      return bpp;
-   }
+    /* setup and enter mode */
+    if ((vl_setup_mode(p) == 0) && (drv->entermode(p, refresh, fbbits) == 0)) {
+	vl_flip = drv->blit;
+	if (fake) {
+	    drv->get(VL_GET_CI_PREC, (int *)(&min));
+	    fake_buildpalette(min);
+	    init_tab_16_8();
+	}
+	return bpp;
+    }
 
    /* abort */
    return 0;
diff --git a/src/mesa/drivers/dos/video.h b/src/mesa/drivers/dos/video.h
index e928f19c37..e084116742 100644
--- a/src/mesa/drivers/dos/video.h
+++ b/src/mesa/drivers/dos/video.h
@@ -23,9 +23,9 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.5 for Mesa
+ * DOS/DJGPP device driver for Mesa
  *
- *  Copyright (C) 2002 - Borca Daniel
+ *  Author: Daniel Borca
  *  Email : dborca@users.sourceforge.net
  *  Web   : http://www.geocities.com/dborca
  */
@@ -43,16 +43,7 @@ typedef int fixed;
 #define VL_GET_SCREEN_SIZE 0x0202
 #define VL_GET_VIDEO_MODES 0x0300
 
-extern int (*vl_mixfix) (fixed r, fixed g, fixed b);
-extern int (*vl_mixrgb) (const unsigned char rgb[]);
-extern int (*vl_mixrgba) (const unsigned char rgba[]);
-extern void (*vl_getrgba) (unsigned int offset, unsigned char rgba[4]);
-
-extern void (*vl_clear) (int color);
-extern void (*vl_rect) (int x, int y, int width, int height, int color);
 extern void (*vl_flip) (void);
-extern void (*vl_putpixel) (unsigned int offset, int color);
-extern int (*vl_getpixel) (unsigned int offset);
 
 void vl_setCI (int index, float red, float green, float blue);
 
@@ -60,6 +51,6 @@ int vl_sync_buffer (void **buffer, int x, int y, int width, int height);
 int vl_get (int pname, int *params);
 
 void vl_video_exit (void);
-int vl_video_init (int width, int height, int bpp, int rgb, int refresh);
+int vl_video_init (int width, int height, int bpp, int rgb, int refresh, int fbbits);
 
 #endif
diff --git a/src/mesa/drivers/dos/virtual.S b/src/mesa/drivers/dos/virtual.S
deleted file mode 100644
index c5cc1fe86f..0000000000
--- a/src/mesa/drivers/dos/virtual.S
+++ /dev/null
@@ -1,489 +0,0 @@
-/*
- * Mesa 3-D graphics library
- * Version:  4.0
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*
- * DOS/DJGPP device driver v1.3 for Mesa
- *
- *  Copyright (C) 2002 - Borca Daniel
- *  Email : dborca@yahoo.com
- *  Web   : http://www.geocities.com/dborca
- */
-
-
-		.file	"virtual.S"
-
-/*
- * extern void *vl_current_draw_buffer;
- * extern int vl_current_width, vl_current_bytes;
- */
-
-		.text
-
-/* Desc: void v_clear8 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear8
-_v_clear8:
-		movl	4(%esp), %eax
-		movb	%al, %ah
-		pushw	%ax
-		pushw	%ax
-		popl	%eax
-		jmp	_v_clear_common
-
-/* Desc: void v_clear16 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear16
-_v_clear16:
-		movl	4(%esp), %eax
-		pushw	%ax
-		pushw	%ax
-		popl	%eax
-		jmp	_v_clear_common
-
-/* Desc: void v_clear32 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear32
-_v_clear32:
-		movl	4(%esp), %eax
-		.balign	4
-_v_clear_common:
-		movl	_vl_current_bytes, %ecx
-		movl	_vl_current_draw_buffer, %edx
-		shrl	$2, %ecx
-		.balign	4
-	0:
-		movl	%eax, (%edx)
-		addl	$4, %edx
-		decl	%ecx
-		jnz	0b
-		ret
-
-/* Desc: void v_clear8_mmx (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear8_mmx
-_v_clear8_mmx:
-#ifdef USE_MMX_ASM
-		movd	4(%esp), %mm0
-		punpcklbw %mm0, %mm0
-		punpcklwd %mm0, %mm0
-		jmp	_v_clear_common_mmx
-#endif
-
-/* Desc: void v_clear16_mmx (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear16_mmx
-_v_clear16_mmx:
-#ifdef USE_MMX_ASM
-		movd	4(%esp), %mm0
-		punpcklwd %mm0, %mm0
-		jmp	_v_clear_common_mmx
-#endif
-
-/* Desc: void v_clear32_mmx (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear32_mmx
-_v_clear32_mmx:
-#ifdef USE_MMX_ASM
-		movd	4(%esp), %mm0
-		.balign	4
-_v_clear_common_mmx:
-		punpckldq %mm0, %mm0
-		movl	_vl_current_bytes, %ecx
-		movl	_vl_current_draw_buffer, %edx
-		shrl	$3, %ecx
-		.balign	4
-	0:
-		movq	%mm0, (%edx)
-		addl	$8, %edx
-		decl	%ecx
-		jnz	0b
-		emms
-#endif
-		ret
-
-/* Desc: void v_clear24 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear24
-_v_clear24:
-		movl	$0xaaaaaaab, %eax
-		mull	_vl_current_bytes
-		movl	4(%esp), %eax
-		movl	%edx, %ecx
-		pushl	%ebx
-		movl	_vl_current_draw_buffer, %edx
-		shrl	%ecx
-		movb	10(%esp), %bl
-		.balign	4
-	0:
-		movw	%ax, (%edx)
-		movb	%bl, 2(%edx)
-		addl	$3, %edx
-		decl	%ecx
-		jnz	0b
-		popl	%ebx
-		ret
-
-/* Desc: void v_clear24_mmx (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_clear24_mmx
-_v_clear24_mmx:
-#ifdef USE_MMX_ASM
-		movl	4(%esp), %eax
-		movl	%eax, %edx
-		movl	%eax, %ecx
-		shll	$16, %edx
-		rorl	$8, %ecx
-		movw	%cx, %dx
-		rorl	$16, %ecx
-		movb	%dh, %cl
-		shll	$8, %eax
-		movb	%ch, %al
-		rorl	$8, %eax
-
-		pushl	%edx
-		pushl	%eax
-		movq	(%esp), %mm0
-		pushl	%ecx
-		movq	(%esp), %mm1
-		pushl	%edx
-		movq	(%esp), %mm2
-
-		movl	$0xaaaaaaab, %eax
-		mull	_vl_current_bytes
-		movl	%edx, %ecx
-		movl	_vl_current_draw_buffer, %edx
-		shrl	$4, %ecx
-		.balign	4
-	0:
-		movq	%mm0, (%edx)
-		movq	%mm1, 8(%edx)
-		movq	%mm2, 16(%edx)
-		addl	$24, %edx
-		decl	%ecx
-		jnz	0b
-		emms
-		addl	$16, %esp
-#endif
-		ret
-
-/* Desc: void v_rect8 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_rect8
-_v_rect8:
-		cld
-		pushl	%esi
-		pushl	%edi
-		movl	28(%esp), %eax
-		movl	_vl_current_width, %esi
-		movl	16(%esp), %edi
-		movb	%al, %ah
-		movl	20(%esp), %ecx
-		imull	%esi, %edi
-		movl	24(%esp), %edx
-		subl	%ecx, %esi
-		addl	12(%esp), %edi
-		pushw	%ax
-		pushw	%ax
-		pushl	%ds
-		popl	%es
-		addl	_vl_current_draw_buffer, %edi
-		popl	%eax
-		pushl	%ebx
-		movl	%ecx, %ebx
-		andl	$3, %ebx
-		.balign	4
-	0:
-		pushl	%ecx
-		.balign	4
-	1:
-		shrl	$2, %ecx
-		rep;	stosl
-		testl	%ebx, %ebx
-		jz	2f
-		movl	%ebx, %ecx
-		rep;	stosb
-		.balign	4
-	2:
-		popl	%ecx
-		addl	%esi, %edi
-		decl	%edx
-		jnz	0b
-		popl	%ebx
-		popl	%edi
-		popl	%esi
-		ret
-
-/* Desc: void v_rect16 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_rect16
-_v_rect16:
-		cld
-		pushl	%esi
-		pushl	%edi
-		movl	28(%esp), %eax
-		movl	_vl_current_width, %esi
-		movl	16(%esp), %edi
-		movl	20(%esp), %ecx
-		imull	%esi, %edi
-		movl	24(%esp), %edx
-		subl	%ecx, %esi
-		addl	12(%esp), %edi
-		pushw	%ax
-		shll	%esi
-		pushw	%ax
-		shll	%edi
-		pushl	%ds
-		popl	%es
-		addl	_vl_current_draw_buffer, %edi
-		popl	%eax
-		.balign	4
-	0:
-		pushl	%ecx
-		.balign	4
-	1:
-		shrl	%ecx
-		rep;	stosl
-		jnc	2f
-		stosw
-		.balign	4
-	2:
-		popl	%ecx
-		addl	%esi, %edi
-		decl	%edx
-		jnz	0b
-		popl	%edi
-		popl	%esi
-		ret
-
-/* Desc: void v_rect24 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_rect24
-_v_rect24:
-		pushl	%esi
-		pushl	%edi
-		movl	28(%esp), %eax
-		movl	_vl_current_width, %esi
-		movl	16(%esp), %edi
-		movl	20(%esp), %ecx
-		imull	%esi, %edi
-		movl	24(%esp), %edx
-		subl	%ecx, %esi
-		addl	12(%esp), %edi
-		leal	(%esi, %esi, 2), %esi
-		pushl	%ebx
-		leal	(%edi, %edi, 2), %edi
-		movl	%eax, %ebx
-		addl	_vl_current_draw_buffer, %edi
-		shrl	$16, %ebx
-		.balign	4
-	0:
-		pushl	%ecx
-		.balign	4
-	1:
-		movw	%ax, (%edi)
-		movb	%bl, 2(%edi)
-		addl	$3, %edi
-		decl	%ecx
-		jnz	1b
-		popl	%ecx
-		addl	%esi, %edi
-		decl	%edx
-		jnz	0b
-		popl	%ebx
-		popl	%edi
-		popl	%esi
-		ret
-
-/* Desc: void v_rect32 (int color);
- *
- * In  : color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_rect32
-_v_rect32:
-		pushl	%esi
-		pushl	%edi
-		movl	_vl_current_width, %esi
-		movl	16(%esp), %edi
-		movl	20(%esp), %ecx
-		imull	%esi, %edi
-		movl	24(%esp), %edx
-		subl	%ecx, %esi
-		addl	12(%esp), %edi
-		shll	$2, %esi
-		shll	$2, %edi
-		movl	28(%esp), %eax
-		addl	_vl_current_draw_buffer, %edi
-		.balign	4
-	0:
-		pushl	%ecx
-		.balign	4
-	1:
-		movl	%eax, (%edi)
-		addl	$4, %edi
-		decl	%ecx
-		jnz	1b
-		popl	%ecx
-		addl	%esi, %edi
-		decl	%edx
-		jnz	0b
-		popl	%edi
-		popl	%esi
-		ret
-
-/* Desc: void v_putpixel8 (unsigned int offset, int color);
- *
- * In  : offset within buffer, color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_putpixel8
-_v_putpixel8:
-		movl	8(%esp), %ecx
-		movl	4(%esp), %edx
-		movl	_vl_current_draw_buffer, %eax
-		movb	%cl, (%eax,%edx)
-		ret
-
-/* Desc: void v_putpixel16 (unsigned int offset, int color);
- *
- * In  : offset within buffer, color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_putpixel16
-_v_putpixel16:
-		movl	8(%esp), %ecx
-		movl	4(%esp), %edx
-		movl	_vl_current_draw_buffer, %eax
-		movw	%cx, (%eax,%edx,2)
-		ret
-
-/* Desc: void v_putpixel24 (unsigned int offset, int color);
- *
- * In  : offset within buffer, color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_putpixel24
-_v_putpixel24:
-		movl	4(%esp), %eax
-		movl	8(%esp), %edx
-		movl	_vl_current_draw_buffer, %ecx
-		leal	(%eax,%eax,2), %eax
-		movw	%dx, (%ecx,%eax)
-		shrl	$16, %edx
-		movb	%dl, 2(%ecx,%eax)
-		ret
-
-/* Desc: void v_putpixel32 (unsigned int offset, int color);
- *
- * In  : offset within buffer, color
- * Out : -
- *
- * Note: uses current draw buffer
- */
-		.p2align 5,,31
-		.global	_v_putpixel32
-_v_putpixel32:
-		movl	8(%esp), %ecx
-		movl	4(%esp), %edx
-		movl	_vl_current_draw_buffer, %eax
-		movl	%ecx, (%eax,%edx,4)
-		ret