mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
815 lines
21 KiB
815 lines
21 KiB
DOSSEG
|
|
.MODEL LARGE
|
|
|
|
VGA_BUFFER_SEG equ 0a000h
|
|
VGA_WIDTH_PIXELS equ 640
|
|
VGA_HEIGHT_SCAN_LINES equ 480
|
|
VGA_BYTES_PER_SCAN_LINE equ (VGA_WIDTH_PIXELS/8)
|
|
|
|
VGA_REGISTER equ 3ceh
|
|
|
|
VGAREG_SETRESET equ 0
|
|
VGAREG_ENABLESETRESET equ 1
|
|
VGAREG_READMAPSELECT equ 4
|
|
VGAREG_MODE equ 5
|
|
VGAREG_BITMASK equ 8
|
|
|
|
|
|
|
|
.CODE
|
|
|
|
extrn _malloc:far
|
|
|
|
.286
|
|
|
|
|
|
;++
|
|
;
|
|
; VOID
|
|
; _far
|
|
; VgaBitBlt(
|
|
; IN USHORT x,
|
|
; IN USHORT y,
|
|
; IN USHORT w,
|
|
; IN USHORT h,
|
|
; IN USHORT BytesPerRow,
|
|
; IN BOOL IsColor,
|
|
; IN FPBYTE PixelMap,
|
|
; IN FPVOID Data
|
|
; );
|
|
;
|
|
; Routine Description:
|
|
;
|
|
; Blits a rectangular block from memory to the screen.
|
|
; The block is interpreted as a monochrome bitmap.
|
|
;
|
|
; Arguments:
|
|
;
|
|
; x - gives the x position of the left edge of the target.
|
|
;
|
|
; y - gives the y position of the *bottom* edge of the target.
|
|
; The data is expected to be in standard Windows bottom-up
|
|
; format, and the bitmap grows upward from this line as
|
|
; it's transferred.
|
|
;
|
|
; w - gives the width in pixels of a row of the source bitmap.
|
|
;
|
|
; h - gives the number of lines in the source bitmap. The target
|
|
; is lines y through (y-h)+1 inclusive, in a bottom-up fashion.
|
|
;
|
|
; BytesPerRow - supplies the number of bytes in a row of data in the
|
|
; bitmap. Rows in a Windows bitmap are padded to a dword boundary.
|
|
;
|
|
; IsColor - if 0 the bitmap is interpreted as 1 bpp. If non-0 the bitmap
|
|
; is interpreted as 4 bpp.
|
|
;
|
|
; PixelMap - supplies an array of translations from pixel values in
|
|
; the source bitmap to values to be placed into video memory
|
|
; for that pixel. Each n-bit (1 for mono, 4 for color) value from
|
|
; the source bitmap is used as an index into this array.
|
|
; The 4-bit value looked up in the array is what is actually
|
|
; placed into video memory for the pixel. For mono this is a
|
|
; 2 byte table, for color it's 16.
|
|
;
|
|
; Data - supplies a pointer to the bitmap bits. The bits are expected
|
|
; to be in the standard Windows bitmap bottom-up arrangement.
|
|
; Each row of pixels is padded to a 4-byte boundary.
|
|
;
|
|
; Return Value:
|
|
;
|
|
; None.
|
|
;
|
|
;--
|
|
|
|
vbb_x equ word ptr [bp+6]
|
|
vbb_y equ word ptr [bp+8]
|
|
vbb_w equ word ptr [bp+10]
|
|
vbb_h equ [bp+12]
|
|
vbb_BytesPerRow equ word ptr [bp+14]
|
|
vbb_IsColor equ word ptr [bp+16]
|
|
vbb_PixelMap equ dword ptr [bp+18]
|
|
vbb_PixelMapl equ word ptr [bp+18]
|
|
vbb_PixelMaph equ word ptr [bp+20]
|
|
vbb_Datal equ word ptr [bp+22]
|
|
vbb_Datah equ word ptr [bp+24]
|
|
|
|
vbb_InitialShift equ byte ptr [bp-1]
|
|
vbb_DataByteMask equ byte ptr [bp-2]
|
|
vbb_ShiftAdjust equ byte ptr [bp-4]
|
|
vbb_PixelsRemain equ word ptr [bp-6]
|
|
vbb_BufferOffset equ word ptr [bp-8]
|
|
vbb_NextRowDelta equ word ptr [bp-10]
|
|
|
|
LocalPixelMap db 16 dup (?)
|
|
|
|
public _VgaBitBlt
|
|
_VgaBitBlt proc far
|
|
|
|
push bp
|
|
mov bp,sp
|
|
sub sp,10
|
|
|
|
push ds
|
|
push es
|
|
push si
|
|
push di
|
|
push bx
|
|
|
|
;
|
|
; Adjust for top-down vs bottom-up bitmap
|
|
;
|
|
mov vbb_NextRowDelta,VGA_BYTES_PER_SCAN_LINE
|
|
test byte ptr vbb_h[1],80h
|
|
jns @f
|
|
neg word ptr vbb_h ; make the height positive
|
|
neg vbb_NextRowDelta ; move backwards through buffer
|
|
|
|
;
|
|
; Set up read mode 0 and write mode 2.
|
|
;
|
|
@@: mov dx,VGA_REGISTER
|
|
mov al,VGAREG_MODE
|
|
mov ah,2 ; write mode 2, read mode 0
|
|
out dx,ax
|
|
|
|
;
|
|
; Set up bpp-dependent values
|
|
;
|
|
cmp vbb_IsColor,0
|
|
jz vbbmono
|
|
mov vbb_InitialShift,4
|
|
mov vbb_DataByteMask,0fh
|
|
mov vbb_ShiftAdjust,4 ; adjust shift count by 4 bits
|
|
mov cx,8 ; pixel map is 16 bytes = 8 words
|
|
jmp short vbbmovemap
|
|
vbbmono:
|
|
mov vbb_InitialShift,7
|
|
mov vbb_DataByteMask,1
|
|
mov vbb_ShiftAdjust,1 ; adjust shift count by 1 bit
|
|
mov cx,1 ; pixel map is 2 bytes = 1 words
|
|
vbbmovemap:
|
|
;
|
|
; Place the pixel map into memory addressable via cs.
|
|
; cx = count of words to move
|
|
;
|
|
push cs
|
|
pop es
|
|
lea di,LocalPixelMap ; es:di -> local copy of pixel map
|
|
mov si,vbb_PixelMapl
|
|
or si,vbb_PixelMaph
|
|
jnz vbbmovemap2 ; caller specified a pixel map
|
|
|
|
;
|
|
; No pixel map specified, build identity map
|
|
;
|
|
mov al,0
|
|
stosb
|
|
cmp vbb_IsColor,0
|
|
jne vbbcolor
|
|
mov al,0fh
|
|
stosb
|
|
jmp short vbbmovemap2
|
|
vbbcolor:
|
|
inc al
|
|
stosb
|
|
mov ax,0302h
|
|
stosw
|
|
mov ax,0504h
|
|
stosw
|
|
mov ax,0706h
|
|
stosw
|
|
mov ax,0908h
|
|
stosw
|
|
mov ax,0b0ah
|
|
stosw
|
|
mov ax,0d0ch
|
|
stosw
|
|
mov ax,0f0eh
|
|
stosw
|
|
jmp short vbbmovemap3
|
|
vbbmovemap2:
|
|
lds si,vbb_PixelMap ; ds:si -> pixel map
|
|
rep movsw
|
|
vbbmovemap3:
|
|
mov ax,vbb_Datah
|
|
mov ds,ax ; ds addresses bitmap data
|
|
mov ax,VGA_BUFFER_SEG
|
|
mov es,ax ; es addresses VGA video buffer
|
|
|
|
;
|
|
; Calculate address of first byte in video buffer we need to touch.
|
|
; Note that the y position is the *bottom* of the area to blit.
|
|
;
|
|
mov ax,VGA_BYTES_PER_SCAN_LINE
|
|
mul word ptr vbb_y ; ax = offset of first byte on line
|
|
mov vbb_BufferOffset,ax
|
|
mov ax,vbb_x
|
|
mov cl,3 ; divide by # bits in a byte (2^3)
|
|
shr ax,cl ; ax = offset of byte within line
|
|
add vbb_BufferOffset,ax ; form offset of byte in buffer
|
|
|
|
lea bx,LocalPixelMap ; cs:bx -> local copy of pixel map
|
|
mov dx,VGA_REGISTER ; mul above clobbered dx
|
|
|
|
vbbrow:
|
|
dec word ptr vbb_h ; done yet?
|
|
js vbbdone ; number went from 0 to -1, so we're done.
|
|
|
|
mov si,vbb_Datal ; ds:si -> start of row in bitmap data
|
|
mov ax,vbb_BytesPerRow
|
|
add vbb_Datal,ax ; point at next row for next iteration
|
|
mov di,vbb_BufferOffset
|
|
mov cx,vbb_NextRowDelta ; move up or down for next row
|
|
add vbb_BufferOffset,cx
|
|
|
|
mov cx,vbb_w
|
|
mov vbb_PixelsRemain,cx ; number of pixels remaining in row
|
|
|
|
mov cx,vbb_x
|
|
and cl,7 ; cl = bit number of first bit on line
|
|
sub cl,7
|
|
neg cl ; cl = shift count
|
|
mov ah,1
|
|
shl ah,cl ; ah = initial bit mask
|
|
|
|
mov al,es:[di] ; load latches for current byte
|
|
|
|
vbbfetch:
|
|
mov cl,vbb_InitialShift ; cl = shift count to extract data from bitmap
|
|
lodsb ; get next byte from bitmap
|
|
mov ch,al ; save it
|
|
|
|
vbbbyte:
|
|
;
|
|
; ah = current bit mask
|
|
;
|
|
mov al,VGAREG_BITMASK
|
|
out dx,ax
|
|
|
|
mov al,ch ; restore byte from bitmap
|
|
shr al,cl ; place value into low n bits
|
|
and al,vbb_DataByteMask ; al = value from bitmap
|
|
xlatb cs:[bx] ; al = pixel value to put into video memory
|
|
|
|
;
|
|
; Skip this pixel if the pixel value is greater than legal values
|
|
;
|
|
test al,0f0h
|
|
jnz vbbpix
|
|
|
|
;
|
|
; Stick this pixel into video memory.
|
|
; The bit mask is already set up to isloate the single pixel
|
|
; we want to modify.
|
|
;
|
|
mov es:[di],al
|
|
|
|
vbbpix:
|
|
;
|
|
; Adjust the bitmask to isolate the next pixel.
|
|
; If we've reached the end of the current byte then load the
|
|
; latches for the next one.
|
|
;
|
|
ror ah,1
|
|
jnc @f
|
|
inc di
|
|
@@: mov al,es:[di] ; update latches
|
|
|
|
;
|
|
; Now check termination conditions to see if we're done with
|
|
; the current row and if we're done with the current byte.
|
|
;
|
|
dec vbb_PixelsRemain ; done with this row yet?
|
|
jz vbbrow ; yes, start next row
|
|
sub cl,vbb_ShiftAdjust ; adjust shift count
|
|
jge vbbbyte ; get next pixel from byte we loaded earlier
|
|
jl vbbfetch ; get next byte from bitmap
|
|
|
|
vbbdone:
|
|
;
|
|
; Restore BIOS defaults
|
|
;
|
|
mov dx,VGA_REGISTER
|
|
mov al,VGAREG_MODE
|
|
mov ah,0 ; write mode 0, read mode 0
|
|
out dx,ax
|
|
|
|
pop bx
|
|
pop di
|
|
pop si
|
|
pop es
|
|
pop ds
|
|
leave
|
|
ret
|
|
|
|
_VgaBitBlt endp
|
|
|
|
|
|
;++
|
|
;
|
|
; VOID
|
|
; _far
|
|
; VgaClearRegion(
|
|
; IN USHORT x,
|
|
; IN USHORT y,
|
|
; IN USHORT w,
|
|
; IN USHORT h,
|
|
; IN BYTE PixelValue
|
|
; );
|
|
;
|
|
; Routine Description:
|
|
;
|
|
; Clears a given region on the vga screen to a given pixel value.
|
|
;
|
|
; Arguments:
|
|
;
|
|
; x,y,w,h - give the x and y of the upper left corner
|
|
; of the region to clear, and its width and height.
|
|
;
|
|
; PixelValue - supplies pixel value to clear to.
|
|
;
|
|
; Return Value:
|
|
;
|
|
; None.
|
|
;
|
|
;--
|
|
|
|
vcr_x equ word ptr [bp+6]
|
|
vcr_y equ word ptr [bp+8]
|
|
vcr_w equ [bp+10]
|
|
vcr_h equ word ptr [bp+12]
|
|
vcr_PixelValue equ byte ptr [bp+14]
|
|
|
|
vcr_FirstByte equ [bp+8]
|
|
vcr_startmask equ byte ptr [bp+6]
|
|
vcr_endmask equ byte ptr [bp+7]
|
|
vcr_fullbytes equ byte ptr [bp+15]
|
|
|
|
|
|
public _VgaClearRegion
|
|
_VgaClearRegion proc far
|
|
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
|
|
;
|
|
; Calculate offset of first byte in first row we care about.
|
|
;
|
|
mov ax,VGA_BYTES_PER_SCAN_LINE
|
|
mul word ptr vcr_y ; ax = y position
|
|
mov vcr_FirstByte,ax ; store offset
|
|
|
|
;
|
|
; Now add in the byte offset of the byte containing the first pixel on
|
|
; each scan line.
|
|
;
|
|
mov ax,vcr_x ; ax = x position
|
|
mov cx,8 ; divide by # of bits in a byte
|
|
div cl ; ah = bit, al = byte
|
|
add vcr_FirstByte,al
|
|
adc byte ptr vcr_FirstByte[1],0 ; [bp+8] -> byte in scan line with first pixel
|
|
|
|
;
|
|
; Calculate bitmask for partial byte at start of line.
|
|
; The layout of the video buffer is such that the mask to address
|
|
; the 0th pixel is 80, to address the 1st pixel is 40, etc.
|
|
; Thus the bit within the byte is essentially the number of
|
|
; high bits in the 8 bit mask that need to be 0.
|
|
;
|
|
sub cl,ah ; cl = count of 1 bits, ch = 0
|
|
cmp cx,vcr_w ; too many for desired width?
|
|
pushf
|
|
|
|
mov ch,1
|
|
shl ch,cl
|
|
dec ch ; ch = bitmask, bottom cl bits are 1
|
|
|
|
popf
|
|
jbe vcr_storestart ; don't need to truncate width
|
|
|
|
sub cl,vcr_w ; cl = count of unwanted low bits
|
|
mov al,1
|
|
shl al,cl
|
|
dec al
|
|
not al
|
|
and ch,al
|
|
mov cl,vcr_w
|
|
|
|
vcr_storestart:
|
|
;
|
|
; cl = # pixels in partial byte
|
|
; ch = bitmask
|
|
;
|
|
mov vcr_startmask,ch ; save mask for start
|
|
xor ch,ch ; cx = pixels accounted for so far
|
|
mov ax,vcr_w
|
|
sub ax,cx ; ax = remaining width
|
|
jnz vcr_calcbytes
|
|
mov vcr_fullbytes,dl ; no full bytes
|
|
mov vcr_endmask,dl ; no partial at end of line
|
|
jmp short vcrdoit
|
|
|
|
vcr_calcbytes:
|
|
;
|
|
; ax = remaining width
|
|
;
|
|
mov cl,8
|
|
div cl ; al = full bytes, ah = partial
|
|
mov vcr_fullbytes,al
|
|
|
|
;
|
|
; Now calculate the mask for the partial byte at the end
|
|
; of each line. This will involve setting n of the high bits
|
|
; in a mask.
|
|
;
|
|
mov cl,8
|
|
sub cl,ah
|
|
mov al,1
|
|
shl al,cl
|
|
dec al
|
|
not al
|
|
mov vcr_endmask,al
|
|
|
|
vcrdoit:
|
|
mov dx,VGA_REGISTER
|
|
|
|
;
|
|
; The enable set/reset is set up so that the data that gets written
|
|
; into video memory comes from the set/reset register, not the cpu.
|
|
; Thus the content of ax is irrelevent when we store to video mem.
|
|
;
|
|
mov al,VGAREG_SETRESET ; set/reset register
|
|
mov ah,vcr_PixelValue ; ah = pixel value
|
|
out dx,ax ; load set/reset register
|
|
|
|
mov al,VGAREG_ENABLESETRESET ; enable set/reset register
|
|
mov ah,15 ; mask = write planes from set/reset
|
|
out dx,ax ; load enable set/reset register
|
|
|
|
mov ax,VGA_BUFFER_SEG
|
|
mov es,ax
|
|
|
|
mov cx,vcr_h ; get row count
|
|
|
|
nextrow:
|
|
push cx
|
|
|
|
mov di,vcr_FirstByte ; es:di -> first byte in target
|
|
add word ptr vcr_FirstByte,VGA_BYTES_PER_SCAN_LINE
|
|
|
|
;
|
|
; Do partial byte at relevent part of start of line
|
|
;
|
|
mov al,VGAREG_BITMASK
|
|
mov ah,vcr_startmask
|
|
out dx,ax
|
|
mov al,es:[di] ; load latches
|
|
stosb ; update video memory
|
|
|
|
;
|
|
; Do all full bytes on this line
|
|
;
|
|
mov al,VGAREG_BITMASK
|
|
mov ah,255
|
|
out dx,ax
|
|
mov cl,vcr_fullbytes
|
|
mov ch,0
|
|
rep stosb
|
|
|
|
;
|
|
; And finally the trail part
|
|
;
|
|
mov al,VGAREG_BITMASK
|
|
mov ah,vcr_endmask
|
|
out dx,ax
|
|
mov al,es:[di] ; load latches
|
|
stosb ; update video memory
|
|
|
|
pop cx ; restore row count
|
|
loop nextrow
|
|
|
|
;
|
|
; Restore default enable set/reset, bitmask
|
|
;
|
|
mov al,VGAREG_ENABLESETRESET
|
|
mov ah,0
|
|
mov dx,VGA_REGISTER
|
|
out dx,ax
|
|
mov al,VGAREG_BITMASK
|
|
mov ah,255
|
|
out dx,ax
|
|
|
|
pop di
|
|
leave
|
|
ret
|
|
|
|
_VgaClearRegion endp
|
|
|
|
|
|
;++
|
|
;
|
|
; VOID
|
|
; _far
|
|
; VgaClearScreen(
|
|
; IN BYTE PixelValue
|
|
; );
|
|
;
|
|
; Routine Description:
|
|
;
|
|
; Clears the 640x480 vga graphics screen.
|
|
;
|
|
; Arguments:
|
|
;
|
|
; PixelValue - supplies pixel value to clear to.
|
|
;
|
|
; Return Value:
|
|
;
|
|
; None.
|
|
;
|
|
;--
|
|
|
|
vcs_PixelValue equ [bp+6]
|
|
|
|
public _VgaClearScreen
|
|
_VgaClearScreen proc far
|
|
|
|
push bp
|
|
mov bp,sp
|
|
|
|
push vcs_PixelValue
|
|
push VGA_HEIGHT_SCAN_LINES
|
|
push VGA_WIDTH_PIXELS
|
|
push 0
|
|
push 0
|
|
|
|
call _VgaClearRegion
|
|
|
|
add sp,10
|
|
|
|
leave
|
|
ret
|
|
|
|
_VgaClearScreen endp
|
|
|
|
|
|
;++
|
|
;
|
|
; VOID
|
|
; _far
|
|
; VgaInit(
|
|
; VOID
|
|
; );
|
|
;
|
|
; Routine Description:
|
|
;
|
|
; Initializes display support by setting 640x480 vga graphics mode
|
|
; and clearing the screen.
|
|
;
|
|
; Arguments:
|
|
;
|
|
; None.
|
|
;
|
|
; Return Value:
|
|
;
|
|
; None.
|
|
;
|
|
;--
|
|
|
|
public _VgaInit
|
|
_VgaInit proc far
|
|
|
|
mov ax,12h
|
|
mov bx,0
|
|
int 10h
|
|
push 0 ; pixel value
|
|
call _VgaClearScreen
|
|
add sp,2
|
|
ret
|
|
|
|
_VgaInit endp
|
|
|
|
|
|
|
|
;++
|
|
;
|
|
; FPVOID
|
|
; _far
|
|
; VgaSaveBlock(
|
|
; IN USHORT x,
|
|
; IN USHORT y,
|
|
; IN USHORT w,
|
|
; IN USHORT h,
|
|
; IN FPUSHORT BytesPerRow
|
|
; );
|
|
;
|
|
; Routine Description:
|
|
;
|
|
; Grabs a block of memory from the screen and places it into a block
|
|
; of memory. The block can later be used with VgaBitBlt.
|
|
;
|
|
; This routine limits the size of the block to 32K. If the block
|
|
; would be larger than this, the routine fails.
|
|
;
|
|
; Arguments:
|
|
;
|
|
; x - supplies x coordinate of left edge of area to save.
|
|
; This MUST be an even multiple of 8. If it is not, the routine
|
|
; fails and returns NULL.
|
|
;
|
|
; y - supplies y coordinate of top of area to save.
|
|
;
|
|
; w - supplies width in pixels of area to save. This MUST be an even
|
|
; multiple of 8. If it is not, the routine fails and returns NULL.
|
|
;
|
|
; h - supplies height of area to save.
|
|
;
|
|
; BytesPerRow - receives number of bytes in a row of the saved block.
|
|
; This value is suitable for passing in as the BytesPerRow parameter
|
|
; to VgaBitBlt.
|
|
;
|
|
; Return Value:
|
|
;
|
|
; Pointer to bits, allocated via malloc(). Caller can free when finished.
|
|
; NULL if couldn't allocate enough memory for the saved block or invalid
|
|
; parameters were given.
|
|
;
|
|
;--
|
|
|
|
vsb_x equ word ptr [bp+6]
|
|
vsb_y equ word ptr [bp+8]
|
|
vsb_w equ word ptr [bp+10]
|
|
vsb_h equ word ptr [bp+12]
|
|
vsb_BytesPerRow equ dword ptr [bp+14]
|
|
|
|
vsb_BytesLeft equ word ptr [bp-2]
|
|
|
|
MakeAndSave2Pixels label near
|
|
;
|
|
; Take the 4 bytes from the bit planes and based on the top
|
|
; 2 bits of each, build 2 pixel values and save into the
|
|
; target bitmap. We take advantage of the fact that the sar
|
|
; instruction replicates the top bit as it shifts. This allows
|
|
; us to essentially shift 2 adjacent bits into nonadjacent
|
|
; bit positions.
|
|
;
|
|
mov dx,bx
|
|
mov ax,cx
|
|
sar dh,3 ; shift bit 7 to bit 7 and bit 6 to bit 3
|
|
sar dl,4 ; shift bit 7 to bit 6 and bit 6 to bit 2
|
|
sar ah,5 ; shift bit 7 to bit 5 and bit 6 to bit 1
|
|
sar al,6 ; shift bit 7 to bit 4 and bit 6 to bit 0
|
|
and dx,8844h ; isolate top 2 bits for each of two pixels
|
|
and ax,2211h ; and then isolate bottom 2 bits
|
|
or al,ah ; or in bit 1 for each pixel
|
|
or al,dl ; or in bit 2 for each pixel
|
|
or al,dh ; or in bit 3 for each pixel
|
|
stosb ; al has 2 pixel values, save in bitmap
|
|
retn
|
|
|
|
public _VgaSaveBlock
|
|
_VgaSaveBlock proc far
|
|
|
|
push bp
|
|
mov bp,sp
|
|
sub sp,2
|
|
push es
|
|
push si
|
|
push di
|
|
push bx
|
|
push ds
|
|
|
|
;
|
|
; Check conditions. Violation of them is catastrophic
|
|
; as the implementation simply can't handle it.
|
|
;
|
|
test vsb_x,7
|
|
jnz vsbinval
|
|
test vsb_w,7
|
|
jz vsbok
|
|
vsbinval:
|
|
xor ax,ax
|
|
mov dx,ax
|
|
jmp vsb_done
|
|
|
|
;
|
|
; Calculate the bytes per row. Rows are padded to a dword boundary.
|
|
; There are 4 bits per pixel and 8 bits per byte, so we can simply divide
|
|
; the width by 2 to calculate this value. Note that the result is
|
|
; always naturally aligned to a dword boundary.
|
|
;
|
|
vsbok:
|
|
mov ax,vsb_w
|
|
shr vsb_w,3 ; width is now expressed in bytes
|
|
shr ax,1
|
|
les di,vsb_BytesPerRow
|
|
mov es:[di],ax ; store in caller's variable
|
|
|
|
;
|
|
; Calculate the size of the buffer we need, which is simply
|
|
; height * bytes-per-row. Allocate a buffer and zero it out.
|
|
;
|
|
; NOTE: we have not disturbed ds yet. ds MUST be the caller's value
|
|
; before we attempt to call the CRTs!
|
|
;
|
|
; ax = bytes per row
|
|
;
|
|
mul vsb_h ; ax = buffer size needed
|
|
cmp dx,0 ; > 64K?
|
|
jnz vsbinval ; yes, too big
|
|
cmp ah,0 ; > 32K?
|
|
jl vsbinval ; yes, too big
|
|
push ax ; pass size to malloc
|
|
call _malloc
|
|
pop cx ; throw away size param off stack
|
|
mov bx,dx
|
|
or bx,ax
|
|
jz vsb_done ; dx:ax set for error return
|
|
|
|
mov es,dx
|
|
mov di,ax ; es:di -> bits
|
|
push ax ; save offset for later return
|
|
|
|
mov ax,VGA_BYTES_PER_SCAN_LINE
|
|
mul vsb_y ; ax -> first byte on first line
|
|
shr vsb_x,3 ; convert x coord to byte count
|
|
add vsb_x,ax ; vsb_x -> first byte to save
|
|
|
|
mov ax,VGA_BUFFER_SEG
|
|
mov ds,ax ; ds addresses vga video buffer
|
|
|
|
vsbrow:
|
|
mov si,vsb_x ; ds:si -> first byte in vga buf to save
|
|
add vsb_x,VGA_BYTES_PER_SCAN_LINE ; prepare for next iteration
|
|
|
|
mov dx,vsb_w
|
|
mov vsb_BytesLeft,dx
|
|
|
|
vsbbyte:
|
|
;
|
|
; Read the 4 planes at the current byte
|
|
;
|
|
mov dx,VGA_REGISTER
|
|
mov al,VGAREG_READMAPSELECT
|
|
mov ah,3
|
|
out dx,ax
|
|
mov bh,[si]
|
|
dec ah
|
|
out dx,ax
|
|
mov bl,[si]
|
|
dec ah
|
|
out dx,ax
|
|
mov ch,[si]
|
|
dec ah
|
|
out dx,ax
|
|
mov cl,[si]
|
|
inc si
|
|
|
|
;
|
|
; bh = byte from plane 3
|
|
; bl = byte from plane 2
|
|
; ch = byte from plane 1
|
|
; cl = byte from plane 0
|
|
;
|
|
call MakeAndSave2Pixels
|
|
shl bx,2
|
|
shl cx,2
|
|
call MakeAndSave2Pixels
|
|
shl bx,2
|
|
shl cx,2
|
|
call MakeAndSave2Pixels
|
|
shl bx,2
|
|
shl cx,2
|
|
call MakeAndSave2Pixels
|
|
|
|
;
|
|
; Do all bytes on this line.
|
|
;
|
|
dec vsb_BytesLeft
|
|
jnz vsbbyte
|
|
|
|
;
|
|
; Done with line, see if done.
|
|
;
|
|
dec vsb_h
|
|
jnz vsbrow
|
|
|
|
;
|
|
; Done, return buffer to caller.
|
|
;
|
|
mov dx,es
|
|
pop ax ; dx:ax -> bit buffer
|
|
|
|
vsb_done:
|
|
pop ds
|
|
pop bx
|
|
pop di
|
|
pop si
|
|
pop es
|
|
leave
|
|
ret
|
|
|
|
_VgaSaveBlock endp
|
|
|
|
END
|
|
|