; Copyright (c) 1999 Greg Haerr <greg@censoft.com>
; Copyright (c) 1991 David I. Bell
; Permission is granted to use, distribute, or modify this source,
; provided that this copyright notice remains intact.
;
; EGA/VGA Screen Driver 16 color 4 planes, higher speed MASM version
;
; Note: this file is a replacement for vgaplan4.c, when raw
; speed rather than portability is desired
;
; The algorithms for some of these routines are taken from the book:
; Programmer's Guide to PC and PS/2 Video Systems by Richard Wilton.
;
; Routines to draw pixels and lines for EGA/VGA resolutions.
; The drawing mode in the data/rotate register is not changed in this
; module, and must be changed as necessary by the callers.
;
PIXBYTES	= 80		; number of bytes in scan line


MSC = 1
;__MEDIUM__ = 1
	include asm.h
	.header

	.cextrn	gr_mode,word	; temp kluge devdraw.c graphics draw mode
	.dseg
mode_table:
	db	00h,18h,10h,08h	; vga draw modes

	.cseg

;
; int ega_init(PSD psd)
;
	.cproc	ega_init
	mov	ax,1		; success
	ret
	.cendp	ega_init

;
; Routine to draw a horizontal line.
; Called from C:
;	ega_drawhine(x1, x2, y, color);
;
;	works in the following EGA and VGA modes:
;	200 line 16 colors modes
;	350 line modes
;	640x480 16 color

; argument offsets from bp
x1	= arg1		; first X coordinate
x2	= arg1 + 2	; second X coordinate
y	= arg1 + 4	; second Y coordinate
color	= arg1 + 6	; pixel value

	.cproc	ega_drawhline
	push	bp		; setup stack frame and preserve registers
	mov	bp, sp
	push	si
	push	di
	push	es

	; configure the graphics controller

	mov	dx, 03ceh	; DX := Graphics Controller port address

	mov	al, #3		; set data rotate register
	lea	bx, mode_table
	add	bx, @gr_mode
	mov	ah, [bx]
	out	dx, ax

	mov 	ah, color[bp]	; pixel value
	xor	al, al		; Set/Reset register number (0)
	out	dx, ax

	mov	ax, 0f01h	; AH := bit plane mask for Enable Set/Reset
	out	dx, ax		; AL := Enable Set/Reset register number

	push	ds		; preserve DS

	mov	ax, y[bp]
	mov	bx, x1[bp]

	; compute pixel address
	mov	dx, offset PIXBYTES	; AX := [row * PIXBYTES]
	mul	dx
	mov 	cl, bl		; save low order column bits
	shr	bx, 1		; BX := [col / 8]
	shr	bx, 1
	shr	bx, 1
	add	bx, ax		; BX := [row * PIXBYTES] + [col / 8]
	and	cl, 07h		; CL := [col % 8]
	xor	cl, 07h		; CL := 7 - [col % 8]
	mov 	ah, 01h		; AH := 1 << [7 - [col % 8]]	[mask]
	mov	dx, 0a000h	; ES := EGA buffer segment address
	mov	es, dx
				; AH := bit mask
				; ES:BX -> video buffer
				; CL := number bits to shift left
	mov	di, bx		; ES:DI -> buffer
	mov 	dh, ah		; DH := unshifted bit mask for left byte

	not	dh
	shl	dh, cl		; DH := reverse bit mask for first byte
	not	dh		; DH := bit mask for first byte

	mov	cx, x2[bp]
	and	cl, 7
	xor	cl, 7		; CL := number of bits to shift left
	mov 	dl, 0ffh	; DL := unshifted bit mask for right byte
	shl	dl, cl		; DL := bit mask for last byte

	; determine byte offset of first and last pixel in the line

	mov	ax, x2[bp]	; AX := x2
	mov	bx, x1[bp]	; BX := x1

	mov 	cl, 3		; bits to convert pixels to bytes

	shr	ax, cl		; AX := byte offset of X2
	shr	bx, cl		; BX := byte offset of X1
	mov	cx, ax
	sub	cx, bx		; CX := [number of bytes in line] - 1

	; get Graphics Controller port address into DX

	mov	bx, dx		; BH := bit mask for first byte
				; BL := bit mask for last byte
	mov	dx, 03ceh	; DX := Graphics Controller port
	mov 	al, 8		; AL := Bit mask Register number

	; make video buffer addressable through DS:SI

	push	es
	pop	ds
	mov	si, di		; DS:SI -> video buffer

	; set pixels in leftmost byte of the line

	or	bh, bh
	js	L43		; jump if byte-aligned [x1 is leftmost]

	or	cx, cx
	jnz	L42		; jump if more than one byte in the line

	and	bl, bh		; BL := bit mask for the line
	jmp short L44

