WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/video/vesa20.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  VESA20.INC                                                  ;;
;;                                                              ;;
;;  Vesa 2.0 functions for MenuetOS                             ;;
;;                                                              ;;
;;  Copyright 2002 Ville Turjanmaa                              ;;
;;  Alexey, kgaz@crosswindws.net                                ;;
;;  - Voodoo compatible graphics                                ;;
;;  Juan M. Caravaca                                            ;;
;;  - Graphics optimimizations eg. drawline                     ;;
;;                                                              ;;
;;  See file COPYING for details                                ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 996 $
 
 
; If you're planning to write your own video driver I suggest
; you replace the VESA12.INC file and see those instructions.
 
 
;*************************************************
; getpixel
;
; in:
; eax = x coordinate
; ebx = y coordinate
;
; ret:
; ecx = 00 RR GG BB
 
getpixel:
     push    eax ebx edx edi
     call    [get_pixel]
     pop     edi edx ebx eax
     ret
 
Vesa20_getpixel24:
; eax = x
; ebx = y
     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
     lea     edi, [eax+eax*2] ; edi = x*3
     add     edi, ebx         ; edi = x*3+(y*y multiplier)
if SHADOWFB
     mov     ecx, [SHADOWFB+edi]
else
     mov     ecx, [LFB_BASE+edi]
end if
     and     ecx, 0xffffff
     ret
 
Vesa20_getpixel32:
     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
if SHADOWFB
     mov     ecx, [SHADOWFB+edi]
else
     mov     ecx, [LFB_BASE+edi]
end if
     and     ecx, 0xffffff
     ret
 
;*************************************************
 
virtual at esp
 putimg:
   .real_sx        dd ?
   .real_sy        dd ?
   .image_sx       dd ?
   .image_sy       dd ?
   .image_cx       dd ?
   .image_cy       dd ?
   .pti            dd ?
   .abs_cx         dd ?
   .abs_cy         dd ?
   .line_increment dd ?
   .winmap_newline dd ?
   .screen_newline dd ?
   .stack_data = 4*12
   .edi         dd      ?
   .esi         dd      ?
   .ebp         dd      ?
   .esp         dd      ?
   .ebx         dd      ?
   .edx         dd      ?
   .ecx         dd      ?
   .eax         dd      ?
   .ret_addr    dd      ?
   .arg_0       dd      ?
end virtual
 
align 16
; ebx = pointer
; ecx = size [x|y]
; edx = coordinates [x|y]
; ebp = pointer to 'get' function
; esi = pointer to 'init' function
; edi = parameter for 'get' function
 
vesa20_putimage:
     pushad
     call    [disable_mouse]
     sub     esp, putimg.stack_data
; save pointer to image
     mov     [putimg.pti], ebx
; unpack the size
     mov     eax, ecx
     and     ecx, 0xFFFF
     shr     eax, 16
     mov     [putimg.image_sx], eax
     mov     [putimg.image_sy], ecx
; unpack the coordinates
     mov     eax, edx
     and     edx, 0xFFFF
     shr     eax, 16
     mov     [putimg.image_cx], eax
     mov     [putimg.image_cy], edx
; calculate absolute (i.e. screen) coordinates
     mov     eax, [TASK_BASE]
     mov     ebx, [eax-twdw + WDATA.box.left]
     add     ebx, [putimg.image_cx]
     mov     [putimg.abs_cx], ebx
     mov     ebx, [eax-twdw + WDATA.box.top]
     add     ebx, [putimg.image_cy]
     mov     [putimg.abs_cy], ebx
; real_sx = MIN(wnd_sx-image_cx, image_sx);
     mov     ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx
; \begin{diamond}[20.08.2006]
; note that WDATA.box.width is one pixel less than real window x-size
     inc     ebx
; \end{diamond}[20.08.2006]
     sub     ebx, [putimg.image_cx]
     ja      @f
     add     esp, putimg.stack_data
     popad
     ret
@@:
     cmp     ebx, [putimg.image_sx]
     jbe     .end_x
     mov     ebx, [putimg.image_sx]
.end_x:
     mov     [putimg.real_sx], ebx
; init real_sy
     mov     ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
; \begin{diamond}[20.08.2006]
     inc     ebx
; \end{diamond}[20.08.2006]
     sub     ebx, [putimg.image_cy]
     ja      @f
     add     esp, putimg.stack_data
     popad
     ret
@@:
     cmp     ebx, [putimg.image_sy]
     jbe     .end_y
     mov     ebx, [putimg.image_sy]
.end_y:
     mov     [putimg.real_sy], ebx
; line increment
     mov     eax, [putimg.image_sx]
     mov     ecx, [putimg.real_sx]
     sub     eax, ecx
;;     imul    eax, [putimg.source_bpp]
;     lea     eax, [eax + eax * 2]
     call    esi
     add     eax, [putimg.arg_0]
     mov     [putimg.line_increment], eax
; winmap new line increment
     mov     eax, [Screen_Max_X]
     inc     eax
     sub     eax, [putimg.real_sx]
     mov     [putimg.winmap_newline], eax
; screen new line increment
     mov     eax, [BytesPerScanLine]
     mov     ebx, [ScreenBPP]
     shr     ebx, 3
     imul    ecx, ebx
     sub     eax, ecx
     mov     [putimg.screen_newline], eax
; pointer to image
     mov     esi, [putimg.pti]
; pointer to screen
     mov     edx, [putimg.abs_cy]
     imul    edx, [BytesPerScanLine]
     mov     eax, [putimg.abs_cx]
     mov     ebx, [ScreenBPP]
     shr     ebx, 3
     imul    eax, ebx
     add     edx, eax
; pointer to pixel map
     mov     eax, [putimg.abs_cy]
     imul    eax, [Screen_Max_X]
     add     eax, [putimg.abs_cy]
     add     eax, [putimg.abs_cx]
     add     eax, [_display_data]
     xchg    eax, ebp
; get process number
     mov     ebx, [CURRENT_TASK]
     cmp     byte [ScreenBPP], 32
     je      put_image_end_32
;put_image_end_24:
     mov     edi, [putimg.real_sy]
align   4
.new_line:
     mov     ecx, [putimg.real_sx]
;     push    ebp edx
align   4
.new_x:
     push    [putimg.edi]
     mov     eax, [putimg.ebp+4]
     call    eax
     cmp     [ebp], bl
     jne     .skip
;     mov     eax, [esi]        ; eax = RRBBGGRR
if SHADOWFB
     mov     [SHADOWFB+edx], ax
end if
     mov     [LFB_BASE+edx], ax
     shr     eax, 16
if SHADOWFB
     mov     [SHADOWFB+edx+2], al
end if
     mov     [LFB_BASE+edx+2], al
.skip:
;     add     esi, 3 ;[putimg.source_bpp]
     add     edx, 3
     inc     ebp
     dec     ecx
     jnz     .new_x
;     pop     edx ebp
     add     esi, [putimg.line_increment]
     add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
     add     ebp, [putimg.winmap_newline] ;[Screen_Max_X]
;     inc     ebp
     cmp     [putimg.ebp], putimage_get1bpp
     jz      .correct
     cmp     [putimg.ebp], putimage_get4bpp
     jnz     @f
.correct:
     mov     eax, [putimg.edi]
     mov     byte [eax], 80h
@@:
     dec     edi
     jnz     .new_line
.finish:
     add     esp, putimg.stack_data
     popad
     ret
 
put_image_end_32:
     mov     edi, [putimg.real_sy]
align   4
.new_line:
     mov     ecx, [putimg.real_sx]
;     push    ebp edx
align   4
.new_x:
     push    [putimg.edi]
     mov     eax, [putimg.ebp+4]
     call    eax
     cmp     [ebp], bl
     jne     .skip
;     mov     eax, [esi]        ; ecx = RRBBGGRR
if SHADOWFB
     mov     [SHADOWFB+edx], eax
end if
     mov     [LFB_BASE+edx], eax
.skip:
;     add     esi, [putimg.source_bpp]
     add     edx, 4
     inc     ebp
     dec     ecx
     jnz     .new_x
;     pop     edx ebp
     add     esi, [putimg.line_increment]
     add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
     add     ebp, [putimg.winmap_newline] ;[Screen_Max_X]
