[unix-history] / usr / othersrc / public / ghostscript-2.4.1 / gdevegaa.asm

;    Copyright (C) 1989, 1990, 1991 Aladdin Enterprises.  All rights reserved.
;    Distributed by Free Software Foundation, Inc.
;
; This file is part of Ghostscript.
;
; Ghostscript is distributed in the hope that it will be useful, but
; WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
; to anyone for the consequences of using it or for whether it serves any
; particular purpose or works at all, unless he says so in writing.  Refer
; to the Ghostscript General Public License for full details.
;
; Everyone is granted permission to copy, modify and redistribute
; Ghostscript, but only under the conditions described in the Ghostscript
; General Public License.  A copy of this license is supposed to have been
; given to you along with Ghostscript so you can know your rights and
; responsibilities.  It should be in a file named COPYING.  Among other
; things, the copyright notice and this notice must be preserved on all
; copies.

; gdevegaasm.asm
; Assembly code for Ghostscript PC frame buffer driver

gdevegaasm_TEXT	SEGMENT	BYTE PUBLIC 'CODE'
	ASSUME	CS:gdevegaasm_TEXT

; Note: Turbo C uses si and di for register variables, so
; we have to preserve them.

; Normal entry and exit.  Arguments are relative to bp.
enterp	macro
	push	bp
	mov	bp,sp
	x = 6				; offset of arguments,
					; large code model
	endm
leavep	macro
	pop	bp
	endm
; Fast entry and exit, for procedures that don't use bx until
; they've fetched all their arguments.  Arguments are relative to ss:bx.
enterf	macro
	mov	bx,sp
	x = 4				; offset of arguments,
					; large code model
	endm
leavef	macro
	endm

; Fast call to VESA set-page routine.
; void vesa_call_set_page(void (*set_page_proc)(int), int page_no, int win_no)
	PUBLIC	_vesa_call_set_page
_vesa_call_set_page proc far
	enterf
	mov ax,4f05h
	mov dx,ss:[bx+x+4]			; page_no
	push ss:[bx+x+2]			; set_page_proc
	push ss:[bx+x]
	mov bx,ss:[bx+x+6]			; win_no
	ret
_vesa_call_set_page endp

; Structure for operation parameters.
; Note that this structure is shared with C code.
; Not all parameters are used for every operation.
; typedef struct rop_params_s {
p_dest	equ	0	; fb_ptr dest;	/* pointer to frame buffer */
p_draster equ	4	; int draster;	/* raster of frame buffer */
p_src	equ	6	; byte far *src; /* pointer to source data */
p_sraster equ	10	; int sraster;	/* source raster */
p_width	equ	12	; int width;	/* width in bytes */
p_height equ	14	; int height;	/* height in scan lines */
p_shift equ	16	; int shift;	/* amount to right shift source */
p_invert equ	18	; int invert;	/* 0 or -1 to invert source */
p_data	equ	20	; int data;	/* data for fill */
; } rop_params;

; void memsetcol(rop_params _ss *rop)
; {	byte far *addr = rop->dest;
;	int yc = rop->height;
;	while ( yc-- )
;	 { byte discard = *addr;
;	   *addr = rop->data;
;	   addr += rop->draster;
;	 }
; }
	PUBLIC	_memsetcol
_memsetcol proc	far
	enterf
	push	ds
	mov	ax,ss
	mov	ds,ax
	mov	bx,[bx+x]			; rop
	mov	cx,[bx].p_height
	jcxz	msc0				; height == 0
	mov	ax,[bx].p_data
	mov	dx,[bx].p_draster
	lds	bx,[bx].p_dest
; Unroll the loop -- two copies.
	inc	cx		;round up to nearest word.  cx>=2 now.
	shr	cx,1		;make byte count into word count.
	jnc	msc2		;if it had been odd, do a half word first.
msc1:	mov	ah,[bx]
	mov	[bx],al
	add	bx,dx
msc2:	mov	ah,[bx]
	mov	[bx],al
	add	bx,dx
	loop	msc1
	pop	ds
msc0:	leavef
	ret
_memsetcol ENDP

; void memsetrect(rop_params _ss *rop)
; {	byte far *addr = rop->dest;
;	int yc = rop->height;
;	while ( yc-- )
;	 { int cnt = rop->width;
;	   while ( cnt-- ) *addr++ = rop->data;
;	   addr += rop->drast - rop->width;
;	 }
; }
	PUBLIC	_memsetrect
_memsetrect proc	far
	enterf
	push	ds
	mov	ax,ss
	mov	ds,ax
	mov	bx,[bx+x]			; rop
	mov	cx,[bx].p_height
	jcxz	msr0				; height == 0
	push	si
	push	di
	mov	ax,[bx].p_data
	les	di,[bx].p_dest
	cld
	mov	dx,[bx].p_draster
	mov	si,cx				; si = height
	mov	cx,[bx].p_width
	sub	dx,cx
	cmp	cx,10
	ja	msrl				; large count, use fast loop
