Simtel MSDOS 1992 June

home *** CD-ROM | disk | FTP | other *** search

/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / turbo_c / blit.arc / BLIT.ASM next >

Wrap

Assembly Source File | 1988-02-22 | 23.1 KB | 1,071 lines

_DATA segment word public 'DATA' include blit.def count_begin macro thisone = $ dw ? endm count_end macro a ifdif <a>,<> org $-a endif thatone = $ org thisone dw thatone-thisone-2 org thatone endm ;note that the two words previous to the given verb must be the offsets ; (in the data segment!) of two routines. The first (cs:put_byte_subr-4) is ; a routine that puts the byte in al with a mask of 0ffh. The second ; (cs:put_byte_subr-2) is a routine that puts the byte in al using the mask ; in dl. put_byte_subr dw ? ;our transfer mode. count dw ? smaller_delta dw ? larger_delta dw ? epsilon dw ? new_x_size dw ? old_x_size dw ? smaller_line dw ? larger_line dw ? compression db ? not_compression db ? bit_count dw ? ;count of bits in source bitmap. line_count dw ? ;count of lines in source bitmap. scan_line_count dw ? ;count of lines so far done. ;we precompute several things: src_align dw ? ;source bit alignment, 0..7 src_seg dw ? ;segment of source bitmap src_bytes dw ? ;width of source bitmap in bytes src_left_bit db ? ;leftmost bit in source bitmap dest_align dw ? ;destination bit alignment, 0..7 dest_bytes dw ? ;width of dest bitmap in bytes dest_left_bit db ? ;leftmost bit in dest bitmap ;this following table is used to provide shifts of differing counts. ; On a V20, and 80x86; x=1,2,3 we could use the shift with immediate count ; instruction, but then we're screwed on 808x processors. get_byte_ptr dw ? get_ptrs label word dw 0 ;shift count of zero - not used. dw shifted_1_get ;special case - shift count of 1. dw shifted_get dw shifted_get dw shifted_get dw shifted_get dw shifted_get dw shifted_7_get ;special case = shift count of -1 mod 8. shifted_get label byte count_begin mov ax,[si] ;get the next two bytes. inc si rol ax,cl ;align to screen byte. count_end shifted_1_get label byte count_begin mov ax,[si] ;get the next two bytes. inc si rol ax,1 ;align to screen byte. count_end shifted_7_get label byte count_begin mov ax,[si] ;get the next two bytes. inc si xchg ah,al ;rol ax,7 == xchg ah,al;ror ax,1 ror ax,1 ;align to screen byte. count_end pset_verb_1 label byte count_begin stosb count_end pset_verb_2 label byte count_begin xor al,es:[di] and al,dl xor es:[di],al inc di ;go to the next byte. count_end and_not_verb_1 label byte count_begin not al and es:[di],al inc di ;go to the next byte. count_end and_not_verb_2 label byte count_begin not al not dl or al,dl and es:[di],al inc di ;go to the next byte. count_end preset_verb_1 label byte count_begin not al stosb count_end preset_verb_2 label byte count_begin not al xor al,es:[di] and al,dl xor es:[di],al inc di ;go to the next byte. count_end and_verb_1 label byte count_begin and es:[di],al inc di ;go to the next byte. count_end and_verb_2 label byte count_begin not dl or al,dl and es:[di],al inc di ;go to the next byte. count_end or_verb_1 label byte count_begin or es:[di],al inc di ;go to the next byte. count_end or_verb_2 label byte count_begin and al,dl ;only set the bits given in al. or es:[di],al inc di ;go to the next byte. count_end or_not_verb_1 label byte count_begin not al or es:[di],al inc di ;go to the next byte. count_end or_not_verb_2 label byte count_begin not al and al,dl ;only set the bits given in al. or es:[di],al inc di ;go to the next byte. count_end xor_verb_1 label byte count_begin xor es:[di],al inc di ;go to the next byte. count_end xor_verb_2 label byte count_begin and al,dl ;only xor the bits given in al. xor es:[di],al inc di ;go to the next byte. count_end _DATA ends _TEXT segment byte public 'CODE' assume cs:_TEXT, ds:_DATA, ss:_DATA put_sized: mov compression,1 ;assume we're compressing zeroes. mov not_compression,0 cmp put_byte_subr,offset _pset_verb jne put_sized_1 mov compression,-1 ;we're compressing ones mov not_compression,1 put_sized_1: mov ax,bit_count mov old_x_size,ax ;remember the old h size. mov cx,src_align ;compute the src left bit. mov al,80h shr al,cl mov src_left_bit,al mov ax,[di].right ;compute the new h size. sub ax,[di].left mov new_x_size,ax ;remember the new h size. mov dest_align,bp ;compute the dest left bit. mov cx,bp mov al,80h shr al,cl mov dest_left_bit,al mov ax,[di].bot ;compute the new v size. sub ax,[di].top cmp ax,line_count ;which is larger? jb put_shrink_1 ;go if we're shrinking ;expand it here. We have more lines in the dest than the source. mov bx,line_count ;don't include the last scan line. mov smaller_delta,bx mov larger_delta,ax mov line_count,ax mov epsilon,0 call blit_setup mov src_seg,ax mov bx,src_bytes mov scan_line_count,bx put_expand_2: push si push di call put_sized_line pop di pop si mov bx,epsilon mov dx,larger_delta add bx,smaller_delta cmp bx,dx ;past the larger yet? jl put_expand_3 ;no. sub bx,dx ;yes - subtract it. add si,src_bytes ;advance to next line. put_expand_3: mov epsilon,bx add di,dest_bytes dec line_count jne put_expand_2 ret put_shrink_1: ;shrink it here. We have more lines in the source than in the dest. mov smaller_delta,ax mov ax,line_count mov larger_delta,ax mov epsilon,0 call blit_setup mov src_seg,ax mov scan_line_count,0 put_shrink_2: mov bx,src_bytes add scan_line_count,bx ;include another scan line in the processing. mov bx,epsilon mov dx,larger_delta add bx,smaller_delta mov epsilon,bx cmp bx,dx ;past the larger yet? jl put_shrink_3 ;no. sub bx,dx ;yes - subtract it off. mov epsilon,bx push si push di call put_sized_line pop di pop si add si,scan_line_count ;move the source down a line. mov scan_line_count,0 add di,dest_bytes ;move to the next line. put_shrink_3: dec line_count jne put_shrink_2 ret put_sized_line: ;ds:si->array, es:di->screen, bp=destination alignment, ; scan_line_count=number of scan lines to process. ;don't destroy bp. mov ax,new_x_size ;are we changing the x size? cmp ax,old_x_size jb put_smaller_line ;yes - it's shorter. ja put_larger_line ;yes - it's longer. mov bx,ax mov bp,dest_align ;get the destination alignment. jmp put_scan_line ;no - same size. put_larger_line: mov larger_line,ax ;new is larger. mov bit_count,ax xor bx,bx mov ax,old_x_size mov smaller_line,ax mov dl,dest_left_bit mov dh,src_left_bit ;dh=source mask. mov cx,bit_count push ds mov ds,src_seg assume ds:nothing mov ah,[si] ;get the first source byte. inc si put_larger_line_1: xor al,al test dh,ah ;is the source bit set? je put_larger_line_2 ;no. mov al,dl ;yes - get the dest bit in question. put_larger_line_2: call put_byte_subr ;put this byte. add bx,smaller_line cmp bx,larger_line jb put_larger_line_3 sub bx,larger_line ror dh,1 ;move over a source bit. jnc put_larger_line_3 mov ah,[si] inc si put_larger_line_3: ror dl,1 ;move over a dest bit. adc di,0 ;if cy, move over in di. loop put_larger_line_1 ;no. cmp dh,80h ;did we use any of the source bits? jne put_larger_line_5 dec si ;no - backup. put_larger_line_5: pop ds assume ds:_DATA ret put_smaller_line: mov smaller_line,ax mov ax,old_x_size mov larger_line,ax mov bit_count,ax xor bx,bx mov cx,bit_count mov dl,dest_left_bit mov dh,src_left_bit ;dh=source mask. push ds mov ds,src_seg assume ds:nothing mov ah,7fh ;init the sampling sum. put_smaller_line_1: push bx mov bx,0 put_smaller_line_6: add ah,not_compression test [si+bx],dh ;is the source bit set? je put_smaller_line_2 ;no. add ah,compression ;yes - count this bit. put_smaller_line_2: add bx,src_bytes ;move down a scan line. cmp bx,scan_line_count ;have we done all of them? jne put_smaller_line_6 ;no. pop bx add bx,smaller_line cmp bx,larger_line jb put_smaller_line_4 sub bx,larger_line xor al,al ;assume not set. xor ah,compression ;flip the sense if necessary. test ah,80h ;more ones than zeroes? je put_smaller_line_3 ;no. mov al,dl ;yes - set this bit. put_smaller_line_3: call put_byte_subr ;put this byte. mov ah,7fh ;init the sampling sum. ror dl,1 ;move over a dest bit. adc di,0 ;if cy, move over in di. put_smaller_line_4: ror dh,1 ;move over a source bit. adc si,0 loop put_smaller_line_1 ;no. cmp dh,80h ;did we use any of the dest bits? je put_smaller_line_5 ;no. inc si ;yes - skip to next byte. put_smaller_line_5: pop ds assume ds:_DATA ret put_sized_j_1: jmp put_sized public _blit _blit: push bp mov bp,sp push si push di mov si,4[bp] mov di,6[bp] mov ax,8[bp] mov put_byte_subr,ax call blit pop di pop si pop bp ret blit_1: ret blit: ;enter with si->source bitmap, di->dest bitmap, put_byte_subr=transfer mode. mov ax,[si].right ;compute the h size. sub ax,[si].left je blit_1 ;if empty, exit now. mov bit_count,ax mov ax,[si].bot ;compute the v size. sub ax,[si].top je blit_1 ;if empty, exit now. mov line_count,ax mov bp,[di].left ;compute the destination alignment. and bp,7 mov ax,[si].left ;compute the source alignment. and ax,7 mov src_align,ax mov ax,[si].bytes ;get the source width. mov src_bytes,ax mov ax,[di].bytes ;get the destination width. mov dest_bytes,ax mov ax,[di].right ;are we changing the h size? sub ax,[di].left cmp ax,bit_count jne put_sized_j_1 ;yes. mov ax,[di].bot ;are we changing the v size? sub ax,[di].top cmp ax,line_count jne put_sized_j_1 ;yes. cmp bit_count,8 ;does it fit in one byte? jbe blit_2 ;yes - do it "quickly" jmp compile_blit ;no - do it "slowly" blit_2: call blit_setup mov dx,00ffh ;compute the mask. mov cx,bit_count ror dx,cl ;make the necessary number of bits. mov dl,0 ;get rid of the unnecessary bits. mov cx,bp shr dx,cl ;shift the mask to where it should be. mov cx,bp ;shift count is dest align-src align. sub cx,src_align and cl,16-1 ;only 16 bits in a register. mov bx,put_byte_subr ;get the byte store routine. mov bp,dest_bytes dec bp push ds ;save our data segment, mov ds,ax ; and get the source segment. assume ds:nothing blit_3: mov ax,[si] ;get the byte into ax add si,src_bytes ;move down a line. ror ax,cl ;shift it to where it should be. xchg dh,dl ;put the byte in al at es:di using the mask in dl call bx ;bx=put_byte_subr inc di ;move over one byte. xchg dh,dl ;get the right mask. mov al,ah ;get the right byte. call bx ;bx=put_byte_subr add di,bp ;bp=dest_bytes. dec line_count jne blit_3 pop ds assume ds:_DATA ret copy_code macro lodsw mov cx,ax rep movsb endm compile_blit: push si push di push cs pop es mov di,offset put_rect_subr ;in the following code, bp is the destination alignment, ; dx is the byte count, si and cx are scratch, bx is used temporarily, ; and es:di->the code that we're compiling. cmp bp,src_align je compile_aligned jmp compile_shifted compile_aligned: push di ;remember where to loop back to. mov bx,bit_count ;get the number of bits left to do. or bp,bp ;dest alignment zero? je compile_aligned_2 ;yes - don't mask on the left. mov al,0b2h ;opcode of "mov dl,immed8" mov cx,bp ;store the mask. mov ah,0ffh shr ah,cl stosw mov al,0ach ;opcode of lodsb stosb mov si,put_byte_subr ;compile the masked version. mov si,cs:[si-2] copy_code add bx,bp ;say that we've done the first few bits. sub bx,8 ;. . compile_aligned_2: shr bx,1 ;truncate to an even number of bytes. shr bx,1 shr bx,1 cmp put_byte_subr,offset _pset_verb ;are we doing pset? jne compile_aligned_7 ;no - have to do it "slowly" shr bx,1 ;prepare to move words. jnc compile_aligned_8 ;is the count odd? go if not. mov al,0a4h ;opcode of "movsb" stosb compile_aligned_8: mov al,0b9h ;opcode of "mov cx,immed16" stosb mov ax,bx stosw mov ax,0f3h + 0a5h*256 ;opcode of "rep movsw" stosw jmp short compile_aligned_5 compile_aligned_7: mov dx,bx ;remember the total number of bytes. inc bx ;round up. shr bx,1 ;remember the number of loop iterations. or bx,bx ;are there any iterations at all? je compile_aligned_5 ;no - skip the loop. mov al,0b9h ;opcode of "mov cx,immed16" stosb mov ax,bx stosw test dx,1 ;do we need to jump to the second store? je compile_aligned_6 ;no. mov ax,0ebh + 256*0 ;opcode of "jmp short $+2" stosw compile_aligned_6: mov bx,di ;remember where the jump is. ;bx now holds the offset of the jump into the loop, which is also ; the beginning of the loop. mov al,0ach ;opcode of lodsb stosb mov si,put_byte_subr ;compile the unmasked version. mov si,cs:[si-4] ;get the address of it. copy_code test dx,1 ;are we jumping into the loop here? je compile_aligned_4 ;no. mov ax,di ;yes - compute the jump offset. sub ax,bx mov cs:[bx-1],al ;store it. compile_aligned_4: mov al,0ach ;opcode of lodsb stosb mov si,put_byte_subr ;compile the unmasked version. mov si,cs:[si-4] ;get the address of it. copy_code mov al,0e2h ;opcode of "loop" stosb mov ax,bx ;compute the jump offset. sub ax,di dec ax ;because bx->jump offset, not afterward. stosb compile_aligned_5: mov cx,bit_count add cx,bp ;dest_align and cx,7 ;does it align to a right edge? je compile_aligned_1 ;yes - skip the right mask. ;cx now holds the right mask bit count. mov ax,00ffh ;rotate the bits into ah. ror ax,cl mov al,0b2h ;opcode of "mov dl,immed8" stosw mov al,0ach ;opcode of lodsb stosb mov si,put_byte_subr ;compile the masked version. mov si,cs:[si-2] copy_code compile_aligned_1: jmp compile_blit_2 ;join with the shifting code. compile_shifted: mov si,src_align ;use the proper get byte routine. sub si,bp and si,7 ;only eight different ones. shl si,1 ;index into word table. mov si,get_ptrs[si] mov get_byte_ptr,si mov al,0b1h ;opcode of "mov cl,immed8" stosb mov ax,src_align ;shift count is src align-dest align. sub ax,bp and al,7 ;don't shift too far. stosb cmp bp,src_align ;if we're shifting right, we need to jbe compile_shifted_0 ; backup the source by one. mov al,4eh ;opcode of "dec si" stosb compile_shifted_0: push di ;remember where the loop code starts. mov bx,bit_count ;get the bit count. or bp,bp ;is dest alignment zero? je compile_shifted_2 ;yes - don't bother masking the left. mov al,0b2h ;opcode of "mov dl,immed8" mov cx,bp ;store the mask. mov ah,0ffh shr ah,cl stosw mov si,get_byte_ptr ;compile the code to get a byte. copy_code mov si,put_byte_subr ;compile the masked version. mov si,cs:[si-2] copy_code add bx,bp ;say that we've done the first few bits. sub bx,8 ;. . compile_shifted_2: shr bx,1 ;truncate to an even number of bytes. shr bx,1 shr bx,1 mov dx,bx ;remember the total number of bytes. inc bx ;round up. shr bx,1 ;remember the number of loop iterations. or bx,bx ;are there any iterations at all? je compile_shifted_5 ;no - skip the loop. mov al,0bbh ;opcode of "mov bx,immed16" stosb mov ax,bx stosw test dx,1 ;do we need to jump to the second store? je compile_shifted_6 ;no. mov ax,0ebh + 256*0 ;opcode of "jmp short $+2" stosw compile_shifted_6: mov bx,di ;remember where the jump is. ;bx now holds the offset of the jump into the loop, which is also ; the beginning of the loop. mov si,get_byte_ptr ;compile the code to get a byte. copy_code mov si,put_byte_subr ;compile the unmasked version. mov si,cs:[si-4] ;get the address of it. copy_code test dx,1 ;are we jumping into the loop here? je compile_shifted_4 ;no. mov ax,di ;yes - compute the jump offset. sub ax,bx mov cs:[bx-1],al ;store it. compile_shifted_4: mov si,get_byte_ptr ;compile the code to get a byte. copy_code mov si,put_byte_subr ;compile the unmasked version. mov si,cs:[si-4] ;get the address of it. copy_code mov ax,4bh + 256*75h ;opcodes of "dec bx" and "jne" stosw mov ax,bx ;compute the jump offset. sub ax,di dec ax ;because bx->jump offset, not afterward. stosb compile_shifted_5: mov cx,bit_count add cx,bp ;dest_align and cx,7 ;does it align to a right edge? je compile_blit_2 ;yes - skip the right mask. ;bx now holds the right mask bit count. mov ax,00ffh ;rotate the bits into ah. ror ax,cl mov al,0b2h ;opcode of "mov dl,immed8" stosw mov si,get_byte_ptr ;compile the code to get a byte. copy_code mov si,put_byte_subr ;compile the masked version. mov si,cs:[si-2] copy_code compile_blit_2: ;compute the number of bytes that we've affected. mov ax,81h+11000111b*256 ;opcode of "add di,immed16" stosw mov bx,bit_count ;get the bit count. add bx,bp ;add align (take care of left edge) add bx,7 ;round up (take care of right edge) shr bx,1 shr bx,1 shr bx,1 mov ax,dest_bytes ;get the width of the dest bitmap. sub ax,bx ;sub the number of bytes we've done. stosw ;ax=# bytes to next line. mov ax,81h+11000110b*256 ;opcode of "add si,immed16" stosw mov ax,src_bytes ;get the width of the dest bitmap. sub ax,bx ;sub the number of bytes we've done. stosw ;ax=# bytes to next line. mov ax,4dh + 256*75h ;opcodes of "dec bp" and "jne" stosw pop ax ;jump back to the beginning. sub ax,di ;subtract target-(di+1), dec ax ; because di->after opcode, not operand stosb ;store the jump offset ;if we're shifting right, include the following code: cmp bp,src_align ;are we shifting right? jbe compile_blit_3 ;no. mov al,46h ;opcode of "inc si" stosb compile_blit_3: mov ax,01fh + 0c3h*256 ;opcodes of "pop ds" and "ret" stosw pop di ;restore the bitmap pointers. pop si mov bp,line_count ;get the scan line count. call blit_setup push ds mov ds,ax put_rect_subr: db 100h dup(90h) blit_setup: ;enter with ds:si->source bitmap, ds:di->dest bitmap. ;exit with ax:si->source bits, es:di->dest bits mov bx,[di].left ;get x shr bx,1 ;get rid of bit position shr bx,1 shr bx,1 mov ax,[di].top ;compute y-position*dest_bytes mul [di].bytes add bx,ax les di,[di].pntr ;get the pointer to the bitmap. add di,bx ;add the offset into the bitmap. mov bx,[si].left ;get x shr bx,1 ;get rid of bit position shr bx,1 shr bx,1 mov ax,[si].top ;compute y-position*src_bytes mul [si].bytes add bx,ax mov ax,[si].pntr.segm ;get the segment into ax. mov si,[si].pntr.offs ;get the offset into si. add si,bx ;add the offset into the bitmap. ret put_scan_line: ;ds:si->array, es:di->screen, bx=bit count, bp=destination alignment ;don't destroy bp. mov cx,bp ;get destination alignment. jcxz put_noshift ;go if it aligns. mov dl,0ffh ;al=source mask shr dl,cl mov al,[si] ;dh=source byte shr al,cl ;align to screen byte. add bx,bp ;pretend that we've done a whole byte. sub bx,8 ;more bytes? jle put_scan_line_2 mov cx,8 ;make cl=8-shift count. sub cx,bp cmp put_byte_subr,offset _pset_verb je put_scan_line_8 call put_byte_subr inc di ;go to the next byte. mov dl,0ffh ;eight bits in the rest of the bytes. jmp short put_scan_line_5 put_scan_line_8: mov ah,es:[di] ;get the dest byte. xor al,ah ;flip the pattern using the dest bits. and al,dl ;get rid of the bits we won't change. xor al,ah ;flip using only the bits that change. put_scan_line_7: stosb mov ax,[si] ;get the next two bytes. inc si ;go to the this byte. rol ax,cl ;align to screen byte. sub bx,8 ;more bytes? ja put_scan_line_7 ;yes - keep doing them mov dl,0ffh ;eight bits in the next byte. jmp short put_scan_line_2 ;no - finish off the last. put_scan_line_4: ;put the byte in al at es:di using the mask in dl call put_byte_subr inc di put_scan_line_5: mov ax,[si] ;get the next two bytes. inc si ;go to the next byte. rol ax,cl ;align to screen byte. sub bx,8 ;more bytes? ja put_scan_line_4 ;yes - keep doing them put_scan_line_2: add bx,8 mov cl,bl shr dl,cl not dl ;we're not including the bits to the right. call put_byte_subr cmp bp,bx ;did we use any bits from the right byte. jae put_scan_line_3 ;no. inc si ;yes - skip past it. put_scan_line_3: ret put_noshift: ;ds:si->array, es:di->screen, bx=bit count, bp=destination alignment (0). mov dl,0ffh ;eight bits in the rest of the bytes. mov cx,bx shr cx,1 shr cx,1 shr cx,1 and bx,7 jcxz put_noshift_2 cmp put_byte_subr,offset _pset_verb jne put_noshift_4 shr cx,1 ;move words. jnc put_noshift_1 movsb put_noshift_1: rep movsw jmp short put_noshift_2 put_noshift_4: ;put the byte in al at es:di using the mask in dl lodsb call put_byte_subr inc di loop put_noshift_4 put_noshift_2: mov cx,bx ;get the number of bits in the next byte. jcxz put_noshift_3 ;if none, just skip. mov al,[si] inc si mov dx,0ff00h ;shift the bits in from ah. shr dx,cl call put_byte_subr put_noshift_3: ret ;note that the two words previous to the given verb must be the offsets ; (in the data segment!) of two routines. The first (cs:put_byte_subr-4) is ; a routine that puts the byte in al with a mask of 0ffh. The second ; (cs:put_byte_subr-2) is a routine that puts the byte in al using the mask ; in dl. ;new old ; | 0 1 ;----------- ; 0 | 0 0 ; 1 | 1 1 dw pset_verb_1 dw pset_verb_2 public _pset_verb _pset_verb: xor al,es:[di] and al,dl xor es:[di],al ret ;new old ; | 0 1 ;----------- ; 0 | 0 1 ; 1 | 0 0 dw and_not_verb_1 dw and_not_verb_2 public _and_not_verb _and_not_verb: not al not dl or al,dl not dl and es:[di],al ret ;new old ; | 0 1 ;----------- ; 0 | 1 1 ; 1 | 0 0 dw preset_verb_1 dw preset_verb_2 public _preset_verb _preset_verb: not al xor al,es:[di] and al,dl xor es:[di],al ret ;new old ; | 0 1 ;----------- ; 0 | 0 0 ; 1 | 0 1 dw and_verb_1 dw and_verb_2 public _and_verb _and_verb: not dl or al,dl not dl and es:[di],al ret ;new old ; | 0 1 ;----------- ; 0 | 0 1 ; 1 | 1 1 dw or_verb_1 dw or_verb_2 public _or_verb _or_verb: and al,dl ;only set the bits given in dl. or es:[di],al ret ;new old ; | 0 1 ;----------- ; 0 | 1 1 ; 1 | 0 1 dw or_not_verb_1 dw or_not_verb_2 public _or_not_verb _or_not_verb: not al and al,dl ;only set the bits given in dl. or es:[di],al ret ;new old ; | 0 1 ;----------- ; 0 | 0 1 ; 1 | 1 0 dw xor_verb_1 dw xor_verb_2 public _xor_verb _xor_verb: and al,dl ;only xor the bits given in dl. xor es:[di],al ret _TEXT ends end