Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-22 11:28:56 +00:00
Code Issues Packages Projects Releases Wiki Activity
38128ea134
Descent3/lnxmvelib/mvelibla.asm
Kevin Bentley df209742fc Initial import
2024-04-15 21:43:29 -06:00

3633 lines
68 KiB
NASM
Raw Blame History

; mvelibwa.c
;
; Interplay Movie (MVE) File Player Library (32-Bit Win95 Version)
; Assembly Language Components
; Written by Paul Allen Edelstein
;
; (c) 1997 Interplay Productions. All Rights Reserved.
; This file is confidential and consists of proprietary information
; of Interplay Productions. This file and associated libraries
; may not, in whole or in part, be disclosed to third parties,
; incorporated into any software product which is not being created
; for Interplay Productions, copied or duplicated in any form,
; without the prior written permission of Interplay Productions.
; Further, you may not reverse engineer, decompile or otherwise
; attempt to derive source code of this material.
;
;;--- Options ---
ONLYNEW equ 0 ; For debug, disables motion comp
LOGGING equ 0 ; Log timing statistics
PARTIAL equ 1 ; Support for partial updates
PKDATA equ 1 ; Support for packed data
HICOLOR equ 1 ; Support for HiColor
INTERP equ 0 ; Interpolated squares
; 0:none (4x4x8), 1:generic dither,
; 2:direction dither, 3:blend
COMPOPS equ 1 ; Compressed opcode table
SCALING equ 1 ; Scaling support
DECOMPD equ 0 ; Support for dithered half vert res
TRANS16 equ 1 ; Support for translating 16-bit rgb format
;;--- Constants ---
; Width and height of sections in pixels.
SWIDTH equ 8
SHEIGHT equ 8
LOG2_SWIDTH equ 3
LOG2_SHEIGHT equ 3
;;---
EXTERN pal_tbl ;:BYTE ; unsigned char pal_tbl[3*256];
EXTERN pal15_tbl ;:WORD ; unsigned short pal15_tbl[256];
EXTERN nf_trans16_lo
EXTERN nf_trans16_hi
EXTERN snd_8to16 ;: WORD ; short snd_8to16[256];
EXTERN nf_buf_cur ;: PTRBYTE ; unsigned char* nf_buf_cur;
EXTERN nf_buf_prv ;: PTRBYTE ; unsigned char* nf_buf_prv;
;; NextFrame parameters
EXTERN nf_wqty ;: BYTE ;unsigned char nf_wqty; // (width/SWIDTH)
EXTERN nf_hqty ;: BYTE ;unsigned char nf_hqty; // (height/SHEIGHT)
EXTERN nf_fqty ;: BYTE ;unsigned char nf_fqty; // Number of fields
EXTERN nf_hicolor ;: DWORD ;unsigned nf_hicolor; // HiColor (0:none,1:normal,2:swapped)
;; <derived quantities>
EXTERN nf_width ;: DWORD ;unsigned nf_width; // wqty * SWIDTH
EXTERN nf_height ;: DWORD ;unsigned nf_height; // hqty * SHEIGHT;
EXTERN nf_new_line ;: DWORD ;unsigned nf_new_line; // width - SWIDTH
EXTERN nf_new_row0 ;: DWORD ;unsigned nf_new_row0; // SHEIGHT*width*2-width
EXTERN nf_back_right ;: DWORD ;unsigned nf_back_right; // (SHEIGHT-1)*width
;; Frame parameters
;; Portion of current frame which has been updated
;; and needs to be sent to screen.
;;
EXTERN nf_new_x ;: DWORD ;unsigned nf_new_x;
EXTERN nf_new_y ;: DWORD ;unsigned nf_new_y;
EXTERN nf_new_w ;: DWORD ;unsigned nf_new_w;
EXTERN nf_new_h ;: DWORD ;unsigned nf_new_h;
; These are all of our global parameter-passing variables - AH
extern sndDecompM16_dst
extern sndDecompM16_src
extern sndDecompM16_len
extern sndDecompM16_prev
extern sndDecompM16_return
extern sndDecompS16_dst
extern sndDecompS16_src
extern sndDecompS16_len
extern sndDecompS16_prev
extern sndDecompS16_return
extern nfHPkDecomp_ops
extern nfHPkDecomp_comp
extern nfHPkDecomp_x
extern nfHPkDecomp_y
extern nfHPkDecomp_w
extern nfHPkDecomp_h
; This is the global array of pointers to memory locations that
; need to be self-modified - AH
extern global_unlock_memory_pointers
; These are our functions that the C stubs call - AH
global _asm_sndDecompM16
global _asm_sndDecompS16
global _asm_nfPkConfig
global _asm_nfHPkDecomp
; This is our memory "unlock" function for the self-mofiying asm - AH
global _asm_selfModify
SECTION .data
db "(c) 1997 Interplay Productions. All Rights Reserved.\n"
db "This file is confidential and consists of proprietary information\n"
db "of Interplay Productions. This file and associated libraries\n"
db "may not, in whole or in part, be disclosed to third parties,\n"
db "incorporated into any software product which is not being created\n"
db "for Interplay Productions, copied or duplicated in any form,\n"
db "without the prior written permission of Interplay Productions.\n"
db "Further, you may not reverse engineer, decompile or otherwise\n"
db "attempt to derive source code of this material.\n",0
tbuf dd 0 ;LOCAL tbuf : PTRBYTE
new_row dd 0 ;LOCAL new_row :DWORD
DiffBufPtrs dd 0 ;LOCAL DiffBufPtrs :DWORD
nfpk_back_right dd 0 ;LOCAL nfpk_back_right : DWORD
wcnt dd 0 ;LOCAL wcnt :DWORD
bcomp dd 0 ;LOCAL bcomp :PTRBYTE
nfhpk_OpTbl: ;label dword
dd nf0 ;dword offset nf0 ; Prev Same (0)
dd nf1 ;dword offset nf1 ; No change (and copied to screen) (0)
dd nf2 ;dword offset nf2 ; Near shift from older part of current buf (1)
dd nf3 ;dword offset nf3 ; Near shift from newer part of current buf (1)
dd nf4 ;dword offset nf4 ; Near shift from previous buffer (1)
dd nf5 ;dword offset nf5 ; Far shift from previous buffer (2)
dd nf6 ;dword offset nf6 ; Far shift from current buffer (2)
; [Or if COMPOPS, run of no changes (0)]
dd nf7 ;dword offset nf7 ; 8x8x1 (10 bytes) or low 4x4x1 (4 bytes)
dd nf8 ;dword offset nf8 ; 2x2 4x4x1 (16 bytes) or 2x1 4x8x1 (12 bytes) or 1x2 8x4x1 (12 bytes)
dd nf9 ;dword offset nf9 ; 8x8x2 (20 bytes) or low 4x4x2 (8 bytes) or
; low 4x8x2 (12 bytes) or low 8x4x2 (12 bytes)
dd nf10 ;dword offset nf10 ; 2x2 4x4x2 (32 bytes) or 2x1 4x8x2 (24 bytes) or 1x2 4x8x2 (24 bytes)
dd nf11 ;dword offset nf11 ; 8x8x8 (64 bytes)
dd nf12 ;dword offset nf12 ; low 4x4x8 (16 bytes)
dd nf13 ;dword offset nf13 ; 2x2 4x4x0 (ie 2x2x8) (4 bytes)
dd nf14 ;dword offset nf14 ; 8x8x0 (1 byte)
dd nf15 ;dword offset nf15 ; mix 8x8x0 (2 bytes)
; signed 8-bit y * nf_width
nfpk_ShiftY times 256 dd 0
; Constant tables
; 8-bit -8:7 x nf_width + -8:7
nfpk_ShiftP1
%assign y -8
%rep 16 ;16
%assign x -8
%rep 16 ;16
db x,y
%assign x x+1
%endrep
%assign y y+1
%endrep
; 8-bit to right and below in roughly 0:14*nf_width + -14:14 (-3 cases)
; negative is
; 8-bit to left and above in roughly -14:0*nf_width + -14:14 (-3 cases)
nfpk_ShiftP2
%assign y 0
%rep 8 ;8
%assign x 8
%rep 7 ;7
db x,y
%assign x x+1
%endrep
%assign y y+1
%endrep
%assign y 8
%rep 6 ;6
%assign x -14
%rep 14 ;14
db x,y
%assign x x+1
%endrep
%assign x 0
%rep 15 ;15
db x,y
%assign x x+1
%endrep
%assign y y+1
%endrep
%assign x -14
%rep 14 ;14
db x,14
%assign x x+1
%endrep
%assign x 0
%rep 12 ;12
db x,14
%assign x x+1
%endrep
; Constant tables
nfhpk_mov4l ;LABEL DWORD
; low 4x1 in 8x1 (patch +1)
; mov eax, ebx/ecx
db 0c0h+3, 0c0h+3, 0c0h+3, 0c0h+3
db 0c0h+1, 0c0h+3, 0c0h+3, 0c0h+3
db 0c0h+3, 0c0h+1, 0c0h+3, 0c0h+3
db 0c0h+1, 0c0h+1, 0c0h+3, 0c0h+3
db 0c0h+3, 0c0h+3, 0c0h+1, 0c0h+3
db 0c0h+1, 0c0h+3, 0c0h+1, 0c0h+3
db 0c0h+3, 0c0h+1, 0c0h+1, 0c0h+3
db 0c0h+1, 0c0h+1, 0c0h+1, 0c0h+3
db 0c0h+3, 0c0h+3, 0c0h+3, 0c0h+1
db 0c0h+1, 0c0h+3, 0c0h+3, 0c0h+1
db 0c0h+3, 0c0h+1, 0c0h+3, 0c0h+1
db 0c0h+1, 0c0h+1, 0c0h+3, 0c0h+1
db 0c0h+3, 0c0h+3, 0c0h+1, 0c0h+1
db 0c0h+1, 0c0h+3, 0c0h+1, 0c0h+1
db 0c0h+3, 0c0h+1, 0c0h+1, 0c0h+1
db 0c0h+1, 0c0h+1, 0c0h+1, 0c0h+1
nfhpk_mov8 ;LABEL DWORD
; 8x1 (each two bits select a pair of colors in a reg)
; low 4x2 in 8x2 (each two bits select a duplicated color in reg)
; (patch +1)
; mov ds:[edi+0/4/8/12], ebx/edx/ecx/ebp
; Note: Patched code specifies mov [ebp+0]... instead
; of mov [edi+0]... to insure that 8-bit offsets are
; used by the assembler even for offset of zero.
%assign m4 24
%rep 4
%assign m3 24
%rep 4
%assign m2 24
%rep 4
%assign m1 24
%rep 4
db m1+047h,m2+047h,m3+047h,m4+047h
%if (m1 == 24)
%assign m1 16
%elif (m1 == 16)
%assign m1 8
%elif (m1 == 8)
%assign m1 40
%endif
%endrep
%if (m2 == 24)
%assign m2 16
%elif (m2 == 16)
%assign m2 8
%elif (m2 == 8)
%assign m2 40
%endif
%endrep
%if (m3 == 24)
%assign m3 16
%elif (m3 == 16)
%assign m3 8
%elif (m3 == 8)
%assign m3 40
%endif
%endrep
%if (m4 == 24)
%assign m4 16
%elif (m4 == 16)
%assign m4 8
%elif (m4 == 8)
%assign m4 40
%endif
%endrep
nfhpk_mov4
; 4x2 (patch +2)
; mov ax, bx/dx/cx/bp
; low 4x2 in 8x2 (patch +1)
; mov eax, ebx/edx/ecx/ebp
%assign m4 0c3h
%rep 4
%assign m3 0c3h
%rep 4
%assign m2 0c3h
%rep 4
%assign m1 0c3h
%rep 4
db m1,m2,m3,m4
%if (m1 == 0c3h)
%assign m1 0c2h
%elif (m1 == 0c2h)
%assign m1 0c1h
%elif (m1 == 0c1h)
%assign m1 0c5h
%endif
%endrep
%if (m2 == 0c3h)
%assign m2 0c2h
%elif (m2 == 0c2h)
%assign m2 0c1h
%elif (m2 == 0c1h)
%assign m2 0c5h
%endif
%endrep
%if (m3 == 0c3h)
%assign m3 0c2h
%elif (m3 == 0c2h)
%assign m3 0c1h
%elif (m3 == 0c1h)
%assign m3 0c5h
%endif
%endrep
%if (m4 == 0c3h)
%assign m4 0c2h
%elif (m4 == 0c2h)
%assign m4 0c1h
%elif (m4 == 0c1h)
%assign m4 0c5h
%endif
%endrep
SEGMENT .text
_asm_selfModify:
pushf
; Move the pointer to the start of the pointer array into eax
mov eax, global_unlock_memory_pointers
; Load unlock addresses from _asm_nfHPkDecomp
mov dword [eax], nf7_0
mov dword [eax + 4], nf8_0
mov dword [eax + 8], nf9_0
mov dword [eax + 12], nf10_0
mov dword [eax + 16], nf23_0
mov dword [eax + 20], nf24_0
mov dword [eax + 24], nf25_0
mov dword [eax + 28], nf26_0
mov dword [eax + 32], nf42_0
popf
ret
;--------------------------------------------------------------------
; Sound Management
;--------------------
;unsigned sndDecompM16(unsigned short *dst, unsigned char *src,
; unsigned len, unsigned prev);
;
;Decompresses a mono stream containing len samples
;(src is len bytes, dst is len*2 bytes)
;prev is the previous decompression state or zero.
;Returns new decompression state.
;
_asm_sndDecompM16: ; PROC USES ESI EDI EBX, \
; dst:PTRWORD, src:PTRBYTE, len:DWORD, prev:DWORD
mov eax, [sndDecompM16_prev]
mov ecx, [sndDecompM16_len]
jecxz done
mov esi, [sndDecompM16_src]
mov edi, [sndDecompM16_dst]
xor ebx, ebx
lp: mov bl, byte [esi]
add esi, 1
add ax, word [snd_8to16 + ebx*2]
mov word [edi], ax
add edi, 2
dec ecx
jnz lp
done:
; Store our return value - AH
mov dword [sndDecompM16_return], eax
ret
;sndDecompM16 ENDP
;unsigned sndDecompS16(unsigned short *dst, unsigned char *src,
; unsigned len, unsigned prev);
;
;Decompresses a stereo stream containing len samples
;(src is len*2 bytes, dst is len*4 bytes)
;prev is the previous decompression state or zero
; (It encodes the 16-bit states of the two stereo channels
; in its low and high order 16-bit halves.)
;Returns new decompression state.
;
_asm_sndDecompS16: ; PROC USES ESI EDI EBX, \
; dst:PTRWORD, src:PTRBYTE, len:DWORD, prev:DWORD
movzx eax, word [sndDecompS16_prev]
movzx edx, word [sndDecompS16_prev+2]
mov ecx, [sndDecompS16_len]
jecxz Sdone
mov esi, [sndDecompS16_src]
mov edi, [sndDecompS16_dst]
xor ebx, ebx
Slp: mov bl, byte [esi]
add esi, 1
add ax, word [snd_8to16 + ebx*2]
mov word [edi], ax
add edi, 2
mov bl, byte [esi]
add esi, 1
add dx, word [snd_8to16 + ebx*2]
mov word [edi], dx
add edi, 2
dec ecx
jnz Slp
Sdone: shl edx, 16
or eax, edx
; Store our return value - AH
mov dword [sndDecompS16_return], eax
ret
;sndDecompS16 ENDP
;--------------------------------------------------------------------
; NextFrame (Video Decompression)
;----------------------------------
%macro NF_DECOMP_INIT 1 ;HI_COLOR_FLAG: REQ
mov eax, [nf_buf_prv] ;br ; DiffBufPtrs = nf_buf_prv - nf_buf_cur
sub eax, [nf_buf_cur] ;br
mov [DiffBufPtrs], eax
xor ebx, ebx ; ebx = nf_fqty (convert to 32-bits)
mov bl, [nf_fqty]
mov eax, [nfHPkDecomp_x] ;br ; nf_new_x = x*SWIDTH*2^HI_COLOR_FLAG;
shl eax, LOG2_SWIDTH+%1 ;HI_COLOR_FLAG
mov [nf_new_x], eax
mov eax, [nfHPkDecomp_w] ;br ; nf_new_w = w*SWIDTH*2^HI_COLOR_FLAG;
shl eax, LOG2_SWIDTH+%1 ;HI_COLOR_FLAG
mov [nf_new_w], eax
mov eax, [nfHPkDecomp_y] ;br ; nf_new_y = y*nf_fqty*SHEIGHT;
shl eax, LOG2_SHEIGHT
mul ebx ;nf_fqty
mov [nf_new_y], eax
mov eax, [nfHPkDecomp_h] ;br ; nf_new_h = h*nf_fqty*SHEIGHT;
shl eax, LOG2_SHEIGHT
mul ebx ;nf_fqty
mov [nf_new_h], eax
mov eax, [nf_new_row0] ;br ; new_row = nf_new_row0 - nf_new_w;
sub eax, [nf_new_w] ;br
mov [new_row], eax
;; Move to correct place in current buffer
mov eax, [nf_buf_cur] ;br ; tbuf = nf_buf_cur
mov [tbuf], eax
; %if (nfHPkDecomp_x || nfHPkDecomp_y) ; if (x||y)
; cmp, jnz, jz and labels are mine - AH
cmp dword [nfHPkDecomp_x], 0
jne before
cmp dword [nfHPkDecomp_y], 0
je after
before:
mov eax, [nf_new_y] ;br ; tbuf += nf_new_y*nf_width + nf_new_x;
mul dword [nf_width] ; Added dword - AH
add eax, [nf_new_x] ;br
add [tbuf], eax
after:
; %endif
%endmacro ; DECOMP_INIT
;----------------------------------------------------------------------
; nfPkConfig initializes tables used by nfPkDecomp
; which are dependent on screen size.
_asm_nfPkConfig: ; PROC USES ESI EDI EBX
; Build ShiftY table
;
lea edi, [nfpk_ShiftY]
mov ebx, [nf_width]
mov eax, 0
mov ecx, 128
lp1: mov [edi], eax
add edi,4
add eax,ebx
dec ecx
jne lp1
mov eax, ebx
shl eax, 7
neg eax
mov ecx, 128
lp2: mov [edi], eax
add edi,4
add eax,ebx
dec ecx
jne lp2
ret
;nfPkConfig ENDP
%macro Trans16_3 3 ; dst:req, idx:req, mask
xor eax, eax
mov al, [%2]
mov %1, [nf_trans16_lo + eax*2]
xor eax, eax
mov al, [%2+1]
or %1, [nf_trans16_hi + eax*2]
%endmacro
%macro Trans16 2 ; dst:req, idx:req
xor eax, eax
mov al, [%2]
mov %1, [nf_trans16_lo + eax*2]
xor eax, eax
mov al, [%2+1]
or %1, [nf_trans16_hi + eax*2]
%endmacro
_asm_nfHPkDecomp: ; PROC USES ESI EDI EBX, \
; ops:PTRBYTE, comp:PTRBYTE, \
; x:DWORD, y:DWORD, w:DWORD, h:DWORD
NF_DECOMP_INIT 1
mov eax, [nf_back_right] ;br
sub eax, SWIDTH*2
mov [nfpk_back_right], eax
mov esi, [nfHPkDecomp_comp] ;br
mov edi, [tbuf]
xor eax, eax
mov ax, [esi]
add eax, esi
mov [bcomp], eax
add esi, 2
nf_StartRow:
mov eax, [nfHPkDecomp_w] ;br
shr eax, 1
mov [wcnt],eax
ALIGN 4
nf_NextPair:
dec dword [wcnt] ; Added dword - AH
js nf_NextRow
mov ebx, [nfHPkDecomp_ops] ; br
mov al, [ebx]
inc ebx
mov [nfHPkDecomp_ops], ebx
xor ebx, ebx
mov bl, al
shr bl, 4
and eax, 0Fh
push dword nf_NextPair ; Added dword on these two - AH
push dword [nfhpk_OpTbl + ebx*4]
jmp [nfhpk_OpTbl + eax*4]
nf_NextRow:
add edi, [new_row] ;br
dec dword [nfHPkDecomp_h] ; Added dword - AH
jnz nf_StartRow
ret
;----------------------------------------
ALIGN 4
nf0: ; No change from previous buffer
mov eax, [DiffBufPtrs] ; br
jmp nf_shift
;----------------------------------------
ALIGN 4
nf1: ; No change (and copied to screen)
add edi, SWIDTH*2
retn
;----------------------------------------
ALIGN 4
nf2: ; Near shift from older part of current buffer
xor eax, eax
mov ebx, [bcomp] ; br
inc dword [bcomp] ; Added dword - AH
mov al, [ebx]
mov ax, [nfpk_ShiftP2 + eax*2]
nf_xyc_shift:
xor ebx, ebx
mov bl, ah
shl eax, 24
sar eax, 24-1
add eax, [nfpk_ShiftY + ebx*4]
jmp nf_shift
;----------------------------------------
ALIGN 4
nf3: ; Near shift from newer part of current buffer
xor eax, eax
mov ebx, [bcomp] ; br
inc dword [bcomp] ; Added dword - AH
mov al, [ebx]
mov ax, [nfpk_ShiftP2 + eax*2]
neg al
neg ah
jmp nf_xyc_shift
;----------------------------------------
ALIGN 4
nf4: ; Near shift from previous buffer
xor eax, eax
mov ebx, [bcomp] ; br
inc dword [bcomp] ; Added dword - AH
mov al, [ebx]
mov ax, [nfpk_ShiftP1 + eax*2]
jmp nf_xyp_shift
;----------------------------------------
ALIGN 4
nf5: ; Far shift from previous buffer
mov ax, [esi]
add esi, 2
nf_xyp_shift:
xor ebx, ebx
mov bl, ah
shl eax, 24
sar eax, 24-1
add eax, [nfpk_ShiftY + ebx*4]
add eax, [DiffBufPtrs] ; br
jmp nf_shift
;----------------------------------------
ALIGN 4
nf6: ; Far shift from current buffer
mov ax, [esi]
add esi, 2
jmp nf_xyc_shift
;----------------------------------------
ALIGN 4
nf_shift:
mov ebx, esi ; save esi
lea esi, [edi+eax]
mov edx, [nf_width]
%rep 7
mov eax, [esi]
mov [edi], eax
mov eax, [esi+4]
mov [edi+4], eax
mov eax, [esi+8]
mov [edi+8], eax
mov eax, [esi+12]
mov [edi+12], eax
add esi, edx
add edi, edx
%endrep
mov eax, [esi]
mov [edi], eax
mov eax, [esi+4]
mov [edi+4], eax
mov eax, [esi+8]
mov [edi+8], eax
mov eax, [esi+12]
mov [edi+12], eax
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
mov esi, ebx ; restore esi
retn
;----------------------------------------
ALIGN 4
nf7: ; 8x8x1 (12 bytes)
test word [esi], 08000h
jnz near nf23
xor eax, eax
lea ecx, [nfhpk_mov8]
lea edx, [nf7_11+1] ; Removed byte ds:- AH
mov al, [esi+4]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_11-nf7_11)], bl
mov [edx+(nf7_12-nf7_11)], bh
shr ebx, 16
mov [edx+(nf7_13-nf7_11)], bl
mov [edx+(nf7_14-nf7_11)], bh
mov al, [esi+5]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_21-nf7_11)], bl
mov [edx+(nf7_22-nf7_11)], bh
shr ebx, 16
mov [edx+(nf7_23-nf7_11)], bl
mov [edx+(nf7_24-nf7_11)], bh
mov al, [esi+6]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_31-nf7_11)], bl
mov [edx+(nf7_32-nf7_11)], bh
shr ebx, 16
mov [edx+(nf7_33-nf7_11)], bl
mov [edx+(nf7_34-nf7_11)], bh
mov al, [esi+7]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_41-nf7_11)], bl
mov [edx+(nf7_42-nf7_11)], bh
shr ebx, 16
mov [edx+(nf7_43-nf7_11)], bl
mov [edx+(nf7_44-nf7_11)], bh
lea edx, [edx+(nf7_51-nf7_11)]
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_51-nf7_51)], bl
mov [edx+(nf7_52-nf7_51)], bh
shr ebx, 16
mov [edx+(nf7_53-nf7_51)], bl
mov [edx+(nf7_54-nf7_51)], bh
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_61-nf7_51)], bl
mov [edx+(nf7_62-nf7_51)], bh
shr ebx, 16
mov [edx+(nf7_63-nf7_51)], bl
mov [edx+(nf7_64-nf7_51)], bh
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_71-nf7_51)], bl
mov [edx+(nf7_72-nf7_51)], bh
shr ebx, 16
mov [edx+(nf7_73-nf7_51)], bl
mov [edx+(nf7_74-nf7_51)], bh
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf7_81-nf7_51)], bl
mov [edx+(nf7_82-nf7_51)], bh
shr ebx, 16
mov [edx+(nf7_83-nf7_51)], bl
mov [edx+(nf7_84-nf7_51)], bh
push ebp
push esi
; load ebx,edx,ecx,ebp with 00,01,10,11 color combinations
; (note that bits are read least significant first).
Trans16 cx, esi+2
shl ecx, 16
Trans16 cx, esi
mov esi,[nf_width]
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
jmp nf7_0 ; flush prefetch
ALIGN 4
nf7_0:
nf7_11: mov [ebp+0], ebx
nf7_12: mov [ebp+4], ebx
nf7_13: mov [ebp+8], ebx
nf7_14: mov [ebp+12], ebx
add edi, esi
nf7_21: mov [ebp+0], ebx
nf7_22: mov [ebp+4], ebx
nf7_23: mov [ebp+8], ebx
nf7_24: mov [ebp+12], ebx
add edi, esi
nf7_31: mov [ebp+0], ebx
nf7_32: mov [ebp+4], ebx
nf7_33: mov [ebp+8], ebx
nf7_34: mov [ebp+12], ebx
add edi, esi
nf7_41: mov [ebp+0], ebx
nf7_42: mov [ebp+4], ebx
nf7_43: mov [ebp+8], ebx
nf7_44: mov [ebp+12], ebx
add edi, esi
nf7_51: mov [ebp+0], ebx
nf7_52: mov [ebp+4], ebx
nf7_53: mov [ebp+8], ebx
nf7_54: mov [ebp+12], ebx
add edi, esi
nf7_61: mov [ebp+0], ebx
nf7_62: mov [ebp+4], ebx
nf7_63: mov [ebp+8], ebx
nf7_64: mov [ebp+12], ebx
add edi, esi
nf7_71: mov [ebp+0], ebx
nf7_72: mov [ebp+4], ebx
nf7_73: mov [ebp+8], ebx
nf7_74: mov [ebp+12], ebx
add edi, esi
nf7_81: mov [ebp+0], ebx
nf7_82: mov [ebp+4], ebx
nf7_83: mov [ebp+8], ebx
nf7_84: mov [ebp+12], ebx
pop esi
pop ebp
add esi, 12
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf7+16
nf23: ; low 4x4x1 (6 bytes)
xor eax, eax
lea ecx, [nfhpk_mov4l]
lea edx, [nf23_11+1] ; Removed byte ds: - AH
mov al, [esi+4]
and al, 0fH
mov ebx, [ecx+eax*4]
mov [edx+(nf23_11-nf23_11)], bl
mov [edx+(nf23_12-nf23_11)], bh
shr ebx, 16
mov [edx+(nf23_13-nf23_11)], bl
mov [edx+(nf23_14-nf23_11)], bh
mov al, [esi+4]
shr al, 4
mov ebx, [ecx+eax*4]
mov [edx+(nf23_31-nf23_11)], bl
mov [edx+(nf23_32-nf23_11)], bh
shr ebx, 16
mov [edx+(nf23_33-nf23_11)], bl
mov [edx+(nf23_34-nf23_11)], bh
mov al, [esi+5]
and al, 0fH
mov ebx, [ecx+eax*4]
mov [edx+(nf23_51-nf23_11)], bl
mov [edx+(nf23_52-nf23_11)], bh
shr ebx, 16
mov [edx+(nf23_53-nf23_11)], bl
mov [edx+(nf23_54-nf23_11)], bh
mov al, [esi+5]
shr al, 4
mov ebx, [ecx+eax*4]
mov [edx+(nf23_71-nf23_11)], bl
mov [edx+(nf23_72-nf23_11)], bh
shr ebx, 16
mov [edx+(nf23_73-nf23_11)], bl
mov [edx+(nf23_74-nf23_11)], bh
mov edx, [nf_width]
; load ebx,ecx with 00,11 color combinations
Trans16_3 cx, esi, 1
shrd ebx, ecx, 16
mov bx, cx
Trans16 cx, esi+2
shrd eax, ecx, 16
mov ax, cx
mov ecx, eax
jmp nf23_0 ; flush prefetch
ALIGN 4
nf23_0:
nf23_11:mov eax, ebx
mov [edi], eax
mov [edi+edx], eax
nf23_12:mov eax, ebx
mov [edi+4], eax
mov [edi+edx+4], eax
nf23_13:mov eax, ebx
mov [edi+8], eax
mov [edi+edx+8], eax
nf23_14:mov eax, ebx
mov [edi+12], eax
mov [edi+edx+12], eax
lea edi, [edi+edx*2]
nf23_31:mov eax, ebx
mov [edi], eax
mov [edi+edx], eax
nf23_32:mov eax, ebx
mov [edi+4], eax
mov [edi+edx+4], eax
nf23_33:mov eax, ebx
mov [edi+8], eax
mov [edi+edx+8], eax
nf23_34:mov eax, ebx
mov [edi+12], eax
mov [edi+edx+12], eax
lea edi, [edi+edx*2]
nf23_51:mov eax, ebx
mov [edi], eax
mov [edi+edx], eax
nf23_52:mov eax, ebx
mov [edi+4], eax
mov [edi+edx+4], eax
nf23_53:mov eax, ebx
mov [edi+8], eax
mov [edi+edx+8], eax
nf23_54:mov eax, ebx
mov [edi+12], eax
mov [edi+edx+12], eax
lea edi, [edi+edx*2]
nf23_71:mov eax, ebx
mov [edi], eax
mov [edi+edx], eax
nf23_72:mov eax, ebx
mov [edi+4], eax
mov [edi+edx+4], eax
nf23_73:mov eax, ebx
mov [edi+8], eax
mov [edi+edx+8], eax
nf23_74:mov eax, ebx
mov [edi+12], eax
mov [edi+edx+12], eax
add edi, edx
sub edi, [nfpk_back_right]
add esi, 6
retn
;----------------------------------------
ALIGN 4
nf8: ; 2x2 4x4x1 (24 bytes)
test word [esi], 08000h
jnz near nf24
xor eax, eax
lea ecx, [nfhpk_mov8]
lea edx, [nf8_11+1] ; Removed byte ds: - AH
mov al, [esi+4]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_11-nf8_11)], bl
mov [edx+(nf8_12-nf8_11)], bh
shr ebx, 16
mov [edx+(nf8_13-nf8_11)], bl
mov [edx+(nf8_14-nf8_11)], bh
mov al, [esi+5]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_21-nf8_11)], bl
mov [edx+(nf8_22-nf8_11)], bh
shr ebx, 16
mov [edx+(nf8_23-nf8_11)], bl
mov [edx+(nf8_24-nf8_11)], bh
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_31-nf8_11)], bl
mov [edx+(nf8_32-nf8_11)], bh
shr ebx, 16
mov [edx+(nf8_33-nf8_11)], bl
mov [edx+(nf8_34-nf8_11)], bh
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_41-nf8_11)], bl
mov [edx+(nf8_42-nf8_11)], bh
shr ebx, 16
mov [edx+(nf8_43-nf8_11)], bl
mov [edx+(nf8_44-nf8_11)], bh
add edx, nf8_51-nf8_11
mov al, [esi+16]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_51-nf8_51)], bl
mov [edx+(nf8_52-nf8_51)], bh
shr ebx, 16
mov [edx+(nf8_53-nf8_51)], bl
mov [edx+(nf8_54-nf8_51)], bh
mov al, [esi+17]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_61-nf8_51)], bl
mov [edx+(nf8_62-nf8_51)], bh
shr ebx, 16
mov [edx+(nf8_63-nf8_51)], bl
mov [edx+(nf8_64-nf8_51)], bh
mov al, [esi+22]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_71-nf8_51)], bl
mov [edx+(nf8_72-nf8_51)], bh
shr ebx, 16
mov [edx+(nf8_73-nf8_51)], bl
mov [edx+(nf8_74-nf8_51)], bh
mov al, [esi+23]
mov ebx, [ecx+eax*4]
mov [edx+(nf8_81-nf8_51)], bl
mov [edx+(nf8_82-nf8_51)], bh
shr ebx, 16
mov [edx+(nf8_83-nf8_51)], bl
mov [edx+(nf8_84-nf8_51)], bh
push ebp
push esi
; load ebx,edx,ecx,ebp with 00,01,10,11 color combinations
; (note that bits are read least significant first).
Trans16 cx, esi+18+2
shl ecx, 16
Trans16 cx, esi+18
push ecx
Trans16 cx, esi+12+2
shl ecx, 16
Trans16 cx, esi+12
push ecx
Trans16 cx, esi+6+2
shl ecx, 16
Trans16 cx, esi+6
push ecx
Trans16 cx, esi+2
shl ecx, 16
Trans16 cx, esi
mov esi,[nf_width]
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
jmp nf8_0 ; flush prefetch
ALIGN 4
nf8_0:
nf8_11: mov [ebp+0], ebx
nf8_12: mov [ebp+4], ebx
add edi, esi
nf8_13: mov [ebp+0], ebx
nf8_14: mov [ebp+4], ebx
add edi, esi
nf8_21: mov [ebp+0], ebx
nf8_22: mov [ebp+4], ebx
add edi, esi
nf8_23: mov [ebp+0], ebx
nf8_24: mov [ebp+4], ebx
add edi, esi
pop ecx
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
nf8_31: mov [ebp+0], ebx
nf8_32: mov [ebp+4], ebx
add edi, esi
nf8_33: mov [ebp+0], ebx
nf8_34: mov [ebp+4], ebx
add edi, esi
nf8_41: mov [ebp+0], ebx
nf8_42: mov [ebp+4], ebx
add edi, esi
nf8_43: mov [ebp+0], ebx
nf8_44: mov [ebp+4], ebx
add edi, esi
lea eax, [esi*8-8]
sub edi, eax
pop ecx
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
nf8_51: mov [ebp+0], ebx
nf8_52: mov [ebp+4], ebx
add edi, esi
nf8_53: mov [ebp+0], ebx
nf8_54: mov [ebp+4], ebx
add edi, esi
nf8_61: mov [ebp+0], ebx
nf8_62: mov [ebp+4], ebx
add edi, esi
nf8_63: mov [ebp+0], ebx
nf8_64: mov [ebp+4], ebx
add edi, esi
pop ecx
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
nf8_71: mov [ebp+0], ebx
nf8_72: mov [ebp+4], ebx
add edi, esi
nf8_73: mov [ebp+0], ebx
nf8_74: mov [ebp+4], ebx
add edi, esi
nf8_81: mov [ebp+0], ebx
nf8_82: mov [ebp+4], ebx
add edi, esi
nf8_83: mov [ebp+0], ebx
nf8_84: mov [ebp+4], ebx
pop esi
pop ebp
add esi, 24
sub edi, 8
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf8+16
nf24: ; 2x1 4x8x1 (16 bytes)
test word [esi+8], 08000h
jnz near nf40
xor eax, eax
lea ecx, [nfhpk_mov8]
lea edx, [nf24_11+1] ; Removed byte ds: - AH
mov al, [esi+4]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_11-nf24_11)], bl
mov [edx+(nf24_12-nf24_11)], bh
shr ebx, 16
mov [edx+(nf24_13-nf24_11)], bl
mov [edx+(nf24_14-nf24_11)], bh
mov al, [esi+5]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_21-nf24_11)], bl
mov [edx+(nf24_22-nf24_11)], bh
shr ebx, 16
mov [edx+(nf24_23-nf24_11)], bl
mov [edx+(nf24_24-nf24_11)], bh
mov al, [esi+6]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_31-nf24_11)], bl
mov [edx+(nf24_32-nf24_11)], bh
shr ebx, 16
mov [edx+(nf24_33-nf24_11)], bl
mov [edx+(nf24_34-nf24_11)], bh
mov al, [esi+7]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_41-nf24_11)], bl
mov [edx+(nf24_42-nf24_11)], bh
shr ebx, 16
mov [edx+(nf24_43-nf24_11)], bl
mov [edx+(nf24_44-nf24_11)], bh
add edx, nf24_51-nf24_11
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_51-nf24_51)], bl
mov [edx+(nf24_52-nf24_51)], bh
shr ebx, 16
mov [edx+(nf24_53-nf24_51)], bl
mov [edx+(nf24_54-nf24_51)], bh
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_61-nf24_51)], bl
mov [edx+(nf24_62-nf24_51)], bh
shr ebx, 16
mov [edx+(nf24_63-nf24_51)], bl
mov [edx+(nf24_64-nf24_51)], bh
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_71-nf24_51)], bl
mov [edx+(nf24_72-nf24_51)], bh
shr ebx, 16
mov [edx+(nf24_73-nf24_51)], bl
mov [edx+(nf24_74-nf24_51)], bh
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf24_81-nf24_51)], bl
mov [edx+(nf24_82-nf24_51)], bh
shr ebx, 16
mov [edx+(nf24_83-nf24_51)], bl
mov [edx+(nf24_84-nf24_51)], bh
push ebp
push esi
; load ebx,edx,ecx,ebp with 00,01,10,11 color combinations
; (note that bits are read least significant first).
Trans16 cx, esi+8+2
shl ecx, 16
Trans16 cx, esi+8
push ecx
Trans16 cx, esi+2
shl ecx, 16
Trans16_3 cx, esi, 1
mov esi,[nf_width]
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
jmp nf24_0 ; flush prefetch
ALIGN 4
nf24_0:
nf24_11:mov [ebp+0], ebx
nf24_12:mov [ebp+4], ebx
add edi, esi
nf24_13:mov [ebp+0], ebx
nf24_14:mov [ebp+4], ebx
add edi, esi
nf24_21:mov [ebp+0], ebx
nf24_22:mov [ebp+4], ebx
add edi, esi
nf24_23:mov [ebp+0], ebx
nf24_24:mov [ebp+4], ebx
add edi, esi
nf24_31:mov [ebp+0], ebx
nf24_32:mov [ebp+4], ebx
add edi, esi
nf24_33:mov [ebp+0], ebx
nf24_34:mov [ebp+4], ebx
add edi, esi
nf24_41:mov [ebp+0], ebx
nf24_42:mov [ebp+4], ebx
add edi, esi
nf24_43:mov [ebp+0], ebx
nf24_44:mov [ebp+4], ebx
add edi, esi
lea eax, [esi*8-8]
sub edi, eax
pop ecx
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
nf24_51:mov [ebp+0], ebx
nf24_52:mov [ebp+4], ebx
add edi, esi
nf24_53:mov [ebp+0], ebx
nf24_54:mov [ebp+4], ebx
add edi, esi
nf24_61:mov [ebp+0], ebx
nf24_62:mov [ebp+4], ebx
add edi, esi
nf24_63:mov [ebp+0], ebx
nf24_64:mov [ebp+4], ebx
add edi, esi
nf24_71:mov [ebp+0], ebx
nf24_72:mov [ebp+4], ebx
add edi, esi
nf24_73:mov [ebp+0], ebx
nf24_74:mov [ebp+4], ebx
add edi, esi
nf24_81:mov [ebp+0], ebx
nf24_82:mov [ebp+4], ebx
add edi, esi
nf24_83:mov [ebp+0], ebx
nf24_84:mov [ebp+4], ebx
pop esi
pop ebp
add esi, 16
sub edi, 8
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf8+32
nf40: ; 1x2 8x4x1 (16 bytes)
xor eax, eax
lea ecx, [nfhpk_mov8]
lea edx, [nf40_11+1] ; Removed byte ds: - AH
mov al, [esi+4]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_11-nf40_11)], bl
mov [edx+(nf40_12-nf40_11)], bh
shr ebx, 16
mov [edx+(nf40_13-nf40_11)], bl
mov [edx+(nf40_14-nf40_11)], bh
mov al, [esi+5]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_21-nf40_11)], bl
mov [edx+(nf40_22-nf40_11)], bh
shr ebx, 16
mov [edx+(nf40_23-nf40_11)], bl
mov [edx+(nf40_24-nf40_11)], bh
mov al, [esi+6]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_31-nf40_11)], bl
mov [edx+(nf40_32-nf40_11)], bh
shr ebx, 16
mov [edx+(nf40_33-nf40_11)], bl
mov [edx+(nf40_34-nf40_11)], bh
mov al, [esi+7]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_41-nf40_11)], bl
mov [edx+(nf40_42-nf40_11)], bh
shr ebx, 16
mov [edx+(nf40_43-nf40_11)], bl
mov [edx+(nf40_44-nf40_11)], bh
add edx, nf40_51-nf40_11
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_51-nf40_51)], bl
mov [edx+(nf40_52-nf40_51)], bh
shr ebx, 16
mov [edx+(nf40_53-nf40_51)], bl
mov [edx+(nf40_54-nf40_51)], bh
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_61-nf40_51)], bl
mov [edx+(nf40_62-nf40_51)], bh
shr ebx, 16
mov [edx+(nf40_63-nf40_51)], bl
mov [edx+(nf40_64-nf40_51)], bh
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_71-nf40_51)], bl
mov [edx+(nf40_72-nf40_51)], bh
shr ebx, 16
mov [edx+(nf40_73-nf40_51)], bl
mov [edx+(nf40_74-nf40_51)], bh
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf40_81-nf40_51)], bl
mov [edx+(nf40_82-nf40_51)], bh
shr ebx, 16
mov [edx+(nf40_83-nf40_51)], bl
mov [edx+(nf40_84-nf40_51)], bh
push ebp
push esi
; load ebx,edx,ecx,ebp with 00,01,10,11 color combinations
; (note that bits are read least significant first).
Trans16 cx, esi+8+2
shl ecx, 16
Trans16_3 cx, esi+8, 1
push ecx
Trans16 cx, esi+2
shl ecx, 16
Trans16_3 cx, esi, 1
mov esi,[nf_width]
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
jmp nf40_0 ; flush prefetch
ALIGN 4
nf40_0:
nf40_11:mov [ebp+0], ebx
nf40_12:mov [ebp+4], ebx
nf40_13:mov [ebp+8], ebx
nf40_14:mov [ebp+12], ebx
add edi, esi
nf40_21:mov [ebp+0], ebx
nf40_22:mov [ebp+4], ebx
nf40_23:mov [ebp+8], ebx
nf40_24:mov [ebp+12], ebx
add edi, esi
nf40_31:mov [ebp+0], ebx
nf40_32:mov [ebp+4], ebx
nf40_33:mov [ebp+8], ebx
nf40_34:mov [ebp+12], ebx
add edi, esi
nf40_41:mov [ebp+0], ebx
nf40_42:mov [ebp+4], ebx
nf40_43:mov [ebp+8], ebx
nf40_44:mov [ebp+12], ebx
add edi, esi
pop ecx
mov edx, ecx
ror edx, 16
mov ebx, edx
mov bx, cx
mov ebp, ecx
mov bp, dx
nf40_51:mov [ebp+0], ebx
nf40_52:mov [ebp+4], ebx
nf40_53:mov [ebp+8], ebx
nf40_54:mov [ebp+12], ebx
add edi, esi
nf40_61:mov [ebp+0], ebx
nf40_62:mov [ebp+4], ebx
nf40_63:mov [ebp+8], ebx
nf40_64:mov [ebp+12], ebx
add edi, esi
nf40_71:mov [ebp+0], ebx
nf40_72:mov [ebp+4], ebx
nf40_73:mov [ebp+8], ebx
nf40_74:mov [ebp+12], ebx
add edi, esi
nf40_81:mov [ebp+0], ebx
nf40_82:mov [ebp+4], ebx
nf40_83:mov [ebp+8], ebx
nf40_84:mov [ebp+12], ebx
pop esi
pop ebp
add esi, 16
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
nf9: ; 8x8x2 (24 bytes)
test word [esi], 08000h
jnz near nf41
test word [esi+4], 08000h
jnz near nf25
xor eax, eax
lea ecx, [nfhpk_mov4]
lea edx, [nf9_11+2] ; Removed byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_11-nf9_11)], bh
mov [edx+(nf9_12-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_13-nf9_11)], bh
mov [edx+(nf9_14-nf9_11)], bl
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_15-nf9_11)], bh
mov [edx+(nf9_16-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_17-nf9_11)], bh
mov [edx+(nf9_18-nf9_11)], bl
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_21-nf9_11)], bh
mov [edx+(nf9_22-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_23-nf9_11)], bh
mov [edx+(nf9_24-nf9_11)], bl
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_25-nf9_11)], bh
mov [edx+(nf9_26-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_27-nf9_11)], bh
mov [edx+(nf9_28-nf9_11)], bl
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_31-nf9_11)], bh
mov [edx+(nf9_32-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_33-nf9_11)], bh
mov [edx+(nf9_34-nf9_11)], bl
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_35-nf9_11)], bh
mov [edx+(nf9_36-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_37-nf9_11)], bh
mov [edx+(nf9_38-nf9_11)], bl
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_41-nf9_11)], bh
mov [edx+(nf9_42-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_43-nf9_11)], bh
mov [edx+(nf9_44-nf9_11)], bl
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_45-nf9_11)], bh
mov [edx+(nf9_46-nf9_11)], bl
shr ebx, 16
mov [edx+(nf9_47-nf9_11)], bh
mov [edx+(nf9_48-nf9_11)], bl
lea edx, [edx+(nf9_51-nf9_11)]
mov al, [esi+16]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_51-nf9_51)], bh
mov [edx+(nf9_52-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_53-nf9_51)], bh
mov [edx+(nf9_54-nf9_51)], bl
mov al, [esi+17]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_55-nf9_51)], bh
mov [edx+(nf9_56-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_57-nf9_51)], bh
mov [edx+(nf9_58-nf9_51)], bl
mov al, [esi+18]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_61-nf9_51)], bh
mov [edx+(nf9_62-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_63-nf9_51)], bh
mov [edx+(nf9_64-nf9_51)], bl
mov al, [esi+19]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_65-nf9_51)], bh
mov [edx+(nf9_66-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_67-nf9_51)], bh
mov [edx+(nf9_68-nf9_51)], bl
mov al, [esi+20]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_71-nf9_51)], bh
mov [edx+(nf9_72-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_73-nf9_51)], bh
mov [edx+(nf9_74-nf9_51)], bl
mov al, [esi+21]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_75-nf9_51)], bh
mov [edx+(nf9_76-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_77-nf9_51)], bh
mov [edx+(nf9_78-nf9_51)], bl
mov al, [esi+22]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_81-nf9_51)], bh
mov [edx+(nf9_82-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_83-nf9_51)], bh
mov [edx+(nf9_84-nf9_51)], bl
mov al, [esi+23]
mov ebx, [ecx+eax*4]
mov [edx+(nf9_85-nf9_51)], bh
mov [edx+(nf9_86-nf9_51)], bl
shr ebx, 16
mov [edx+(nf9_87-nf9_51)], bh
mov [edx+(nf9_88-nf9_51)], bl
push ebp
push esi
; Load bx,dx,cx,bp with four colors
Trans16 bx, esi
Trans16 dx, esi+2
Trans16 cx, esi+4
Trans16 bp, esi+6
mov esi, [nf_width]
jmp nf9_0 ; flush prefetch
ALIGN 4
nf9_0:
nf9_11: mov ax, bx
shl eax, 16
nf9_12: mov ax, bx
mov [edi], eax
nf9_13: mov ax, bx
shl eax, 16
nf9_14: mov ax, bx
mov [edi+4], eax
nf9_15: mov ax, bx
shl eax, 16
nf9_16: mov ax, bx
mov [edi+8], eax
nf9_17: mov ax, bx
shl eax, 16
nf9_18: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_21: mov ax, bx
shl eax, 16
nf9_22: mov ax, bx
mov [edi], eax
nf9_23: mov ax, bx
shl eax, 16
nf9_24: mov ax, bx
mov [edi+4], eax
nf9_25: mov ax, bx
shl eax, 16
nf9_26: mov ax, bx
mov [edi+8], eax
nf9_27: mov ax, bx
shl eax, 16
nf9_28: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_31: mov ax, bx
shl eax, 16
nf9_32: mov ax, bx
mov [edi], eax
nf9_33: mov ax, bx
shl eax, 16
nf9_34: mov ax, bx
mov [edi+4], eax
nf9_35: mov ax, bx
shl eax, 16
nf9_36: mov ax, bx
mov [edi+8], eax
nf9_37: mov ax, bx
shl eax, 16
nf9_38: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_41: mov ax, bx
shl eax, 16
nf9_42: mov ax, bx
mov [edi], eax
nf9_43: mov ax, bx
shl eax, 16
nf9_44: mov ax, bx
mov [edi+4], eax
nf9_45: mov ax, bx
shl eax, 16
nf9_46: mov ax, bx
mov [edi+8], eax
nf9_47: mov ax, bx
shl eax, 16
nf9_48: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_51: mov ax, bx
shl eax, 16
nf9_52: mov ax, bx
mov [edi], eax
nf9_53: mov ax, bx
shl eax, 16
nf9_54: mov ax, bx
mov [edi+4], eax
nf9_55: mov ax, bx
shl eax, 16
nf9_56: mov ax, bx
mov [edi+8], eax
nf9_57: mov ax, bx
shl eax, 16
nf9_58: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_61: mov ax, bx
shl eax, 16
nf9_62: mov ax, bx
mov [edi], eax
nf9_63: mov ax, bx
shl eax, 16
nf9_64: mov ax, bx
mov [edi+4], eax
nf9_65: mov ax, bx
shl eax, 16
nf9_66: mov ax, bx
mov [edi+8], eax
nf9_67: mov ax, bx
shl eax, 16
nf9_68: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_71: mov ax, bx
shl eax, 16
nf9_72: mov ax, bx
mov [edi], eax
nf9_73: mov ax, bx
shl eax, 16
nf9_74: mov ax, bx
mov [edi+4], eax
nf9_75: mov ax, bx
shl eax, 16
nf9_76: mov ax, bx
mov [edi+8], eax
nf9_77: mov ax, bx
shl eax, 16
nf9_78: mov ax, bx
mov [edi+12], eax
add edi, esi
nf9_81: mov ax, bx
shl eax, 16
nf9_82: mov ax, bx
mov [edi], eax
nf9_83: mov ax, bx
shl eax, 16
nf9_84: mov ax, bx
mov [edi+4], eax
nf9_85: mov ax, bx
shl eax, 16
nf9_86: mov ax, bx
mov [edi+8], eax
nf9_87: mov ax, bx
shl eax, 16
nf9_88: mov ax, bx
mov [edi+12], eax
pop esi
pop ebp
add esi, 24
sub edi, [nfpk_back_right] ; br
retn
;----------------------------------------
ALIGN 4
;nf9+16
nf25: ; low 4x4x2 (12 bytes)
xor eax, eax
lea ecx, [nfhpk_mov4]
lea edx, [nf25_11+1] ; Removed byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf25_11-nf25_11)], bl
mov [edx+(nf25_12-nf25_11)], bh
shr ebx, 16
mov [edx+(nf25_13-nf25_11)], bl
mov [edx+(nf25_14-nf25_11)], bh
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf25_21-nf25_11)], bl
mov [edx+(nf25_22-nf25_11)], bh
shr ebx, 16
mov [edx+(nf25_23-nf25_11)], bl
mov [edx+(nf25_24-nf25_11)], bh
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf25_31-nf25_11)], bl
mov [edx+(nf25_32-nf25_11)], bh
shr ebx, 16
mov [edx+(nf25_33-nf25_11)], bl
mov [edx+(nf25_34-nf25_11)], bh
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf25_41-nf25_11)], bl
mov [edx+(nf25_42-nf25_11)], bh
shr ebx, 16
mov [edx+(nf25_43-nf25_11)], bl
mov [edx+(nf25_44-nf25_11)], bh
push ebp
push esi
; Load ebx,edx,ecx,ebp with four colors, duplicated in high order.
Trans16 cx, esi
shrd ebx, ecx, 16
mov bx, cx
Trans16 cx, esi+2
shrd edx, ecx, 16
mov dx, cx
Trans16_3 cx, esi+4, 1
shrd eax, ecx, 16
mov ax, cx
push eax
Trans16 cx, esi+6
shrd ebp, ecx, 16
mov bp, cx
pop ecx
mov esi, [nf_width]
jmp nf25_0 ; flush prefetch
ALIGN 4
nf25_0:
nf25_11:mov eax, ebx
mov [edi], eax
mov [edi+esi], eax
nf25_12:mov eax, ebx
mov [edi+4], eax
mov [edi+esi+4], eax
nf25_13:mov eax, ebx
mov [edi+8], eax
mov [edi+esi+8], eax
nf25_14:mov eax, ebx
mov [edi+12], eax
mov [edi+esi+12], eax
lea edi, [edi+esi*2]
nf25_21:mov eax, ebx
mov [edi], eax
mov [edi+esi], eax
nf25_22:mov eax, ebx
mov [edi+4], eax
mov [edi+esi+4], eax
nf25_23:mov eax, ebx
mov [edi+8], eax
mov [edi+esi+8], eax
nf25_24:mov eax, ebx
mov [edi+12], eax
mov [edi+esi+12], eax
lea edi, [edi+esi*2]
nf25_31:mov eax, ebx
mov [edi], eax
mov [edi+esi], eax
nf25_32:mov eax, ebx
mov [edi+4], eax
mov [edi+esi+4], eax
nf25_33:mov eax, ebx
mov [edi+8], eax
mov [edi+esi+8], eax
nf25_34:mov eax, ebx
mov [edi+12], eax
mov [edi+esi+12], eax
lea edi, [edi+esi*2]
nf25_41:mov eax, ebx
mov [edi], eax
mov [edi+esi], eax
nf25_42:mov eax, ebx
mov [edi+4], eax
mov [edi+esi+4], eax
nf25_43:mov eax, ebx
mov [edi+8], eax
mov [edi+esi+8], eax
nf25_44:mov eax, ebx
mov [edi+12], eax
mov [edi+esi+12], eax
add edi, esi
pop esi
pop ebp
add esi, 12
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf9+32
nf41: ; low 4x8x2 (16 bytes)
test word [esi+4], 08000h
jnz near nf57
xor eax, eax
lea ecx, [nfhpk_mov8]
lea edx, [nf41_11+1] ; Removed byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_11-nf41_11)], bl
mov [edx+(nf41_12-nf41_11)], bh
shr ebx, 16
mov [edx+(nf41_13-nf41_11)], bl
mov [edx+(nf41_14-nf41_11)], bh
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_21-nf41_11)], bl
mov [edx+(nf41_22-nf41_11)], bh
shr ebx, 16
mov [edx+(nf41_23-nf41_11)], bl
mov [edx+(nf41_24-nf41_11)], bh
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_31-nf41_11)], bl
mov [edx+(nf41_32-nf41_11)], bh
shr ebx, 16
mov [edx+(nf41_33-nf41_11)], bl
mov [edx+(nf41_34-nf41_11)], bh
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_41-nf41_11)], bl
mov [edx+(nf41_42-nf41_11)], bh
shr ebx, 16
mov [edx+(nf41_43-nf41_11)], bl
mov [edx+(nf41_44-nf41_11)], bh
lea edx, [edx+(nf41_51-nf41_11)]
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_51-nf41_51)], bl
mov [edx+(nf41_52-nf41_51)], bh
shr ebx, 16
mov [edx+(nf41_53-nf41_51)], bl
mov [edx+(nf41_54-nf41_51)], bh
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_61-nf41_51)], bl
mov [edx+(nf41_62-nf41_51)], bh
shr ebx, 16
mov [edx+(nf41_63-nf41_51)], bl
mov [edx+(nf41_64-nf41_51)], bh
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_71-nf41_51)], bl
mov [edx+(nf41_72-nf41_51)], bh
shr ebx, 16
mov [edx+(nf41_73-nf41_51)], bl
mov [edx+(nf41_74-nf41_51)], bh
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf41_81-nf41_51)], bl
mov [edx+(nf41_82-nf41_51)], bh
shr ebx, 16
mov [edx+(nf41_83-nf41_51)], bl
mov [edx+(nf41_84-nf41_51)], bh
push ebp
push esi
; Load ebx,edx,ecx,ebp with four colors, duplicated in high order.
Trans16_3 cx, esi, 1
shrd ebx, ecx, 16
mov bx, cx
Trans16 cx, esi+2
shrd edx, ecx, 16
mov dx, cx
Trans16 cx, esi+4
shrd eax, ecx, 16
mov ax, cx
push eax
Trans16 cx, esi+6
shrd ebp, ecx, 16
mov bp, cx
pop ecx
mov esi, [nf_width]
jmp nf41_0 ; flush prefetch
ALIGN 4
nf41_0:
nf41_11:mov [ebp+0], ebx
nf41_12:mov [ebp+4], ebx
nf41_13:mov [ebp+8], ebx
nf41_14:mov [ebp+12], ebx
add edi, esi
nf41_21:mov [ebp+0], ebx
nf41_22:mov [ebp+4], ebx
nf41_23:mov [ebp+8], ebx
nf41_24:mov [ebp+12], ebx
add edi, esi
nf41_31:mov [ebp+0], ebx
nf41_32:mov [ebp+4], ebx
nf41_33:mov [ebp+8], ebx
nf41_34:mov [ebp+12], ebx
add edi, esi
nf41_41:mov [ebp+0], ebx
nf41_42:mov [ebp+4], ebx
nf41_43:mov [ebp+8], ebx
nf41_44:mov [ebp+12], ebx
add edi, esi
nf41_51:mov [ebp+0], ebx
nf41_52:mov [ebp+4], ebx
nf41_53:mov [ebp+8], ebx
nf41_54:mov [ebp+12], ebx
add edi, esi
nf41_61:mov [ebp+0], ebx
nf41_62:mov [ebp+4], ebx
nf41_63:mov [ebp+8], ebx
nf41_64:mov [ebp+12], ebx
add edi, esi
nf41_71:mov [ebp+0], ebx
nf41_72:mov [ebp+4], ebx
nf41_73:mov [ebp+8], ebx
nf41_74:mov [ebp+12], ebx
add edi, esi
nf41_81:mov [ebp+0], ebx
nf41_82:mov [ebp+4], ebx
nf41_83:mov [ebp+8], ebx
nf41_84:mov [ebp+12], ebx
pop esi
pop ebp
add esi, 16
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf9+48
nf57: ; low 8x4x2 (16 bytes)
xor eax, eax
lea ecx, [nfhpk_mov4]
lea edx, [nf57_11+2] ; Removed byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_11-nf57_11)], bh
mov [edx+(nf57_12-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_13-nf57_11)], bh
mov [edx+(nf57_14-nf57_11)], bl
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_15-nf57_11)], bh
mov [edx+(nf57_16-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_17-nf57_11)], bh
mov [edx+(nf57_18-nf57_11)], bl
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_21-nf57_11)], bh
mov [edx+(nf57_22-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_23-nf57_11)], bh
mov [edx+(nf57_24-nf57_11)], bl
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_25-nf57_11)], bh
mov [edx+(nf57_26-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_27-nf57_11)], bh
mov [edx+(nf57_28-nf57_11)], bl
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_31-nf57_11)], bh
mov [edx+(nf57_32-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_33-nf57_11)], bh
mov [edx+(nf57_34-nf57_11)], bl
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_35-nf57_11)], bh
mov [edx+(nf57_36-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_37-nf57_11)], bh
mov [edx+(nf57_38-nf57_11)], bl
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_41-nf57_11)], bh
mov [edx+(nf57_42-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_43-nf57_11)], bh
mov [edx+(nf57_44-nf57_11)], bl
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf57_45-nf57_11)], bh
mov [edx+(nf57_46-nf57_11)], bl
shr ebx, 16
mov [edx+(nf57_47-nf57_11)], bh
mov [edx+(nf57_48-nf57_11)], bl
push ebp
push esi
; Load bx,dx,cx,bp with four colors
Trans16_3 bx, esi, 1
Trans16 dx, esi+2
Trans16_3 cx, esi+4, 1
Trans16 bp, esi+6
mov esi, [nf_width]
jmp nf57_0 ; flush prefetch
ALIGN 4
nf57_0:
nf57_11:mov ax, bx
shl eax, 16
nf57_12:mov ax, bx
mov [edi], eax
mov [edi+esi], eax
nf57_13:mov ax, bx
shl eax, 16
nf57_14:mov ax, bx
mov [edi+4], eax
mov [edi+esi+4], eax
nf57_15:mov ax, bx
shl eax, 16
nf57_16:mov ax, bx
mov [edi+8], eax
mov [edi+esi+8], eax
nf57_17:mov ax, bx
shl eax, 16
nf57_18:mov ax, bx
mov [edi+12], eax
mov [edi+esi+12], eax
lea edi, [edi+esi*2]
nf57_21:mov ax, bx
shl eax, 16
nf57_22:mov ax, bx
mov [edi], eax
mov [edi+esi], eax
nf57_23:mov ax, bx
shl eax, 16
nf57_24:mov ax, bx
mov [edi+4], eax
mov [edi+esi+4], eax
nf57_25:mov ax, bx
shl eax, 16
nf57_26:mov ax, bx
mov [edi+8], eax
mov [edi+esi+8], eax
nf57_27:mov ax, bx
shl eax, 16
nf57_28:mov ax, bx
mov [edi+12], eax
mov [edi+esi+12], eax
lea edi, [edi+esi*2]
nf57_31:mov ax, bx
shl eax, 16
nf57_32:mov ax, bx
mov [edi], eax
mov [edi+esi], eax
nf57_33:mov ax, bx
shl eax, 16
nf57_34:mov ax, bx
mov [edi+4], eax
mov [edi+esi+4], eax
nf57_35:mov ax, bx
shl eax, 16
nf57_36:mov ax, bx
mov [edi+8], eax
mov [edi+esi+8], eax
nf57_37:mov ax, bx
shl eax, 16
nf57_38:mov ax, bx
mov [edi+12], eax
mov [edi+esi+12], eax
lea edi, [edi+esi*2]
nf57_41:mov ax, bx
shl eax, 16
nf57_42:mov ax, bx
mov [edi], eax
mov [edi+esi], eax
nf57_43:mov ax, bx
shl eax, 16
nf57_44:mov ax, bx
mov [edi+4], eax
mov [edi+esi+4], eax
nf57_45:mov ax, bx
shl eax, 16
nf57_46:mov ax, bx
mov [edi+8], eax
mov [edi+esi+8], eax
nf57_47:mov ax, bx
shl eax, 16
nf57_48:mov ax, bx
mov [edi+12], eax
mov [edi+esi+12], eax
add edi, esi
pop esi
pop ebp
add esi, 16
sub edi, [nfpk_back_right] ;br
retn
;----------------------------------------
ALIGN 4
nf10: ; 2x2 4x4x2 (48 bytes)
test word [esi], 08000h
jnz near nf26
xor eax, eax
lea ecx, [nfhpk_mov4]
lea edx, [nf10_11+2] ; Remove byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_11-nf10_11)], bh
mov [edx+(nf10_12-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_13-nf10_11)], bh
mov [edx+(nf10_14-nf10_11)], bl
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_15-nf10_11)], bh
mov [edx+(nf10_16-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_17-nf10_11)], bh
mov [edx+(nf10_18-nf10_11)], bl
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_21-nf10_11)], bh
mov [edx+(nf10_22-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_23-nf10_11)], bh
mov [edx+(nf10_24-nf10_11)], bl
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_25-nf10_11)], bh
mov [edx+(nf10_26-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_27-nf10_11)], bh
mov [edx+(nf10_28-nf10_11)], bl
mov al, [esi+20]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_31-nf10_11)], bh
mov [edx+(nf10_32-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_33-nf10_11)], bh
mov [edx+(nf10_34-nf10_11)], bl
mov al, [esi+21]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_35-nf10_11)], bh
mov [edx+(nf10_36-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_37-nf10_11)], bh
mov [edx+(nf10_38-nf10_11)], bl
mov al, [esi+22]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_41-nf10_11)], bh
mov [edx+(nf10_42-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_43-nf10_11)], bh
mov [edx+(nf10_44-nf10_11)], bl
mov al, [esi+23]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_45-nf10_11)], bh
mov [edx+(nf10_46-nf10_11)], bl
shr ebx, 16
mov [edx+(nf10_47-nf10_11)], bh
mov [edx+(nf10_48-nf10_11)], bl
lea edx, [edx+(nf10_51-nf10_11)]
mov al, [esi+32]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_51-nf10_51)], bh
mov [edx+(nf10_52-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_53-nf10_51)], bh
mov [edx+(nf10_54-nf10_51)], bl
mov al, [esi+33]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_55-nf10_51)], bh
mov [edx+(nf10_56-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_57-nf10_51)], bh
mov [edx+(nf10_58-nf10_51)], bl
mov al, [esi+34]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_61-nf10_51)], bh
mov [edx+(nf10_62-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_63-nf10_51)], bh
mov [edx+(nf10_64-nf10_51)], bl
mov al, [esi+35]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_65-nf10_51)], bh
mov [edx+(nf10_66-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_67-nf10_51)], bh
mov [edx+(nf10_68-nf10_51)], bl
mov al, [esi+44]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_71-nf10_51)], bh
mov [edx+(nf10_72-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_73-nf10_51)], bh
mov [edx+(nf10_74-nf10_51)], bl
mov al, [esi+45]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_75-nf10_51)], bh
mov [edx+(nf10_76-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_77-nf10_51)], bh
mov [edx+(nf10_78-nf10_51)], bl
mov al, [esi+46]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_81-nf10_51)], bh
mov [edx+(nf10_82-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_83-nf10_51)], bh
mov [edx+(nf10_84-nf10_51)], bl
mov al, [esi+47]
mov ebx, [ecx+eax*4]
mov [edx+(nf10_85-nf10_51)], bh
mov [edx+(nf10_86-nf10_51)], bl
shr ebx, 16
mov [edx+(nf10_87-nf10_51)], bh
mov [edx+(nf10_88-nf10_51)], bl
push ebp
push esi
; Load bx,dx,cx,bp with four colors
Trans16 bx, esi
Trans16 dx, esi+2
Trans16 cx, esi+4
Trans16 bp, esi+6
mov esi, [nf_width]
jmp nf10_0 ; flush prefetch
ALIGN 4
nf10_0:
nf10_11:mov ax, bx
shl eax, 16
nf10_12:mov ax, bx
mov [edi], eax
nf10_13:mov ax, bx
shl eax, 16
nf10_14:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_15:mov ax, bx
shl eax, 16
nf10_16:mov ax, bx
mov [edi], eax
nf10_17:mov ax, bx
shl eax, 16
nf10_18:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_21:mov ax, bx
shl eax, 16
nf10_22:mov ax, bx
mov [edi], eax
nf10_23:mov ax, bx
shl eax, 16
nf10_24:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_25:mov ax, bx
shl eax, 16
nf10_26:mov ax, bx
mov [edi], eax
nf10_27:mov ax, bx
shl eax, 16
nf10_28:mov ax, bx
mov [edi+4], eax
add edi, esi
; Load bx,dx,cx,bp with four colors
mov esi, [esp]
Trans16 bx, esi+12
Trans16 dx, esi+14
Trans16 cx, esi+16
Trans16 bp, esi+18
mov esi, [nf_width]
nf10_31:mov ax, bx
shl eax, 16
nf10_32:mov ax, bx
mov [edi], eax
nf10_33:mov ax, bx
shl eax, 16
nf10_34:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_35:mov ax, bx
shl eax, 16
nf10_36:mov ax, bx
mov [edi], eax
nf10_37:mov ax, bx
shl eax, 16
nf10_38:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_41:mov ax, bx
shl eax, 16
nf10_42:mov ax, bx
mov [edi], eax
nf10_43:mov ax, bx
shl eax, 16
nf10_44:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_45:mov ax, bx
shl eax, 16
nf10_46:mov ax, bx
mov [edi], eax
nf10_47:mov ax, bx
shl eax, 16
nf10_48:mov ax, bx
mov [edi+4], eax
add edi, esi
lea eax, [esi*8-8]
sub edi, eax
; Load bx,dx,cx,bp with four colors
mov esi, [esp]
Trans16 bx, esi+24
Trans16 dx, esi+26
Trans16 cx, esi+28
Trans16 bp, esi+30
mov esi, [nf_width]
nf10_51:mov ax, bx
shl eax, 16
nf10_52:mov ax, bx
mov [edi], eax
nf10_53:mov ax, bx
shl eax, 16
nf10_54:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_55:mov ax, bx
shl eax, 16
nf10_56:mov ax, bx
mov [edi], eax
nf10_57:mov ax, bx
shl eax, 16
nf10_58:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_61:mov ax, bx
shl eax, 16
nf10_62:mov ax, bx
mov [edi], eax
nf10_63:mov ax, bx
shl eax, 16
nf10_64:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_65:mov ax, bx
shl eax, 16
nf10_66:mov ax, bx
mov [edi], eax
nf10_67:mov ax, bx
shl eax, 16
nf10_68:mov ax, bx
mov [edi+4], eax
add edi, esi
; Load bx,dx,cx,bp with four colors
mov esi, [esp]
Trans16 bx, esi+36
Trans16 dx, esi+38
Trans16 cx, esi+40
Trans16 bp, esi+42
mov esi, [nf_width]
nf10_71:mov ax, bx
shl eax, 16
nf10_72:mov ax, bx
mov [edi], eax
nf10_73:mov ax, bx
shl eax, 16
nf10_74:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_75:mov ax, bx
shl eax, 16
nf10_76:mov ax, bx
mov [edi], eax
nf10_77:mov ax, bx
shl eax, 16
nf10_78:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_81:mov ax, bx
shl eax, 16
nf10_82:mov ax, bx
mov [edi], eax
nf10_83:mov ax, bx
shl eax, 16
nf10_84:mov ax, bx
mov [edi+4], eax
add edi, esi
nf10_85:mov ax, bx
shl eax, 16
nf10_86:mov ax, bx
mov [edi], eax
nf10_87:mov ax, bx
shl eax, 16
nf10_88:mov ax, bx
mov [edi+4], eax
pop esi
pop ebp
add esi, 48
sub edi, 8
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf10+16
nf26: ; 2x1 4x8x2 (32 bytes)
test word [esi+16], 08000h
jnz near nf42
xor eax, eax
lea ecx, [nfhpk_mov4]
lea edx, [nf26_11+2] ; Removed byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_11-nf26_11)], bh
mov [edx+(nf26_12-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_13-nf26_11)], bh
mov [edx+(nf26_14-nf26_11)], bl
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_15-nf26_11)], bh
mov [edx+(nf26_16-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_17-nf26_11)], bh
mov [edx+(nf26_18-nf26_11)], bl
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_21-nf26_11)], bh
mov [edx+(nf26_22-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_23-nf26_11)], bh
mov [edx+(nf26_24-nf26_11)], bl
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_25-nf26_11)], bh
mov [edx+(nf26_26-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_27-nf26_11)], bh
mov [edx+(nf26_28-nf26_11)], bl
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_31-nf26_11)], bh
mov [edx+(nf26_32-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_33-nf26_11)], bh
mov [edx+(nf26_34-nf26_11)], bl
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_35-nf26_11)], bh
mov [edx+(nf26_36-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_37-nf26_11)], bh
mov [edx+(nf26_38-nf26_11)], bl
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_41-nf26_11)], bh
mov [edx+(nf26_42-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_43-nf26_11)], bh
mov [edx+(nf26_44-nf26_11)], bl
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_45-nf26_11)], bh
mov [edx+(nf26_46-nf26_11)], bl
shr ebx, 16
mov [edx+(nf26_47-nf26_11)], bh
mov [edx+(nf26_48-nf26_11)], bl
lea edx, [edx+(nf26_51-nf26_11)]
mov al, [esi+24]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_51-nf26_51)], bh
mov [edx+(nf26_52-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_53-nf26_51)], bh
mov [edx+(nf26_54-nf26_51)], bl
mov al, [esi+25]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_55-nf26_51)], bh
mov [edx+(nf26_56-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_57-nf26_51)], bh
mov [edx+(nf26_58-nf26_51)], bl
mov al, [esi+26]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_61-nf26_51)], bh
mov [edx+(nf26_62-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_63-nf26_51)], bh
mov [edx+(nf26_64-nf26_51)], bl
mov al, [esi+27]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_65-nf26_51)], bh
mov [edx+(nf26_66-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_67-nf26_51)], bh
mov [edx+(nf26_68-nf26_51)], bl
mov al, [esi+28]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_71-nf26_51)], bh
mov [edx+(nf26_72-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_73-nf26_51)], bh
mov [edx+(nf26_74-nf26_51)], bl
mov al, [esi+29]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_75-nf26_51)], bh
mov [edx+(nf26_76-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_77-nf26_51)], bh
mov [edx+(nf26_78-nf26_51)], bl
mov al, [esi+30]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_81-nf26_51)], bh
mov [edx+(nf26_82-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_83-nf26_51)], bh
mov [edx+(nf26_84-nf26_51)], bl
mov al, [esi+31]
mov ebx, [ecx+eax*4]
mov [edx+(nf26_85-nf26_51)], bh
mov [edx+(nf26_86-nf26_51)], bl
shr ebx, 16
mov [edx+(nf26_87-nf26_51)], bh
mov [edx+(nf26_88-nf26_51)], bl
push ebp
push esi
; Load bx,dx,cx,bp with four colors
Trans16_3 bx, esi, 1
Trans16 dx, esi+2
Trans16 cx, esi+4
Trans16 bp, esi+6
mov esi, [nf_width]
jmp nf26_0 ; flush prefetch
ALIGN 4
nf26_0:
nf26_11:mov ax, bx
shl eax, 16
nf26_12:mov ax, bx
mov [edi], eax
nf26_13:mov ax, bx
shl eax, 16
nf26_14:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_15:mov ax, bx
shl eax, 16
nf26_16:mov ax, bx
mov [edi], eax
nf26_17:mov ax, bx
shl eax, 16
nf26_18:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_21:mov ax, bx
shl eax, 16
nf26_22:mov ax, bx
mov [edi], eax
nf26_23:mov ax, bx
shl eax, 16
nf26_24:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_25:mov ax, bx
shl eax, 16
nf26_26:mov ax, bx
mov [edi], eax
nf26_27:mov ax, bx
shl eax, 16
nf26_28:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_31:mov ax, bx
shl eax, 16
nf26_32:mov ax, bx
mov [edi], eax
nf26_33:mov ax, bx
shl eax, 16
nf26_34:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_35:mov ax, bx
shl eax, 16
nf26_36:mov ax, bx
mov [edi], eax
nf26_37:mov ax, bx
shl eax, 16
nf26_38:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_41:mov ax, bx
shl eax, 16
nf26_42:mov ax, bx
mov [edi], eax
nf26_43:mov ax, bx
shl eax, 16
nf26_44:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_45:mov ax, bx
shl eax, 16
nf26_46:mov ax, bx
mov [edi], eax
nf26_47:mov ax, bx
shl eax, 16
nf26_48:mov ax, bx
mov [edi+4], eax
add edi, esi
lea eax, [esi*8-8]
sub edi, eax
; Load bx,dx,cx,bp with four colors
mov esi, [esp]
Trans16 bx, esi+16
Trans16 dx, esi+18
Trans16 cx, esi+20
Trans16 bp, esi+22
mov esi, [nf_width]
nf26_51:mov ax, bx
shl eax, 16
nf26_52:mov ax, bx
mov [edi], eax
nf26_53:mov ax, bx
shl eax, 16
nf26_54:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_55:mov ax, bx
shl eax, 16
nf26_56:mov ax, bx
mov [edi], eax
nf26_57:mov ax, bx
shl eax, 16
nf26_58:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_61:mov ax, bx
shl eax, 16
nf26_62:mov ax, bx
mov [edi], eax
nf26_63:mov ax, bx
shl eax, 16
nf26_64:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_65:mov ax, bx
shl eax, 16
nf26_66:mov ax, bx
mov [edi], eax
nf26_67:mov ax, bx
shl eax, 16
nf26_68:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_71:mov ax, bx
shl eax, 16
nf26_72:mov ax, bx
mov [edi], eax
nf26_73:mov ax, bx
shl eax, 16
nf26_74:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_75:mov ax, bx
shl eax, 16
nf26_76:mov ax, bx
mov [edi], eax
nf26_77:mov ax, bx
shl eax, 16
nf26_78:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_81:mov ax, bx
shl eax, 16
nf26_82:mov ax, bx
mov [edi], eax
nf26_83:mov ax, bx
shl eax, 16
nf26_84:mov ax, bx
mov [edi+4], eax
add edi, esi
nf26_85:mov ax, bx
shl eax, 16
nf26_86:mov ax, bx
mov [edi], eax
nf26_87:mov ax, bx
shl eax, 16
nf26_88:mov ax, bx
mov [edi+4], eax
pop esi
pop ebp
add esi, 32
sub edi, 8
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
;nf10+32
nf42: ; 1x2 8x4x2 (32 bytes)
xor eax, eax
lea ecx, [nfhpk_mov4]
lea edx, [nf42_11+2] ; removed byte ds: - AH
mov al, [esi+8]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_11-nf42_11)], bh
mov [edx+(nf42_12-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_13-nf42_11)], bh
mov [edx+(nf42_14-nf42_11)], bl
mov al, [esi+9]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_15-nf42_11)], bh
mov [edx+(nf42_16-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_17-nf42_11)], bh
mov [edx+(nf42_18-nf42_11)], bl
mov al, [esi+10]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_21-nf42_11)], bh
mov [edx+(nf42_22-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_23-nf42_11)], bh
mov [edx+(nf42_24-nf42_11)], bl
mov al, [esi+11]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_25-nf42_11)], bh
mov [edx+(nf42_26-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_27-nf42_11)], bh
mov [edx+(nf42_28-nf42_11)], bl
mov al, [esi+12]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_31-nf42_11)], bh
mov [edx+(nf42_32-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_33-nf42_11)], bh
mov [edx+(nf42_34-nf42_11)], bl
mov al, [esi+13]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_35-nf42_11)], bh
mov [edx+(nf42_36-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_37-nf42_11)], bh
mov [edx+(nf42_38-nf42_11)], bl
mov al, [esi+14]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_41-nf42_11)], bh
mov [edx+(nf42_42-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_43-nf42_11)], bh
mov [edx+(nf42_44-nf42_11)], bl
mov al, [esi+15]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_45-nf42_11)], bh
mov [edx+(nf42_46-nf42_11)], bl
shr ebx, 16
mov [edx+(nf42_47-nf42_11)], bh
mov [edx+(nf42_48-nf42_11)], bl
lea edx, [edx+(nf42_51-nf42_11)]
mov al, [esi+24]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_51-nf42_51)], bh
mov [edx+(nf42_52-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_53-nf42_51)], bh
mov [edx+(nf42_54-nf42_51)], bl
mov al, [esi+25]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_55-nf42_51)], bh
mov [edx+(nf42_56-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_57-nf42_51)], bh
mov [edx+(nf42_58-nf42_51)], bl
mov al, [esi+26]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_61-nf42_51)], bh
mov [edx+(nf42_62-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_63-nf42_51)], bh
mov [edx+(nf42_64-nf42_51)], bl
mov al, [esi+27]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_65-nf42_51)], bh
mov [edx+(nf42_66-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_67-nf42_51)], bh
mov [edx+(nf42_68-nf42_51)], bl
mov al, [esi+28]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_71-nf42_51)], bh
mov [edx+(nf42_72-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_73-nf42_51)], bh
mov [edx+(nf42_74-nf42_51)], bl
mov al, [esi+29]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_75-nf42_51)], bh
mov [edx+(nf42_76-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_77-nf42_51)], bh
mov [edx+(nf42_78-nf42_51)], bl
mov al, [esi+30]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_81-nf42_51)], bh
mov [edx+(nf42_82-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_83-nf42_51)], bh
mov [edx+(nf42_84-nf42_51)], bl
mov al, [esi+31]
mov ebx, [ecx+eax*4]
mov [edx+(nf42_85-nf42_51)], bh
mov [edx+(nf42_86-nf42_51)], bl
shr ebx, 16
mov [edx+(nf42_87-nf42_51)], bh
mov [edx+(nf42_88-nf42_51)], bl
push ebp
push esi
; Load bx,dx,cx,bp with four colors
Trans16_3 bx, esi, 1
Trans16 dx, esi+2
Trans16 cx, esi+4
Trans16 bp, esi+6
mov esi, [nf_width]
jmp nf42_0 ; flush prefetch
ALIGN 4
nf42_0:
nf42_11:mov ax, bx
shl eax, 16
nf42_12:mov ax, bx
mov [edi], eax
nf42_13:mov ax, bx
shl eax, 16
nf42_14:mov ax, bx
mov [edi+4], eax
nf42_15:mov ax, bx
shl eax, 16
nf42_16:mov ax, bx
mov [edi+8], eax
nf42_17:mov ax, bx
shl eax, 16
nf42_18:mov ax, bx
mov [edi+12], eax
add edi, esi
nf42_21:mov ax, bx
shl eax, 16
nf42_22:mov ax, bx
mov [edi], eax
nf42_23:mov ax, bx
shl eax, 16
nf42_24:mov ax, bx
mov [edi+4], eax
nf42_25:mov ax, bx
shl eax, 16
nf42_26:mov ax, bx
mov [edi+8], eax
nf42_27:mov ax, bx
shl eax, 16
nf42_28:mov ax, bx
mov [edi+12], eax
add edi, esi
nf42_31:mov ax, bx
shl eax, 16
nf42_32:mov ax, bx
mov [edi], eax
nf42_33:mov ax, bx
shl eax, 16
nf42_34:mov ax, bx
mov [edi+4], eax
nf42_35:mov ax, bx
shl eax, 16
nf42_36:mov ax, bx
mov [edi+8], eax
nf42_37:mov ax, bx
shl eax, 16
nf42_38:mov ax, bx
mov [edi+12], eax
add edi, esi
nf42_41:mov ax, bx
shl eax, 16
nf42_42:mov ax, bx
mov [edi], eax
nf42_43:mov ax, bx
shl eax, 16
nf42_44:mov ax, bx
mov [edi+4], eax
nf42_45:mov ax, bx
shl eax, 16
nf42_46:mov ax, bx
mov [edi+8], eax
nf42_47:mov ax, bx
shl eax, 16
nf42_48:mov ax, bx
mov [edi+12], eax
add edi, esi
; Load bx,dx,cx,bp with four colors
mov esi, [esp]
Trans16_3 bx, esi+16, 1
Trans16 dx, esi+18
Trans16 cx, esi+20
Trans16 bp, esi+22
mov esi, [nf_width]
nf42_51:mov ax, bx
shl eax, 16
nf42_52:mov ax, bx
mov [edi], eax
nf42_53:mov ax, bx
shl eax, 16
nf42_54:mov ax, bx
mov [edi+4], eax
nf42_55:mov ax, bx
shl eax, 16
nf42_56:mov ax, bx
mov [edi+8], eax
nf42_57:mov ax, bx
shl eax, 16
nf42_58:mov ax, bx
mov [edi+12], eax
add edi, esi
nf42_61:mov ax, bx
shl eax, 16
nf42_62:mov ax, bx
mov [edi], eax
nf42_63:mov ax, bx
shl eax, 16
nf42_64:mov ax, bx
mov [edi+4], eax
nf42_65:mov ax, bx
shl eax, 16
nf42_66:mov ax, bx
mov [edi+8], eax
nf42_67:mov ax, bx
shl eax, 16
nf42_68:mov ax, bx
mov [edi+12], eax
add edi, esi
nf42_71:mov ax, bx
shl eax, 16
nf42_72:mov ax, bx
mov [edi], eax
nf42_73:mov ax, bx
shl eax, 16
nf42_74:mov ax, bx
mov [edi+4], eax
nf42_75:mov ax, bx
shl eax, 16
nf42_76:mov ax, bx
mov [edi+8], eax
nf42_77:mov ax, bx
shl eax, 16
nf42_78:mov ax, bx
mov [edi+12], eax
add edi, esi
nf42_81:mov ax, bx
shl eax, 16
nf42_82:mov ax, bx
mov [edi], eax
nf42_83:mov ax, bx
shl eax, 16
nf42_84:mov ax, bx
mov [edi+4], eax
nf42_85:mov ax, bx
shl eax, 16
nf42_86:mov ax, bx
mov [edi+8], eax
nf42_87:mov ax, bx
shl eax, 16
nf42_88:mov ax, bx
mov [edi+12], eax
pop esi
pop ebp
add esi, 32
sub edi, [nfpk_back_right] ;br
retn
;----------------------------------------
ALIGN 4
nf11: ; 8x8x16 (128 bytes)
mov edx, [nf_width]
%macro Trans16Blk 1 ; MACRO idx
Trans16 bx, %1 ;idx
mov [edi], bx
Trans16 bx, (%1 + 2) ;idx+2
mov [edi+2], bx
Trans16 bx, (%1 + 4) ;idx+4
mov [edi+4], bx
Trans16 bx, (%1 + 6) ;idx+6
mov [edi+6], bx
Trans16 bx, (%1 + 8) ;idx+8
mov [edi+8], bx
Trans16 bx, (%1 + 10) ;idx+10
mov [edi+10], bx
Trans16 bx, (%1 + 12) ;idx+12
mov [edi+12], bx
Trans16 bx, (%1 + 14) ;idx+14
mov [edi+14], bx
%endmacro
Trans16Blk esi ;0
add edi, edx
Trans16Blk esi+16 ;1
add edi, edx
Trans16Blk esi+32 ;2
add edi, edx
Trans16Blk esi+48 ;3
add edi, edx
Trans16Blk esi+64 ;4
add edi, edx
Trans16Blk esi+80 ;5
add edi, edx
Trans16Blk esi+96 ;6
add edi, edx
Trans16Blk esi+112 ;7
add esi, 128
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
nf12: ; low 4x4x16 (32 bytes)
mov edx, [nf_width]
Trans16 bx, esi
shrd eax, ebx, 16
mov ax, bx
mov [edi], eax
mov [edi+edx], eax
Trans16 bx, esi+2
shrd eax, ebx, 16
mov ax, bx
mov [edi+4], eax
mov [edi+edx+4], eax
Trans16 bx, esi+4
shrd eax, ebx, 16
mov ax, bx
mov [edi+8], eax
mov [edi+edx+8], eax
Trans16 bx, esi+6
shrd eax, ebx, 16
mov ax, bx
mov [edi+12], eax
mov [edi+edx+12], eax
lea edi, [edi+edx*2]
Trans16 bx, esi+8
shrd eax, ebx, 16
mov ax, bx
mov [edi], eax
mov [edi+edx], eax
Trans16 bx, esi+10
shrd eax, ebx, 16
mov ax, bx
mov [edi+4], eax
mov [edi+edx+4], eax
Trans16 bx, esi+12
shrd eax, ebx, 16
mov ax, bx
mov [edi+8], eax
mov [edi+edx+8], eax
Trans16 bx, esi+14
shrd eax, ebx, 16
mov ax, bx
mov [edi+12], eax
mov [edi+edx+12], eax
lea edi, [edi+edx*2]
Trans16 bx, esi+16
shrd eax, ebx, 16
mov ax, bx
mov [edi], eax
mov [edi+edx], eax
Trans16 bx, esi+18
shrd eax, ebx, 16
mov ax, bx
mov [edi+4], eax
mov [edi+edx+4], eax
Trans16 bx, esi+20
shrd eax, ebx, 16
mov ax, bx
mov [edi+8], eax
mov [edi+edx+8], eax
Trans16 bx, esi+22
shrd eax, ebx, 16
mov ax, bx
mov [edi+12], eax
mov [edi+edx+12], eax
lea edi, [edi+edx*2]
Trans16 bx, esi+24
shrd eax, ebx, 16
mov ax, bx
mov [edi], eax
mov [edi+edx], eax
Trans16 bx, esi+26
shrd eax, ebx, 16
mov ax, bx
mov [edi+4], eax
mov [edi+edx+4], eax
Trans16 bx, esi+28
shrd eax, ebx, 16
mov ax, bx
mov [edi+8], eax
mov [edi+edx+8], eax
Trans16 bx, esi+30
shrd eax, ebx, 16
mov ax, bx
mov [edi+12], eax
mov [edi+edx+12], eax
add edi, edx
sub edi, [nfpk_back_right] ;br
add esi, 32
retn
;----------------------------------------
ALIGN 4
nf13: ; 2x2 4x4x0 (8 bytes)
mov edx, [nf_width]
Trans16 cx, esi
shrd ebx, ecx, 16
mov bx, cx
Trans16 cx, esi+2
shrd eax, ecx, 16
mov ax, cx
mov ecx, eax
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ecx
mov [edi+12], ecx
mov [edi+edx], ebx
mov [edi+edx+4], ebx
mov [edi+edx+8], ecx
mov [edi+edx+12], ecx
lea edi, [edi+edx*2]
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ecx
mov [edi+12], ecx
mov [edi+edx], ebx
mov [edi+edx+4], ebx
mov [edi+edx+8], ecx
mov [edi+edx+12], ecx
lea edi, [edi+edx*2]
Trans16 cx, esi+4
shrd ebx, ecx, 16
mov bx, cx
Trans16 cx, esi+6
shrd eax, ecx, 16
mov ax, cx
mov ecx, eax
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ecx
mov [edi+12], ecx
mov [edi+edx], ebx
mov [edi+edx+4], ebx
mov [edi+edx+8], ecx
mov [edi+edx+12], ecx
lea edi, [edi+edx*2]
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ecx
mov [edi+12], ecx
mov [edi+edx], ebx
mov [edi+edx+4], ebx
mov [edi+edx+8], ecx
mov [edi+edx+12], ecx
add edi, edx
sub edi, [nfpk_back_right] ; br
add esi, 8
retn
;----------------------------------------
ALIGN 4
nf14: ; 8x8x0 (2 bytes)
Trans16 cx, esi
add esi, 2
shrd ebx, ecx, 16
mov bx, cx
nf_solid:
mov edx, [nf_width]
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
add edi, edx
mov [edi], ebx
mov [edi+4], ebx
mov [edi+8], ebx
mov [edi+12], ebx
sub edi, [nfpk_back_right] ;br ; (SHEIGHT-1)*width+8
retn
;----------------------------------------
ALIGN 4
nf15: ; unused
retn
;nfHPkDecomp ENDP
Reference in New Issue View Git Blame Copy Permalink