;     inc     ebp
     cmp     [putimg.ebp], putimage_get1bpp
     jz      .correct
     cmp     [putimg.ebp], putimage_get4bpp
     jnz     @f
.correct:
     mov     eax, [putimg.edi]
     mov     byte [eax], 80h
@@:
     dec     edi
     jnz     .new_line
.finish:
     add     esp, putimg.stack_data
     popad
     call   VGA__putimage
     mov     [EGA_counter],1
     ret
 
 
;*************************************************
align 4
__sys_putpixel:
 
; eax = x coordinate
; ebx = y coordinate
; ecx = ?? RR GG BB    ; 0x01000000 negation
; edi = 0x00000001 force
 
;;;        mov  [novesachecksum], dword 0
     pushad
     test  edi,1                 ; force ?
     jnz   .forced
; not forced:
     push  ecx               ; save 24th bit in case negative pixel wanted
     call  checkpixel
     test  ecx,ecx
     pop   ecx
     jnz   .exit
.forced:
     cmp   [Screen_Max_X], eax
     jb    .exit
     cmp   [Screen_Max_Y], ebx
     jb    .exit
.ok:
; check if negation
     test  ecx,0x01000000
     jz    .noneg
     call  getpixel
     not   ecx
     mov   [esp+32-8],ecx
.noneg:
; OK to set pixel
     call  [put_pixel]    ; call the real put_pixel function
.exit:
     popad
     ret
 
align 4
Vesa20_putpixel24:
; eax = x
; ebx = y
     imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
     lea     edi, [eax+eax*2]  ; edi = x*3
     mov     eax, [esp+32-8+4]
if SHADOWFB
     mov     [SHADOWFB+ebx+edi], ax
end if
     mov     [LFB_BASE+ebx+edi], ax
     shr     eax, 16
if SHADOWFB
     mov     [SHADOWFB+ebx+edi+2], al
end if
     mov     [LFB_BASE+ebx+edi+2], al
     ret
 
 
align 4
Vesa20_putpixel32:
; eax = x
; ebx = y
     imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
     lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
     mov     eax, [esp+32-8+4] ; eax = color
if SHADOWFB
     mov     [SHADOWFB+edi], eax
end if
     mov     [LFB_BASE+edi], eax
     ret
 
;*************************************************
 
;align 4
calculate_edi:
     mov     edi, ebx
     imul    edi, [Screen_Max_X]
     add     edi, ebx
     add     edi, eax
     ret
 
;*************************************************
 
; DRAWLINE
 
align 4
__sys_draw_line:
;     inc   [mouse_pause]
     call    [disable_mouse]
 
; draw a line
; eax = HIWORD = x1
;       LOWORD = x2
; ebx = HIWORD = y1
;       LOWORD = y2
; ecx = color
; edi = force ?
        pusha
 
dl_x1 equ esp+20
dl_y1 equ esp+16
dl_x2 equ esp+12
dl_y2 equ esp+8
dl_dx equ esp+4
dl_dy equ esp+0
 
     xor     edx, edx      ; clear edx
     xor     esi, esi      ; unpack arguments
     xor     ebp, ebp
     mov     si, ax        ; esi = x2
     mov     bp, bx        ; ebp = y2
     shr     eax, 16       ; eax = x1
     shr     ebx, 16       ; ebx = y1
     push    eax           ; save x1
     push    ebx           ; save y1
     push    esi           ; save x2
     push    ebp           ; save y2
; checking x-axis...
     sub     esi, eax      ; esi = x2-x1
     push    esi           ; save y2-y1
     jl      .x2lx1        ; is x2 less than x1 ?
     jg      .no_vline     ; x1 > x2 ?
     mov     edx, ebp      ; else (if x1=x2)
     call    vline
     push    edx    ; necessary to rightly restore stack frame at .exit
     jmp     .exit
.x2lx1:
     neg     esi            ; get esi absolute value
.no_vline:
; checking y-axis...
     sub     ebp, ebx       ; ebp = y2-y1
     push    ebp            ; save y2-y1
     jl      .y2ly1         ; is y2 less than y1 ?
     jg      .no_hline      ; y1 > y2 ?
     mov     edx, [dl_x2]   ; else (if y1=y2)
     call    hline
     jmp     .exit
 
.y2ly1:
     neg     ebp            ; get ebp absolute value
.no_hline:
     cmp     ebp, esi
     jle     .x_rules       ; |y2-y1| < |x2-x1|  ?
     cmp     [dl_y2], ebx   ; make sure y1 is at the begining
     jge     .no_reverse1
     neg     dword [dl_dx]
     mov     edx, [dl_x2]
     mov     [dl_x2], eax
     mov     [dl_x1], edx
     mov     edx, [dl_y2]
     mov     [dl_y2], ebx
     mov     [dl_y1], edx
.no_reverse1:
     mov     eax, [dl_dx]
     cdq                    ; extend eax sing to edx
     shl     eax, 16        ; using 16bit fix-point maths
     idiv    ebp            ; eax = ((x2-x1)*65536)/(y2-y1)
     mov     edx, ebp       ; edx = counter (number of pixels to draw)
     mov     ebp, 1 *65536  ; <<16   ; ebp = dy = 1.0
     mov     esi, eax       ; esi = dx
     jmp     .y_rules
 
.x_rules:
     cmp     [dl_x2], eax    ; make sure x1 is at the begining
     jge     .no_reverse2
     neg     dword [dl_dy]
     mov     edx, [dl_x2]
     mov     [dl_x2], eax
     mov     [dl_x1], edx
     mov     edx, [dl_y2]
     mov     [dl_y2], ebx
     mov     [dl_y1], edx
.no_reverse2:
     xor     edx, edx
     mov     eax, [dl_dy]
     cdq                    ; extend eax sing to edx
     shl     eax, 16        ; using 16bit fix-point maths
     idiv    esi            ; eax = ((y2-y1)*65536)/(x2-x1)
     mov     edx, esi       ; edx = counter (number of pixels to draw)
     mov     esi, 1 *65536  ;<< 16   ; esi = dx = 1.0
     mov     ebp, eax       ; ebp = dy
.y_rules:
     mov     eax, [dl_x1]
     mov     ebx, [dl_y1]
     shl     eax, 16
     shl     ebx, 16
align 4
.draw:
     push    eax ebx
     shr     eax, 16
     shr     ebx, 16
     call    [putpixel]
     pop     ebx eax
     add     ebx, ebp        ; y = y+dy
     add     eax, esi        ; x = x+dx
     dec     edx
     jnz     .draw
; force last drawn pixel to be at (x2,y2)
     mov     eax, [dl_x2]
     mov     ebx, [dl_y2]
     call    [putpixel]
.exit:
     add     esp, 6*4
     popa
;     dec   [mouse_pause]
     call   [draw_pointer]
     ret
 
 
hline:
; draw an horizontal line
; eax = x1
; edx = x2
; ebx = y
; ecx = color
; edi = force ?
     push    eax edx
     cmp     edx, eax      ; make sure x2 is above x1
     jge     @f
     xchg    eax, edx
align   4
@@:
     call    [putpixel]
     inc     eax
     cmp     eax, edx
     jle     @b
     pop     edx eax
     ret
 
 
vline:
; draw a vertical line
; eax = x
; ebx = y1
; edx = y2
; ecx = color
; edi = force ?
     push    ebx edx
     cmp     edx, ebx      ; make sure y2 is above y1
     jge     @f
     xchg    ebx, edx
align   4
@@:
     call    [putpixel]
     inc     ebx
     cmp     ebx, edx
     jle     @b
     pop     edx ebx
     ret
 
 
;*************************************************
 
 
virtual at esp
drbar:
     .bar_sx       dd ?
     .bar_sy       dd ?
     .bar_cx       dd ?
     .bar_cy       dd ?
     .abs_cx       dd ?
     .abs_cy       dd ?
     .real_sx      dd ?
     .real_sy      dd ?
     .color        dd ?
     .line_inc_scr dd ?
     .line_inc_map dd ?
     .stack_data = 4*11
end virtual
 
