home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / PIXELATE.ZIP / PIXELATE.TXT < prev   
Internet Message Format  |  1993-04-13  |  20KB
  1. Path: pdxgate!usenet.ee.pdx.edu!reed!ogicse!decwrl!wupost!howland.reston.ans.net!bogus.sura.net!news-feed-1.peachnet.edu!umn.edu!gaia.ucs.orst.edu!ucs.orst.edu!ketrenoj
  2. From: ketrenoj@ucs.orst.edu (Lord Logics)
  3. Newsgroups: comp.sys.ibm.pc.demos
  4. Subject: Scaling code in ASM . . .
  5. Message-ID: <1q568m$hdv@gaia.ucs.orst.edu>
  6. Date: 10 Apr 93 01:01:10 GMT
  7. Organization: University Computing Services - OSU
  8. Lines: 97
  9. NNTP-Posting-Host: ucs.orst.edu
  10.  
  11. Fellow netters, coders, and other people . . .
  12.  
  13. Finally a decent news group for exchanging source code . . .  here's
  14. my first contribution.  I wrote the code in the beginning of last 
  15. summer.  It was the first code I wrote that implemented the VGA (I had 
  16. just purchased VGA)  Anyway, this is the fastest method I could come up 
  17. with for scaling an image.  If there is a faster way, please post, or if 
  18. you make any optimizations to this routine, please post them as well.
  19.  
  20. Sorry if it is hard to follow, and if the comments are confusing.
  21.  
  22. Oh yeah, I don't know what the normal message limit is, so I'll split 
  23. this up into 100 line increments.  Should be a total of 3 posts.
  24.  
  25. NOTE:  I haven't tested this routine in quite a while, and I can't 
  26. remember if I had made any changes since I last used it.  If it doesn't 
  27. work, let me know and I'll work on it.
  28.  
  29.  
  30. James
  31. -=[ Lord Logics ]=-
  32.  
  33. ketrenoj@ucs.orst.edu
  34.  
  35.  
  36.  
  37. ;----------
  38.  
  39. .model huge,c
  40. .data
  41.  
  42.         X_SIZE          dw      0
  43.         Y_SIZE          dw      0
  44.         X_SKIP          dw      0
  45.  
  46. .code
  47. ;*************************************************************************
  48. ;** PROC: pixelate()
  49. ;** PURP: To put an image onto the screen from VGA memory w/ pitching
  50. ;** USAG: pixelate(char *buffer,int x,int y,int ratio);
  51. ;**       Ratio is a word.  The value is in a ratio of 256.  So,
  52. ;**       the ratio of 520 would result in 49% of the original size.
  53. ;**       (In other words, 256/Ratio = New Size)
  54. ;**
  55. ;**       Buffer is broken down as follows:
  56. ;**       X Size (2), Y Size (2), then the image. 
  57. ;**
  58. ;**       NOTE:  No clipping is done for this, and it is currently
  59. ;**              only written to support chained mode.  I am rewriting
  60. ;**              it to perform clipping and support for unchained video
  61. ;**              modes.  Questions or comments email:
  62. ;**            
  63. ;**              ketrenoj@ucs.orst.edu
  64. ;**              -=[ Lord Logics ]=-      
  65. ;**       Group: None.  Want me?  Contact me . . .
  66. ;**
  67. ;*************************************************************************
  68. pixelate        proc far
  69.         push    bp
  70.         mov     bp,sp
  71.         push    es
  72.         push    ds
  73.         push    si
  74.         push    di
  75.  
  76.         cld
  77.  
  78.         mov     ax,@data
  79.         mov     ds,ax
  80.  
  81.         mov     di,[bp+8]       ; Set ES:[DI] to point to the buffer . . .
  82.         mov     es,di           ; :
  83.         mov     di,[bp+6]       ; :
  84.  
  85.         mov     dx,es:[di]      ; X_SIZE is stored in DX
  86.         mov     cx,es:[di+2]    ; Y_SIZE is stored in CX
  87.  
  88.         mov     ax,[bp+14]      ; We will now do some adjustemnts via ratio
  89.         push    dx              ; Set up the ratio factor to adjust the
  90.         push    ax              ; : X_SIZE and Y_SIZE, and X and Y POS.
  91.         mul     dx              ; :
  92.         mov     bx,0100h        ; :
  93.         div     bx              ; :
  94.         mov     X_SIZE,ax       ; : Newly adjusted X_SIZE (after pitching)
  95.         pop     ax              ; :
  96.         mul     cx              ; :
  97.         div     bx              ; :
  98.         mov     Y_SIZE,ax       ; : Newly adjusted Y_SIZE (after pitching)
  99.         pop     dx              ; :
  100.  
  101. ;** Now check to make sure that there is indeed something to display . . .
  102.         cmp     X_SIZE,0        ; Check to see if there is still an image.
  103.         jz      px_d            ; :
  104.         cmp     Y_SIZE,0        ; :
  105.         jz      px_d            ; :
  106.  
  107. ; Continued in next post . . .
  108.  
  109. Path: pdxgate!usenet.ee.pdx.edu!reed!ogicse!flop.ENGR.ORST.EDU!gaia.ucs.orst.edu!ucs.orst.edu!ketrenoj
  110. From: ketrenoj@ucs.orst.edu (Lord Logics)
  111. Newsgroups: comp.sys.ibm.pc.demos
  112. Subject: Scaling code in ASM [2/3]
  113. Message-ID: <1q56d9$ho7@gaia.ucs.orst.edu>
  114. Date: 10 Apr 93 01:03:37 GMT
  115. References: <1q568m$hdv@gaia.ucs.orst.edu>
  116. Organization: University Computing Services - OSU
  117. Lines: 87
  118. NNTP-Posting-Host: ucs.orst.edu
  119.  
  120. ; Continued from last post . . .
  121.  
  122. ;** Now we will figure out how much the X and Y POS will be changed . . .
  123. ;** On entry:
  124. ;** AX - Nothing
  125. ;** BX - Nothing
  126. ;** CX - Y_SIZE (no pitching)
  127. ;** DX - X_SIZE (no pitching)
  128. ;** ES:[DI] - Image Buffer
  129. ;** DS:[SI] - Nothing
  130. px_sx:  sub     dx,X_SIZE       ; Set up the X_SIZE variance . . .
  131.         jge     px_xn           ; : Variance = 1/2 the size difference . . .
  132.         neg     dx              ; :
  133.         shr     dx,1            ; :
  134.         neg     dx              ; :
  135.         jmp     px_sy           ; :
  136. px_xn:  shr     dx,1            ; :
  137. px_sy:  sub     cx,Y_SIZE       ; Set up the Y_SIZE variance . . .
  138.         jge     px_yn           ; :
  139.         neg     cx              ; :
  140.         shr     cx,1            ; :
  141.         neg     cx              ; :
  142.         jmp     px_si           ; :
  143. px_yn:  shr     cx,1            ; :
  144.  
  145. px_si:  xor     bx,bx           ; Clear initial DI displacement.
  146.         push    dx
  147.         mov     ax,[bp+12]      ; Set up the starting point and check
  148.         add     ax,cx           ; : to make sure that the image will fit
  149.         cmp     ax,200          ; : within our bounds (ie, the screen).
  150.         jge     px_d            ; :
  151.         cmp     ax,0            ; :
  152.         jge     px_s1           ; :
  153.         push    ax              ; :
  154.         neg     ax              ; :
  155.         sub     Y_SIZE,ax       ; :             THE FOLLOWING MAY CAUSE
  156.         jle     px_ddx          ; :             PROBLEMS DURING CLIPPING.
  157.         mov     dx,es:[di]      ; : Set DX to X_SIZE (no pitching)
  158.         push    ax              ; :
  159.         mul     dx              ; :
  160.         mov     bx,ax           ; : BX stores DI adjustment . . .
  161.         mov     dx,320          ; :
  162.         pop     ax              ; :
  163.         mul     dx              ; :
  164.         mov     si,ax           ; :
  165.         pop     ax              ; :
  166.         jmp     px_s2           ; :
  167.  
  168. ;**
  169. ;** Exit the procedure . . .
  170. ;**
  171. px_ddx: pop     dx
  172. px_dax: pop     ax
  173. px_d:   pop     di
  174.         pop     si
  175.         pop     ds
  176.         pop     es
  177.         pop     bp
  178.         ret
  179.  
  180. px_s1:  mov     dx,320          ; Adjust SI for proper positioning.
  181.         mul     dx              ; :
  182.         mov     si,ax           ; :
  183.  
  184. px_s2:  pop     dx              ; Now do the X Adjusting . . .
  185.         mov     ax,[bp+10]      ; Set up the starting point and check
  186.         add     ax,dx           ; : to make sure that the image will fit
  187.         cmp     ax,320          ; : within our bounds (ie, the screen).
  188.         jge     px_d            ; :
  189.         cmp     ax,0            ; :
  190.         jge     px_s3           ; :
  191.         neg     ax              ; :
  192.         sub     X_SIZE,ax       ; :
  193.         jle     px_d            ; :
  194.         add     bx,ax           ; :
  195.         jmp     px_s4           ; :
  196.  
  197. px_s3:  add     si,ax           ; Set up screen position adjustment
  198. px_s4:  mov     cx,bx
  199.         mov     bx,es:[di]
  200.         add     di,cx
  201.         add     di,4
  202.         mov     cx,Y_SIZE
  203.         mov     dx,X_SIZE
  204.         jmp     px_pixel
  205.  
  206. ; Continued in next post . . .
  207.  
  208. Path: pdxgate!usenet.ee.pdx.edu!reed!ogicse!flop.ENGR.ORST.EDU!gaia.ucs.orst.edu!ucs.orst.edu!ketrenoj
  209. From: ketrenoj@ucs.orst.edu (Lord Logics)
  210. Newsgroups: comp.sys.ibm.pc.demos
  211. Subject: Scaling code in ASM [3/3]
  212. Message-ID: <1q56ii$hrj@gaia.ucs.orst.edu>
  213. Date: 10 Apr 93 01:06:26 GMT
  214. References: <1q568m$hdv@gaia.ucs.orst.edu>
  215. Organization: University Computing Services - OSU
  216. Lines: 87
  217. NNTP-Posting-Host: ucs.orst.edu
  218.  
  219. ; Continued from last post . . .
  220.  
  221. ;**
  222. ;** Display the image as quick as possible.
  223. ;**
  224. ;** On entry:
  225. ;** ES:[DI] Points to image buffer
  226. ;** DS:[SI] Points to screen memory location (start point)
  227. ;** AX - nothing important
  228. ;** BX - X_SIZE w/out any pitching.  This is used to add to the memory
  229. ;**      buffer for each line displayed.
  230. ;** CX - Y_COUNT size.  The number of Y_LINES to display
  231. ;** DX - X_COUNT size.  The number of X_LINES to display
  232. ;**
  233. px_pixel:
  234.         ;** First we must set up our ratio skipping . . .
  235.         push    dx              ; Save X_COUNT
  236.         push    bx              ; Save X_SIZE
  237.         mov     bx,[bp+14]      ; Set skipping bytes . . .
  238.         xor     dx,dx           ; :
  239.         mov     ax,0FFFFh       ; :
  240.         or      bx,bx           ; :
  241.         jz      px_pd           ; :
  242.         div     bx              ; :
  243.         jmp     px_pf           ; :
  244. px_pd:  mov     ax,0100h        ; :
  245. px_pf:  mov     [bp+14],ax      ; :
  246.         pop     bx              ; Restore X_SIZE
  247.         pop     dx              ; Restore X_COUNT
  248.  
  249.  
  250.         ;** Now we must set up our starting points . . .
  251.         mov     ax,es           ; Set DS:[SI] to our image,
  252.         mov     ds,ax           ; : ES:[DI] to the screen position,
  253.         mov     ax,0A000h       ; : BP to point to the ratio skip,
  254.         mov     es,ax           ; : and AX to the skip, roll over . . .
  255.         xchg    si,di           ; :
  256.         add     bp,14           ; :
  257.         mov     al,[bp+1]       ; :
  258.         xor     ah,ah           ; :
  259.         mov     [bp-2],ah       ; :
  260.  
  261.         ;** Now, actually display the image via to for/next loops . . .
  262. pxq_y:  push    cx              ; Save the Y_COUNT
  263.         push    ax              ; Save the Whole Adjustment
  264.         push    bx              ; Save the X_SIZE (no pitching)
  265.         push    dx              ; Save the X_COUNT
  266.         push    si              ; Save the start of line position
  267.  
  268.         ;** Now we will loop through the X_LINE, first setting up the
  269.         ;** : values needed internally though . . .
  270.         mov     cx,dx           ; Set CX to X_COUNT
  271.         mov     dl,[bp]         ; Set DL to Ratio
  272.         xor     dh,dh           ; Clear the Spill Over
  273.  
  274. pxq_x:  movsb                   ; Move one byte
  275.         dec     si              ; : Fix the SI from being incremented.
  276.         add     dh,dl           ; Do pitching . . .
  277.         adc     si,ax           ; :
  278.         loop    pxq_x           ; Do the entire X_LINE
  279.  
  280.         ;** Now we will adjust for the next X_LINE along the Y_LINE . . .
  281.         pop     si              ; Restore start of line position.
  282.         pop     bx              ; Adjust the dest screen position . . .
  283.         add     di,320          ; :
  284.         sub     di,bx           ; :
  285.  
  286.         add     [bp-2],dl       ; Do the pitching . . .
  287.         adc     ax,0            ; :
  288.         mov     dx,ax           ; :
  289.         pop     ax              ; : Restore AX to the X_SIZE
  290.         mov     cx,bx           ; : Set CX to X_COUNT
  291.         mov     bx,ax           ; : Set BX to X_SIZE
  292.         mul     dx              ; :
  293.         add     si,ax           ; :
  294.         pop     ax              ; : Restore Whole Adjustment
  295.         mov     dx,cx           ; : Set DX to X_COUNT
  296.         pop     cx              ; Restore Y_COUNT
  297.         loop    pxq_y           ; Do the entire Y_LINE.
  298.         jmp     px_d            ; Exit the PIXELATE routine.
  299. pixelate        endp            ; END OF PIXELATE
  300.         end
  301.  
  302.  
  303. ; That's it.  It was written using MASM (don't know what version) but i don't
  304. ; think it uses any special pseudo ops from that, so it should work on TASM.
  305. ; 
  306.  
  307. Path: pdxgate!usenet.ee.pdx.edu!reed!ogicse!emory!news-feed-1.peachnet.edu!bogus.sura.net!howland.reston.ans.net!ux1.cso.uiuc.edu!news.cso.uiuc.edu!uxa.cso.uiuc.edu!jas37876
  308. From: jas37876@uxa.cso.uiuc.edu (John A. Slagel)
  309. Newsgroups: comp.sys.ibm.pc.demos
  310. Subject: ModeX Bitmap Scaling Code...
  311. Message-ID: <C58vGz.6Ev@news.cso.uiuc.edu>
  312. Date: 10 Apr 93 01:43:47 GMT
  313. Sender: usenet@news.cso.uiuc.edu (Net Noise owner)
  314. Organization: University of Illinois at Urbana
  315. Lines: 260
  316.  
  317.  
  318.     Well, seeing how someone posted code to do scaling, here's my
  319.     equivalent code for ModeX.  It requires an input bitmap of
  320.     128x128 and scales up or down, with clipping, and the clipping
  321.     only slows the display down by a constant amount no matter how
  322.     much is clipped.  This only changes the pixel plane once for
  323.     every column, so it is very fast for a ModeX routine.  
  324.  
  325.     I'm posting this in hopes that people unselfishly post some
  326.     of there own code... Anyway, enjoy.   
  327.  
  328.     Oh yeah, erase the .sig at the end.
  329.  
  330. ;=============================================================================
  331. ; XSTRETCHBMP By John A. Slagel,  jas37876@uxa.cso.uiuc.edu
  332. ; Feel free to use this any way you want.  Let me know if you find any
  333. ; bugs or optimizations, and I would be interested in seeing any final
  334. ; projects that use this. Thanks.
  335. ;
  336. ; This routine stretches (or shrinks) a 128x128 bitmap in VGA ModeX.
  337. ;   o Color Indices of 255 are "invisible" or "masked" -- They don't draw.
  338. ;   o Only changes the bitplane 1 time per column, so it is fairly fast.
  339. ;   o Can only be used in 320x??? modes.
  340. ;   o Requires a 128x128 bitmap.
  341. ;   o Will only stretch proportionally.
  342. ;   o Can stretch from 2 up to very large stretching.
  343. ;   o Clips according to ClipLt, ClipRt, ClipTp, ClipBt, which should be
  344. ;     declared in your C routine in another module. You also need to have
  345. ;     the ModeXseg variable declared elsewhere. Normally A000, A800, etc..
  346. ;   o Clipping only takes a constant time when it is neccessary.
  347. ;   o Requires a 386 processor
  348. ;   o Requires MASM 5.1
  349. ;   o C-callable as:
  350. ;       void XSTRETCHBMP( int x, int y, int w, BYTE  *Bitmap );
  351. ;            x,y = Screen Position
  352. ;            w   = Width to stretch it on the screen
  353. ;            Bitmap = Pointer to 128x128 byte array of pixel data 
  354. ;       Needs extern variables,ClipLt, ClipRt, ClipTp, ClipBt, ModeXseg
  355. ;============================================================================
  356. .MODEL LARGE, C
  357. .386
  358.  
  359. .DATA
  360. SC_INDEX1       EQU 03C4h
  361. SC_INDEX2       EQU 03C5h
  362. MAP_MASK        EQU 2
  363. INVISIBLE_COLOR EQU 255
  364.  
  365. extrn ClipTp:word
  366. extrn ClipLt:word
  367. extrn ClipRt:word
  368. extrn ClipBt:word
  369. extrn ModeXseg:word
  370.  
  371. .CODE
  372.  
  373. XSTRETCHBMP PROC FAR USES DI SI, DestXStart:WORD, DestYStart:WORD, DestSize:WORD, Bitmap:FAR PTR
  374. LOCAL DestHeight:WORD, DecisionY:WORD, DestWidth:WORD,  DecisionX:WORD, DestSize2:WORD, Doff:WORD, Soff:WORD
  375.  
  376.         mov     DestHeight,0 
  377.         mov     DecisionY, 0
  378.         mov     DestWidth, 0
  379.         mov     DecisionX, 0
  380.         mov     DestSize2, 0
  381.         mov     Doff, 0
  382.         mov     Soff, 0
  383.  
  384.         cmp     DestSize, 2
  385.         jl      Done        ; If it is too small then exit 
  386.  
  387.         mov     ax, DestYStart
  388.         cmp     ax, ClipBt
  389.         jg      Done        ; If it is too far down then exit 
  390.  
  391.         add     ax, DestSize
  392.         dec     ax
  393.         cmp     ax, ClipTp
  394.         jl      Done        ; If it is too far up then exit
  395.  
  396.         mov     ax, DestXStart
  397.         cmp     ax, ClipRt
  398.         jg      Done        ; If it is too far right then exit 
  399.  
  400.         add     ax, DestSize
  401.         dec     ax 
  402.         cmp     ax, ClipLt
  403.         jl      Done            ; If it is too far left then exit
  404.  
  405.         mov     ax, DestSize
  406.         mov     DestWidth,  ax  ; Initialize DestWidth=DestSize
  407.         mov     DestHeight, ax  ; Initialize DestHeight=DestSize
  408.  
  409.         mov     Soff, 0         ; Point Soff to start of bitmap
  410.  
  411.         mov     DestSize2, ax
  412.         shl     DestSize2, 1    ; Calculate DestSize*2 for later
  413.  
  414.         shl     ax, 1
  415.         neg     ax
  416.         mov     DecisionX, ax   ; DecisionX = -DestSize
  417.         mov     DecisionY, ax   ; DecisionY = -DestSize
  418.  
  419.         movsx   eax, ClipTp
  420.         movsx   ecx, DestYStart
  421.         sub     eax, ecx        ; EAX = ClipTp-DestYStart
  422.         jle     NoTopClip
  423.         ;Clip off the top
  424.         sub     DestHeight, ax  ; DestHeight -= (ClipTp-DestYStart)
  425.         mov     ebx, eax        ; EBX = AmountClippedY
  426.         xor     edx, edx        ; EDX = 0
  427.         shl     eax, 7          ; EDX:EAX = AmountClippedY * 128
  428.         movzx   ecx, DestSize
  429.         div     ecx             ; EAX (SourceStartY) = EDX:EAX / DestSize 
  430.         add     Soff, ax        ; Soff = SourceStartY (EAX) 
  431.         shl     Soff, 7         ;                           * 128
  432.         shl     ebx, 8          ; EBX = AmountClippedY * 256
  433.         shl     ecx, 1          ; ECX = DestSize2
  434.         mul     ecx             ; EDX:EAX = SourceStartY * DestSize2
  435.         sub     ebx, eax
  436.         add     DecisionY, bx
  437.         mov     ax, ClipTp
  438.         mov     DestYStart, ax
  439.  
  440. NoTopClip:  
  441.         mov     ax, DestYStart
  442.         add     ax, DestHeight
  443.         dec     ax
  444.         cmp     ax, ClipBt
  445.         jle NoBottomClip  
  446.         ; Clip off the bottom
  447.         mov     ax, ClipBt
  448.         sub     ax, DestYStart
  449.         inc     ax
  450.         mov     DestHeight, ax
  451.  
  452. NoBottomClip:   
  453.         movsx   eax, ClipLt
  454.         movsx   ecx, DestXStart
  455.         sub     eax, ecx
  456.         jle     NoLeftClip
  457.         ;Clip off the left side
  458.         sub     DestWidth, ax   ; DestWidth -= (ClipLT-DestXStart)
  459.         mov     ebx, eax        ; EBX = AmountClippedX
  460.         xor     edx, edx        ; EDX = 0
  461.         shl     eax, 7          ; EDX:EAX = AmountClippedX * 128
  462.         movzx   ecx, DestSize
  463.         div     ecx             ; EAX (SourceStartX) = EDX:EAX / DestSize 
  464.         add     Soff, ax        ; Soff += SourceStartX (EAX) 
  465.         shl     ebx, 8          ; EBX = AmountClippedX * 256
  466.         shl     ecx, 1          ; ECX = DestSize2
  467.         mul     ecx             ; EDX:EAX = SourceStartX * DestSize2
  468.         sub     ebx, eax
  469.         add     DecisionX, bx
  470.         mov     ax, ClipLt
  471.         mov     DestXStart, ax
  472. NoLeftClip:     
  473.         mov     ax, DestXStart
  474.         add     ax, DestWidth
  475.         dec     ax
  476.         cmp     ax, ClipRt
  477.         jle NoClipRight 
  478.         ; Clip off the right
  479.         mov     ax, ClipRt
  480.         sub     ax, DestXStart
  481.         inc     ax
  482.         mov     DestWidth, ax
  483.  
  484.         ;Calculate starting video address
  485. NoClipRight:    
  486.         mov     ax, ModeXseg 
  487.         mov     gs, ax
  488.         movsx   eax, DestYStart 
  489.         lea     eax, [eax*2]
  490.         lea     eax, [eax*8]
  491.         lea     eax, [eax+eax*4]
  492.         mov     bx, DestXStart
  493.         mov     cx, bx
  494.         shr     bx, 2
  495.         add     ax, bx
  496.         mov     Doff, ax    ; gS:Doff -> VGA memory
  497.  
  498.     mov     dx, SC_INDEX1
  499.         mov     al, MAP_MASK
  500.         out     dx, al
  501.         inc     dx
  502.         and     cx, 3
  503.         mov     al, 11h
  504.         shl     al, cl
  505.     out     dx, al      ; Select the first plane
  506.         
  507.         lfs     si, Bitmap
  508.         add     Soff, si
  509.     mov     dx, DestSize2
  510. ColumnLoop:     
  511.         mov     di, Doff
  512.         mov     si, Soff
  513.         mov     bx, DecisionY
  514.         mov     cx, DestHeight
  515.         inc     cx
  516.  
  517.         jmp     NextPixel
  518. RowLoop:        
  519.         mov     gs:[di], ah
  520.         add     di, 80
  521.         add     bx, 256
  522.     js      Visible
  523. IncSourceY:     
  524.         add     si, 128
  525.     sub     bx, dx
  526.         jns     IncSourceY
  527. NextPixel:      
  528.         mov     ah, fs:[si]
  529.         cmp     ah, INVISIBLE_COLOR
  530.         je      MaskedPixel
  531. Visible:
  532.         loop    RowLoop
  533. DoneWithCol:    
  534.         rol     al, 1
  535.         adc     Doff, 0
  536.     mov     dx, SC_INDEX2
  537.     out     dx, al
  538.     mov     dx, DestSize2
  539.     add     DecisionX, 256
  540.         js      NextCol
  541.         mov     bx, DecisionX
  542. IncSourceX: 
  543.         inc     Soff
  544.     sub     bx, dx
  545.         jns     IncSourceX
  546.         mov     DecisionX, bx
  547. NextCol:        
  548.         dec     DestWidth
  549.         jnz     ColumnLoop
  550. Done:           
  551.         ret
  552.  
  553. MRowLoop:       
  554.         add     di, 80
  555.         add     bx, 256
  556.         js      MaskedPixel
  557. MSourceIncY:    
  558.         add     si, 128
  559.     sub     bx, dx
  560.         jns     MSourceIncY
  561.         mov     ah, fs:[si]
  562.         cmp     ah, INVISIBLE_COLOR
  563.         jne     Visible
  564. MaskedPixel:    
  565.         loop    MRowLoop
  566.         jmp     DoneWithCol
  567.  
  568. XSTRETCHBMP     ENDP
  569.  
  570.  
  571. END
  572. -- 
  573. -----------------------------------------------------------------------------
  574.  John A. Slagel              "My old man used to tell me, before he left this
  575.  j-slagel1@uiuc.edu           shitty world, never chase buses or women- you
  576.  (217) 337-7930               always get left behind." -The Marlboro Man
  577.  
  578.