;--------------------------------------------
; code to fade VGA in and out. Author unknown.

;+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
; extern "C" void fadepalout(int start, int count)
;
; This function fades the vga palette from the values in palette
; to 0 using a 64 pass incremental RGB fade. Similar in execution to
; _fadepalin above.
;
; note: start and count are in the range 0..255, and denote the first
; palette register to process, and the number of subsequent registers
; to process. The palette argument points to an array of 768 bytes of
; DAC palette data. Only the low six bits of each byte are significant.
; Palette registers outside the specified range are not affected.

_fadepalout     PROC
        	ARG start: WORD, count: WORD

	push    bp
       	mov     bp, sp
        push    es
        push    ds
       	push    di
        push    si
       	push    dx
        push    cx
       	push    bx
        jmp     o_go
       	opal    db 768 dup (20)  ; temporary palette area
o_go:
       	push    cs               ; get code segment into es
       	pop     es
       	mov     dx,offset opal   ; es:dx points to start of opal
       	push    dx               ; save offset of opal
       	xor     bx,bx
       	mov     cx,100h
       	mov     ax,1017h         ; bios read dac registers function
       	int     10h              ; read the palette registers into opal
       	pop     di               ; offset of opal, was in dx!
       	mov     ax,start         ; get offset of first palette byte to
       	mov     bx,3             ; be processed
       	mul     bx
       	add     di,ax            ; adjust offset into opal
       	mov     ax,count         ; find the number of bytes to be processed
       	mov     bx,3
       	mul     bx               ; leave it in ax
       	mov     cx,64            ; 64 passes through fade loop
o_fade_loop:
        push    cx               ; save the fade loop counter
        push    di               ; save offset of first byte processed in
        mov     bl,cl            ; we'll use the pass number as a threshold
        mov     cx,ax            ; load number of bytes to process into cx
o_pal_cmp_loop:
        cmp     bl,es:[di]       ; start decrementing when palette value
        jnz     o_no_dec         ; is equal loop count (it will stay equal
       	dec     BYTE PTR es:[di] ; to loop count for the rest of this pass)
o_no_dec:
        inc     di
        loop    o_pal_cmp_loop   ; do the next byte

        mov     bx,sp            ; need the stack pointer for a moment
        mov     di,ss:[bx]       ; restore offset into pal without popping
        mov     cx,count         ; number of triplets to process
        push    ax               ; need to use ax for port i/o

    	mov 	dx,03DAh         ; CRT controller input status 1 register
o_vbi_1:
	in 	al,dx	    	 ; watch vertical blanking bit
	test 	al,08h           ; wait for it to clear to make sure
	jnz o_vbi_1              ; we're not in a blanking interval
o_vbi_2:
	in 	al,dx            ; now wait for the start of the
	test 	al,08h           ; next blanking interval
	jz o_vbi_2

       	mov     ah,BYTE PTR start    	; get 1st register to process into ah
       	mov     dx,03c8h             	; DAC palette index register
o_pal_load_loop:
        mov     al, ah               	; get next palette number to write
        out     dx, al               	; write the register number to the dac
        inc     dx                   	; address dac data register
        mov     al, BYTE PTR [es:di] 	; get first byte of triplet
        out     dx, al               	; write it to the dac data register
        inc     di                   	; point to second byte
        mov     al, BYTE PTR [es:di] 	; get second byte of triplet
        out     dx, al               	; write it to the dac data register
        inc     di                   	; point to third byte
        mov     al, BYTE PTR [es:di] 	; get third byte of triplet
        out     dx, al               	; write it to the dac data register
        inc     di                   	; point to first byte of next triplet
        dec     dx                   	; address the dac index register
        inc     ah                   	; point to next palette register
        loop    o_pal_load_loop      	; process next triplet

        pop     ax                ; restore ax
        pop     di                ; restore the offset into pal
        pop     cx                ; restore the fade loop counter
        loop    o_fade_loop       ; do the next pass through the fade loop

        pop     bx
        pop     cx
        pop     dx
        pop     si
        pop     di
        pop     ds
        pop     es
        pop     bp
        ret
_fadepalout     ENDP
;+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+


;+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
; extern "C" void fadepalin(int start, int count, const byte* palette)
;
; This function fades the vga palette from 0 to the values in palette
; using a 64 pass incremental RGB fade.
;
; note: start and count are in the range 0..255, and denote the first
; palette register to process, and the number of subsequent registers
; to process. The palette argument points to an array of 768 bytes of
; DAC palette data. Only the low six bits of each byte are significant.
; Palette registers outside the specified range are not affected.

_fadepalin	PROC
	        ARG start: WORD, count: WORD, palette: DWORD

        push    bp
        mov     bp, sp
        push    es                ; we use just about everything
        push    ds
        push    di
        push    si
        push    dx
        push    cx
        push    bx
        jmp     go

        pal     db 768 dup (0)    ; working palette area