align 4
; eax   cx
; ebx   cy
; ecx   xe
; edx   ye
; edi   color
_vesa20_drawbar:
vesa20_drawbar:
     pushad
     call    [disable_mouse]
     sub     esp, drbar.stack_data
     mov     [drbar.color], edi
     sub     edx, ebx
     jle     .exit          ;// mike.dld, 2005-01-29
     sub     ecx, eax
     jle     .exit          ;// mike.dld, 2005-01-29
     mov     [drbar.bar_sy], edx
     mov     [drbar.bar_sx], ecx
     mov     [drbar.bar_cx], eax
     mov     [drbar.bar_cy], ebx
     mov     edi, [TASK_BASE]
     add     eax, [edi-twdw + WDATA.box.left] ; win_cx
     add     ebx, [edi-twdw + WDATA.box.top] ; win_cy
     mov     [drbar.abs_cx], eax
     mov     [drbar.abs_cy], ebx
; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
     mov     ebx, [edi-twdw + WDATA.box.width] ; ebx = wnd_sx
; \begin{diamond}[20.08.2006]
; note that WDATA.box.width is one pixel less than real window x-size
     inc     ebx
; \end{diamond}[20.08.2006]
     sub     ebx, [drbar.bar_cx]
     ja      @f
.exit:                       ;// mike.dld, 2005-01-29
     add     esp, drbar.stack_data
     popad
     xor     eax, eax
     inc     eax
     ret
@@:
     cmp     ebx, [drbar.bar_sx]
     jbe     .end_x
     mov     ebx, [drbar.bar_sx]
.end_x:
     mov     [drbar.real_sx], ebx
; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
     mov     ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
; \begin{diamond}[20.08.2006]
     inc     ebx
; \end{diamond}
     sub     ebx, [drbar.bar_cy]
     ja      @f
     add     esp, drbar.stack_data
     popad
     xor     eax, eax
     inc     eax
     ret
@@:
     cmp     ebx, [drbar.bar_sy]
     jbe     .end_y
     mov     ebx, [drbar.bar_sy]
.end_y:
     mov     [drbar.real_sy], ebx
; line_inc_map
     mov     eax, [Screen_Max_X]
     sub     eax, [drbar.real_sx]
     inc     eax
     mov     [drbar.line_inc_map], eax
; line_inc_scr
     mov     eax, [drbar.real_sx]
     mov     ebx, [ScreenBPP]
     shr     ebx, 3
     imul    eax, ebx
     neg     eax
     add     eax, [BytesPerScanLine]
     mov     [drbar.line_inc_scr], eax
; pointer to screen
     mov     edx, [drbar.abs_cy]
     imul    edx, [BytesPerScanLine]
     mov     eax, [drbar.abs_cx]
;     mov    ebx, [ScreenBPP]
;     shr     ebx, 3
     imul    eax, ebx
     add     edx, eax
; pointer to pixel map
     mov     eax, [drbar.abs_cy]
     imul    eax, [Screen_Max_X]
     add     eax, [drbar.abs_cy]
     add     eax, [drbar.abs_cx]
     add     eax, [_display_data]
     xchg    eax, ebp
; get process number
     mov     ebx, [CURRENT_TASK]
     cmp     byte [ScreenBPP], 24
     jne     draw_bar_end_32
draw_bar_end_24:
     mov     eax, [drbar.color]    ;; BBGGRR00
     mov     bh, al                ;; bh  = BB
     shr     eax, 8                ;; eax = RRGG
; eax - color high   RRGG
; bl - process num
; bh - color low    BB
; ecx - temp
; edx - pointer to screen
; esi - counter
; edi - counter
     mov     esi, [drbar.real_sy]
align   4
.new_y:
     mov     edi, [drbar.real_sx]
align   4
.new_x:
     cmp     byte [ebp], bl
     jne     .skip
if SHADOWFB
     mov     [SHADOWFB+edx], bh
     mov     [SHADOWFB+edx + 1], ax
end if
     mov     [LFB_BASE+edx], bh
     mov     [LFB_BASE+edx + 1], ax
.skip:
; add pixel
     add     edx, 3
     inc     ebp
     dec     edi
     jnz     .new_x
; add line
     add     edx, [drbar.line_inc_scr]
     add     ebp, [drbar.line_inc_map]
;  drawing gradient bars
     test    eax, 0x00800000
     jz      @f
     test    bh, bh
     jz      @f
     dec     bh
@@:
; 
     dec     esi
     jnz     .new_y
     add     esp, drbar.stack_data
     popad
     xor     eax, eax
     ret
 
draw_bar_end_32:
     mov     eax, [drbar.color]    ;; BBGGRR00
     mov     esi, [drbar.real_sy]
align   4
.new_y:
     mov     edi, [drbar.real_sx]
align   4
.new_x:
     cmp     byte [ebp], bl
     jne     .skip
if SHADOWFB
     mov     [SHADOWFB+edx], eax
end if
     mov     [LFB_BASE+edx], eax
.skip:
; add pixel
     add     edx, 4
     inc     ebp
     dec     edi
     jnz     .new_x
; add line
     add     edx, [drbar.line_inc_scr]
     add     ebp, [drbar.line_inc_map]
;  drawing gradient bars
     test    eax, 0x80000000
     jz      @f
     test    al, al
     jz      @f
     dec     al
@@:
; 
     dec     esi
     jnz     .new_y
     add     esp, drbar.stack_data
     popad
     call    VGA_draw_bar
     xor     eax, eax
     mov     [EGA_counter],1
     ret
 
 
vesa20_drawbackground_tiled:
        call    [disable_mouse]
        pushad
; External loop for all y from start to end
        mov     ebx, [draw_data+32+RECT.top]    ; y start
dp2:
        mov     ebp, [draw_data+32+RECT.left]   ; x start
; 1) Calculate pointers in display_data (does pixel belong to OS thread?) [ebp]
;                       and LFB data (output for our function) [edi]
        mov     eax, [BytesPerScanLine]
        mul     ebx
        xchg    ebp, eax
        add     ebp, eax
        add     ebp, eax
        add     ebp, eax
        cmp     byte [ScreenBPP], 24    ; 24 or 32 bpp ? - x size
        jz      @f
        add     ebp, eax
@@:
       ; add     ebp, LFB_BASE
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
        call    calculate_edi
        xchg    edi, ebp
 
        add ebp, [_display_data]
 
; Now eax=x, ebx=y, edi->output, ebp=offset in display_data
; 2) Calculate offset in background memory block
        push    eax
        xor     edx, edx
        mov     eax, ebx
        div     dword [BgrDataHeight]   ; edx := y mod BgrDataHeight
        pop     eax
        push    eax
        mov     ecx, [BgrDataWidth]
        mov     esi, edx
        imul    esi, ecx                ; esi := (y mod BgrDataHeight) * BgrDataWidth
        xor     edx, edx
        div     ecx             ; edx := x mod BgrDataWidth
        sub     ecx, edx
        add     esi, edx        ; esi := (y mod BgrDataHeight)*BgrDataWidth + (x mod BgrDataWidth)
        pop     eax
        lea     esi, [esi*3]
        add     esi, [img_background]
        xor     edx, edx
        inc     edx
; 3) Loop through redraw rectangle and copy background data
; Registers meaning:
; eax = x, ebx = y (screen coordinates)
; ecx = deltax - number of pixels left in current tile block
; edx = 1
; esi -> bgr memory, edi -> output
; ebp = offset in display_data
dp3:
        cmp     [ebp], dl
        jnz     nbgp
        movsb
        movsb
        movsb
        jmp     @f
nbgp:
        add     esi, 3
        add     edi, 3
@@:
        cmp     byte [ScreenBPP], 25    ; 24 or 32 bpp?
        sbb     edi, -1         ; +1 for 32 bpp
; I do not use 'inc eax' because this is slightly slower then 'add eax,1'
        add     ebp, edx
        add     eax, edx
        cmp     eax, [draw_data+32+RECT.right]
        ja      dp4
        sub     ecx, edx
        jnz     dp3
; next tile block on x-axis
        mov     ecx, [BgrDataWidth]
        sub     esi, ecx
        sub     esi, ecx
        sub     esi, ecx
        jmp     dp3
