![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fastline.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 / i386|
Return to fastline.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 / i386 |
1.1 root 1: ;---------------------------Module-Header------------------------------;
2: ; Module Name: fastline.asm
3: ;
4: ; This module goes completely overboard in trying to do fast lines.
5: ; It handles only solid R2_COPYPEN unclipped lines.
6: ;
7: ; Unfortunately, I know of only 4 performance tricks:
8: ;
9: ; 1) Most VGAs can co-process the last write to video memory,
10: ; so we employ a traditional Bresenham-style algorithm (as
11: ; opposed to a run-length version) as this minimizes our
12: ; set-up time, and we can do some work between video writes
13: ; without any throughput penalty.
14: ;
15: ; 2) Most VGAs can do one aligned word write faster than two
16: ; byte writes; consequently we derive a double-stepping DDA
17: ; that does aligned word writes whenever possible (note that
18: ; this only makes sense on x-major lines).
19: ;
20: ; 3) Planar mode can be used to speed up long horizontal lines,
21: ; where the cost to switch from linear to planar mode is offset
22: ; by the ability to light 8 pixels on every word write instead
23: ; of 2.
24: ;
25: ; 4) Most lines have integer end-points, so we accelerate those.
26: ;
27: ; If you're not familiar with GIQ lines, this is not the code to start
28: ; with.
29: ;
30: ; Copyright (c) 1992-1993 Microsoft Corporation
31: ;-----------------------------------------------------------------------;
32:
33: .386
34:
35: .model small,c
36:
37: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
38: assume fs:nothing,gs:nothing
39:
40: .xlist
41: include stdcall.inc ;calling convention cmacros
42: include i386\egavga.inc
43: include i386\strucs.inc
44: include i386\driver.inc
45: include i386\lines.inc
46: .list
47:
48: ; Length of horizontal line needed before we'll do it in planar mode:
49:
50: NUM_PELS_NEEDED_FOR_PLANAR_HORIZONTAL equ 64
51:
52: ; Line coordinates are given in 28.4 fixed point format:
53:
54: F equ 16
55: FLOG2 equ 4
56:
57: ; The following values must match those in winddi.h!
58:
59: PD_BEGINSUBPATH equ 00000001h
60: PD_ENDSUBPATH equ 00000002h
61: PD_RESETSTYLE equ 00000004h
62: PD_CLOSEFIGURE equ 00000008h
63: PD_BEZIERS equ 00000010h
64:
65: PATHDATA struc
66:
67: pd_flags dd ?
68: pd_count dd ?
69: pd_pptfx dd ?
70:
71: PATHDATA ends
72:
73: ;-------------------------------------------------------------------------;
74: ; I felt a compelling need to use 'ebp' as a 7th general register, and we
75: ; have no nifty macros for dereferencing frame variables off 'esp'. So
76: ; with this structure I am rolling my own stack frame:
77:
78: STATE_MEM_SIZE equ 4 ;4 dwords
79: PROC_MEM_SIZE equ 6 ;6 dwords
80:
81: STACK_FRAME struc
82:
83: ; State variables (don't add/delete fields without modifying STATE_MEM_SIZE!)
84:
85: sf_ulOurEbp dd ? ;useful for debugging
86: sf_ulOriginalEbx dd ?
87: sf_ulOriginalEdi dd ?
88: sf_ulOriginalEsi dd ?
89:
90: ; Frame variables (feel free to add/delete fields):
91:
92: sf_lDelta dd ? ;sign depends on going up or down
93: sf_pfnReturn dd ? ;where to jump after getting next bank
94: sf_pfnNextBank dd ? ;routine for getting the next bank
95: sf_y0 dd ? ;GIQ variables
96: sf_y1 dd ?
97: sf_x1 dd ?
98: sf_pjStart dd ? ;for remembering edi
99: sf_cAfterThisBank dd ? ;# of pixels to light after this bank
100: sf_ptlOrg db (size POINTL) dup (?)
101: ;our origin for normalizing the line
102: sf_ptfxLast db (size POINTL) dup (?)
103: ;the most recent point
104: sf_ptfxStartFigure db (size POINTL) dup (?)
105: ;the figure's 1st point
106: sf_bMore dd ? ;more path records to get?
107: sf_pptfxEnd dd ? ;points to last point in record
108: sf_pptfx dd ? ;points to current point
109: sf_pd db (size PATHDATA) dup (?)
110: ;pathdata structure
111:
112: ; Procedure variables (don't add/delete fields without modifying
113: ; PROC_MEM_SIZE!)
114:
115: sf_ulOriginalEbp dd ?
116: sf_ulOriginalReturn dd ?
117: sf_ppdev dd ?
118: sf_ppo dd ?
119: sf_lNextScan dd ?
120: sf_iColor dd ?
121:
122: STACK_FRAME ends
123:
124: .data
125:
126: EXTRNP PATHOBJ_bEnum,8
127:
128: .code
129:
130: ROUND_X_DOWN equ 01h
131: ROUND_Y_DOWN equ 02h
132: ROUND_SLOPE_ONE equ 04h
133: ROUND_X_AND_Y_DOWN equ (ROUND_X_DOWN + ROUND_Y_DOWN)
134: ROUND_X_DOWN_SLOPE_ONE equ (ROUND_X_DOWN + ROUND_SLOPE_ONE)
135: ROUND_Y_DOWN_SLOPE_ONE equ (ROUND_Y_DOWN + ROUND_SLOPE_ONE)
136:
137: ;--------------------------------Macro----------------------------------;
138: ; GIQ flags
139: ;
140: ; This macros computes the start pixel, the number of pixels to
141: ; be lit, and the initial error term given a GIQ line. The line must
142: ; have already been normalized such that dM >= dN, dN >= 0.
143: ;
144: ; Input: eax - M0
145: ; ebx - N0
146: ; ecx - dM
147: ; edx - dN
148: ; Trashes:
149: ; esi, ebp
150: ; [esp].sf_ptlOrg.ptl_x, [esp].sf_ptlOrg.ptl_y
151: ; Output:
152: ; [esp].sf_x1 - x-coordinate of last pixel (exclusive)
153: ; eax - x-coordinate of first pixel
154: ; ebx - error term
155: ; ecx - dM
156: ; edx - dN
157: ; edi - y-coordinate of first pixel
158: ;-----------------------------------------------------------------------;
159:
160: GIQ macro flags
161: local compute_x1, compute_error_term
162:
163: ; We normalize our coordinate system so that if the start point is
164: ; (M0/F, N0/F), the origin is at (floor(M0/F), (N0/F)):
165:
166: mov esi,eax
167: mov edi,ebx
168: sar esi,FLOG2
169: sar edi,FLOG2
170: mov [esp].sf_ptlOrg.ptl_x,esi
171: ;ptlOrg.x = floor(M0 / F)
172: mov [esp].sf_ptlOrg.ptl_y,edi
173: ;ptlOrg.y = floor(N0 / F)
174:
175: ; Calculate the correct [esp].sf_x1:
176:
177: lea edi,[ebx + edx] ;edi = N1
178: and edi,F - 1
179:
180: if (flags AND ROUND_X_DOWN)
181:
182: if (flags AND ROUND_SLOPE_ONE)
183: lea ebp,[eax + ecx]
184: and ebp,F - 1 ;ebp = M1
185: sub ebp,8
186: cmp ebp,edi ;cmp M1 - 8, N1
187: jne short compute_x1
188:
189: lea ebp,[eax + ecx]
190: sar ebp,FLOG2
191: jmp short compute_error_term
192: endif
193:
194: compute_x1:
195:
196: cmp edi,1
197: sbb edi,8 ;N1 -= 8
198: else
199: sub edi,8 ;N1 -= 8
200: endif
201: sbb esi,esi
202: xor edi,esi
203: sub edi,esi ;N1 = ABS(N1)
204:
205: lea ebp,[eax + ecx]
206: mov esi,ebp
207: sar ebp,FLOG2
208: and esi,F - 1
209: jz short @f ;special case for M1 == 0
210: cmp esi,edi ;cmp M1, N1
211: sbb ebp,-1 ;ebp is now one pixel past the actual
212: @@: ; end coordinate (note that it hasn't
213: ; been affected by the origin shift)
214:
215: compute_error_term:
216:
217: ; eax = M0
218: ; ebx = N0
219: ; ebp = x1
220: ; ecx = dM
221: ; edx = dN
222:
223: and ebx,F - 1
224: mov [esp].sf_x1,ebp ;save x1
225:
226: ; Calculate our error term for x = 0.
227: ;
228: ; NOTE: Since this routine is used only for lines that are unclipped, we
229: ; are guaranteed by our screen size that the values will be far less
230: ; than 32 bits in significance, and so we don't worry about overflow.
231: ; If this is used for clipped lines, these multiplies will have to
232: ; be converted to give 64 bit results, because we can have 36 bits of
233: ; significance!
234:
235:
236: lea edi,[ebx + 8] ;edi = N0 + 8
237: mov esi,ecx
238: imul esi,edi ;esi = dM * (N0 + 8)
239: mov edi,edx
240:
241: ; We have to special case when M0 is 0 -- we know x0 will be zero.
242: ; So we jump ahead a bit to a place where 'eax' is assumed to contain
243: ; x0 -- and it just so happens 'eax' is zero in this case:
244:
245: and eax,F - 1
246: jz short @f
247: imul edi,eax ;edi = dN * M0
248: sub esi,edi
249:
250: ; Calculate the x-coordinate of the first pixel:
251:
252: if (flags AND ROUND_X_DOWN)
253:
254: if (flags AND ROUND_SLOPE_ONE)
255: cmp ebx,8
256: sbb ebx,-1
257: endif
258:
259: cmp ebx,1
260: sbb ebx,8 ;N0 -= 8
261: else
262: sub ebx,8 ;N0 -= 8
263: endif
264: sbb edi,edi
265: xor ebx,edi
266: sub ebx,edi ;N0 = ABS(N0)
267: cmp eax,ebx
268: sbb eax,eax
269: not eax ;eax = -x0
270:
271: ; Now adjust the error term accordingly:
272:
273: @@:
274: if (flags AND ROUND_Y_DOWN)
275: dec esi
276: endif
277: sar esi,FLOG2 ;esi = floor((N0 + 8) dM - M0 dN] / 16)
278:
279: mov ebx,[esp].sf_ptlOrg.ptl_x
280: mov edi,[esp].sf_ptlOrg.ptl_y
281:
282: sub ebx,eax ;ebx = ptlOrg.ptl_x + x0
283:
284: and eax,edx
285: add eax,esi
286: sub eax,ecx ;eax = dN * x0 + initial error - dM
287: jl short @f ;if the error term >= 0, we have to
288: sub eax,ecx ; add 1 to the y position and subtract
289: inc edi ; dM off again
290: @@:
291: xchg eax,ebx
292:
293: endm
294:
295: ;--------------------------------Macro----------------------------------;
296: ; GIQR flags
297: ;
298: ; Same as above, except it handles flips about the line x = y.
299: ;
300: ; Input: eax - M0
301: ; ebx - N0
302: ; ecx - dM
303: ; edx - dN
304: ; Trashes:
305: ; esi, ebp
306: ; [esp].sf_ptlOrg.ptl_x, [esp].sf_ptlOrg.ptl_y
307: ; Output:
308: ; [esp].sf_y1 - y-coordinate of last pixel (exclusive)
309: ; eax - x-coordinate of first pixel
310: ; ebx - error term
311: ; ecx - dM
312: ; edx - dN
313: ; edi - y-coordinate of first pixel
314: ;-----------------------------------------------------------------------;
315:
316: GIQR macro flags
317:
318: ; We normalize our coordinate system so that if the start point is
319: ; (M0/F, N0/F), the origin is at (floor(M0/F), (N0/F)):
320:
321: mov esi,eax
322: mov edi,ebx
323: sar esi,FLOG2
324: sar edi,FLOG2
325: mov [esp].sf_ptlOrg.ptl_x,esi
326: ;ptlOrg.x = floor(M0 / F)
327: mov [esp].sf_ptlOrg.ptl_y,edi
328: ;ptlOrg.y = floor(N0 / F)
329:
330: ; Calculate the correct [esp].sf_y1:
331:
332: lea edi,[eax + ecx] ;edi = M1
333: and edi,F - 1
334:
335: if (flags AND ROUND_Y_DOWN)
336: cmp edi,1
337: sbb edi,8 ;M1 -= 8
338: else
339: sub edi,8 ;M1 -= 8
340: endif
341: sbb esi,esi
342: xor edi,esi
343: sub edi,esi ;M1 = ABS(M1)
344:
345: lea ebp,[ebx + edx]
346: mov esi,ebp
347: sar ebp,FLOG2
348: and esi,F - 1
349: jz short @f ;special case for N1 == 0
350: cmp esi,edi ;cmp N1, M1
351: sbb ebp,-1 ;ebp is now one pixel past the actual
352: @@: ; end coordinate (note that it hasn't
353: ; been affected by the origin shift)
354: and eax,F - 1
355: mov [esp].sf_y1,ebp
356:
357: ; Calculate our error term for y = 0.
358: ;
359: ; NOTE: Since this routine is used only for lines that are unclipped, we
360: ; are guaranteed by our screen size that the values will be far less
361: ; than 32 bits in significance, and so we don't worry about overflow.
362: ; If this is used for clipped lines, these multiplies will have to
363: ; be converted to give 64 bit results, because we can have 36 bits of
364: ; significance!
365:
366: lea edi,[eax + 8] ;edi = M0 + 8
367: mov esi,edx
368: imul esi,edi ;esi = dN * (M0 + 8)
369: mov edi,ecx
370:
371: ; We have to special case when N0 is 0 -- we know y0 will be zero.
372: ; So we jump ahead a bit to a place where 'ebx' is assumed to contain
373: ; y0 -- and it just so happens 'ebx' is zero in this case:
374:
375: and ebx,F - 1
376: jz short @f
377: imul edi,ebx ;edi = dM * N0
378: sub esi,edi
379:
380: ; Calculate the x-coordinate of the first pixel:
381:
382: if (flags AND ROUND_Y_DOWN)
383: cmp eax,1
384: sbb eax,8 ;M0 -= 8
385: else
386: sub eax,8 ;M0 -= 8
387: endif
388: sbb edi,edi
389: xor eax,edi
390: sub eax,edi ;M0 = ABS(M0)
391: cmp ebx,eax
392: sbb ebx,ebx
393: not ebx ;ebx = -y0
394:
395: ; Now adjust the error term accordingly:
396:
397: @@:
398: if (flags AND ROUND_X_DOWN)
399: dec esi
400: endif
401: sar esi,FLOG2 ;esi = floor((M0 + 8) dN - N0 dM] / 16)
402:
403: mov eax,[esp].sf_ptlOrg.ptl_x
404: mov edi,[esp].sf_ptlOrg.ptl_y
405:
406: sub edi,ebx ;edi = ptlOrg.ptl_y + y0
407:
408: and ebx,ecx
409: add ebx,esi
410: sub ebx,edx ;ebx = dM * x0 + initial error - dN
411: jl short @f ;if the error term >= 0, we have to
412: sub ebx,edx ; add 1 to the x position and subtract
413: inc eax ; dN off again
414: @@:
415:
416: endm
417:
418: ;---------------------------Public-Routine------------------------------;
419: ; vFastLine(ppdev, ppo, lNextScan, iColor)
420: ;
421: ; Draws fast lines. Or at least attempts to.
422: ;
423: ; Input:
424: ;
425: ; ppdev - PDEV pointer
426: ; ppo - path
427: ; lNextScan - delta to start of next scan (same as ppdev->lNextScan)
428: ; iColor - color (least significant byte must be the same as the next
429: ; least signficant byte, so that we can do words writes)
430: ;
431: ;-----------------------------------------------------------------------;
432:
433: ; NOTE: Don't go changing parameters without also changing STACK_FRAME!
434:
435: cProc vFastLine,16,< \
436: uses esi edi ebx, \
437: ebp_ppdev: ptr, \
438: ebp_ppo: ptr, \
439: ebp_lNextScan: ptr, \
440: ebp_iColor: dword >
441:
442: ; Leave room for our stack frame.
443: ;
444: ; NOTE: Don't add local variables here -- you can't reference them with
445: ; ebp anyway! Add them to the STACK_FRAME structure.
446:
447: local aj[(size STACK_FRAME) - 4 * (STATE_MEM_SIZE + PROC_MEM_SIZE)]: byte
448:
449: ; We save 'ebp' on the stack (note that STACK_FRAME accounts for this push):
450:
451: push ebp
452:
453: ; Now get some path stuff:
454:
455: next_record:
456:
457: mov esi,[esp].sf_ppo
458: lea eax,[esp].sf_pd
459: cCall PATHOBJ_bEnum,<esi,eax>
460: mov [esp].sf_bMore,eax ;save away return code for later
461:
462: mov eax,[esp].sf_pd.pd_count;if 0 points in record, get outta here
463: or eax,eax
464: jz check_for_closefigure
465:
466: lea edi,[8 * eax - 8]
467: add edi,[esp].sf_pd.pd_pptfx
468: mov [esp].sf_pptfxEnd,edi ;points to last point in record
469:
470: mov ebx,[esp].sf_pd.pd_flags
471: test ebx,PD_BEGINSUBPATH
472: jz short continue_subpath
473:
474: ; Handle a new sub-path:
475:
476: mov esi,[esp].sf_pd.pd_pptfx
477: add esi,8
478: mov [esp].sf_pptfx,esi
479:
480: mov ecx,[edi].ptl_x ;remember last point in case we have
481: mov edx,[edi].ptl_y ; to continue to another record
482: mov [esp].sf_ptfxLast.ptl_x,ecx
483: mov [esp].sf_ptfxLast.ptl_y,edx
484:
485: mov eax,[esi - 8].ptl_x ;load up current start and end point
486: mov ebx,[esi - 8].ptl_y
487: mov ecx,[esi].ptl_x
488: mov edx,[esi].ptl_y
489: mov [esp].sf_ptfxStartFigure.ptl_x,eax
490: mov [esp].sf_ptfxStartFigure.ptl_y,ebx
491:
492: cmp esi,[esp].sf_pptfxEnd ;we have to be careful when the only
493: ; point in the record is the start-
494: ; figure point (pretty rare)
495: jbe new_line
496: jmp short next_record
497:
498: continue_subpath:
499:
500: ; This record continues the path:
501:
502: mov esi,[esp].sf_pd.pd_pptfx
503: mov eax,[esp].sf_ptfxLast.ptl_x ;load up current start point
504: mov ebx,[esp].sf_ptfxLast.ptl_y
505:
506: mov ecx,[edi].ptl_x ;remember last point in case we have
507: mov edx,[edi].ptl_y ; to continue to another record
508: mov [esp].sf_ptfxLast.ptl_x,ecx
509: mov [esp].sf_ptfxLast.ptl_y,edx
510:
511: mov ecx,[esi].ptl_x ;load up current end point
512: mov edx,[esi].ptl_y
513: mov [esp].sf_pptfx,esi
514: jmp short new_line
515:
516: ;/////////////////////////////////////////////////////////////////////
517: ;// Next Line Stuff
518: ;/////////////////////////////////////////////////////////////////////
519:
520: handle_closefigure:
521: mov [esp].sf_pd.pd_flags,0
522: mov eax,[esp].sf_ptfxLast.ptl_x
523: mov ebx,[esp].sf_ptfxLast.ptl_y
524: mov ecx,[esp].sf_ptfxStartFigure.ptl_x
525: mov edx,[esp].sf_ptfxStartFigure.ptl_y
526: jmp new_line
527:
528: ; Before getting the next path record, see if we have to do a closefigure:
529:
530: check_for_closefigure:
531: test [esp].sf_pd.pd_flags,PD_CLOSEFIGURE
532: jnz handle_closefigure
533: mov ecx,[esp].sf_bMore
534: or ecx,ecx
535: jnz next_record
536:
537: all_done:
538:
539: pop ebp
540: cRet vFastLine
541:
542: public next_line
543: next_line:
544: mov esi,[esp].sf_pptfx
545: cmp esi,[esp].sf_pptfxEnd
546: jae short check_for_closefigure
547:
548: mov eax,[esi].ptl_x
549: mov ebx,[esi].ptl_y
550: mov ecx,[esi+8].ptl_x
551: mov edx,[esi+8].ptl_y
552: add esi,8
553: mov [esp].sf_pptfx,esi
554:
555: ;/////////////////////////////////////////////////////////////////////
556: ;// Main Loop
557: ;/////////////////////////////////////////////////////////////////////
558:
559: public new_line
560: new_line:
561:
562: ; Octants are numbered as follows:
563: ;
564: ; \ 5 | 6 /
565: ; \ | /
566: ; 4 \ | / 7
567: ; \ /
568: ; -----+-----
569: ; /|\
570: ; 3 / | \ 0
571: ; / | \
572: ; / 2 | 1 \
573: ;
574:
575: ; eax = M0
576: ; ebx = N0
577: ; ecx = M1 (dM)
578: ; edx = N1 (dN)
579:
580: sub ecx,eax
581: jl octants_2_3_4_5
582: sub edx,ebx
583: jl octants_6_7
584: cmp ecx,edx
585: jl octant_1
586:
587: ;/////////////////////////////////////////////////////////////////////
588: ;// Octant 0
589: ;/////////////////////////////////////////////////////////////////////
590:
591: public octant_0
592: octant_0:
593: mov esi,[esp].sf_lNextScan
594: mov [esp].sf_lDelta,esi ;we're going down
595: mov [esp].sf_pfnNextBank,offset bank_x_major_next_lower
596:
597: mov esi,ecx
598: or esi,edx
599: jz next_line ;we do an early check here for
600: ; lines that start and end on the
601: ; same GIQ point, because those
602: ; occur surprisingly often.
603: or esi,eax
604: or esi,ebx
605: and esi,F - 1
606: jnz oct_0_non_integer
607:
608: or edx,edx
609: jz do_horizontal_line
610:
611: mov esi,[esp].sf_ppdev
612: sar eax,FLOG2 ;x0
613: sar ebx,FLOG2 ;y0
614:
615: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
616: jl short oct_0_map_in_bank
617:
618: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
619: jl short oct_0_done_bank_map
620:
621: oct_0_map_in_bank:
622: push eax
623: push ecx
624: push edx
625:
626: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
627:
628: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
629: <esi, ebx, JustifyTop> ;###
630:
631: pop edx
632: pop ecx
633: pop eax
634:
635: public oct_0_done_bank_map
636: oct_0_done_bank_map:
637: mov edi,[esp].sf_lNextScan
638: imul edi,ebx
639: add edi,[esi].pdev_pvBitmapStart
640: add edi,eax ;edi now points to start byte
641:
642: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
643: sub ebp,ebx ;### ebp = # of scans before end of bank
644:
645: mov esi,ecx
646: sar esi,FLOG2 ;esi = # of pixels to lay down
647:
648: mov ebx,-1 ;### round y = 1/2 *DOWN* in value
649: sub ebx,ecx
650: sar ebx,1 ;now have error term
651:
652: mov eax,[esp].sf_iColor
653: sub ecx,edx ;ecx = dM - dN
654: cmp edx,ecx
655: jg oct_07b
656:
657: ;-------------------------------------------------------------------------;
658: ; Left-to-right Lines With ABS(Slope) <= 1/2
659: ; ------------------------------------------
660: ;
661: ; Since the line's slope is less than 1/2, we have only 3 possibilities
662: ; at each pair of pixels:
663: ;
664: ; Case 1: o Case 2: o o Case 3: o o o
665: ; o o o
666: ;
667: ; Case: err + dN >= 0 err + 2dN >= 0 err + 2dN < 0
668: ; New: err += 2dN - dM err += 2dN - dM err += 2dN
669: ;
670: ; eax = color
671: ; ebx = error term
672: ; ecx = dM - dN
673: ; edx = dN
674: ; esi = # of pixels to lay down
675: ; edi = memory pointer
676: ; ebp = # of scans before end of bank
677: ;-------------------------------------------------------------------------;
678:
679: public oct_07a
680: oct_07a:
681: test edi,1
682: jz short oct_07a_main ;start is word aligned
683:
684: ; Handle unaligned start:
685:
686: dec esi
687: jl next_line
688:
689: mov [edi],al
690: inc edi
691: add ebx,edx ;err += dN
692: jl short oct_07a_main
693:
694: add edi,[esp].sf_lDelta
695: dec ebp ;hit a new bank?
696: jz short oct_07a_next_bank_3
697: oct_07a_done_bank_3:
698: sub ebx,ecx ;err += dN - dM
699: jl short oct_07a_continue
700:
701: ;;; Case 1:
702:
703: public oct_07a_case_1
704: oct_07a_case_1:
705: sub esi,2
706: jl short oct_07a_done
707: mov [edi],al
708: add edi,[esp].sf_lDelta
709: add edi,2
710: dec ebp
711: jz short oct_07a_next_bank_1
712: oct_07a_done_bank_1:
713: mov [edi-1],al
714: sub ebx,ecx ;err += dN - dM
715: ;;;case 1 is done
716: ;;; Main loop:
717:
718: oct_07a_main:
719: add ebx,edx ;err += dN
720: jge short oct_07a_case_1
721: oct_07a_continue:
722: sub esi,2
723: jl short oct_07a_done
724: mov [edi],ax
725: add edi,2
726: add ebx,edx ;err += dN
727: jl short oct_07a_main ;;;case 3 is done
728:
729: ;;; Handle end of case 2:
730:
731: add edi,[esp].sf_lDelta
732: dec ebp
733: jz short oct_07a_next_bank_2
734: oct_07a_done_bank_2:
735: sub ebx,ecx ;err += dN - dM
736: jge short oct_07a_case_1
737: jmp short oct_07a_continue ;;;case 2 is done
738:
739: oct_07a_done:
740: inc esi ;esi = -1 means do another pixel
741: jnz next_line
742: mov [edi],al
743: jmp next_line
744:
745: oct_07a_next_bank_1:
746: mov [esp].sf_pfnReturn,offset oct_07a_done_bank_1
747: jmp [esp].sf_pfnNextBank
748: oct_07a_next_bank_2:
749: mov [esp].sf_pfnReturn,offset oct_07a_done_bank_2
750: jmp [esp].sf_pfnNextBank
751: oct_07a_next_bank_3:
752: mov [esp].sf_pfnReturn,offset oct_07a_done_bank_3
753: jmp [esp].sf_pfnNextBank
754:
755: ;-------------------------------------------------------------------------;
756: ; Left-to-right Lines With 1/2 < ABS(Slope) <= 1
757: ; ----------------------------------------------
758: ;
759: ; Since the line's slope is between 1/2 and 1, we have only 3 possibilities
760: ; at each pair of pixels:
761: ;
762: ; Case 1: o o Case 2: o Case 3: o
763: ; o o o o
764: ; o
765: ;
766: ; Case: err + dN < 0 err + 2dN - dM < 0 err + 2dN - dM >= 0
767: ; New: err += 2dN - dM err += 2dN - dM err += 2dN - 2dM
768: ;
769: ; eax = color
770: ; ebx = error term
771: ; ecx = dM - dN
772: ; edx = dN
773: ; esi = # of pixels to lay down
774: ; edi = memory pointer
775: ; ebp = # of scans before end of bank
776: ;-------------------------------------------------------------------------;
777:
778: public oct_07b
779: oct_07b:
780: test edi,1
781: jz short oct_07b_main
782:
783: dec esi
784: jl next_line
785:
786: mov [edi],al
787: inc edi
788: add ebx,edx ;err += dN
789: jl short oct_07b_main
790:
791: add edi,[esp].sf_lDelta
792: dec ebp
793: jz short oct_07b_next_bank_4
794: oct_07b_done_bank_4:
795: sub ebx,ecx ;err += dN - dM
796: jge short oct_07b_continue
797:
798: public oct_07b_case_1
799: oct_07b_case_1:
800: sub esi,2
801: jl short oct_07b_done
802: mov [edi],ax
803: add edi,[esp].sf_lDelta
804: add edi,2
805: dec ebp
806: jz short oct_07b_next_bank_1
807: oct_07b_done_bank_1:
808: sub ebx,ecx ;err += dN - dM
809: ;;;case 1 is done
810: ;;; Main loop:
811:
812: oct_07b_main:
813: add ebx,edx ;err += dN
814: jl short oct_07b_case_1
815: oct_07b_continue:
816: sub esi,2
817: jl short oct_07b_done
818: mov [edi],al
819: add edi,[esp].sf_lDelta
820: add edi,2
821: dec ebp
822: jz short oct_07b_next_bank_2
823: oct_07b_done_bank_2:
824: mov [edi-1],al
825: sub ebx,ecx ;err += dN - dM
826: jl short oct_07b_main ;;;case 2 is done
827:
828: add edi,[esp].sf_lDelta
829: dec ebp
830: jz oct_07b_next_bank_3
831: oct_07b_done_bank_3:
832: sub ebx,ecx ;err += dN - dM
833: jl short oct_07b_case_1 ;;;case 3 is done
834: jmp short oct_07b_continue
835:
836: oct_07b_next_bank_4:
837: mov [esp].sf_pfnReturn,offset oct_07b_done_bank_4
838: jmp [esp].sf_pfnNextBank
839: oct_07b_next_bank_3:
840: mov [esp].sf_pfnReturn,offset oct_07b_done_bank_3
841: jmp [esp].sf_pfnNextBank
842: oct_07b_next_bank_2:
843: mov [esp].sf_pfnReturn,offset oct_07b_done_bank_2
844: jmp [esp].sf_pfnNextBank
845: oct_07b_next_bank_1:
846: mov [esp].sf_pfnReturn,offset oct_07b_done_bank_1
847: jmp [esp].sf_pfnNextBank
848:
849: oct_07b_done:
850: inc esi
851: jnz next_line ;esi = -1 means do another pixel
852: mov [edi],al
853: jmp next_line
854:
855: ;-------------------------------------------------------------------------;
856:
857: public oct_0_non_integer
858: oct_0_non_integer:
859: cmp ecx,edx
860: je oct_0_slope_one ;have a special case rounding rule for
861: ; 45 degree lines (which only affects
862: ; non-integer lines)
863:
864: GIQ ROUND_X_AND_Y_DOWN ;### round x=1/2, y=1/2 down in value
865:
866: or edx,edx
867: jz do_non_integer_horizontal_line
868:
869: oct_0_common:
870: mov esi,[esp].sf_ppdev
871: cmp edi,[esi].pdev_rcl1WindowClip.yTop
872: jl short oct_0_nonint_map_in_bank
873:
874: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
875: jl short oct_0_nonint_done_bank_map
876:
877: oct_0_nonint_map_in_bank:
878: push eax
879: push ecx
880: push edx
881:
882: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
883: <esi, edi, JustifyTop> ;###
884:
885: pop edx
886: pop ecx
887: pop eax
888:
889: oct_0_nonint_done_bank_map:
890: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
891: sub ebp,edi ;### ebp = # scans before end of bank
892:
893: imul edi,[esp].sf_lNextScan ;
894: add edi,[esi].pdev_pvBitmapStart
895: add edi,eax ;edi now points to start byte
896:
897: mov esi,[esp].sf_x1
898: sub esi,eax ;esi = # pixels to lay down
899:
900: mov eax,[esp].sf_iColor
901:
902: sub ecx,edx ;ecx = dM - dN
903: cmp edx,ecx
904: jg oct_07b
905: jmp oct_07a
906:
907: ;-------------------------------------------------------------------;
908: ; 45 degree lines have a special rounding rule: when the line
909: ; runs exactly half way between to pixels, the upper or right pel
910: ; is illuminated. This translates into x=1/2 rounding up, and
911: ; y=1/2 rounding down in value:
912:
913: public oct_0_slope_one
914: oct_0_slope_one:
915: GIQ ROUND_Y_DOWN_SLOPE_ONE ;round y=1/2 down in value
916: jmp oct_0_common
917:
918: ;/////////////////////////////////////////////////////////////////////
919: ;// Octant 1
920: ;/////////////////////////////////////////////////////////////////////
921:
922: public octant_1
923: octant_1:
924: mov [esp].sf_pfnNextBank,offset bank_y_major_next_lower
925:
926: mov esi,eax
927: or esi,ebx
928: or esi,ecx
929: or esi,edx
930: and esi,F - 1
931: jnz oct_1_non_integer
932:
933: mov esi,[esp].sf_ppdev
934: sar eax,FLOG2 ;x0
935: sar ebx,FLOG2 ;y0
936:
937: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
938: jl short oct_1_map_in_bank
939:
940: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
941: jl short oct_1_done_bank_map
942:
943: oct_1_map_in_bank:
944: push eax
945: push ecx
946: push edx
947:
948: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
949:
950: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
951: <esi, ebx, JustifyTop> ;###
952:
953: pop edx
954: pop ecx
955: pop eax
956:
957: public oct_1_done_bank_map
958: oct_1_done_bank_map:
959: mov edi,[esp].sf_lNextScan
960: imul edi,ebx
961: add edi,[esi].pdev_pvBitmapStart
962: add edi,eax ;edi now points to start byte
963:
964: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
965: sub ebp,ebx ;### ebp = # of scans before end of bank
966:
967: mov esi,edx
968: sar esi,FLOG2 ;esi = # of pixels to lay down
969:
970: sub esi,ebp
971: sbb ebx,ebx
972: and ebx,esi
973: add ebp,ebx ;ebp = # of pels in this bank
974:
975: mov [esp].sf_cAfterThisBank,esi
976: mov esi,[esp].sf_lNextScan
977:
978: mov ebx,-1 ;### round x = 1/2 *DOWN* in value
979: sub ebx,edx
980: sar ebx,1 ;now have error term
981:
982: mov eax,[esp].sf_iColor
983:
984: ;-------------------------------------------------------------------------;
985: ; Left-to-right Lines With Abs(Slope) > 1/2
986: ; -----------------------------------------
987: ;
988: ; eax = color
989: ; ebx = error term
990: ; ecx = dM
991: ; edx = dN
992: ; esi = delta
993: ; edi = memory pointer
994: ; ebp = # of scans before end of bank
995: ;-------------------------------------------------------------------------;
996:
997: oct_1_main_loop:
998: dec ebp
999: jl short oct_1_see_if_more
1000: mov [edi],al
1001: add edi,esi
1002: add ebx,ecx ;err += dM
1003: jl short oct_1_main_loop
1004:
1005: inc edi ;one to right
1006: sub ebx,edx ;err -= dN
1007:
1008: ; Unroll a bit:
1009:
1010: dec ebp
1011: jl short oct_1_see_if_more
1012: mov [edi],al
1013: add edi,esi
1014: add ebx,ecx ;err += dM
1015: jl short oct_1_main_loop
1016:
1017: inc edi ;one to right
1018: sub ebx,edx ;err -= dN
1019: jmp short oct_1_main_loop
1020:
1021: public oct_1_see_if_more
1022: oct_1_see_if_more:
1023: mov eax,[esp].sf_cAfterThisBank
1024: cmp eax,0
1025: jle next_line
1026:
1027: mov [esp].sf_pfnReturn,offset oct_1_main_loop
1028: jmp [esp].sf_pfnNextBank
1029:
1030: public oct_1_non_integer
1031: oct_1_non_integer:
1032: GIQR ROUND_X_AND_Y_DOWN ;### round x=1/2, y=1/2 down in value
1033:
1034: mov esi,[esp].sf_ppdev
1035: cmp edi,[esi].pdev_rcl1WindowClip.yTop
1036: jl short oct_1_nonint_map_in_bank
1037:
1038: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
1039: jl short oct_1_nonint_done_bank_map
1040:
1041: oct_1_nonint_map_in_bank:
1042: push eax
1043: push ecx
1044: push edx
1045:
1046: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1047: <esi, edi, JustifyTop> ;###
1048:
1049: pop edx
1050: pop ecx
1051: pop eax
1052:
1053: oct_1_nonint_done_bank_map:
1054: mov [esp].sf_y0,edi
1055: imul edi,[esp].sf_lNextScan
1056: add edi,[esi].pdev_pvBitmapStart
1057: add edi,eax ;edi points to start byte
1058:
1059: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
1060: mov esi,[esp].sf_y1
1061: sub esi,ebp
1062:
1063: sbb eax,eax
1064: and eax,esi
1065: add ebp,eax
1066: sub ebp,[esp].sf_y0 ;ebp = min(y1,
1067: ; ppdev->rcl1WindowClip.yBottom) - y0
1068: ; (# of pixels to lay down)
1069:
1070: mov [esp].sf_cAfterThisBank,esi
1071:
1072: mov esi,[esp].sf_lNextScan
1073: mov eax,[esp].sf_iColor
1074:
1075: jmp oct_1_main_loop
1076:
1077: ;/////////////////////////////////////////////////////////////////////
1078: ;// Octant 3
1079: ;/////////////////////////////////////////////////////////////////////
1080:
1081: octants_2_3_4_5:
1082: neg ecx ;dM = -dM (now positive)
1083: neg eax ;M0 = -M0
1084: sub edx,ebx
1085: jl octants_4_5
1086: cmp ecx,edx
1087: jl octant_2
1088:
1089: public octant_3
1090: octant_3:
1091: mov esi,[esp].sf_lNextScan
1092: mov [esp].sf_lDelta,esi ;we're going down
1093: mov [esp].sf_pfnNextBank,offset bank_x_major_next_lower
1094:
1095: mov esi,eax
1096: or esi,ebx
1097: or esi,ecx
1098: or esi,edx
1099: and esi,F - 1
1100: jnz oct_3_non_integer
1101:
1102: or edx,edx
1103: jz flip_and_do_horizontal_line
1104:
1105: mov esi,[esp].sf_ppdev
1106:
1107: neg eax ;### untransform M0
1108:
1109: sar eax,FLOG2 ;x0
1110: sar ebx,FLOG2 ;y0
1111:
1112: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
1113: jl short oct_3_map_in_bank
1114:
1115: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
1116: jl short oct_3_done_bank_map
1117:
1118: oct_3_map_in_bank:
1119: push eax
1120: push ecx
1121: push edx
1122:
1123: ; ebx, esi, edi and esi are preserved according to C calling conventions:
1124:
1125: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1126: <esi, ebx, JustifyTop> ;###
1127:
1128: pop edx
1129: pop ecx
1130: pop eax
1131:
1132: public oct_3_done_bank_map
1133: oct_3_done_bank_map:
1134: mov edi,[esp].sf_lNextScan
1135: imul edi,ebx
1136: add edi,[esi].pdev_pvBitmapStart
1137: add edi,eax ;edi now points to start byte
1138:
1139: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
1140: sub ebp,ebx ;### ebp = # of scans before end of bank
1141:
1142: mov esi,ecx
1143: sar esi,FLOG2 ;esi = # of pixels to lay down
1144:
1145: mov ebx,-1 ;### round y = 1/2 *DOWN* in value
1146: sub ebx,ecx
1147: sar ebx,1 ;now have error term
1148:
1149: mov eax,[esp].sf_iColor
1150: sub ecx,edx ;ecx = dM - dN
1151: cmp edx,ecx
1152: jg oct_34b
1153:
1154: ;-------------------------------------------------------------------------;
1155: ; Right-to-left Lines With ABS(Slope) <= 1/2
1156: ; ------------------------------------------
1157: ;
1158: ; Since the line's slope is less than 1/2, we have only 3 possibilities
1159: ; at each pair of pixels:
1160: ;
1161: ; Case 1: o Case 2: o o Case 3: o o o
1162: ; o o o
1163: ;
1164: ; Case: err + dN >= 0 err + 2dN >= 0 err + 2dN < 0
1165: ; New: err += 2dN - dM err += 2dN - dM err += 2dN
1166: ;
1167: ; eax = color
1168: ; ebx = error term
1169: ; ecx = dM - dN
1170: ; edx = dN
1171: ; esi = # of pixels to lay down
1172: ; edi = memory pointer
1173: ; ebp = # of scans before end of bank
1174: ;-------------------------------------------------------------------------;
1175:
1176: oct_34a:
1177: test edi,1
1178: jnz short oct_34a_main ;### start is word aligned
1179:
1180: ; Handle unaligned start:
1181:
1182: dec esi
1183: jl next_line
1184:
1185: mov [edi],al
1186: dec edi ;###
1187: add ebx,edx ;err += dN
1188: jl short oct_34a_main
1189:
1190: add edi,[esp].sf_lDelta
1191: dec ebp ;hit a new bank?
1192: jz short oct_34a_next_bank_3
1193: oct_34a_done_bank_3:
1194: sub ebx,ecx ;err += dN - dM
1195: jl short oct_34a_continue
1196:
1197: ;;; Case 1:
1198:
1199: public oct_34a_case_1
1200: oct_34a_case_1:
1201: sub esi,2
1202: jl short oct_34a_done
1203: mov [edi],al
1204: add edi,[esp].sf_lDelta
1205: sub edi,2 ;###
1206: dec ebp
1207: jz short oct_34a_next_bank_1
1208: oct_34a_done_bank_1:
1209: mov [edi+1],al
1210: sub ebx,ecx ;err += dN - dM
1211: ;;;case 1 is done
1212: ;;; Main loop:
1213:
1214: oct_34a_main:
1215: add ebx,edx ;err += dN
1216: jge short oct_34a_case_1
1217: oct_34a_continue:
1218: sub esi,2
1219: jl short oct_34a_done
1220: mov [edi-1],ax ;###
1221: sub edi,2 ;###
1222: add ebx,edx ;err += dN
1223: jl short oct_34a_main ;;;case 3 is done
1224:
1225: ;;; Handle end of case 2:
1226:
1227: add edi,[esp].sf_lDelta
1228: dec ebp
1229: jz short oct_34a_next_bank_2
1230: oct_34a_done_bank_2:
1231: sub ebx,ecx ;err += dN - dM
1232: jge short oct_34a_case_1
1233: jmp short oct_34a_continue ;;;case 2 is done
1234:
1235: oct_34a_done:
1236: inc esi ;esi = -1 means do another pixel
1237: jnz next_line
1238: mov [edi],al
1239: jmp next_line
1240:
1241: oct_34a_next_bank_1:
1242: mov [esp].sf_pfnReturn,offset oct_34a_done_bank_1
1243: jmp [esp].sf_pfnNextBank
1244: oct_34a_next_bank_2:
1245: mov [esp].sf_pfnReturn,offset oct_34a_done_bank_2
1246: jmp [esp].sf_pfnNextBank
1247: oct_34a_next_bank_3:
1248: mov [esp].sf_pfnReturn,offset oct_34a_done_bank_3
1249: jmp [esp].sf_pfnNextBank
1250:
1251: ;-------------------------------------------------------------------------;
1252: ; Right-to-left Lines With 1/2 < ABS(Slope) <= 1
1253: ; ----------------------------------------------
1254: ;
1255: ; Since the line's slope is between 1/2 and 1, we have only 3 possibilities
1256: ; at each pair of pixels:
1257: ;
1258: ; Case 1: o o Case 2: o Case 3: o
1259: ; o o o o
1260: ; o
1261: ;
1262: ; Case: err + dN < 0 err + 2dN - dM < 0 err + 2dN - dM >= 0
1263: ; New: err += 2dN - dM err += 2dN - dM err += 2dN - 2dM
1264: ;
1265: ; eax = color
1266: ; ebx = error term
1267: ; ecx = dM - dN
1268: ; edx = dN
1269: ; esi = # of pixels to lay down
1270: ; edi = memory pointer
1271: ; ebp = # of scans before end of bank
1272: ;-------------------------------------------------------------------------;
1273:
1274: public oct_34b
1275: oct_34b:
1276: test edi,1
1277: jnz short oct_34b_main ;###
1278:
1279: dec esi
1280: jl next_line
1281:
1282: mov [edi],al
1283: dec edi ;###
1284: add ebx,edx ;err += dN
1285: jl short oct_34b_main
1286:
1287: add edi,[esp].sf_lDelta
1288: dec ebp
1289: jz short oct_34b_next_bank_4
1290: oct_34b_done_bank_4:
1291: sub ebx,ecx ;err += dN - dM
1292: jge short oct_34b_continue
1293:
1294: public oct_34b_case_1
1295: oct_34b_case_1:
1296: sub esi,2
1297: jl short oct_34b_done
1298: mov [edi-1],ax ;###
1299: add edi,[esp].sf_lDelta
1300: sub edi,2 ;###
1301: dec ebp
1302: jz short oct_34b_next_bank_1
1303: oct_34b_done_bank_1:
1304: sub ebx,ecx ;err += dN - dM
1305: ;;;case 1 is done
1306: ;;; Main loop:
1307:
1308: oct_34b_main:
1309: add ebx,edx ;err += dN
1310: jl short oct_34b_case_1
1311: oct_34b_continue:
1312: sub esi,2
1313: jl short oct_34b_done
1314: mov [edi],al
1315: add edi,[esp].sf_lDelta
1316: sub edi,2 ;###
1317: dec ebp
1318: jz short oct_34b_next_bank_2
1319: oct_34b_done_bank_2:
1320: mov [edi+1],al
1321: sub ebx,ecx ;err += dN - dM
1322: jl short oct_34b_main ;;;case 2 is done
1323:
1324: add edi,[esp].sf_lDelta
1325: dec ebp
1326: jz oct_34b_next_bank_3
1327: oct_34b_done_bank_3:
1328: sub ebx,ecx ;err += dN - dM
1329: jl short oct_34b_case_1 ;;;case 3 is done
1330: jmp short oct_34b_continue
1331:
1332: oct_34b_next_bank_4:
1333: mov [esp].sf_pfnReturn,offset oct_34b_done_bank_4
1334: jmp [esp].sf_pfnNextBank
1335: oct_34b_next_bank_3:
1336: mov [esp].sf_pfnReturn,offset oct_34b_done_bank_3
1337: jmp [esp].sf_pfnNextBank
1338: oct_34b_next_bank_2:
1339: mov [esp].sf_pfnReturn,offset oct_34b_done_bank_2
1340: jmp [esp].sf_pfnNextBank
1341: oct_34b_next_bank_1:
1342: mov [esp].sf_pfnReturn,offset oct_34b_done_bank_1
1343: jmp [esp].sf_pfnNextBank
1344:
1345: oct_34b_done:
1346: inc esi
1347: jnz next_line ;esi = -1 means do another pixel
1348: mov [edi],al
1349: jmp next_line
1350:
1351: ;-------------------------------------------------------------------------;
1352:
1353: public oct_3_non_integer
1354: oct_3_non_integer:
1355: GIQ ROUND_Y_DOWN ;### round y=1/2 down in value
1356: ;### (remember that we're flipped
1357: ;### in 'x')
1358:
1359: or edx,edx
1360: jz flip_and_do_non_integer_horizontal_line
1361:
1362: mov esi,[esp].sf_ppdev
1363: neg eax ;### Untransform x0
1364: cmp edi,[esi].pdev_rcl1WindowClip.yTop
1365: jl short oct_3_nonint_map_in_bank
1366:
1367: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
1368: jl short oct_3_nonint_done_bank_map
1369:
1370: oct_3_nonint_map_in_bank:
1371: push eax
1372: push ecx
1373: push edx
1374:
1375: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1376: <esi, edi, JustifyTop> ;###
1377:
1378: pop edx
1379: pop ecx
1380: pop eax
1381:
1382: oct_3_nonint_done_bank_map:
1383: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
1384: sub ebp,edi ;### ebp = # scans before end of bank
1385:
1386: imul edi,[esp].sf_lNextScan ;
1387: add edi,[esi].pdev_pvBitmapStart
1388: add edi,eax ;edi now points to start byte
1389:
1390: mov esi,[esp].sf_x1
1391: add esi,eax ;### esi = # pixels to lay down
1392:
1393: mov eax,[esp].sf_iColor
1394:
1395: sub ecx,edx ;ecx = dM - dN
1396: cmp edx,ecx
1397: jg oct_34b
1398: jmp oct_34a
1399:
1400: ;/////////////////////////////////////////////////////////////////////
1401: ;// Octant 2
1402: ;/////////////////////////////////////////////////////////////////////
1403:
1404: public octant_2
1405: octant_2:
1406: mov [esp].sf_pfnNextBank,offset bank_y_major_next_lower
1407:
1408: mov esi,eax
1409: or esi,ebx
1410: or esi,ecx
1411: or esi,edx
1412: and esi,F - 1
1413: jnz oct_2_non_integer
1414:
1415: neg eax ;### untransform M0
1416:
1417: mov esi,[esp].sf_ppdev
1418: sar eax,FLOG2 ;x0
1419: sar ebx,FLOG2 ;y0
1420:
1421: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
1422: jl short oct_2_map_in_bank
1423:
1424: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
1425: jl short oct_2_done_bank_map
1426:
1427: oct_2_map_in_bank:
1428: push eax
1429: push ecx
1430: push edx
1431:
1432: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
1433:
1434: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1435: <esi, ebx, JustifyTop> ;###
1436:
1437: pop edx
1438: pop ecx
1439: pop eax
1440:
1441: public oct_2_done_bank_map
1442: oct_2_done_bank_map:
1443: mov edi,[esp].sf_lNextScan
1444: imul edi,ebx
1445: add edi,[esi].pdev_pvBitmapStart
1446: add edi,eax ;edi now points to start byte
1447:
1448: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
1449: sub ebp,ebx ;### ebp = # of scans before end of bank
1450:
1451: mov esi,edx
1452: sar esi,FLOG2 ;esi = # of pixels to lay down
1453:
1454: sub esi,ebp
1455: sbb ebx,ebx
1456: and ebx,esi
1457: add ebp,ebx ;ebp = # of pels in this bank
1458:
1459: mov [esp].sf_cAfterThisBank,esi
1460: mov esi,[esp].sf_lNextScan
1461:
1462: xor ebx,ebx ;### round x = 1/2 *UP* in value
1463: sub ebx,edx
1464: sar ebx,1 ;now have error term
1465:
1466: mov eax,[esp].sf_iColor
1467:
1468: ;-------------------------------------------------------------------------;
1469: ; Right-to-left Lines With Abs(Slope) > 1/2
1470: ; -----------------------------------------
1471: ;
1472: ; eax = color
1473: ; ebx = error term
1474: ; ecx = dM
1475: ; edx = dN
1476: ; esi = delta
1477: ; edi = memory pointer
1478: ; ebp = # of scans before end of bank
1479: ;-------------------------------------------------------------------------;
1480:
1481: oct_2_main_loop:
1482: dec ebp
1483: jl short oct_2_see_if_more
1484: mov [edi],al
1485: add edi,esi
1486: add ebx,ecx ;err += dM
1487: jl short oct_2_main_loop
1488:
1489: dec edi ;one to left
1490: sub ebx,edx ;err -= dN
1491:
1492: ; Unroll a bit:
1493:
1494: dec ebp
1495: jl short oct_2_see_if_more
1496: mov [edi],al
1497: add edi,esi
1498: add ebx,ecx ;err += dM
1499: jl short oct_2_main_loop
1500:
1501: dec edi ;one to left
1502: sub ebx,edx ;err -= dN
1503: jmp short oct_2_main_loop
1504:
1505: public oct_2_see_if_more
1506: oct_2_see_if_more:
1507: mov eax,[esp].sf_cAfterThisBank
1508: cmp eax,0
1509: jle next_line
1510:
1511: mov [esp].sf_pfnReturn,offset oct_2_main_loop
1512: jmp [esp].sf_pfnNextBank
1513:
1514: public oct_2_non_integer
1515: oct_2_non_integer:
1516: GIQR ROUND_Y_DOWN ;### round y=1/2 down in value
1517: ;### (remember that we're flipped
1518: ;### in 'x')
1519:
1520: mov esi,[esp].sf_ppdev
1521:
1522: neg eax ;### untransform x0
1523:
1524: cmp edi,[esi].pdev_rcl1WindowClip.yTop
1525: jl short oct_2_nonint_map_in_bank
1526:
1527: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
1528: jl short oct_2_nonint_done_bank_map
1529:
1530: oct_2_nonint_map_in_bank:
1531: push eax
1532: push ecx
1533: push edx
1534:
1535: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1536: <esi, edi, JustifyTop> ;###
1537:
1538: pop edx
1539: pop ecx
1540: pop eax
1541:
1542: oct_2_nonint_done_bank_map:
1543: mov [esp].sf_y0,edi
1544: imul edi,[esp].sf_lNextScan
1545: add edi,[esi].pdev_pvBitmapStart
1546: add edi,eax ;edi points to start byte
1547:
1548: mov ebp,[esi].pdev_rcl1WindowClip.yBottom
1549: mov esi,[esp].sf_y1
1550: sub esi,ebp
1551:
1552: sbb eax,eax
1553: and eax,esi
1554: add ebp,eax
1555: sub ebp,[esp].sf_y0 ;ebp = min(y1,
1556: ; ppdev->rcl1WindowClip.yBottom) - y0
1557: ; (# of pixels to lay down)
1558:
1559: mov [esp].sf_cAfterThisBank,esi
1560:
1561: mov esi,[esp].sf_lNextScan
1562: mov eax,[esp].sf_iColor
1563:
1564: jmp oct_2_main_loop
1565:
1566: ;/////////////////////////////////////////////////////////////////////
1567: ;// Octant 4
1568: ;/////////////////////////////////////////////////////////////////////
1569:
1570: octants_4_5:
1571: neg edx
1572: neg ebx
1573: cmp ecx,edx
1574: jl octant_5
1575:
1576: public octant_4
1577: octant_4:
1578: mov esi,[esp].sf_lNextScan
1579: neg esi
1580: mov [esp].sf_lDelta,esi ;we're going up
1581: mov [esp].sf_pfnNextBank,offset bank_x_major_next_upper
1582:
1583: mov esi,eax
1584: or esi,ebx
1585: or esi,ecx
1586: or esi,edx
1587: and esi,F - 1
1588: jnz oct_4_non_integer
1589:
1590: neg eax ;### untransform x
1591: neg ebx ;### untransform y
1592:
1593: mov esi,[esp].sf_ppdev
1594: sar eax,FLOG2 ;x0
1595: sar ebx,FLOG2 ;y0
1596:
1597: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
1598: jl short oct_4_map_in_bank
1599:
1600: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
1601: jl short oct_4_done_bank_map
1602:
1603: oct_4_map_in_bank:
1604: push eax
1605: push ecx
1606: push edx
1607:
1608: ; ebx, esi, edi and esi are preserved according to C calling conventions:
1609:
1610: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1611: <esi, ebx, JustifyBottom> ;###
1612:
1613: pop edx
1614: pop ecx
1615: pop eax
1616:
1617: public oct_4_done_bank_map
1618: oct_4_done_bank_map:
1619: mov edi,[esp].sf_lNextScan
1620: imul edi,ebx
1621: add edi,[esi].pdev_pvBitmapStart
1622: add edi,eax ;edi now points to start byte
1623:
1624: mov ebp,ebx ;###
1625: sub ebp,[esi].pdev_rcl1WindowClip.yTop
1626: inc ebp ;### ebp = # scans before end of bank
1627:
1628: mov esi,ecx
1629: sar esi,FLOG2 ;esi = # of pixels to lay down
1630:
1631: xor ebx,ebx ;### round y = 1/2 *UP* in value
1632: sub ebx,ecx
1633: sar ebx,1 ;now have error term
1634:
1635: mov eax,[esp].sf_iColor
1636: sub ecx,edx ;ecx = dM - dN
1637: cmp edx,ecx
1638: jg oct_34b
1639: jmp oct_34a
1640:
1641: public oct_4_non_integer
1642: oct_4_non_integer:
1643: cmp ecx,edx
1644: je oct_4_slope_one
1645: GIQ 0 ;###
1646: ;### (remember that we're flipped
1647: ;### in 'x' and 'y')
1648:
1649: oct_4_common:
1650: mov esi,[esp].sf_ppdev
1651: neg edi ;### untransform y
1652: neg eax ;### untransform x
1653:
1654: cmp edi,[esi].pdev_rcl1WindowClip.yTop
1655: jl short oct_4_nonint_map_in_bank
1656:
1657: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
1658: jl short oct_4_nonint_done_bank_map
1659:
1660: oct_4_nonint_map_in_bank:
1661: push eax
1662: push ecx
1663: push edx
1664:
1665: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1666: <esi, edi, JustifyBottom>;###
1667:
1668: pop edx
1669: pop ecx
1670: pop eax
1671:
1672: oct_4_nonint_done_bank_map:
1673: mov ebp,edi ;###
1674: sub ebp,[esi].pdev_rcl1WindowClip.yTop
1675: inc ebp ;### esp = # scans before end of bank
1676:
1677: imul edi,[esp].sf_lNextScan
1678: add edi,[esi].pdev_pvBitmapStart
1679: add edi,eax ;edi now points to start byte
1680:
1681: mov esi,[esp].sf_x1
1682: add esi,eax ;### esi = # pixels to lay down
1683:
1684: mov eax,[esp].sf_iColor
1685:
1686: sub ecx,edx ;ecx = dM - dN
1687: cmp edx,ecx
1688: jg oct_34b
1689: jmp oct_34a
1690:
1691: ;-------------------------------------------------------------------;
1692: ; 45 degree lines have a special rounding rule: when the line
1693: ; runs exactly half way between to pixels, the upper or right pel
1694: ; is illuminated. This translates into x=1/2 rounding up, and
1695: ; y=1/2 rounding down in value:
1696:
1697: public oct_4_slope_one
1698: oct_4_slope_one:
1699: GIQ ROUND_X_DOWN_SLOPE_ONE ;round x=1/2 down in value
1700: jmp oct_4_common
1701:
1702: ;/////////////////////////////////////////////////////////////////////
1703: ;// Octant 5
1704: ;/////////////////////////////////////////////////////////////////////
1705:
1706: public octant_5
1707: octant_5:
1708: mov [esp].sf_pfnNextBank,offset bank_y_major_next_upper
1709:
1710: mov esi,eax
1711: or esi,ebx
1712: or esi,ecx
1713: or esi,edx
1714: and esi,F - 1
1715: jnz oct_5_non_integer
1716:
1717: mov esi,[esp].sf_ppdev
1718: neg eax ;### untransform
1719: neg ebx ;### untransform
1720: sar eax,FLOG2 ;x0
1721: sar ebx,FLOG2 ;y0
1722:
1723: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
1724: jl short oct_5_map_in_bank
1725:
1726: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
1727: jl short oct_5_done_bank_map
1728:
1729: oct_5_map_in_bank:
1730: push eax
1731: push ecx
1732: push edx
1733:
1734: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
1735:
1736: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1737: <esi,ebx,JustifyBottom> ;###
1738:
1739: pop edx
1740: pop ecx
1741: pop eax
1742:
1743: public oct_5_done_bank_map
1744: oct_5_done_bank_map:
1745: mov edi,[esp].sf_lNextScan
1746: imul edi,ebx
1747: add edi,[esi].pdev_pvBitmapStart
1748: add edi,eax ;edi now points to start byte
1749:
1750: mov ebp,ebx ;###
1751: sub ebp,[esi].pdev_rcl1WindowClip.yTop
1752: inc ebp ;### ebp = # scans before end of bank
1753:
1754: mov esi,edx
1755: sar esi,FLOG2 ;esi = # of pixels to lay down
1756:
1757: sub esi,ebp
1758: sbb ebx,ebx
1759: and ebx,esi
1760: add ebp,ebx ;ebp = # of pels in this bank
1761:
1762: mov [esp].sf_cAfterThisBank,esi
1763: mov esi,[esp].sf_lNextScan
1764: neg esi ;### going down!
1765:
1766: xor ebx,ebx ;### round x = 1/2 *UP* in value
1767: sub ebx,edx
1768: sar ebx,1 ;now have error term
1769:
1770: mov eax,[esp].sf_iColor
1771: jmp oct_2_main_loop
1772:
1773: public oct_5_non_integer
1774: oct_5_non_integer:
1775: GIQR 0 ;###
1776: ;### (remember that we're flipped
1777: ;### in 'x' and 'y')
1778:
1779: mov esi,[esp].sf_ppdev
1780:
1781: neg edi ;### untransform y0
1782: neg eax ;### untransform x0
1783:
1784: cmp edi,[esi].pdev_rcl1WindowClip.yTop
1785: jl short oct_5_nonint_map_in_bank
1786:
1787: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
1788: jl short oct_5_nonint_done_bank_map
1789:
1790: oct_5_nonint_map_in_bank:
1791: push eax
1792: push ecx
1793: push edx
1794:
1795: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1796: <esi,edi,JustifyBottom> ;###
1797:
1798: pop edx
1799: pop ecx
1800: pop eax
1801:
1802: oct_5_nonint_done_bank_map:
1803: mov [esp].sf_y0,edi
1804: imul edi,[esp].sf_lNextScan
1805: add edi,[esi].pdev_pvBitmapStart
1806: add edi,eax ;edi points to start byte
1807:
1808: mov ebp,[esp].sf_y0 ;###
1809: mov esi,[esi].pdev_rcl1WindowClip.yTop
1810: dec esi ;### make top exclusive
1811: sub ebp,esi ;###
1812: add esi,[esp].sf_y1 ;### don't forget that y1 wasn't un-
1813: ;### transformed (so this is an 'add')
1814:
1815: jg short @F ;###
1816: add ebp,esi ;###
1817: @@:
1818: mov [esp].sf_cAfterThisBank,esi
1819:
1820: mov esi,[esp].sf_lNextScan
1821: neg esi ;### going down!
1822: mov eax,[esp].sf_iColor
1823:
1824: jmp oct_2_main_loop
1825:
1826: ;/////////////////////////////////////////////////////////////////////
1827: ;// Octant 6
1828: ;/////////////////////////////////////////////////////////////////////
1829:
1830: public octants_6_7
1831: octants_6_7:
1832: neg edx ;dN = -dN (now positive)
1833: neg ebx ;M1 = -M1
1834: cmp ecx,edx
1835: jge octant_7
1836:
1837: public octant_6
1838: octant_6:
1839: mov [esp].sf_pfnNextBank,offset bank_y_major_next_upper
1840:
1841: mov esi,eax
1842: or esi,ebx
1843: or esi,ecx
1844: or esi,edx
1845: and esi,F - 1
1846: jnz oct_6_non_integer
1847:
1848: mov esi,[esp].sf_ppdev
1849: neg ebx ;### untransform
1850: sar eax,FLOG2 ;x0
1851: sar ebx,FLOG2 ;y0
1852:
1853: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
1854: jl short oct_6_map_in_bank
1855:
1856: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
1857: jl short oct_6_done_bank_map
1858:
1859: oct_6_map_in_bank:
1860: push eax
1861: push ecx
1862: push edx
1863:
1864: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
1865:
1866: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1867: <esi,ebx,JustifyBottom> ;###
1868:
1869: pop edx
1870: pop ecx
1871: pop eax
1872:
1873: public oct_6_done_bank_map
1874: oct_6_done_bank_map:
1875: mov edi,[esp].sf_lNextScan
1876: imul edi,ebx
1877: add edi,[esi].pdev_pvBitmapStart
1878: add edi,eax ;edi now points to start byte
1879:
1880: mov ebp,ebx ;###
1881: sub ebp,[esi].pdev_rcl1WindowClip.yTop
1882: inc ebp ;### ebp = # scans before end of bank
1883:
1884: mov esi,edx
1885: sar esi,FLOG2 ;esi = # of pixels to lay down
1886:
1887: sub esi,ebp
1888: sbb ebx,ebx
1889: and ebx,esi
1890: add ebp,ebx ;ebp = # of pels in this bank
1891:
1892: mov [esp].sf_cAfterThisBank,esi
1893: mov esi,[esp].sf_lNextScan
1894: neg esi ;### going down!
1895:
1896: mov ebx,-1 ;### round x = 1/2 *DOWN* in value
1897: sub ebx,edx
1898: sar ebx,1 ;now have error term
1899:
1900: mov eax,[esp].sf_iColor
1901: jmp oct_1_main_loop
1902:
1903: public oct_6_non_integer
1904: oct_6_non_integer:
1905: GIQR ROUND_X_DOWN ;### round x=1/2 down in value
1906: ;### (remember that we're flipped
1907: ;### in 'y')
1908:
1909: mov esi,[esp].sf_ppdev
1910:
1911: neg edi ;### untransform y0
1912:
1913: cmp edi,[esi].pdev_rcl1WindowClip.yTop
1914: jl short oct_6_nonint_map_in_bank
1915:
1916: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
1917: jl short oct_6_nonint_done_bank_map
1918:
1919: oct_6_nonint_map_in_bank:
1920: push eax
1921: push ecx
1922: push edx
1923:
1924: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1925: <esi,edi,JustifyBottom> ;###
1926:
1927: pop edx
1928: pop ecx
1929: pop eax
1930:
1931: oct_6_nonint_done_bank_map:
1932: mov [esp].sf_y0,edi
1933: imul edi,[esp].sf_lNextScan
1934: add edi,[esi].pdev_pvBitmapStart
1935: add edi,eax ;edi points to start byte
1936:
1937: mov ebp,[esp].sf_y0 ;###
1938: mov esi,[esi].pdev_rcl1WindowClip.yTop
1939: dec esi ;### make top exclusive
1940: sub ebp,esi ;###
1941: add esi,[esp].sf_y1 ;### don't forget that y1 wasn't un-
1942: ;### transformed (so this is an 'add')
1943:
1944: jg short @F ;###
1945: add ebp,esi ;###
1946: @@:
1947: mov [esp].sf_cAfterThisBank,esi
1948:
1949: mov esi,[esp].sf_lNextScan
1950: neg esi ;### going down!
1951: mov eax,[esp].sf_iColor
1952:
1953: jmp oct_1_main_loop
1954:
1955: ;/////////////////////////////////////////////////////////////////////
1956: ;// Octant 7
1957: ;/////////////////////////////////////////////////////////////////////
1958:
1959: public octant_7
1960: octant_7:
1961: mov esi,[esp].sf_lNextScan
1962: neg esi
1963: mov [esp].sf_lDelta,esi ;we're going up
1964: mov [esp].sf_pfnNextBank,offset bank_x_major_next_upper
1965:
1966: mov esi,eax
1967: or esi,ebx
1968: or esi,ecx
1969: or esi,edx
1970: and esi,F - 1
1971: jnz oct_7_non_integer
1972:
1973: neg ebx ;### untransform y
1974:
1975: mov esi,[esp].sf_ppdev
1976: sar eax,FLOG2 ;x0
1977: sar ebx,FLOG2 ;y0
1978:
1979: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
1980: jl short oct_7_map_in_bank
1981:
1982: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
1983: jl short oct_7_done_bank_map
1984:
1985: oct_7_map_in_bank:
1986: push eax
1987: push ecx
1988: push edx
1989:
1990: ; ebx, esi, edi and esi are preserved according to C calling conventions:
1991:
1992: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
1993: <esi, ebx, JustifyBottom> ;###
1994:
1995: pop edx
1996: pop ecx
1997: pop eax
1998:
1999: public oct_7_done_bank_map
2000: oct_7_done_bank_map:
2001: mov edi,[esp].sf_lNextScan
2002: imul edi,ebx
2003: add edi,[esi].pdev_pvBitmapStart
2004: add edi,eax ;edi now points to start byte
2005:
2006: mov ebp,ebx ;###
2007: sub ebp,[esi].pdev_rcl1WindowClip.yTop
2008: inc ebp ;### ebp = # scans before end of bank
2009:
2010: mov esi,ecx
2011: sar esi,FLOG2 ;esi = # of pixels to lay down
2012:
2013: xor ebx,ebx ;### round y = 1/2 *UP* in value
2014: sub ebx,ecx
2015: sar ebx,1 ;now have error term
2016:
2017: mov eax,[esp].sf_iColor
2018: sub ecx,edx ;ecx = dM - dN
2019: cmp edx,ecx
2020: jg oct_07b
2021: jmp oct_07a
2022:
2023: public oct_7_non_integer
2024: oct_7_non_integer:
2025: cmp ecx,edx
2026: je oct_7_slope_one
2027: GIQ ROUND_X_DOWN ;### round x=1/2 down in value
2028: ;### (remember that we're flipped
2029: ;### in 'y')
2030:
2031: oct_7_common:
2032: mov esi,[esp].sf_ppdev
2033: neg edi ;### untransform y
2034:
2035: cmp edi,[esi].pdev_rcl1WindowClip.yTop
2036: jl short oct_7_nonint_map_in_bank
2037:
2038: cmp edi,[esi].pdev_rcl1WindowClip.yBottom
2039: jl short oct_7_nonint_done_bank_map
2040:
2041: oct_7_nonint_map_in_bank:
2042: push eax
2043: push ecx
2044: push edx
2045:
2046: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
2047: <esi, edi, JustifyBottom>;###
2048:
2049: pop edx
2050: pop ecx
2051: pop eax
2052:
2053: oct_7_nonint_done_bank_map:
2054: mov ebp,edi ;###
2055: sub ebp,[esi].pdev_rcl1WindowClip.yTop
2056: inc ebp ;### esp = # scans before end of bank
2057:
2058: imul edi,[esp].sf_lNextScan
2059: add edi,[esi].pdev_pvBitmapStart
2060: add edi,eax ;edi now points to start byte
2061:
2062: mov esi,[esp].sf_x1
2063: sub esi,eax ;esi = # pixels to lay down
2064:
2065: mov eax,[esp].sf_iColor
2066:
2067: sub ecx,edx ;ecx = dM - dN
2068: cmp edx,ecx
2069: jg oct_07b
2070: jmp oct_07a
2071:
2072: ;-------------------------------------------------------------------;
2073: ; We have to special case those lines with a slope of exactly -1 when
2074: ; 'x' rounds down in value after normalizing:
2075:
2076: public oct_7_slope_one
2077: oct_7_slope_one:
2078: GIQ ROUND_X_DOWN_SLOPE_ONE
2079: jmp oct_7_common
2080:
2081: ;-------------------------------------------------------------------------;
2082: ; Function to get next lower bank for x-major lines.
2083: ;-------------------------------------------------------------------------;
2084:
2085: public bank_x_major_next_lower
2086: bank_x_major_next_lower:
2087: push ebx
2088: mov ebx,[esp+4].sf_ppdev ;NOTE: Add 4 because of above push!
2089: push ecx
2090: push edx
2091: push esi
2092:
2093: mov esi,[ebx].pdev_rcl1WindowClip.yBottom
2094: sub edi,[ebx].pdev_pvBitmapStart
2095:
2096: ptrCall <dword ptr [ebx].pdev_pfnBankControl>, \
2097: <ebx,esi,JustifyTop>
2098:
2099: add edi,[ebx].pdev_pvBitmapStart
2100: mov ebp,[ebx].pdev_rcl1WindowClip.yBottom
2101: sub ebp,esi
2102:
2103: pop esi
2104: pop edx
2105: pop ecx
2106: pop ebx
2107: mov eax,[esp].sf_iColor
2108:
2109: jmp [esp].sf_pfnReturn
2110:
2111: ;-------------------------------------------------------------------------;
2112: ; Function to get next upper bank for x-major lines.
2113: ;-------------------------------------------------------------------------;
2114:
2115: public bank_x_major_next_upper
2116: bank_x_major_next_upper:
2117: push ebx
2118: mov ebx,[esp+4].sf_ppdev ;NOTE: Add 4 because of above push!
2119: push ecx
2120: push edx
2121: push esi
2122:
2123: mov esi,[ebx].pdev_rcl1WindowClip.yTop
2124: dec esi
2125: sub edi,[ebx].pdev_pvBitmapStart
2126:
2127: ptrCall <dword ptr [ebx].pdev_pfnBankControl>, \
2128: <ebx,esi,JustifyBottom>
2129:
2130: add edi,[ebx].pdev_pvBitmapStart
2131: lea ebp,[esi+1]
2132: sub ebp,[ebx].pdev_rcl1WindowClip.yTop
2133:
2134: pop esi
2135: pop edx
2136: pop ecx
2137: pop ebx
2138: mov eax,[esp].sf_iColor
2139:
2140: jmp [esp].sf_pfnReturn
2141:
2142: ;-------------------------------------------------------------------------;
2143: ; Function to get next lower bank for y-major lines.
2144: ;-------------------------------------------------------------------------;
2145:
2146: public bank_y_major_next_lower
2147: bank_y_major_next_lower:
2148:
2149: ; eax = # pels after this bank
2150:
2151: push ebx
2152: mov ebx,[esp+4].sf_ppdev ;NOTE: Plus 4 because of above push!
2153: push ecx
2154: push edx
2155: push esi
2156:
2157: mov esi,[ebx].pdev_rcl1WindowClip.yBottom
2158: sub edi,[ebx].pdev_pvBitmapStart
2159:
2160: push eax
2161: ptrCall <dword ptr [ebx].pdev_pfnBankControl>, \
2162: <ebx,esi,JustifyTop>
2163: pop eax
2164:
2165: add edi,[ebx].pdev_pvBitmapStart
2166: mov ebp,[ebx].pdev_rcl1WindowClip.yBottom
2167: sub ebp,esi ;ebp = # of pels can do in this bank
2168: sub eax,ebp ;esi = # of pels after this bank
2169: sbb ebx,ebx
2170: and ebx,eax
2171: add ebp,ebx ;ebp = # of pels in this bank
2172:
2173: pop esi
2174: pop edx
2175: pop ecx
2176: pop ebx
2177:
2178: mov [esp].sf_cAfterThisBank,eax
2179: ;this has to be done after 'esp' is
2180: ; restored!
2181:
2182: mov eax,[esp].sf_iColor
2183:
2184: jmp [esp].sf_pfnReturn
2185:
2186: ;-------------------------------------------------------------------------;
2187: ; Function to get next upper bank for y-major lines.
2188: ;-------------------------------------------------------------------------;
2189:
2190: public bank_y_major_next_upper
2191: bank_y_major_next_upper:
2192:
2193: ; eax = # pels after this bank
2194:
2195: push ebx
2196: mov ebx,[esp+4].sf_ppdev ;NOTE: Plus 4 because of above push!
2197: push ecx
2198: push edx
2199: push esi
2200:
2201: mov ebp,[ebx].pdev_rcl1WindowClip.yTop
2202: dec ebp
2203:
2204: sub edi,[ebx].pdev_pvBitmapStart
2205:
2206: push eax
2207: ptrCall <dword ptr [ebx].pdev_pfnBankControl>, \
2208: <ebx,ebp,JustifyBottom>
2209: pop eax
2210:
2211: add edi,[ebx].pdev_pvBitmapStart
2212:
2213: inc ebp ;restore exclusiveness
2214: sub ebp,[ebx].pdev_rcl1WindowClip.yTop
2215: ;ebp = # of pels can do in this bank
2216: sub eax,ebp ;esi = # of pels after this bank
2217: sbb ebx,ebx
2218: and ebx,eax
2219: add ebp,ebx ;ebp = # of pels in this bank
2220:
2221: pop esi
2222: pop edx
2223: pop ecx
2224: pop ebx
2225:
2226: mov [esp].sf_cAfterThisBank,eax
2227: ;this has to be done after 'esp' is
2228: ; restored!
2229:
2230: mov eax,[esp].sf_iColor
2231:
2232: jmp [esp].sf_pfnReturn
2233:
2234: ;/////////////////////////////////////////////////////////////////////
2235: ;// Horizontal Line
2236: ;/////////////////////////////////////////////////////////////////////
2237:
2238: public flip_and_do_non_integer_horizontal_line
2239: flip_and_do_non_integer_horizontal_line:
2240: mov ebx,edi
2241: mov ecx,[esp].sf_x1
2242: sub ecx,eax
2243: jle next_line
2244: add eax,ecx
2245: neg eax
2246: inc eax ;x0' = -(-original x0 - dx) + 1
2247: jmp short horizontal_common
2248:
2249: public do_non_integer_horizontal_line
2250: do_non_integer_horizontal_line:
2251: mov ebx,edi
2252: mov ecx,[esp].sf_x1
2253: sub ecx,eax
2254: jg short horizontal_common
2255: jmp next_line
2256:
2257: public flip_and_do_horizontal_line
2258: flip_and_do_horizontal_line:
2259:
2260: ; This 'flip' entry point is for lines that were originally right-to-left:
2261:
2262: add eax,ecx
2263: neg eax
2264: add eax,F ;M0' = -(-original M0 - original dM) + 1
2265:
2266: public do_horizontal_line
2267: do_horizontal_line:
2268: sar eax,FLOG2 ;x0 (we're now in pixel coordinates)
2269: sar ebx,FLOG2 ;y0
2270: sar ecx,FLOG2 ;dx
2271: jz next_line
2272:
2273: ; NOTE: Have to have some pixels to light at this point
2274: ;
2275: ; eax = x0 (in pixel coordinates)
2276: ; ebx = y0
2277: ; ecx = dx (# pixels to light)
2278:
2279: horizontal_common:
2280: mov esi,[esp].sf_ppdev
2281:
2282: cmp ecx,NUM_PELS_NEEDED_FOR_PLANAR_HORIZONTAL
2283: jl do_short_horizontal_line
2284:
2285: test [esi].pdev_fl,DRIVER_PLANAR_CAPABLE
2286: jz do_short_horizontal_line
2287:
2288: ;---------------------------------------------------------------------;
2289: ; Draw horizontal lines using planar mode.
2290: ;
2291: ; NOTE: This code assumes that the length is at least 8 pels long!
2292:
2293: public horizontal_planar
2294: horizontal_planar:
2295: mov edi,[esi].pdev_lPlanarNextScan
2296: imul edi,ebx
2297:
2298: cmp ebx,[esi].pdev_rcl1PlanarClip.yTop
2299: jl short hor_planar_map_bank
2300:
2301: cmp ebx,[esi].pdev_rcl1PlanarClip.yBottom
2302: jl short hor_planar_done_bank
2303:
2304: hor_planar_map_bank:
2305: push eax
2306: push ecx
2307:
2308: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
2309:
2310: ptrCall <dword ptr [esi].pdev_pfnPlanarControl>, \
2311: <esi,ebx,JustifyTop>
2312:
2313: pop ecx
2314: pop eax
2315:
2316: hor_planar_done_bank:
2317: add edi,[esi].pdev_pvBitmapStart
2318:
2319: mov ebp,eax ;save x0
2320: sar eax,2
2321: add edi,eax ;edi now points to start byte
2322:
2323: and ebp,3
2324: jz short hor_planar_start_middle
2325:
2326: ; When the left end doesn't start on a quadpixel boundary, we have to
2327: ; adjust the start address and do some other stuff:
2328:
2329: mov [esp].sf_pjStart,edi
2330: inc edi
2331: sub ebp,4
2332: add ecx,ebp ;adjust byte count to account for
2333: ; fractional start
2334:
2335: hor_planar_start_middle:
2336: mov eax,[esp].sf_iColor ;load the color
2337: mov esi,ecx ;save length
2338:
2339: test edi,1
2340: jz short hor_planar_middle_aligned
2341: mov [edi],al ;handle unaligned whole start byte
2342: inc edi
2343: sub ecx,4
2344: hor_planar_middle_aligned:
2345: shr ecx,3 ;NOTE: we look at the carry later!
2346: rep stosw ;write middle as words
2347: jnc short hor_planar_handle_ends
2348: ;NOTE: here we look at the carry!
2349: mov [edi],al ;handle whole end byte
2350: inc edi
2351:
2352: hor_planar_handle_ends:
2353: mov edx,VGA_BASE + SEQ_DATA
2354: and esi,3
2355: jz short hor_planar_left
2356: hor_planar_right:
2357: mov ecx,esi
2358: mov eax,0f0h
2359: rol al,cl ;we compute the mask instead of
2360: ; using a look-up table, because the
2361: ; table probably wouldn't be in the
2362: ; cache
2363:
2364: ; Set right mask by disabling some planes:
2365:
2366: out dx,al
2367:
2368: push eax ;we add a delay here because some
2369: pop eax ; cards can't handle a write too soon
2370: ; after an out. Hopefully this will
2371: ; help.
2372:
2373: mov eax,[esp].sf_iColor
2374: mov [edi],al
2375:
2376: hor_planar_left:
2377: and ebp,3
2378: jz short hor_planar_done
2379:
2380: mov ecx,ebp
2381: mov eax,0fh
2382: shl eax,cl
2383:
2384: ; Set left mask by disabling some planes:
2385:
2386: out dx,al
2387:
2388: push eax ;we add a delay here because some
2389: pop eax ; cards can't handle a write too soon
2390: ; after an out. Hopefully this will
2391: ; help.
2392:
2393: mov edi,[esp].sf_pjStart
2394: mov eax,[esp].sf_iColor
2395: mov [edi],al
2396:
2397: hor_planar_done:
2398: mov al,MM_ALL
2399: out dx,al
2400:
2401: jmp next_line
2402:
2403: ;---------------------------------------------------------------------;
2404: ; Draw horizontal lines using linear mode.
2405:
2406: public do_short_horizontal_line
2407: do_short_horizontal_line:
2408: mov edi,[esp].sf_lNextScan
2409: imul edi,ebx
2410: add edi,eax
2411:
2412: cmp ebx,[esi].pdev_rcl1WindowClip.yTop
2413: jl short hor_map_in_bank
2414:
2415: cmp ebx,[esi].pdev_rcl1WindowClip.yBottom
2416: jl short hor_done_bank_map
2417:
2418: hor_map_in_bank:
2419: push ecx
2420:
2421: ; ebx, esi, edi and ebp are preserved according to C calling conventions:
2422:
2423: ptrCall <dword ptr [esi].pdev_pfnBankControl>, \
2424: <esi,ebx,JustifyTop>
2425:
2426: pop ecx
2427:
2428: hor_done_bank_map:
2429: add edi,[esi].pdev_pvBitmapStart
2430: ;edi now points to start byte
2431: mov eax,[esp].sf_iColor
2432:
2433: test edi,1
2434: jz short hor_aligned
2435: mov [edi],al ;write initial unaligned byte
2436: inc edi
2437: dec ecx
2438: jz next_line
2439:
2440: hor_aligned:
2441: shr ecx,1 ;NOTE: we look at the carry later!
2442: rep stosw ;write middle words
2443: jnc next_line ;NOTE: here we look at the carry!
2444: mov [edi],al ;write last byte
2445: jmp next_line
2446:
2447:
2448: endProc vFastLine
2449:
2450: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.