go:
        ; setup for and make bios call to load the current dac palette
        ; into the table at pal

        push    cs             ; get code segment into es
        pop     es
        mov     dx, offset pal ; es:dx points to start of pal
        push    dx             ; save offset of pal
        xor     bx,bx          ; need to get the current palette into
        mov     cx,100h        ; pal using bios int 10h, 10h, 17h
        mov     ax,1017h       ; set up and generate the interrupt
        int     10h            ; read the palette registers into pal
        pop     di             ; offset of pal, was in dx!

        ; get the palette pointer, then calculate the offset to the
        ; first byte processed, based on start, and the number of
        ; bytes to process based on count. Use the offset to adjust
        ; the string pointers in si and di, and leave the byte
        ; count in ax

	lds     si,palette       ; get address of target palette
	mov     ax,start         ; get offset of first palette byte to
        mov     bx,3             ; be processed
	mul     bx
        add     si,ax            ; adjust di and si point first byte in the
	add     di,ax            ; target and temporary palettes
        mov     ax,count         ; find the number of bytes to be processed
	mov     bx,3
        mul     bx               ; leave it in ax

        ; clear the bytes in the triplets which will be operated on by
        ; the fade. All other registers are unaffected

        push    di        ; save the starting offset into pal
        push    ax        ; save the number of bytes to process
        mov     cx,ax     ; set up a loop counter
       	xor     ax,ax     ; clear ax
        rep     stosb     ; fill relevant range of pal with 0's
       	pop     ax        ; restore the number of bytes to process
        pop     di        ; restore the starting offset into pal
       	mov     cx,64     ; 64 passes through fade loop

        ; the fade loop will execute 64 times. On each pass the inner
        ; loop adjusts the working palette, then waits for a blanking
        ; interval, and loads the working palette into the DAC

fade_loop:
       	push    cx        ; save the fade loop counter
       	push    di        ; save offset of first byte processed in
       	push    si        ; temp and target palettes
       	mov     bl,cl     ; outer loop count into bl
       	mov     cx,ax     ; load number of bytes to process into cx

        ; inner loop makes one pass through the palette for each pass
        ; through the outer loop. Each byte is incremented if it's
        ; target value is one greater than the outer loop count. Using
        ; this logic ensures that all bytes arrive at their target values
        ; on the same pass through the outer loop

pal_cmp_loop:
       	cmp     bl,ds:[si]    ; start incrementing when palette value
       	jns     no_add        ; is one greater than loop count
       	inc     BYTE PTR es:[di]
no_add:
       	inc     si            ; point to the next byte in both palettes
       	inc     di
       	loop    pal_cmp_loop  ; do the next byte

        ; setup for palette load. As much as possible was moved above the
        ; blanking interval wait, in order to maximize the amount of the
        ; blanking interval remaining in which to do the palette loading

        mov     bx, sp
        mov     di, ss:[bx+02]      ; restore offset into pal without
       	mov     cx, count           ; popping number of triplets to
        push    ax                  ; process need to use ax for port i/o

        ; monitor bit 1 of CRT controller's input status 1 register to
        ; sense a vertical blanking interval. Wait for any current vbi
        ; to end, then wait for the next full one to begin.

    	mov 	dx,03DAh            ; CRT controller input status 1 register
vbi_1:
	in 	al, dx              ; watch vertical blanking bit
	test 	al,08h              ; wait for it to clear to make
	jnz 	vbi_1               ; sure we're not in a blanking
					    ; interval
vbi_2:
	in 	al,dx               ; now wait for the start of the
	test 	al,08h              ; next blanking interval
	jz 	vbi_2

        ; load the relevant triplets from pal into the VGA DAC palette

       	mov     ah,BYTE PTR start  ; get first register to process into ah
       	mov     dx,03c8h           ; DAC palette index register
pal_load_loop:
        mov     al,ah               ; get next palette number to write
        out     dx,al               ; write the reg. number to the dac
        inc     dx                  ; address dac data register
        mov     al,BYTE PTR [es:di] ; get first byte of triplet
        out     dx,al               ; write it to the dac data reg.
        inc     di                  ; point to second byte
        mov     al,BYTE PTR [es:di] ; get second byte of triplet
        out     dx,al               ; write it to the dac data reg.
        inc     di                  ; point to third byte
        mov     al,BYTE PTR [es:di] ; get third byte of triplet
        out     dx,al               ; write it to the dac data reg.
        inc     di                  ; point to 1st byte of next triplet
        dec     dx                  ; address the dac index register
        inc     ah                  ; point to next palette register
        loop    pal_load_loop       ; process next triplet

        ; clean-up for the next pass through the fade loop

        pop     ax                ; restore ax
        pop     si                ; restore the offset into palette
        pop     di                ; restore the offset into pal
        pop     cx                ; restore the fade loop counter
        loop    fade_loop         ; do the next pass through the
        			  ; fade loop

        pop     bx
        pop     cx
        pop     dx
        pop     si
        pop     di
        pop     ds
        pop     es
        pop     bp
        ret
_fadepalin      ENDP