WebSVN – Kolibri OS – Diff – /kernel/tags/kolibri0.7.0.0/video/vesa20.inc


$Revision: 537 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; 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                                ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; If you're planning to write your own video driver I suggest
; you replace the VESA12.INC file and see those instructions.
 
;ScreenWidth             equ     0xfe00
;ScreenHeight            equ     0xfe04
;BytesPerScanLine        equ     0xfe08
;LFBAddress              equ     0xfe80
;ScreenBPP               equ     0xfbf1
;WinMapAddress           equ     0x460000
 
 
 
;*************************************************
; getpixel
;
; in:
; eax = x coordinate
; ebx = y coordinate
;
; ret:
; ecx = 00 RR GG BB
 
getpixel:
     push    eax ebx edx edi
     call    dword [GETPIXEL]
     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)
     add     edi, [LFBAddress]    ; ebx = where pixel is in memory
     mov     ecx, [edi]
     and     ecx, 0xffffff
     ret
 
Vesa20_getpixel32:
     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
     add     edi, [LFBAddress]    ; ebx = where pixel is in memory
     mov     ecx, [edi]
     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]
     sub     eax, [putimg.real_sx]
;;     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, [ScreenWidth]
     inc     eax
     sub     eax, [putimg.real_sx]
     mov     [putimg.winmap_newline], eax
; screen new line increment
     mov     eax, [BytesPerScanLine]
     mov     ecx, [putimg.real_sx]
     movzx   ebx, byte [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]
     movzx   ebx, byte [ScreenBPP]
     shr     ebx, 3
     imul    eax, ebx
     add     edx, eax
     add     edx, [LFBAddress]
; pointer to pixel map
     mov     eax, [putimg.abs_cy]
     imul    eax, [ScreenWidth]
     add     eax, [putimg.abs_cy]
     add     eax, [putimg.abs_cx]
     add     eax, WinMapAddress
     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
     mov     [edx], ax
     shr     eax, 16
     mov     [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] ;[ScreenWidth]
;     inc     ebp
     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
     mov     [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] ;[ScreenWidth]