dp4:
; next scan line
        inc     ebx
        cmp     ebx, [draw_data+32+RECT.bottom]
        jbe     dp2
        popad
        mov     [EGA_counter], 1
        call    VGA_drawbackground
        ret
 
; ----------
 
 
vesa20_drawbackground_stretch:
        call    [disable_mouse]
        pushad
; Helper variables
; calculate 2^32*(BgrDataWidth-1) mod (ScreenWidth-1)
        mov     eax, [BgrDataWidth]
        dec     eax
        xor     edx, edx
        div     dword [Screen_Max_X]
        push    eax     ; high
        xor     eax, eax
        div     dword [Screen_Max_X]
        push    eax     ; low
; the same for height
        mov     eax, [BgrDataHeight]
        dec     eax
        xor     edx, edx
        div     dword [Screen_Max_Y]
        push    eax     ; high
        xor     eax, eax
        div     dword [Screen_Max_Y]
        push    eax     ; low
; External loop for all y from start to end
        mov     ebx, [draw_data+32+RECT.top]    ; y start
        mov     ebp, [draw_data+32+RECT.left]   ; x start
; 1) Calculate pointers in display_data (does pixel belong to OS thread?) [ebp]
;                       and LFB data (output for our function) [edi]
        mov     eax, [BytesPerScanLine]
        mul     ebx
        xchg    ebp, eax
        add     ebp, eax
        add     ebp, eax
        add     ebp, eax
        cmp     byte [ScreenBPP], 24    ; 24 or 32 bpp ? - x size
        jz      @f
        add     ebp, eax
@@:
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
        call    calculate_edi
        xchg    edi, ebp
; Now eax=x, ebx=y, edi->output, ebp=offset in display_data
        push    ebx
        push    eax
; 2) Calculate offset in background memory block
        mov     eax, ebx
        imul    ebx, dword [esp+12]
        mul     dword [esp+8]
        add     edx, ebx        ; edx:eax = y * 2^32*(BgrDataHeight-1)/(ScreenHeight-1)
        mov     esi, edx
        imul    esi, [BgrDataWidth]
        push    edx
        push    eax
        mov     eax, [esp+8]
        mul     dword [esp+28]
        push    eax
        mov     eax, [esp+12]
        mul     dword [esp+28]
        add     [esp], edx
        pop     edx             ; edx:eax = x * 2^32*(BgrDataWidth-1)/(ScreenWidth-1)
        add     esi, edx
        lea     esi, [esi*3]
        add     esi, [img_background]
        push    eax
        push    edx
        push    esi
; 3) Smooth horizontal
bgr_resmooth0:
        mov     ecx, [esp+8]
        mov     edx, [esp+4]
        mov     esi, [esp]
        push    edi
        mov     edi, bgr_cur_line
        call    smooth_line
bgr_resmooth1:
        mov     eax, [esp+16+4]
        inc     eax
        cmp     eax, [BgrDataHeight]
        jae     bgr.no2nd
        mov     ecx, [esp+8+4]
        mov     edx, [esp+4+4]
        mov     esi, [esp+4]
        add     esi, [BgrDataWidth]
        add     esi, [BgrDataWidth]
        add     esi, [BgrDataWidth]
        mov     edi, bgr_next_line
        call    smooth_line
bgr.no2nd:
        pop     edi
sdp3:
        xor     esi, esi
        mov     ecx, [esp+12]
; 4) Loop through redraw rectangle and copy background data
; Registers meaning:
; esi = offset in current line, edi -> output
; ebp = offset in display_data
; dword [esp] = offset in bgr data
; qword [esp+4] = x * 2^32 * (BgrDataWidth-1) / (ScreenWidth-1)
; qword [esp+12] = y * 2^32 * (BgrDataHeight-1) / (ScreenHeight-1)
; dword [esp+20] = x
; dword [esp+24] = y
; precalculated constants:
; qword [esp+28] = 2^32*(BgrDataHeight-1)/(ScreenHeight-1)
; qword [esp+36] = 2^32*(BgrDataWidth-1)/(ScreenWidth-1)
sdp3a:
        mov eax, [_display_data]
        cmp     [ebp+eax], byte 1
        jnz     snbgp
        mov     eax, [bgr_cur_line+esi]
        test    ecx, ecx
        jz      .novert
        mov     ebx, [bgr_next_line+esi]
        call    [overlapping_of_points_ptr]
.novert:
if SHADOWFB
        mov     [SHADOWFB+edi], ax
end if
        mov     [LFB_BASE+edi], ax
        shr     eax, 16
if SHADOWFB
        mov     [SHADOWFB+edi+2], al
end if
        mov     [LFB_BASE+edi+2], al
snbgp:
        cmp     byte [ScreenBPP], 25
        sbb     edi, -4
        add     ebp, 1
        mov     eax, [esp+20]
        add     eax, 1
        mov     [esp+20], eax
        add     esi, 4
        cmp     eax, [draw_data+32+RECT.right]
        jbe     sdp3a
sdp4:
; next y
        mov     ebx, [esp+24]
        add     ebx, 1
        mov     [esp+24], ebx
        cmp     ebx, [draw_data+32+RECT.bottom]
        ja      sdpdone
; advance edi, ebp to next scan line
        sub     eax, [draw_data+32+RECT.left]
        sub     ebp, eax
        add     ebp, [Screen_Max_X]
        add     ebp, 1
        sub     edi, eax
        sub     edi, eax
        sub     edi, eax
        cmp     byte [ScreenBPP], 24
        jz      @f
        sub     edi, eax
@@:
        add     edi, [BytesPerScanLine]
; restore ecx,edx; advance esi to next background line
        mov     eax, [esp+28]
        mov     ebx, [esp+32]
        add     [esp+12], eax
        mov     eax, [esp+16]
        adc     [esp+16], ebx
        sub     eax, [esp+16]
        mov     ebx, eax
        lea     eax, [eax*3]
        imul    eax, [BgrDataWidth]
        sub     [esp], eax
        mov     eax, [draw_data+32+RECT.left]
        mov     [esp+20], eax
        test    ebx, ebx
        jz      sdp3
        cmp     ebx, -1
        jnz     bgr_resmooth0
        push    edi
        mov     esi, bgr_next_line
        mov     edi, bgr_cur_line
        mov     ecx, [Screen_Max_X]
        inc     ecx
        rep     movsd
        jmp     bgr_resmooth1
sdpdone:
        add     esp, 44
        popad
        mov     [EGA_counter],1
        call    VGA_drawbackground
        ret
 
uglobal
align 4
bgr_cur_line    rd      1280    ; maximum width of screen
bgr_next_line   rd      1280
endg
 
smooth_line:
        mov     al, [esi+2]
        shl     eax, 16
        mov     ax, [esi]
        test    ecx, ecx
        jz      @f
        mov     ebx, [esi+2]
        shr     ebx, 8
        call    [overlapping_of_points_ptr]
@@:
        stosd
        mov     eax, [esp+20+8]
        add     eax, 1
        mov     [esp+20+8], eax
        cmp     eax, [draw_data+32+RECT.right]
        ja      @f
        add     ecx, [esp+36+8]
        mov     eax, edx
        adc     edx, [esp+40+8]
        sub     eax, edx
        lea     eax, [eax*3]
        sub     esi, eax
        jmp     smooth_line
@@:
        mov     eax, [draw_data+32+RECT.left]
        mov     [esp+20+8], eax
        ret
 
align 16
overlapping_of_points:
if 0
; this version of procedure works, but is slower than next version
        push    ecx edx
        mov     edx, eax
        push    esi
        shr     ecx, 24
        mov     esi, ecx
        mov     ecx, ebx
        movzx   ebx, dl
        movzx   eax, cl
        sub     eax, ebx
        movzx   ebx, dh
        imul    eax, esi
        add     dl, ah
        movzx   eax, ch
        sub     eax, ebx
        imul    eax, esi
        add     dh, ah
        ror     ecx, 16
        ror     edx, 16
        movzx   eax, cl
        movzx   ebx, dl
        sub     eax, ebx
        imul    eax, esi
        pop     esi
        add     dl, ah
        mov     eax, edx
        pop     edx
        ror     eax, 16
        pop     ecx
        ret