L42:	mov 	ah, bh		; AH := bit mask for first byte
	out	dx, ax		; update graphics controller

	movsb			; update bit planes
	dec	cx

	; use a fast 8086 machine instruction to draw the remainder of the line

L43:	mov 	ah, 0ffh	; AH := bit mask
	out	dx, ax		; update Bit Mask register
	rep movsb		; update all pixels in the line

	; set pixels in the rightmost byte of the line

L44:	mov 	ah, bl		; AH := bit mask for last byte
	out	dx, ax		; update Graphics Controller
	movsb			; update bit planes

	pop	ds		; restore ds


	; restore default Graphics Controller state and return to caller
	;;xor	ax, ax		; AH := 0, AL := 0
	;;out	dx, ax		; restore Set/Reset register
	;;inc	ax		; AH := 0, AL := 1
	;;out	dx, ax		; restore Enable Set/Reset register
	;;mov	ax, 0ff08h	; AH := 0xff, AL := 0
	;;out	dx, ax		; restore Bit Mask register

	pop	es
	pop	di
	pop	si
	pop	bp
	ret
	.cendp	ega_drawhline


;
; Routine to draw a vertical line.
; Called from C:
;	ega_drawvline(x, y1, y2, color);
;
;	works in the following EGA and VGA modes:
;	200 line 16 colors modes
;	350 line modes
;	640x480 16 color

; argument offsets from bp
x	= arg1		; first X coordinate
y1	= arg1 + 2	; first Y coordinate
y2	= arg1 + 4	; second Y coordinate
color	= arg1 + 6	; pixel value

	.cproc	ega_drawvline
	push	bp		; setup stack frame and preserve registers
	mov	bp, sp
	push	ds

	; configure the graphics controller

	mov	dx, 03ceh	; DX := Graphics Controller port address

	mov	al, #3		; set data rotate register
	lea	bx, mode_table
	add	bx, @gr_mode
	mov	ah, [bx]
	out	dx, ax

	mov 	ah, color[bp]	; pixel value
	xor	al, al		; Set/Reset register number (0)
	out	dx, ax

	mov	ax, 0f01h	; AH := bit plane mask for Enable Set/Reset
	out	dx, ax		; AL := Enable Set/Reset register number

	; prepare to draw vertical line

	mov	ax, y1[bp]	; AX := y1
	mov	cx, y2[bp]	; BX := y2
	;;mov	cx, bx
	sub	cx, ax		; CX := dy
	;;jge	L311		; jump if dy >= 0
	;;neg	cx		; force dy >= 0
	;;mov	ax, bx		; AX := y2

L311:	inc	cx		; CX := number of pixels to draw
	mov	bx, x[bp]	; BX := x
	push	cx		; save register

	; compute pixel address
	push	dx
	mov	dx, offset PIXBYTES	; AX := [row * PIXBYTES]
	mul	dx
	mov 	cl, bl		; save low order column bits
	shr	bx, 1		; BX := [col / 8]
	shr	bx, 1
	shr	bx, 1
	add	bx, ax		; BX := [row * PIXBYTES] + [col / 8]
	and	cl, 07h		; CL := [col % 8]
	xor	cl, 07h		; CL := 7 - [col % 8]
	mov 	ah, 01h		; AH := 1 << [7 - [col % 8]]	[mask]
	mov	dx, 0a000h	; DS := EGA buffer segment address
	mov	ds, dx
	pop	dx
				; AH := bit mask
				; DS:BX -> video buffer
				; CL := number bits to shift left

	; set up Graphics controller

	shl	ah, cl		; AH := bit mask in proper position
	mov 	al, 08h		; AL := Bit Mask register number
	out	dx, ax

	pop	cx		; restore register

	; draw the line

	mov	dx, offset PIXBYTES	; increment for video buffer
L1111:	or	[bx], al	; set pixel
	add	bx, dx		; increment to next line
	loop	L1111

	; restore default Graphics Controller state and return to caller
	;;xor	ax, ax		; AH := 0, AL := 0
	;;out	dx, ax		; restore Set/Reset register
	;;inc	ax		; AH := 0, AL := 1
	;;out	dx, ax		; restore Enable Set/Reset register
	;;mov	ax, 0ff08h	; AH := 0xff, AL := 0
	;;out	dx, ax		; restore Bit Mask register

	pop	ds
	pop	bp
	ret
	.cendp	ega_drawvline