; Small count, rep stosb is faster.
msrs:	mov	cx,[bx].p_width
	rep	stosb
	add	di,dx
	dec	si				; count reps
	jnz	msrs
	pop	di
	pop	si
msr0:	pop	ds
	leavef
	ret
; Large count, loop by words rather than bytes.
msrl:	mov	ah,al			;we may be storing words...
msr1:	mov	cx,[bx].p_width
	test	di,1			;test for an even address
	je	msr2			;if even, we can store words.
	stosb				;otherwise we need to even it out.
	dec	cx			;(cx is at least one here)
msr2:	shr	cx,1			;convert byte count into word count
	rep	stosw			;store them puppies as fast as we can.
	jnc	msr3			;if an odd number, store it, too.
	stosb				;(no need to dec cx here).
msr3:	add	di,dx
	dec	si			; count reps
	jnz	msr1
	pop	di
	pop	si
	pop	ds
	leavef
	ret
_memsetrect ENDP

; void memrwcol(rop_params _ss *rop)
; {	byte far *dp = rop->dest, *sp = rop->src;
;	int yc = rop->height;
;	int shift = rop->shift;
;	while ( yc-- )
;	 { byte discard = *dp;
;	   *dp = ((*sp >> shift) + (*sp << (8 - shift))) ^ rop->invert;
;	   dp += rop->draster, sp += rop->sraster;
;	 }
; }
	PUBLIC	_memrwcol
_memrwcol proc far
	enterp
	push	ds
	mov	ax,ss
	mov	ds,ax
	mov	bx,[bp+x]			; rop
	cmp	word ptr [bx].p_height,0
	jz	short mrw0
	push	si
	push	di
; Register usage:
;   ds:si = sp, es:di = dp, bx = sraster, dx = draster, cl = shift,
;   ch = invert, ah = low byte of yc.
	push	[bx].p_height
	mov	dx,[bx].p_draster
	mov	ax,[bx].p_sraster
	mov	cl,[bx].p_shift
	mov	ch,[bx].p_invert
	les	di,[bx].p_dest
	lds	si,[bx].p_src
	mov	bx,ax
	mov	ah,[bp-8]			; low byte of yc
	test	ah,ah
	jz	mrw2
mrw1:	mov	al,[si]
	ror	al,cl
	xor	al,ch
	xchg	es:[di],al
	add	si,bx
	add	di,dx
	dec	ah
	jnz	mrw1
mrw2:	dec	byte ptr [bp-7]			; high byte of yc
	jge	mrw1
	add	sp,2				; pop yc
	pop	di
	pop	si
mrw0:	pop	ds
	leavep
	ret
_memrwcol ENDP

; void memrwcol2(rop_params _ss *rop)
; {	byte far *dp = rop->dest, *sp = rop->src;
;	int yc = rop->height;
;	int shift = rop->shift;
;	while ( yc-- )
;	 { byte discard = *dp;
;	   *dp = ((sp[1] >> shift) + (*sp << (8 - shift))) ^ rop->invert;
;	   dp += rop->draster, sp += rop->sraster;
;	 }
; }
	PUBLIC	_memrwcol2
_memrwcol2 proc far
	enterp
	push	ds
	mov	ax,ss
	mov	ds,ax
	mov	bx,[bp+x]			; rop
	cmp	word ptr [bx].p_height,0
	jz	short mrw20
	push	si
	push	di
; Register usage:
;   ds:si = sp, es:di = dp, bx = sraster, dx = draster, cl = shift,
;   ch = invert.
	push	[bx].p_height
	mov	dx,[bx].p_draster
	mov	ax,[bx].p_sraster
	mov	cl,[bx].p_shift
	mov	ch,[bx].p_invert
	les	di,[bx].p_dest
	lds	si,[bx].p_src
	mov	bx,ax
mrw21:	mov	ax,[si]				; bytes are in wrong order...
	ror	ax,cl
	xor	ah,ch				; ... so result is in ah
	xchg	es:[di],ah
	add	si,bx
	add	di,dx
	dec	word ptr [bp-8]			; yc
	jg	mrw21
	add	sp,2				; pop yc
	pop	di
	pop	si
mrw20:	pop	ds
	leavep
	ret
_memrwcol2 ENDP

gdevegaasm_TEXT	ENDS
	END