else
        push    ecx edx
        mov     edx, eax
        push    esi
        shr     ecx, 26
        mov     esi, ecx
        mov     ecx, ebx
        shl     esi, 9
        movzx   ebx, dl
        movzx   eax, cl
        sub     eax, ebx
        movzx   ebx, dh
        add     dl, [BgrAuxTable+(eax+0x100)+esi]
        movzx   eax, ch
        sub     eax, ebx
        add     dh, [BgrAuxTable+(eax+0x100)+esi]
        ror     ecx, 16
        ror     edx, 16
        movzx   eax, cl
        movzx   ebx, dl
        sub     eax, ebx
        add     dl, [BgrAuxTable+(eax+0x100)+esi]
        pop     esi
        mov     eax, edx
        pop     edx
        ror     eax, 16
        pop     ecx
        ret
end if
 
iglobal
align 4
overlapping_of_points_ptr       dd      overlapping_of_points
endg
 
init_background:
        mov     edi, BgrAuxTable
        xor     edx, edx
.loop2:
        mov     eax, edx
        shl     eax, 8
        neg     eax
        mov     ecx, 0x200
.loop1:
        mov     byte [edi], ah
        inc     edi
        add     eax, edx
        loop    .loop1
        add     dl, 4
        jnz     .loop2
        test    byte [cpu_caps+(CAPS_MMX/8)], 1 shl (CAPS_MMX mod 8)
        jz      @f
        mov     [overlapping_of_points_ptr], overlapping_of_points_mmx
@@:
        ret
 
align 16
overlapping_of_points_mmx:
        movd    mm0, eax
        movd    mm4, eax
        movd    mm1, ebx
        pxor    mm2, mm2
        punpcklbw mm0, mm2
        punpcklbw mm1, mm2
        psubw   mm1, mm0
        movd    mm3, ecx
        psrld   mm3, 24
        packuswb mm3, mm3
        packuswb mm3, mm3
        pmullw  mm1, mm3
        psrlw   mm1, 8
        packuswb mm1, mm2
        paddb   mm4, mm1
        movd    eax, mm4
        ret