;
; Routine to set an individual pixel value.
; Called from C like:
;	ega_drawpixel(x, y, color);
;

; argument offsets from bp
x	= arg1		; X coordinate
y	= arg1+2	; Y coordinate
color	= arg1+4	; pixel value

	.cproc	ega_drawpixel
	push	bp
	mov	bp, sp

	mov	dx, 03ceh	; graphics controller port address
	mov	al, #3		; set data rotate register
	lea	bx, mode_table
	add	bx, @gr_mode
	mov	ah, [bx]
	out	dx, ax

	mov	cx, x[bp]		; ECX := x
	mov	ax, y[bp]		; EAX := y

	mov	dx, offset PIXBYTES	; AX := [y * PIXBYTES]
	mul	dx

	mov	bx, cx		; BX := [x / 8]
	shr	bx, 1
	shr	bx, 1
	shr	bx, 1

	add	bx, ax		; BX := [y * PIXBYTES] + [x / 8]

	and	cl, 07h		; CL := [x % 8]
	xor	cl, 07h		; CL := 7 - [x % 8]
	mov 	ch, 01h		; CH := 1 << [7 - [x % 8]]	[mask]
	shl	ch, cl

	mov	dx, 03ceh	; graphics controller port address

	;;required for old code
	;;mov	ax, 0205h	; select write mode 2
	;;out	dx, ax		; [load value 2 into mode register 5]

	; new code
	xor	ax,ax		; set color register 0
	mov	ah,[bp+8]	; color pixel value
	out	dx,ax

	; original code
	mov 	al, 08h		; set the bit mask register
	mov 	ah, ch		; [load bit mask into register 8]
	out	dx, ax

	push	ds
	mov	ax, 0a000h	; DS := EGA buffer segment address
	mov	ds, ax

	; new code
	or	[bx],al		; quick rmw to set pixel

	;;the following fails under ELKS without cli/sti
	;;using ES works though.  Code changed to use single
	;;rmw above rather than write mode 2, but the
	;;reason for this failure is still unknown...
	;;cli
	;;mov 	al, [bx]	; dummy read to latch bit planes
	;;mov	al, color[bp]	; pixel value
	;;mov 	[bx], al	; write pixel back to bit planes
	;;sti

	pop	ds		; restore registers and return

	mov	ax, 0005h	; restore default write mode 0
	out	dx, ax		; [load value 0 into mode register 5]
	;;mov	ax, 0ff08h	; restore default bit mask
	;;out	dx, ax		; [load value ff into register 8]

	pop	bp
	ret
	.cendp	ega_drawpixel

;
; Routine to read the value of an individual pixel.
; Called from C like:
; 	color = ega_readpixel(x, y);
;

; argument offsets from bp
x	= arg1			; X coordinate
y	= arg1+2		; Y coordinate

	.cproc	ega_readpixel
	push	bp
	mov	bp, sp
	push	si
	push	ds

	mov	ax, y[bp]	; EAX := y
	mov	bx, x[bp]	; EBX := x
	mov	dx, offset PIXBYTES	; AX := [y * PIXBYTES]
	mul	dx

	mov 	cl, bl		; save low order column bits
	shr	bx, 1		; BX := [x / 8]
	shr	bx, 1
	shr	bx, 1

	add	bx, ax		; BX := [y * PIXBYTES] + [x / 8]

	and	cl, 07h		; CL := [x % 8]
	xor 	cl, 07h		; CL := 7 - [x % 8]

	mov	dx, 0a000h	; DS := EGA buffer segment address
	mov	ds, dx

	mov 	ch, 01h		; CH := 1 << [7 - [col % 8]]  [mask]
	shl	ch, cl		; CH := bit mask in proper position

	mov	si, bx		; DS:SI -> region buffer byte
	xor	bl, bl		; BL is used to accumulate the pixel value

	mov	dx, 03ceh	; DX := Graphics Controller port
	mov	ax, 0304h	; AH := initial bit plane number
				; AL := Read Map Select register number

L112:	out	dx, ax		; select bit plane
	mov 	bh, [si]	; BH := byte from current bit plane
	and	bh, ch		; mask one bit
	neg	bh		; bit 7 of BH := 1 if masked bit = 1
				; bit 7 of BH := 0 if masked bit = 0
	rol	bx, 1		; bit 0 of BL := next bit from pixel value
	dec	ah		; AH := next bit plane number
	jge	L112

	xor	ax, ax		; AL := pixel value
	mov 	al, bl

	pop	ds
	pop	si
	pop	bp	
	ret
	.cendp	ega_readpixel

	.cend
	end