;     inc     ebp
     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   [ScreenWidth], eax
     jb    .exit
     cmp   [ScreenHeight], 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  dword [PUTPIXEL]    ; 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]
     add     edi, [LFBAddress]
     add     edi, ebx          ; ebx = where to put pixel in memory
     mov     [edi], ax
     shr     eax, 16
     mov     [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
     add     edi, [LFBAddress]     ; ebx = where to put pixel in memory
     mov     [edi], eax
     ret
 
;*************************************************
 
;align 4
calculate_edi:
     mov     edi, ebx
     imul    edi, [ScreenWidth]
     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:
     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, [ScreenWidth]
     sub     eax, [drbar.real_sx]
     inc     eax
     mov     [drbar.line_inc_map], eax
; line_inc_scr
     mov     eax, [drbar.real_sx]
     movzx   ebx, byte [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]
;     movzx   ebx, byte [ScreenBPP]
;     shr     ebx, 3
     imul    eax, ebx
     add     edx, eax
     add     edx, [LFBAddress]
; pointer to pixel map
     mov     eax, [drbar.abs_cy]
     imul    eax, [ScreenWidth]
     add     eax, [drbar.abs_cy]
     add     eax, [drbar.abs_cx]
     add     eax, WinMapAddress
     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
     mov     [edx], bh
     mov     [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
     mov     [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
 
;voodoodbcplimit:
 
; ebp:=(y+Ywin)*(ScreenXSize+1)+(x+Xwin)+AddrBuffer
 
 
;     pusha
 
;     xor edx,edx
;     mov eax,ebp
;     mov ebx,[ScreenWidth] ; Screen_X_size
;     inc ebx   ; +1
;     sub eax,WinMapAddress ; -AddrBuffer
;     div ebx ;
;     mov ebx,eax ; ebx:=Y
;     mov eax,edx ; eax:=X
;     call cplimit
 
;     test ecx,ecx
;     jne  dbcpl12
;     popa
;     clc
;     ret
;   dbcpl12:
;     popa
;     stc
;     ret
 
 
 
 
;dbcplimit:
 
;        pusha
 
;        xor  edx,edx
;        mov  ebx,[ScreenWidth]
;        inc  ebx
;        sub  eax,WinMapAddress
;        div  ebx
;        mov  ebx,eax
;        mov  eax,edx
;        call cplimit
 
;        test ecx,ecx
;        jne  dbcpl1
;        popa
;        clc
;        ret
;     dbcpl1:
;        popa
;        stc
;        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 WinMapAddress (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     [ScreenBPP], byte 24    ; 24 or 32 bpp ? - x size
        jz      @f
        add     ebp, eax
@@:
        add     ebp, [LFBAddress]
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
        call    calculate_edi
        xchg    edi, ebp
; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress
; 2) Calculate offset in background memory block
        push    eax
        xor     edx, edx
        mov     eax, ebx
        mov     ecx, [BgrDataHeight]
        div     ecx             ; edx := y mod BgrDataHeight
        sub     ecx, edx        ; ecx := BgrDataHeight - (y mod BgrDataHeight)
        pop     eax
        push    eax
        mov     esi, edx
        imul    esi, [BgrDataWidth]             ; esi := (y mod BgrDataHeight) * BgrDataWidth
        xor     edx, edx
        div     dword [BgrDataWidth]            ; edx := x mod BgrDataWidth
        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 WinMapAddress
dp3:
        cmp     [ebp+WinMapAddress], dl
        jnz     nbgp
        movsb
        movsb
        movsb
        jmp     @f
nbgp:
        add     esi, 3
        add     edi, 3
@@:
        cmp     [ScreenBPP], byte 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
        mov     eax, [BgrDataWidth]
        xor     edx, edx
        mov     ecx, [ScreenWidth]
        inc     ecx
        div     ecx
        push    eax     ; quo
        push    edx     ; rem
        mov     eax, [BgrDataHeight]
        xor     edx, edx
        mov     ecx, [ScreenHeight]
        inc     ecx
        div     ecx
        push    eax
        push    edx
; 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 WinMapAddress (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     [ScreenBPP], byte 24    ; 24 or 32 bpp ? - x size
        jz      @f
        add     ebp, eax
@@:
        add     ebp, [LFBAddress]
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
        call    calculate_edi
        xchg    edi, ebp
; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress
        push    ebx
; 2) Calculate offset in background memory block
        push    eax
        mov     eax, ebx
        mul     dword [BgrDataHeight]
        mov     ecx, [ScreenHeight]
        inc     ecx
        div     ecx             ; eax := y * BgrDataHeight / ScreenHeight
                                ; edx := (y * BgrDataHeight) mod ScreenHeight
        mov     esi, eax
        pop     eax
        push    edx             ; dword [esp] = (y * BgrDataHeight) mod ScreenHeight
                                ; dword [esp+4] = y * BgrDataHeight / ScreenHeight
        push    eax
        mov     ecx, [BgrDataWidth]
        lea     edx, [ecx*3]
        imul    edx, [BgrDataHeight]
        add     edx, [img_background]
        push    edx
        mul     ecx
        imul    esi, ecx
        dec     ecx
        push    ecx
        mov     ecx, [ScreenWidth]
        inc     ecx
        div     ecx             ; eax := x * BgrDataWidth / ScreenWidth
                                ; edx := (x * BgrDataWidth) mod ScreenWidth
        add     esi, eax
        lea     esi, [esi*3]
        add     esi, [img_background]
        push    ecx edx esi
; 3) Loop through redraw rectangle and copy background data
; Registers meaning:
; ecx = (x * BgrDataWidth) / ScreenWidth
; edx = (x * BgrDataWidth) mod ScreenWidth (used to fast recalculating of ecx,esi)
; esi -> bgr memory, edi -> output
; ebp = offset in WinMapAddress
; dword [esp] = saved esi
; dword [esp+4] = saved edx
; dword [esp+8] = saved ecx
; dword [esp+12] = BgrDataWidth-1, x-limit for overlapping of points
; dword [esp+16] = end of bgr memory (defines y-limit for overlapping of points)
; dword [esp+20] = x
; dword [esp+24] = (y * BgrDataHeight) mod ScreenHeight (used to fast recalculating of esi)
; dword [esp+28] = y
; precalculated constants:
; dword [esp+32] = BgrDataHeight mod ScreenHeight
; dword [esp+36] = BgrDataHeight div ScreenHeight
; dword [esp+40] = BgrDataWidth mod ScreenWidth
; dword [esp+44] = BgrDataWidth div ScreenWidth
sdp3:
        add     edx, [esp+40]
        cmp     [ebp+WinMapAddress], byte 1
        jnz     snbgp
        mov     al, [esi+2]
        shl     eax, 16
        mov     ax, [esi]
        cmp     ecx, [esp+12]
        jae     @f
        cmp     edx, [ScreenWidth]
        jb      @f
        mov     ebx, [esi+2]
        shr     ebx, 8
        call    overlapping_of_points
@@:
        mov     ebx, [esp+24]
        add     ebx, [esp+32]
        cmp     ebx, [ScreenHeight]
        jbe     @f
        mov     ebx, [BgrDataWidth]
        lea     ebx, [ebx*3]
        add     ebx, esi
        cmp     ebx, [esp+16]
        jae     @f
        mov     ebx, [ebx-1]
        shr     ebx, 8
        call    overlapping_of_points
@@:
        mov     [edi], ax
        shr     eax, 16
        mov     [edi+2], al
snbgp:
        cmp     [ScreenBPP], byte 25
        sbb     edi, -4
        add     ebp, 1
        mov     eax, [esp+20]
        add     eax, 1
        mov     [esp+20], eax
        cmp     eax, [draw_data+32+RECT.right]
        ja      sdp4
        mov     eax, [esp+44]
        add     ecx, eax
        lea     eax, [eax*3]
        add     esi, eax
;        add     edx, [esp+40]
        cmp     edx, [ScreenWidth]
        jbe     sdp3
        sub     edx, [ScreenWidth]
        add     ecx, 1
        add     esi, 3
        sub     edx, 1
        jmp     sdp3
sdp4:
; next y
        mov     ebx, [esp+28]
        add     ebx, 1
        mov     [esp+28], 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, [ScreenWidth]
        add     ebp, 1
        sub     edi, eax
        sub     edi, eax
        sub     edi, eax
        cmp     [ScreenBPP], byte 24
        jz      @f
        sub     edi, eax
@@:
        add     edi, [BytesPerScanLine]
; restore ecx,edx; advance esi to next background line
        pop     esi edx ecx
        push    ecx edx
        xor     ebx, ebx
        mov     eax, [esp+24-4]
        add     eax, [esp+32-4]
        cmp     eax, [ScreenHeight]
        jbe     @f
        sub     eax, [ScreenHeight]
        mov     ebx, 1
        sub     eax, ebx
@@:
        mov     [esp+24-4], eax
        add     ebx, [esp+36-4]
        lea     ebx, [ebx*3]
        imul    ebx, [BgrDataWidth]
        add     esi, ebx
        push    esi
        mov     eax, [draw_data+32+RECT.left]
        mov     [esp+20], eax
        jmp     sdp3
sdpdone:
        add     esp, 48
        popad
        mov     [EGA_counter],1
        call    VGA_drawbackground
        ret
 
overlapping_of_points:
        push    ecx edx edi
        mov     ecx, eax
        mov     edx, ebx
        movzx   eax, cl
        movzx   ebx, dl
        add     eax, ebx
        rcr     eax, 1
        movzx   edi, ax
        movzx   eax, ch
        movzx   ebx, dh
        add     eax, ebx
        rcr     eax, 1
        ror     edi, 8
        add     edi, eax
        shr     ecx, 8
        shr     edx, 8
        movzx   eax, ch
        movzx   ebx, dh
        add     eax, ebx
        rcr     eax, 1
        ror     edi, 8
        add     eax, edi
        ror     eax, 16
        pop     edi edx ecx
        ret

Rev 536	Rev 537
1	$Revision: 536 $	1	$Revision: 537 $
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;; ;;	3	;; ;;
4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;; VESA20.INC ;;	7	;; VESA20.INC ;;
8	;; ;;	8	;; ;;
9	;; Vesa 2.0 functions for MenuetOS ;;	9	;; Vesa 2.0 functions for MenuetOS ;;
10	;; ;;	10	;; ;;
11	;; Copyright 2002 Ville Turjanmaa ;;	11	;; Copyright 2002 Ville Turjanmaa ;;
12	;; Alexey, kgaz@crosswindws.net ;;	12	;; Alexey, kgaz@crosswindws.net ;;
13	;; - Voodoo compatible graphics ;;	13	;; - Voodoo compatible graphics ;;
14	;; Juan M. Caravaca ;;	14	;; Juan M. Caravaca ;;
15	;; - Graphics optimimizations eg. drawline ;;	15	;; - Graphics optimimizations eg. drawline ;;
16	;; ;;	16	;; ;;
17	;; See file COPYING for details ;;	17	;; See file COPYING for details ;;
18	;; ;;	18	;; ;;
19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
20		20
21	; If you're planning to write your own video driver I suggest	21	; If you're planning to write your own video driver I suggest
22	; you replace the VESA12.INC file and see those instructions.	22	; you replace the VESA12.INC file and see those instructions.
23		23
24	;ScreenWidth equ 0xfe00	24	;ScreenWidth equ 0xfe00
25	;ScreenHeight equ 0xfe04	25	;ScreenHeight equ 0xfe04
26	;BytesPerScanLine equ 0xfe08	26	;BytesPerScanLine equ 0xfe08
27	;LFBAddress equ 0xfe80	27	;LFBAddress equ 0xfe80
28	;ScreenBPP equ 0xfbf1	28	;ScreenBPP equ 0xfbf1
29	;WinMapAddress equ 0x460000	29	;WinMapAddress equ 0x460000
30		30
31		31
32		32
33	;*************************************************	33	;*************************************************
34	; getpixel	34	; getpixel
35	;	35	;
36	; in:	36	; in:
37	; eax = x coordinate	37	; eax = x coordinate
38	; ebx = y coordinate	38	; ebx = y coordinate
39	;	39	;
40	; ret:	40	; ret:
41	; ecx = 00 RR GG BB	41	; ecx = 00 RR GG BB
42		42
43	getpixel:	43	getpixel:
44	push eax ebx edx edi	44	push eax ebx edx edi
45	call dword [GETPIXEL]	45	call dword [GETPIXEL]
46	pop edi edx ebx eax	46	pop edi edx ebx eax
47	ret	47	ret
48		48
49	Vesa20_getpixel24:	49	Vesa20_getpixel24:
50	; eax = x	50	; eax = x
51	; ebx = y	51	; ebx = y
52	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	52	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
53	lea edi, [eax+eax2] ; edi = x3	53	lea edi, [eax+eax2] ; edi = x3
54	add edi, ebx ; edi = x3+(yy multiplier)	54	add edi, ebx ; edi = x3+(yy multiplier)
55	add edi, [LFBAddress] ; ebx = where pixel is in memory	55	add edi, [LFBAddress] ; ebx = where pixel is in memory
56	mov ecx, [edi]	56	mov ecx, [edi]
57	and ecx, 0xffffff	57	and ecx, 0xffffff
58	ret	58	ret
59		59
60	Vesa20_getpixel32:	60	Vesa20_getpixel32:
61	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	61	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
62	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)	62	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
63	add edi, [LFBAddress] ; ebx = where pixel is in memory	63	add edi, [LFBAddress] ; ebx = where pixel is in memory
64	mov ecx, [edi]	64	mov ecx, [edi]
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	sub eax, [putimg.real_sx]	166	sub eax, [putimg.real_sx]
167	;; imul eax, [putimg.source_bpp]	167	;; imul eax, [putimg.source_bpp]
168	; lea eax, [eax + eax * 2]	168	; lea eax, [eax + eax * 2]
169	call esi	169	call esi
170	add eax, [putimg.arg_0]	170	add eax, [putimg.arg_0]
171	mov [putimg.line_increment], eax	171	mov [putimg.line_increment], eax
172	; winmap new line increment	172	; winmap new line increment
173	mov eax, [ScreenWidth]	173	mov eax, [ScreenWidth]
174	inc eax	174	inc eax
175	sub eax, [putimg.real_sx]	175	sub eax, [putimg.real_sx]
176	mov [putimg.winmap_newline], eax	176	mov [putimg.winmap_newline], eax
177	; screen new line increment	177	; screen new line increment
178	mov eax, [BytesPerScanLine]	178	mov eax, [BytesPerScanLine]
179	mov ecx, [putimg.real_sx]	179	mov ecx, [putimg.real_sx]
180	movzx ebx, byte [ScreenBPP]	180	movzx ebx, byte [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	movzx ebx, byte [ScreenBPP]	191	movzx ebx, byte [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	add edx, [LFBAddress]	195	add edx, [LFBAddress]
196	; pointer to pixel map	196	; pointer to pixel map
197	mov eax, [putimg.abs_cy]	197	mov eax, [putimg.abs_cy]
198	imul eax, [ScreenWidth]	198	imul eax, [ScreenWidth]
199	add eax, [putimg.abs_cy]	199	add eax, [putimg.abs_cy]
200	add eax, [putimg.abs_cx]	200	add eax, [putimg.abs_cx]
201	add eax, WinMapAddress	201	add eax, WinMapAddress
202	xchg eax, ebp	202	xchg eax, ebp
203	; get process number	203	; get process number
204	mov ebx, [CURRENT_TASK]	204	mov ebx, [CURRENT_TASK]
205	cmp byte [ScreenBPP], 32	205	cmp byte [ScreenBPP], 32
206	je put_image_end_32	206	je put_image_end_32
207	;put_image_end_24:	207	;put_image_end_24:
208	mov edi, [putimg.real_sy]	208	mov edi, [putimg.real_sy]
209	align 4	209	align 4
210	.new_line:	210	.new_line:
211	mov ecx, [putimg.real_sx]	211	mov ecx, [putimg.real_sx]
212	; push ebp edx	212	; push ebp edx
213	align 4	213	align 4
214	.new_x:	214	.new_x:
215	push [putimg.edi]	215	push [putimg.edi]
216	mov eax, [putimg.ebp+4]	216	mov eax, [putimg.ebp+4]
217	call eax	217	call eax
218	cmp [ebp], bl	218	cmp [ebp], bl
219	jne .skip	219	jne .skip
220	; mov eax, [esi] ; eax = RRBBGGRR	220	; mov eax, [esi] ; eax = RRBBGGRR
221	mov [edx], ax	221	mov [edx], ax
222	shr eax, 16	222	shr eax, 16
223	mov [edx+2], al	223	mov [edx+2], al
224	.skip:	224	.skip:
225	; add esi, 3 ;[putimg.source_bpp]	225	; add esi, 3 ;[putimg.source_bpp]
226	add edx, 3	226	add edx, 3
227	inc ebp	227	inc ebp
228	dec ecx	228	dec ecx
229	jnz .new_x	229	jnz .new_x
230	; pop edx ebp	230	; pop edx ebp
231	add esi, [putimg.line_increment]	231	add esi, [putimg.line_increment]
232	add edx, [putimg.screen_newline] ;[BytesPerScanLine]	232	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
233	add ebp, [putimg.winmap_newline] ;[ScreenWidth]	233	add ebp, [putimg.winmap_newline] ;[ScreenWidth]
234	; inc ebp	234	; inc ebp
235	dec edi	235	dec edi
236	jnz .new_line	236	jnz .new_line
237	.finish:	237	.finish:
238	add esp, putimg.stack_data	238	add esp, putimg.stack_data
239	popad	239	popad
240	ret	240	ret
241		241
242	put_image_end_32:	242	put_image_end_32:
243	mov edi, [putimg.real_sy]	243	mov edi, [putimg.real_sy]
244	align 4	244	align 4
245	.new_line:	245	.new_line:
246	mov ecx, [putimg.real_sx]	246	mov ecx, [putimg.real_sx]
247	; push ebp edx	247	; push ebp edx
248	align 4	248	align 4
249	.new_x:	249	.new_x:
250	push [putimg.edi]	250	push [putimg.edi]
251	mov eax, [putimg.ebp+4]	251	mov eax, [putimg.ebp+4]
252	call eax	252	call eax
253	cmp [ebp], bl	253	cmp [ebp], bl
254	jne .skip	254	jne .skip
255	; mov eax, [esi] ; ecx = RRBBGGRR	255	; mov eax, [esi] ; ecx = RRBBGGRR
256	mov [edx], eax	256	mov [edx], eax
257	.skip:	257	.skip:
258	; add esi, [putimg.source_bpp]	258	; add esi, [putimg.source_bpp]
259	add edx, 4	259	add edx, 4
260	inc ebp	260	inc ebp
261	dec ecx	261	dec ecx
262	jnz .new_x	262	jnz .new_x
263	; pop edx ebp	263	; pop edx ebp
264	add esi, [putimg.line_increment]	264	add esi, [putimg.line_increment]
265	add edx, [putimg.screen_newline] ;[BytesPerScanLine]	265	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
266	add ebp, [putimg.winmap_newline] ;[ScreenWidth]	266	add ebp, [putimg.winmap_newline] ;[ScreenWidth]
267	; inc ebp	267	; inc ebp
268	dec edi	268	dec edi
269	jnz .new_line	269	jnz .new_line
270	.finish:	270	.finish:
271	add esp, putimg.stack_data	271	add esp, putimg.stack_data
272	popad	272	popad
273	call VGA__putimage	273	call VGA__putimage
274	mov [EGA_counter],1	274	mov [EGA_counter],1
275	ret	275	ret
276		276
277		277
278	;*************************************************	278	;*************************************************
279	align 4	279	align 4
280	__sys_putpixel:	280	__sys_putpixel:
281		281
282	; eax = x coordinate	282	; eax = x coordinate
283	; ebx = y coordinate	283	; ebx = y coordinate
284	; ecx = ?? RR GG BB ; 0x01000000 negation	284	; ecx = ?? RR GG BB ; 0x01000000 negation
285	; edi = 0x00000001 force	285	; edi = 0x00000001 force
286		286
287	;;; mov [novesachecksum], dword 0	287	;;; mov [novesachecksum], dword 0
288	pushad	288	pushad
289	test edi,1 ; force ?	289	test edi,1 ; force ?
290	jnz .forced	290	jnz .forced
291	; not forced:	291	; not forced:
292	push ecx ; save 24th bit in case negative pixel wanted	292	push ecx ; save 24th bit in case negative pixel wanted
293	call checkpixel	293	call checkpixel
294	test ecx,ecx	294	test ecx,ecx
295	pop ecx	295	pop ecx
296	jnz .exit	296	jnz .exit
297	.forced:	297	.forced:
298	cmp [ScreenWidth], eax	298	cmp [ScreenWidth], eax
299	jb .exit	299	jb .exit
300	cmp [ScreenHeight], ebx	300	cmp [ScreenHeight], ebx
301	jb .exit	301	jb .exit
302	.ok:	302	.ok:
303	; check if negation	303	; check if negation
304	test ecx,0x01000000	304	test ecx,0x01000000
305	jz .noneg	305	jz .noneg
306	call getpixel	306	call getpixel
307	not ecx	307	not ecx
308	mov [esp+32-8],ecx	308	mov [esp+32-8],ecx
309	.noneg:	309	.noneg:
310	; OK to set pixel	310	; OK to set pixel
311	call dword [PUTPIXEL] ; call the real put_pixel function	311	call dword [PUTPIXEL] ; call the real put_pixel function
312	.exit:	312	.exit:
313	popad	313	popad
314	ret	314	ret
315		315
316	align 4	316	align 4
317	Vesa20_putpixel24:	317	Vesa20_putpixel24:
318	; eax = x	318	; eax = x
319	; ebx = y	319	; ebx = y
320	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	320	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
321	lea edi, [eax+eax2] ; edi = x3	321	lea edi, [eax+eax2] ; edi = x3
322	mov eax, [esp+32-8+4]	322	mov eax, [esp+32-8+4]
323	add edi, [LFBAddress]	323	add edi, [LFBAddress]
324	add edi, ebx ; ebx = where to put pixel in memory	324	add edi, ebx ; ebx = where to put pixel in memory
325	mov [edi], ax	325	mov [edi], ax
326	shr eax, 16	326	shr eax, 16
327	mov [edi+2], al	327	mov [edi+2], al
328	ret	328	ret
329		329
330		330
331	align 4	331	align 4
332	Vesa20_putpixel32:	332	Vesa20_putpixel32:
333	; eax = x	333	; eax = x
334	; ebx = y	334	; ebx = y
335	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	335	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
336	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)	336	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
337	mov eax, [esp+32-8+4] ; eax = color	337	mov eax, [esp+32-8+4] ; eax = color
338	add edi, [LFBAddress] ; ebx = where to put pixel in memory	338	add edi, [LFBAddress] ; ebx = where to put pixel in memory
339	mov [edi], eax	339	mov [edi], eax
340	ret	340	ret
341		341
342	;*************************************************	342	;*************************************************
343		343
344	;align 4	344	;align 4
345	calculate_edi:	345	calculate_edi:
346	mov edi, ebx	346	mov edi, ebx
347	imul edi, [ScreenWidth]	347	imul edi, [ScreenWidth]
348	add edi, ebx	348	add edi, ebx
349	add edi, eax	349	add edi, eax
350	ret	350	ret
351		351
352	;*************************************************	352	;*************************************************
353		353
354	; DRAWLINE	354	; DRAWLINE
355		355
356	align 4	356	align 4
357	__sys_draw_line:	357	__sys_draw_line:
358	; inc [mouse_pause]	358	; inc [mouse_pause]
359	call [disable_mouse]	359	call [disable_mouse]
360		360
361	; draw a line	361	; draw a line
362	; eax = HIWORD = x1	362	; eax = HIWORD = x1
363	; LOWORD = x2	363	; LOWORD = x2
364	; ebx = HIWORD = y1	364	; ebx = HIWORD = y1
365	; LOWORD = y2	365	; LOWORD = y2
366	; ecx = color	366	; ecx = color
367	; edi = force ?	367	; edi = force ?
368	pusha	368	pusha
369		369
370	dl_x1 equ esp+20	370	dl_x1 equ esp+20
371	dl_y1 equ esp+16	371	dl_y1 equ esp+16
372	dl_x2 equ esp+12	372	dl_x2 equ esp+12
373	dl_y2 equ esp+8	373	dl_y2 equ esp+8
374	dl_dx equ esp+4	374	dl_dx equ esp+4
375	dl_dy equ esp+0	375	dl_dy equ esp+0
376		376
377	xor edx, edx ; clear edx	377	xor edx, edx ; clear edx
378	xor esi, esi ; unpack arguments	378	xor esi, esi ; unpack arguments
379	xor ebp, ebp	379	xor ebp, ebp
380	mov si, ax ; esi = x2	380	mov si, ax ; esi = x2
381	mov bp, bx ; ebp = y2	381	mov bp, bx ; ebp = y2
382	shr eax, 16 ; eax = x1	382	shr eax, 16 ; eax = x1
383	shr ebx, 16 ; ebx = y1	383	shr ebx, 16 ; ebx = y1
384	push eax ; save x1	384	push eax ; save x1
385	push ebx ; save y1	385	push ebx ; save y1
386	push esi ; save x2	386	push esi ; save x2
387	push ebp ; save y2	387	push ebp ; save y2
388	; checking x-axis...	388	; checking x-axis...
389	sub esi, eax ; esi = x2-x1	389	sub esi, eax ; esi = x2-x1
390	push esi ; save y2-y1	390	push esi ; save y2-y1
391	jl .x2lx1 ; is x2 less than x1 ?	391	jl .x2lx1 ; is x2 less than x1 ?
392	jg .no_vline ; x1 > x2 ?	392	jg .no_vline ; x1 > x2 ?
393	mov edx, ebp ; else (if x1=x2)	393	mov edx, ebp ; else (if x1=x2)
394	call vline	394	call vline
395	push edx ; necessary to rightly restore stack frame at .exit	395	push edx ; necessary to rightly restore stack frame at .exit
396	jmp .exit	396	jmp .exit
397	.x2lx1:	397	.x2lx1:
398	neg esi ; get esi absolute value	398	neg esi ; get esi absolute value
399	.no_vline:	399	.no_vline:
400	; checking y-axis...	400	; checking y-axis...
401	sub ebp, ebx ; ebp = y2-y1	401	sub ebp, ebx ; ebp = y2-y1
402	push ebp ; save y2-y1	402	push ebp ; save y2-y1
403	jl .y2ly1 ; is y2 less than y1 ?	403	jl .y2ly1 ; is y2 less than y1 ?
404	jg .no_hline ; y1 > y2 ?	404	jg .no_hline ; y1 > y2 ?
405	mov edx, [dl_x2] ; else (if y1=y2)	405	mov edx, [dl_x2] ; else (if y1=y2)
406	call hline	406	call hline
407	jmp .exit	407	jmp .exit
408		408
409	.y2ly1:	409	.y2ly1:
410	neg ebp ; get ebp absolute value	410	neg ebp ; get ebp absolute value
411	.no_hline:	411	.no_hline:
412	cmp ebp, esi	412	cmp ebp, esi
413	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?	413	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?
414	cmp [dl_y2], ebx ; make sure y1 is at the begining	414	cmp [dl_y2], ebx ; make sure y1 is at the begining
415	jge .no_reverse1	415	jge .no_reverse1
416	neg dword [dl_dx]	416	neg dword [dl_dx]
417	mov edx, [dl_x2]	417	mov edx, [dl_x2]
418	mov [dl_x2], eax	418	mov [dl_x2], eax
419	mov [dl_x1], edx	419	mov [dl_x1], edx
420	mov edx, [dl_y2]	420	mov edx, [dl_y2]
421	mov [dl_y2], ebx	421	mov [dl_y2], ebx
422	mov [dl_y1], edx	422	mov [dl_y1], edx
423	.no_reverse1:	423	.no_reverse1:
424	mov eax, [dl_dx]	424	mov eax, [dl_dx]
425	cdq ; extend eax sing to edx	425	cdq ; extend eax sing to edx
426	shl eax, 16 ; using 16bit fix-point maths	426	shl eax, 16 ; using 16bit fix-point maths
427	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)	427	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)
428	mov edx, ebp ; edx = counter (number of pixels to draw)	428	mov edx, ebp ; edx = counter (number of pixels to draw)
429	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0	429	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0
430	mov esi, eax ; esi = dx	430	mov esi, eax ; esi = dx
431	jmp .y_rules	431	jmp .y_rules
432		432
433	.x_rules:	433	.x_rules:
434	cmp [dl_x2], eax ; make sure x1 is at the begining	434	cmp [dl_x2], eax ; make sure x1 is at the begining
435	jge .no_reverse2	435	jge .no_reverse2
436	neg dword [dl_dy]	436	neg dword [dl_dy]
437	mov edx, [dl_x2]	437	mov edx, [dl_x2]
438	mov [dl_x2], eax	438	mov [dl_x2], eax
439	mov [dl_x1], edx	439	mov [dl_x1], edx
440	mov edx, [dl_y2]	440	mov edx, [dl_y2]
441	mov [dl_y2], ebx	441	mov [dl_y2], ebx
442	mov [dl_y1], edx	442	mov [dl_y1], edx
443	.no_reverse2:	443	.no_reverse2:
444	xor edx, edx	444	xor edx, edx
445	mov eax, [dl_dy]	445	mov eax, [dl_dy]
446	cdq ; extend eax sing to edx	446	cdq ; extend eax sing to edx
447	shl eax, 16 ; using 16bit fix-point maths	447	shl eax, 16 ; using 16bit fix-point maths
448	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)	448	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)
449	mov edx, esi ; edx = counter (number of pixels to draw)	449	mov edx, esi ; edx = counter (number of pixels to draw)
450	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0	450	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0
451	mov ebp, eax ; ebp = dy	451	mov ebp, eax ; ebp = dy
452	.y_rules:	452	.y_rules:
453	mov eax, [dl_x1]	453	mov eax, [dl_x1]
454	mov ebx, [dl_y1]	454	mov ebx, [dl_y1]
455	shl eax, 16	455	shl eax, 16
456	shl ebx, 16	456	shl ebx, 16
457	align 4	457	align 4
458	.draw:	458	.draw:
459	push eax ebx	459	push eax ebx
460	shr eax, 16	460	shr eax, 16
461	shr ebx, 16	461	shr ebx, 16
462	call [putpixel]	462	call [putpixel]
463	pop ebx eax	463	pop ebx eax
464	add ebx, ebp ; y = y+dy	464	add ebx, ebp ; y = y+dy
465	add eax, esi ; x = x+dx	465	add eax, esi ; x = x+dx
466	dec edx	466	dec edx
467	jnz .draw	467	jnz .draw
468	; force last drawn pixel to be at (x2,y2)	468	; force last drawn pixel to be at (x2,y2)
469	mov eax, [dl_x2]	469	mov eax, [dl_x2]
470	mov ebx, [dl_y2]	470	mov ebx, [dl_y2]
471	call [putpixel]	471	call [putpixel]
472	.exit:	472	.exit:
473	add esp, 6*4	473	add esp, 6*4
474	popa	474	popa
475	; dec [mouse_pause]	475	; dec [mouse_pause]
476	call [draw_pointer]	476	call [draw_pointer]
477	ret	477	ret
478		478
479		479
480	hline:	480	hline:
481	; draw an horizontal line	481	; draw an horizontal line
482	; eax = x1	482	; eax = x1
483	; edx = x2	483	; edx = x2
484	; ebx = y	484	; ebx = y
485	; ecx = color	485	; ecx = color
486	; edi = force ?	486	; edi = force ?
487	push eax edx	487	push eax edx
488	cmp edx, eax ; make sure x2 is above x1	488	cmp edx, eax ; make sure x2 is above x1
489	jge @f	489	jge @f
490	xchg eax, edx	490	xchg eax, edx
491	align 4	491	align 4
492	@@:	492	@@:
493	call [putpixel]	493	call [putpixel]
494	inc eax	494	inc eax
495	cmp eax, edx	495	cmp eax, edx
496	jle @b	496	jle @b
497	pop edx eax	497	pop edx eax
498	ret	498	ret
499		499
500		500

Subversion Repositories Kolibri OS

(root)/kernel/tags/kolibri0.7.0.0/video/vesa20.inc – Rev 536 → 537