Rev 928	Rev 996
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; VESA20.INC ;;	6	;; VESA20.INC ;;
7	;; ;;	7	;; ;;
8	;; Vesa 2.0 functions for MenuetOS ;;	8	;; Vesa 2.0 functions for MenuetOS ;;
9	;; ;;	9	;; ;;
10	;; Copyright 2002 Ville Turjanmaa ;;	10	;; Copyright 2002 Ville Turjanmaa ;;
11	;; Alexey, kgaz@crosswindws.net ;;	11	;; Alexey, kgaz@crosswindws.net ;;
12	;; - Voodoo compatible graphics ;;	12	;; - Voodoo compatible graphics ;;
13	;; Juan M. Caravaca ;;	13	;; Juan M. Caravaca ;;
14	;; - Graphics optimimizations eg. drawline ;;	14	;; - Graphics optimimizations eg. drawline ;;
15	;; ;;	15	;; ;;
16	;; See file COPYING for details ;;	16	;; See file COPYING for details ;;
17	;; ;;	17	;; ;;
18	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	18	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
19		19
20	$Revision: 928 $	20	$Revision: 996 $
21		21
22		22
23	; If you're planning to write your own video driver I suggest	23	; If you're planning to write your own video driver I suggest
24	; you replace the VESA12.INC file and see those instructions.	24	; you replace the VESA12.INC file and see those instructions.
25		25
26		26
27	;*************************************************	27	;*************************************************
28	; getpixel	28	; getpixel
29	;	29	;
30	; in:	30	; in:
31	; eax = x coordinate	31	; eax = x coordinate
32	; ebx = y coordinate	32	; ebx = y coordinate
33	;	33	;
34	; ret:	34	; ret:
35	; ecx = 00 RR GG BB	35	; ecx = 00 RR GG BB
36		36
37	getpixel:	37	getpixel:
38	push eax ebx edx edi	38	push eax ebx edx edi
39	call [get_pixel]	39	call [get_pixel]
40	pop edi edx ebx eax	40	pop edi edx ebx eax
41	ret	41	ret
42		42
43	Vesa20_getpixel24:	43	Vesa20_getpixel24:
44	; eax = x	44	; eax = x
45	; ebx = y	45	; ebx = y
46	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	46	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
47	lea edi, [eax+eax2] ; edi = x3	47	lea edi, [eax+eax2] ; edi = x3
48	add edi, ebx ; edi = x3+(yy multiplier)	48	add edi, ebx ; edi = x3+(yy multiplier)
49	if SHADOWFB	49	if SHADOWFB
50	mov ecx, [SHADOWFB+edi]	50	mov ecx, [SHADOWFB+edi]
51	else	51	else
52	mov ecx, [LFB_BASE+edi]	52	mov ecx, [LFB_BASE+edi]
53	end if	53	end if
54	and ecx, 0xffffff	54	and ecx, 0xffffff
55	ret	55	ret
56		56
57	Vesa20_getpixel32:	57	Vesa20_getpixel32:
58	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	58	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
59	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)	59	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
60	if SHADOWFB	60	if SHADOWFB
61	mov ecx, [SHADOWFB+edi]	61	mov ecx, [SHADOWFB+edi]
62	else	62	else
63	mov ecx, [LFB_BASE+edi]	63	mov ecx, [LFB_BASE+edi]
64	end if	64	end if
65	and ecx, 0xffffff	65	and ecx, 0xffffff
66	ret	66	ret
67		67
68	;*************************************************	68	;*************************************************
69		69
70	virtual at esp	70	virtual at esp
71	putimg:	71	putimg:
72	.real_sx dd ?	72	.real_sx dd ?
73	.real_sy dd ?	73	.real_sy dd ?
74	.image_sx dd ?	74	.image_sx dd ?
75	.image_sy dd ?	75	.image_sy dd ?
76	.image_cx dd ?	76	.image_cx dd ?
77	.image_cy dd ?	77	.image_cy dd ?
78	.pti dd ?	78	.pti dd ?
79	.abs_cx dd ?	79	.abs_cx dd ?
80	.abs_cy dd ?	80	.abs_cy dd ?
81	.line_increment dd ?	81	.line_increment dd ?
82	.winmap_newline dd ?	82	.winmap_newline dd ?
83	.screen_newline dd ?	83	.screen_newline dd ?
84	.stack_data = 4*12	84	.stack_data = 4*12
85	.edi dd ?	85	.edi dd ?
86	.esi dd ?	86	.esi dd ?
87	.ebp dd ?	87	.ebp dd ?
88	.esp dd ?	88	.esp dd ?
89	.ebx dd ?	89	.ebx dd ?
90	.edx dd ?	90	.edx dd ?
91	.ecx dd ?	91	.ecx dd ?
92	.eax dd ?	92	.eax dd ?
93	.ret_addr dd ?	93	.ret_addr dd ?
94	.arg_0 dd ?	94	.arg_0 dd ?
95	end virtual	95	end virtual
96		96
97	align 16	97	align 16
98	; ebx = pointer	98	; ebx = pointer
99	; ecx = size [x\|y]	99	; ecx = size [x\|y]
100	; edx = coordinates [x\|y]	100	; edx = coordinates [x\|y]
101	; ebp = pointer to 'get' function	101	; ebp = pointer to 'get' function
102	; esi = pointer to 'init' function	102	; esi = pointer to 'init' function
103	; edi = parameter for 'get' function	103	; edi = parameter for 'get' function
104		104
105	vesa20_putimage:	105	vesa20_putimage:
106	pushad	106	pushad
107	call [disable_mouse]	107	call [disable_mouse]
108	sub esp, putimg.stack_data	108	sub esp, putimg.stack_data
109	; save pointer to image	109	; save pointer to image
110	mov [putimg.pti], ebx	110	mov [putimg.pti], ebx
111	; unpack the size	111	; unpack the size
112	mov eax, ecx	112	mov eax, ecx
113	and ecx, 0xFFFF	113	and ecx, 0xFFFF
114	shr eax, 16	114	shr eax, 16
115	mov [putimg.image_sx], eax	115	mov [putimg.image_sx], eax
116	mov [putimg.image_sy], ecx	116	mov [putimg.image_sy], ecx
117	; unpack the coordinates	117	; unpack the coordinates
118	mov eax, edx	118	mov eax, edx
119	and edx, 0xFFFF	119	and edx, 0xFFFF
120	shr eax, 16	120	shr eax, 16
121	mov [putimg.image_cx], eax	121	mov [putimg.image_cx], eax
122	mov [putimg.image_cy], edx	122	mov [putimg.image_cy], edx
123	; calculate absolute (i.e. screen) coordinates	123	; calculate absolute (i.e. screen) coordinates
124	mov eax, [TASK_BASE]	124	mov eax, [TASK_BASE]
125	mov ebx, [eax-twdw + WDATA.box.left]	125	mov ebx, [eax-twdw + WDATA.box.left]
126	add ebx, [putimg.image_cx]	126	add ebx, [putimg.image_cx]
127	mov [putimg.abs_cx], ebx	127	mov [putimg.abs_cx], ebx
128	mov ebx, [eax-twdw + WDATA.box.top]	128	mov ebx, [eax-twdw + WDATA.box.top]
129	add ebx, [putimg.image_cy]	129	add ebx, [putimg.image_cy]
130	mov [putimg.abs_cy], ebx	130	mov [putimg.abs_cy], ebx
131	; real_sx = MIN(wnd_sx-image_cx, image_sx);	131	; real_sx = MIN(wnd_sx-image_cx, image_sx);
132	mov ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx	132	mov ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx
133	; \begin{diamond}[20.08.2006]	133	; \begin{diamond}[20.08.2006]
134	; note that WDATA.box.width is one pixel less than real window x-size	134	; note that WDATA.box.width is one pixel less than real window x-size
135	inc ebx	135	inc ebx
136	; \end{diamond}[20.08.2006]	136	; \end{diamond}[20.08.2006]
137	sub ebx, [putimg.image_cx]	137	sub ebx, [putimg.image_cx]
138	ja @f	138	ja @f
139	add esp, putimg.stack_data	139	add esp, putimg.stack_data
140	popad	140	popad
141	ret	141	ret
142	@@:	142	@@:
143	cmp ebx, [putimg.image_sx]	143	cmp ebx, [putimg.image_sx]
144	jbe .end_x	144	jbe .end_x
145	mov ebx, [putimg.image_sx]	145	mov ebx, [putimg.image_sx]
146	.end_x:	146	.end_x:
147	mov [putimg.real_sx], ebx	147	mov [putimg.real_sx], ebx
148	; init real_sy	148	; init real_sy
149	mov ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy	149	mov ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
150	; \begin{diamond}[20.08.2006]	150	; \begin{diamond}[20.08.2006]
151	inc ebx	151	inc ebx
152	; \end{diamond}[20.08.2006]	152	; \end{diamond}[20.08.2006]
153	sub ebx, [putimg.image_cy]	153	sub ebx, [putimg.image_cy]
154	ja @f	154	ja @f
155	add esp, putimg.stack_data	155	add esp, putimg.stack_data
156	popad	156	popad
157	ret	157	ret
158	@@:	158	@@:
159	cmp ebx, [putimg.image_sy]	159	cmp ebx, [putimg.image_sy]
160	jbe .end_y	160	jbe .end_y
161	mov ebx, [putimg.image_sy]	161	mov ebx, [putimg.image_sy]
162	.end_y:	162	.end_y:
163	mov [putimg.real_sy], ebx	163	mov [putimg.real_sy], ebx
164	; line increment	164	; line increment
165	mov eax, [putimg.image_sx]	165	mov eax, [putimg.image_sx]
166	mov ecx, [putimg.real_sx]	166	mov ecx, [putimg.real_sx]
167	sub eax, ecx	167	sub eax, ecx
168	;; imul eax, [putimg.source_bpp]	168	;; imul eax, [putimg.source_bpp]
169	; lea eax, [eax + eax * 2]	169	; lea eax, [eax + eax * 2]
170	call esi	170	call esi
171	add eax, [putimg.arg_0]	171	add eax, [putimg.arg_0]
172	mov [putimg.line_increment], eax	172	mov [putimg.line_increment], eax
173	; winmap new line increment	173	; winmap new line increment
174	mov eax, [Screen_Max_X]	174	mov eax, [Screen_Max_X]
175	inc eax	175	inc eax
176	sub eax, [putimg.real_sx]	176	sub eax, [putimg.real_sx]
177	mov [putimg.winmap_newline], eax	177	mov [putimg.winmap_newline], eax
178	; screen new line increment	178	; screen new line increment
179	mov eax, [BytesPerScanLine]	179	mov eax, [BytesPerScanLine]
180	mov ebx, [ScreenBPP]	180	mov ebx, [ScreenBPP]
181	shr ebx, 3	181	shr ebx, 3
182	imul ecx, ebx	182	imul ecx, ebx
183	sub eax, ecx	183	sub eax, ecx
184	mov [putimg.screen_newline], eax	184	mov [putimg.screen_newline], eax
185	; pointer to image	185	; pointer to image
186	mov esi, [putimg.pti]	186	mov esi, [putimg.pti]
187	; pointer to screen	187	; pointer to screen
188	mov edx, [putimg.abs_cy]	188	mov edx, [putimg.abs_cy]
189	imul edx, [BytesPerScanLine]	189	imul edx, [BytesPerScanLine]
190	mov eax, [putimg.abs_cx]	190	mov eax, [putimg.abs_cx]
191	mov ebx, [ScreenBPP]	191	mov ebx, [ScreenBPP]
192	shr ebx, 3	192	shr ebx, 3
193	imul eax, ebx	193	imul eax, ebx
194	add edx, eax	194	add edx, eax
195	; pointer to pixel map	195	; pointer to pixel map
196	mov eax, [putimg.abs_cy]	196	mov eax, [putimg.abs_cy]
197	imul eax, [Screen_Max_X]	197	imul eax, [Screen_Max_X]
198	add eax, [putimg.abs_cy]	198	add eax, [putimg.abs_cy]
199	add eax, [putimg.abs_cx]	199	add eax, [putimg.abs_cx]
200	add eax, [_display_data]	200	add eax, [_display_data]
201	xchg eax, ebp	201	xchg eax, ebp
202	; get process number	202	; get process number
203	mov ebx, [CURRENT_TASK]	203	mov ebx, [CURRENT_TASK]
204	cmp byte [ScreenBPP], 32	204	cmp byte [ScreenBPP], 32
205	je put_image_end_32	205	je put_image_end_32
206	;put_image_end_24:	206	;put_image_end_24:
207	mov edi, [putimg.real_sy]	207	mov edi, [putimg.real_sy]
208	align 4	208	align 4
209	.new_line:	209	.new_line:
210	mov ecx, [putimg.real_sx]	210	mov ecx, [putimg.real_sx]
211	; push ebp edx	211	; push ebp edx
212	align 4	212	align 4
213	.new_x:	213	.new_x:
214	push [putimg.edi]	214	push [putimg.edi]
215	mov eax, [putimg.ebp+4]	215	mov eax, [putimg.ebp+4]
216	call eax	216	call eax
217	cmp [ebp], bl	217	cmp [ebp], bl
218	jne .skip	218	jne .skip
219	; mov eax, [esi] ; eax = RRBBGGRR	219	; mov eax, [esi] ; eax = RRBBGGRR
220	if SHADOWFB	220	if SHADOWFB
221	mov [SHADOWFB+edx], ax	221	mov [SHADOWFB+edx], ax
222	end if	222	end if
223	mov [LFB_BASE+edx], ax	223	mov [LFB_BASE+edx], ax
224	shr eax, 16	224	shr eax, 16
225	if SHADOWFB	225	if SHADOWFB
226	mov [SHADOWFB+edx+2], al	226	mov [SHADOWFB+edx+2], al
227	end if	227	end if
228	mov [LFB_BASE+edx+2], al	228	mov [LFB_BASE+edx+2], al
229	.skip:	229	.skip:
230	; add esi, 3 ;[putimg.source_bpp]	230	; add esi, 3 ;[putimg.source_bpp]
231	add edx, 3	231	add edx, 3
232	inc ebp	232	inc ebp
233	dec ecx	233	dec ecx
234	jnz .new_x	234	jnz .new_x
235	; pop edx ebp	235	; pop edx ebp
236	add esi, [putimg.line_increment]	236	add esi, [putimg.line_increment]
237	add edx, [putimg.screen_newline] ;[BytesPerScanLine]	237	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
238	add ebp, [putimg.winmap_newline] ;[Screen_Max_X]	238	add ebp, [putimg.winmap_newline] ;[Screen_Max_X]
239	; inc ebp	239	; inc ebp
240	cmp [putimg.ebp], putimage_get1bpp	240	cmp [putimg.ebp], putimage_get1bpp
241	jz .correct	241	jz .correct
242	cmp [putimg.ebp], putimage_get4bpp	242	cmp [putimg.ebp], putimage_get4bpp
243	jnz @f	243	jnz @f
244	.correct:	244	.correct:
245	mov eax, [putimg.edi]	245	mov eax, [putimg.edi]
246	mov byte [eax], 80h	246	mov byte [eax], 80h
247	@@:	247	@@:
248	dec edi	248	dec edi
249	jnz .new_line	249	jnz .new_line
250	.finish:	250	.finish:
251	add esp, putimg.stack_data	251	add esp, putimg.stack_data
252	popad	252	popad
253	ret	253	ret
254		254
255	put_image_end_32:	255	put_image_end_32:
256	mov edi, [putimg.real_sy]	256	mov edi, [putimg.real_sy]
257	align 4	257	align 4
258	.new_line:	258	.new_line:
259	mov ecx, [putimg.real_sx]	259	mov ecx, [putimg.real_sx]
260	; push ebp edx	260	; push ebp edx
261	align 4	261	align 4
262	.new_x:	262	.new_x:
263	push [putimg.edi]	263	push [putimg.edi]
264	mov eax, [putimg.ebp+4]	264	mov eax, [putimg.ebp+4]
265	call eax	265	call eax
266	cmp [ebp], bl	266	cmp [ebp], bl
267	jne .skip	267	jne .skip
268	; mov eax, [esi] ; ecx = RRBBGGRR	268	; mov eax, [esi] ; ecx = RRBBGGRR
269	if SHADOWFB	269	if SHADOWFB
270	mov [SHADOWFB+edx], eax	270	mov [SHADOWFB+edx], eax
271	end if	271	end if
272	mov [LFB_BASE+edx], eax	272	mov [LFB_BASE+edx], eax
273	.skip:	273	.skip:
274	; add esi, [putimg.source_bpp]	274	; add esi, [putimg.source_bpp]
275	add edx, 4	275	add edx, 4
276	inc ebp	276	inc ebp
277	dec ecx	277	dec ecx
278	jnz .new_x	278	jnz .new_x
279	; pop edx ebp	279	; pop edx ebp
280	add esi, [putimg.line_increment]	280	add esi, [putimg.line_increment]
281	add edx, [putimg.screen_newline] ;[BytesPerScanLine]	281	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
282	add ebp, [putimg.winmap_newline] ;[Screen_Max_X]	282	add ebp, [putimg.winmap_newline] ;[Screen_Max_X]
283	; inc ebp	283	; inc ebp
284	cmp [putimg.ebp], putimage_get1bpp	284	cmp [putimg.ebp], putimage_get1bpp
285	jz .correct	285	jz .correct
286	cmp [putimg.ebp], putimage_get4bpp	286	cmp [putimg.ebp], putimage_get4bpp
287	jnz @f	287	jnz @f
288	.correct:	288	.correct:
289	mov eax, [putimg.edi]	289	mov eax, [putimg.edi]
290	mov byte [eax], 80h	290	mov byte [eax], 80h
291	@@:	291	@@:
292	dec edi	292	dec edi
293	jnz .new_line	293	jnz .new_line
294	.finish:	294	.finish:
295	add esp, putimg.stack_data	295	add esp, putimg.stack_data
296	popad	296	popad
297	call VGA__putimage	297	call VGA__putimage
298	mov [EGA_counter],1	298	mov [EGA_counter],1
299	ret	299	ret
300		300
301		301
302	;*************************************************	302	;*************************************************
303	align 4	303	align 4
304	__sys_putpixel:	304	__sys_putpixel:
305		305
306	; eax = x coordinate	306	; eax = x coordinate
307	; ebx = y coordinate	307	; ebx = y coordinate
308	; ecx = ?? RR GG BB ; 0x01000000 negation	308	; ecx = ?? RR GG BB ; 0x01000000 negation
309	; edi = 0x00000001 force	309	; edi = 0x00000001 force
310		310
311	;;; mov [novesachecksum], dword 0	311	;;; mov [novesachecksum], dword 0
312	pushad	312	pushad
313	test edi,1 ; force ?	313	test edi,1 ; force ?
314	jnz .forced	314	jnz .forced
315	; not forced:	315	; not forced:
316	push ecx ; save 24th bit in case negative pixel wanted	316	push ecx ; save 24th bit in case negative pixel wanted
317	call checkpixel	317	call checkpixel
318	test ecx,ecx	318	test ecx,ecx
319	pop ecx	319	pop ecx
320	jnz .exit	320	jnz .exit
321	.forced:	321	.forced:
322	cmp [Screen_Max_X], eax	322	cmp [Screen_Max_X], eax
323	jb .exit	323	jb .exit
324	cmp [Screen_Max_Y], ebx	324	cmp [Screen_Max_Y], ebx
325	jb .exit	325	jb .exit
326	.ok:	326	.ok:
327	; check if negation	327	; check if negation
328	test ecx,0x01000000	328	test ecx,0x01000000
329	jz .noneg	329	jz .noneg
330	call getpixel	330	call getpixel
331	not ecx	331	not ecx
332	mov [esp+32-8],ecx	332	mov [esp+32-8],ecx
333	.noneg:	333	.noneg:
334	; OK to set pixel	334	; OK to set pixel
335	call [put_pixel] ; call the real put_pixel function	335	call [put_pixel] ; call the real put_pixel function
336	.exit:	336	.exit:
337	popad	337	popad
338	ret	338	ret
339		339
340	align 4	340	align 4
341	Vesa20_putpixel24:	341	Vesa20_putpixel24:
342	; eax = x	342	; eax = x
343	; ebx = y	343	; ebx = y
344	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	344	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
345	lea edi, [eax+eax2] ; edi = x3	345	lea edi, [eax+eax2] ; edi = x3
346	mov eax, [esp+32-8+4]	346	mov eax, [esp+32-8+4]
347	if SHADOWFB	347	if SHADOWFB
348	mov [SHADOWFB+ebx+edi], ax	348	mov [SHADOWFB+ebx+edi], ax
349	end if	349	end if
350	mov [LFB_BASE+ebx+edi], ax	350	mov [LFB_BASE+ebx+edi], ax
351	shr eax, 16	351	shr eax, 16
352	if SHADOWFB	352	if SHADOWFB
353	mov [SHADOWFB+ebx+edi+2], al	353	mov [SHADOWFB+ebx+edi+2], al
354	end if	354	end if
355	mov [LFB_BASE+ebx+edi+2], al	355	mov [LFB_BASE+ebx+edi+2], al
356	ret	356	ret
357		357
358		358
359	align 4	359	align 4
360	Vesa20_putpixel32:	360	Vesa20_putpixel32:
361	; eax = x	361	; eax = x
362	; ebx = y	362	; ebx = y
363	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	363	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
364	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)	364	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
365	mov eax, [esp+32-8+4] ; eax = color	365	mov eax, [esp+32-8+4] ; eax = color
366	if SHADOWFB	366	if SHADOWFB
367	mov [SHADOWFB+edi], eax	367	mov [SHADOWFB+edi], eax
368	end if	368	end if
369	mov [LFB_BASE+edi], eax	369	mov [LFB_BASE+edi], eax
370	ret	370	ret
371		371
372	;*************************************************	372	;*************************************************
373		373
374	;align 4	374	;align 4
375	calculate_edi:	375	calculate_edi:
376	mov edi, ebx	376	mov edi, ebx
377	imul edi, [Screen_Max_X]	377	imul edi, [Screen_Max_X]
378	add edi, ebx	378	add edi, ebx
379	add edi, eax	379	add edi, eax
380	ret	380	ret
381		381
382	;*************************************************	382	;*************************************************
383		383
384	; DRAWLINE	384	; DRAWLINE
385		385
386	align 4	386	align 4
387	__sys_draw_line:	387	__sys_draw_line:
388	; inc [mouse_pause]	388	; inc [mouse_pause]
389	call [disable_mouse]	389	call [disable_mouse]
390		390
391	; draw a line	391	; draw a line
392	; eax = HIWORD = x1	392	; eax = HIWORD = x1
393	; LOWORD = x2	393	; LOWORD = x2
394	; ebx = HIWORD = y1	394	; ebx = HIWORD = y1
395	; LOWORD = y2	395	; LOWORD = y2
396	; ecx = color	396	; ecx = color
397	; edi = force ?	397	; edi = force ?
398	pusha	398	pusha
399		399
400	dl_x1 equ esp+20	400	dl_x1 equ esp+20
401	dl_y1 equ esp+16	401	dl_y1 equ esp+16
402	dl_x2 equ esp+12	402	dl_x2 equ esp+12
403	dl_y2 equ esp+8	403	dl_y2 equ esp+8
404	dl_dx equ esp+4	404	dl_dx equ esp+4
405	dl_dy equ esp+0	405	dl_dy equ esp+0
406		406
407	xor edx, edx ; clear edx	407	xor edx, edx ; clear edx
408	xor esi, esi ; unpack arguments	408	xor esi, esi ; unpack arguments
409	xor ebp, ebp	409	xor ebp, ebp
410	mov si, ax ; esi = x2	410	mov si, ax ; esi = x2
411	mov bp, bx ; ebp = y2	411	mov bp, bx ; ebp = y2
412	shr eax, 16 ; eax = x1	412	shr eax, 16 ; eax = x1
413	shr ebx, 16 ; ebx = y1	413	shr ebx, 16 ; ebx = y1
414	push eax ; save x1	414	push eax ; save x1
415	push ebx ; save y1	415	push ebx ; save y1
416	push esi ; save x2	416	push esi ; save x2
417	push ebp ; save y2	417	push ebp ; save y2
418	; checking x-axis...	418	; checking x-axis...
419	sub esi, eax ; esi = x2-x1	419	sub esi, eax ; esi = x2-x1
420	push esi ; save y2-y1	420	push esi ; save y2-y1
421	jl .x2lx1 ; is x2 less than x1 ?	421	jl .x2lx1 ; is x2 less than x1 ?
422	jg .no_vline ; x1 > x2 ?	422	jg .no_vline ; x1 > x2 ?
423	mov edx, ebp ; else (if x1=x2)	423	mov edx, ebp ; else (if x1=x2)
424	call vline	424	call vline
425	push edx ; necessary to rightly restore stack frame at .exit	425	push edx ; necessary to rightly restore stack frame at .exit
426	jmp .exit	426	jmp .exit
427	.x2lx1:	427	.x2lx1:
428	neg esi ; get esi absolute value	428	neg esi ; get esi absolute value
429	.no_vline:	429	.no_vline:
430	; checking y-axis...	430	; checking y-axis...
431	sub ebp, ebx ; ebp = y2-y1	431	sub ebp, ebx ; ebp = y2-y1
432	push ebp ; save y2-y1	432	push ebp ; save y2-y1
433	jl .y2ly1 ; is y2 less than y1 ?	433	jl .y2ly1 ; is y2 less than y1 ?
434	jg .no_hline ; y1 > y2 ?	434	jg .no_hline ; y1 > y2 ?
435	mov edx, [dl_x2] ; else (if y1=y2)	435	mov edx, [dl_x2] ; else (if y1=y2)
436	call hline	436	call hline
437	jmp .exit	437	jmp .exit
438		438
439	.y2ly1:	439	.y2ly1:
440	neg ebp ; get ebp absolute value	440	neg ebp ; get ebp absolute value
441	.no_hline:	441	.no_hline:
442	cmp ebp, esi	442	cmp ebp, esi
443	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?	443	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?
444	cmp [dl_y2], ebx ; make sure y1 is at the begining	444	cmp [dl_y2], ebx ; make sure y1 is at the begining
445	jge .no_reverse1	445	jge .no_reverse1
446	neg dword [dl_dx]	446	neg dword [dl_dx]
447	mov edx, [dl_x2]	447	mov edx, [dl_x2]
448	mov [dl_x2], eax	448	mov [dl_x2], eax
449	mov [dl_x1], edx	449	mov [dl_x1], edx
450	mov edx, [dl_y2]	450	mov edx, [dl_y2]
451	mov [dl_y2], ebx	451	mov [dl_y2], ebx
452	mov [dl_y1], edx	452	mov [dl_y1], edx
453	.no_reverse1:	453	.no_reverse1:
454	mov eax, [dl_dx]	454	mov eax, [dl_dx]
455	cdq ; extend eax sing to edx	455	cdq ; extend eax sing to edx
456	shl eax, 16 ; using 16bit fix-point maths	456	shl eax, 16 ; using 16bit fix-point maths
457	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)	457	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)
458	mov edx, ebp ; edx = counter (number of pixels to draw)	458	mov edx, ebp ; edx = counter (number of pixels to draw)
459	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0	459	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0
460	mov esi, eax ; esi = dx	460	mov esi, eax ; esi = dx
461	jmp .y_rules	461	jmp .y_rules
462		462
463	.x_rules:	463	.x_rules:
464	cmp [dl_x2], eax ; make sure x1 is at the begining	464	cmp [dl_x2], eax ; make sure x1 is at the begining
465	jge .no_reverse2	465	jge .no_reverse2
466	neg dword [dl_dy]	466	neg dword [dl_dy]
467	mov edx, [dl_x2]	467	mov edx, [dl_x2]
468	mov [dl_x2], eax	468	mov [dl_x2], eax
469	mov [dl_x1], edx	469	mov [dl_x1], edx
470	mov edx, [dl_y2]	470	mov edx, [dl_y2]
471	mov [dl_y2], ebx	471	mov [dl_y2], ebx
472	mov [dl_y1], edx	472	mov [dl_y1], edx
473	.no_reverse2:	473	.no_reverse2:
474	xor edx, edx	474	xor edx, edx
475	mov eax, [dl_dy]	475	mov eax, [dl_dy]
476	cdq ; extend eax sing to edx	476	cdq ; extend eax sing to edx
477	shl eax, 16 ; using 16bit fix-point maths	477	shl eax, 16 ; using 16bit fix-point maths
478	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)	478	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)
479	mov edx, esi ; edx = counter (number of pixels to draw)	479	mov edx, esi ; edx = counter (number of pixels to draw)
480	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0	480	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0
481	mov ebp, eax ; ebp = dy	481	mov ebp, eax ; ebp = dy
482	.y_rules:	482	.y_rules:
483	mov eax, [dl_x1]	483	mov eax, [dl_x1]
484	mov ebx, [dl_y1]	484	mov ebx, [dl_y1]
485	shl eax, 16	485	shl eax, 16
486	shl ebx, 16	486	shl ebx, 16
487	align 4	487	align 4
488	.draw:	488	.draw:
489	push eax ebx	489	push eax ebx
490	shr eax, 16	490	shr eax, 16
491	shr ebx, 16	491	shr ebx, 16
492	call [putpixel]	492	call [putpixel]
493	pop ebx eax	493	pop ebx eax
494	add ebx, ebp ; y = y+dy	494	add ebx, ebp ; y = y+dy
495	add eax, esi ; x = x+dx	495	add eax, esi ; x = x+dx
496	dec edx	496	dec edx
497	jnz .draw	497	jnz .draw
498	; force last drawn pixel to be at (x2,y2)	498	; force last drawn pixel to be at (x2,y2)
499	mov eax, [dl_x2]	499	mov eax, [dl_x2]
500	mov ebx, [dl_y2]	500	mov ebx, [dl_y2]

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/video/vesa20.inc – Rev 928 → 996