Commit	Line	Data
893a268e WJ	1	; Copyright (C) 1989, 1990, 1991 Aladdin Enterprises. All rights reserved.
	2	; Distributed by Free Software Foundation, Inc.
	3	;
	4	; This file is part of Ghostscript.
	5	;
	6	; Ghostscript is distributed in the hope that it will be useful, but
	7	; WITHOUT ANY WARRANTY. No author or distributor accepts responsibility
	8	; to anyone for the consequences of using it or for whether it serves any
	9	; particular purpose or works at all, unless he says so in writing. Refer
	10	; to the Ghostscript General Public License for full details.
	11	;
	12	; Everyone is granted permission to copy, modify and redistribute
	13	; Ghostscript, but only under the conditions described in the Ghostscript
	14	; General Public License. A copy of this license is supposed to have been
	15	; given to you along with Ghostscript so you can know your rights and
	16	; responsibilities. It should be in a file named COPYING. Among other
	17	; things, the copyright notice and this notice must be preserved on all
	18	; copies.
	19
	20	; gdevegaasm.asm
	21	; Assembly code for Ghostscript PC frame buffer driver
	22
	23	gdevegaasm_TEXT SEGMENT BYTE PUBLIC 'CODE'
	24	ASSUME CS:gdevegaasm_TEXT
	25
	26	; Note: Turbo C uses si and di for register variables, so
	27	; we have to preserve them.
	28
	29	; Normal entry and exit. Arguments are relative to bp.
	30	enterp macro
	31	push bp
	32	mov bp,sp
	33	x = 6 ; offset of arguments,
	34	; large code model
	35	endm
	36	leavep macro
	37	pop bp
	38	endm
	39	; Fast entry and exit, for procedures that don't use bx until
	40	; they've fetched all their arguments. Arguments are relative to ss:bx.
	41	enterf macro
	42	mov bx,sp
	43	x = 4 ; offset of arguments,
	44	; large code model
	45	endm
	46	leavef macro
	47	endm
	48
	49	; Fast call to VESA set-page routine.
	50	; void vesa_call_set_page(void (*set_page_proc)(int), int page_no, int win_no)
	51	PUBLIC _vesa_call_set_page
	52	_vesa_call_set_page proc far
	53	enterf
	54	mov ax,4f05h
	55	mov dx,ss:[bx+x+4] ; page_no
	56	push ss:[bx+x+2] ; set_page_proc
	57	push ss:[bx+x]
	58	mov bx,ss:[bx+x+6] ; win_no
	59	ret
	60	_vesa_call_set_page endp
	61
	62	; Structure for operation parameters.
	63	; Note that this structure is shared with C code.
	64	; Not all parameters are used for every operation.
