WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-A/trunk/video/vesa20.inc


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-A/trunk/video/vesa20.inc – Rev 1505 → 1664