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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 593 → 753