65	; typedef struct rop_params_s {
66	p_dest equ 0 ; fb_ptr dest; /* pointer to frame buffer */
67	p_draster equ 4 ; int draster; /* raster of frame buffer */
68	p_src equ 6 ; byte far src; / pointer to source data */
69	p_sraster equ 10 ; int sraster; /* source raster */
70	p_width equ 12 ; int width; /* width in bytes */
71	p_height equ 14 ; int height; /* height in scan lines */
72	p_shift equ 16 ; int shift; /* amount to right shift source */
73	p_invert equ 18 ; int invert; /* 0 or -1 to invert source */
74	p_data equ 20 ; int data; /* data for fill */
75	; } rop_params;
76
77	; void memsetcol(rop_params _ss *rop)
78	; { byte far *addr = rop->dest;
79	; int yc = rop->height;
80	; while ( yc-- )
81	; { byte discard = *addr;
82	; *addr = rop->data;
83	; addr += rop->draster;
84	; }
85	; }
86	PUBLIC _memsetcol
87	_memsetcol proc far
88	enterf
89	push ds
90	mov ax,ss
91	mov ds,ax
92	mov bx,[bx+x] ; rop
93	mov cx,[bx].p_height
94	jcxz msc0 ; height == 0
95	mov ax,[bx].p_data
96	mov dx,[bx].p_draster
97	lds bx,[bx].p_dest
98	; Unroll the loop -- two copies.
99	inc cx ;round up to nearest word. cx>=2 now.
100	shr cx,1 ;make byte count into word count.
101	jnc msc2 ;if it had been odd, do a half word first.
102	msc1: mov ah,[bx]
103	mov [bx],al
104	add bx,dx
105	msc2: mov ah,[bx]
106	mov [bx],al
107	add bx,dx
108	loop msc1
109	pop ds
110	msc0: leavef
111	ret
112	_memsetcol ENDP
113
114	; void memsetrect(rop_params _ss *rop)
115	; { byte far *addr = rop->dest;
116	; int yc = rop->height;
117	; while ( yc-- )
118	; { int cnt = rop->width;
119	; while ( cnt-- ) *addr++ = rop->data;
120	; addr += rop->drast - rop->width;
121	; }
122	; }
123	PUBLIC _memsetrect
124	_memsetrect proc far
125	enterf
126	push ds
127	mov ax,ss
128	mov ds,ax
129	mov bx,[bx+x] ; rop
130	mov cx,[bx].p_height
131	jcxz msr0 ; height == 0
132	push si
133	push di
134	mov ax,[bx].p_data
135	les di,[bx].p_dest
136	cld
137	mov dx,[bx].p_draster
138	mov si,cx ; si = height
139	mov cx,[bx].p_width
140	sub dx,cx
141	cmp cx,10
142	ja msrl ; large count, use fast loop
143	; Small count, rep stosb is faster.
144	msrs: mov cx,[bx].p_width
145	rep stosb
146	add di,dx
147	dec si ; count reps
148	jnz msrs
149	pop di
150	pop si
151	msr0: pop ds
152	leavef
153	ret
154	; Large count, loop by words rather than bytes.
155	msrl: mov ah,al ;we may be storing words...
156	msr1: mov cx,[bx].p_width
157	test di,1 ;test for an even address
158	je msr2 ;if even, we can store words.
159	stosb ;otherwise we need to even it out.
160	dec cx ;(cx is at least one here)
161	msr2: shr cx,1 ;convert byte count into word count
162	rep stosw ;store them puppies as fast as we can.
163	jnc msr3 ;if an odd number, store it, too.
164	stosb ;(no need to dec cx here).
165	msr3: add di,dx
166	dec si ; count reps
167	jnz msr1
168	pop di
169	pop si
170	pop ds
171	leavef
172	ret
173	_memsetrect ENDP
174
175	; void memrwcol(rop_params _ss *rop)
176	; { byte far dp = rop->dest, sp = rop->src;
177	; int yc = rop->height;
178	; int shift = rop->shift;
179	; while ( yc-- )
180	; { byte discard = *dp;
181	; dp = ((sp >> shift) + (*sp << (8 - shift))) ^ rop->invert;
182	; dp += rop->draster, sp += rop->sraster;
183	; }
184	; }
185	PUBLIC _memrwcol
186	_memrwcol proc far
187	enterp
188	push ds
189	mov ax,ss
190	mov ds,ax
191	mov bx,[bp+x] ; rop
192	cmp word ptr [bx].p_height,0
193	jz short mrw0
194	push si
195	push di
196	; Register usage:
197	; ds:si = sp, es:di = dp, bx = sraster, dx = draster, cl = shift,
198	; ch = invert, ah = low byte of yc.
199	push [bx].p_height
200	mov dx,[bx].p_draster
201	mov ax,[bx].p_sraster
202	mov cl,[bx].p_shift
203	mov ch,[bx].p_invert
204	les di,[bx].p_dest
205	lds si,[bx].p_src
206	mov bx,ax
207	mov ah,[bp-8] ; low byte of yc
208	test ah,ah
209	jz mrw2
210	mrw1: mov al,[si]
211	ror al,cl
212	xor al,ch
213	xchg es:[di],al
214	add si,bx
215	add di,dx
216	dec ah
217	jnz mrw1
218	mrw2: dec byte ptr [bp-7] ; high byte of yc
219	jge mrw1
220	add sp,2 ; pop yc
221	pop di
222	pop si
223	mrw0: pop ds
224	leavep
225	ret
226	_memrwcol ENDP
227
228	; void memrwcol2(rop_params _ss *rop)
229	; { byte far dp = rop->dest, sp = rop->src;
230	; int yc = rop->height;
231	; int shift = rop->shift;
232	; while ( yc-- )
233	; { byte discard = *dp;
234	; dp = ((sp[1] >> shift) + (sp << (8 - shift))) ^ rop->invert;
235	; dp += rop->draster, sp += rop->sraster;
236	; }
237	; }
238	PUBLIC _memrwcol2
239	_memrwcol2 proc far
240	enterp
241	push ds
242	mov ax,ss
243	mov ds,ax
244	mov bx,[bp+x] ; rop
245	cmp word ptr [bx].p_height,0
246	jz short mrw20
247	push si
248	push di
249	; Register usage:
250	; ds:si = sp, es:di = dp, bx = sraster, dx = draster, cl = shift,
251	; ch = invert.
252	push [bx].p_height
253	mov dx,[bx].p_draster
254	mov ax,[bx].p_sraster
255	mov cl,[bx].p_shift
256	mov ch,[bx].p_invert
257	les di,[bx].p_dest
258	lds si,[bx].p_src
259	mov bx,ax
260	mrw21: mov ax,[si] ; bytes are in wrong order...
261	ror ax,cl
262	xor ah,ch ; ... so result is in ah
263	xchg es:[di],ah
264	add si,bx
265	add di,dx
266	dec word ptr [bp-8] ; yc
267	jg mrw21
268	add sp,2 ; pop yc
269	pop di
270	pop si
271	mrw20: pop ds
272	leavep
273	ret
274	_memrwcol2 ENDP
275
276	gdevegaasm_TEXT ENDS
277	END