Subversion Repositories Kolibri OS

$Revision: 546 $

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;  VESA20.INC                                                  ;;

;;                                                              ;;

;;  Vesa 2.0 functions for MenuetOS                             ;;

;;                                                              ;;

;;  Copyright 2002 Ville Turjanmaa                              ;;

;;  Alexey, kgaz@crosswindws.net                                ;;

;;  - Voodoo compatible graphics                                ;;

;;  Juan M. Caravaca                                            ;;

;;  - Graphics optimimizations eg. drawline                     ;;

;;                                                              ;;

;;  See file COPYING for details                                ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; If you're planning to write your own video driver I suggest

; you replace the VESA12.INC file and see those instructions.

;ScreenWidth             equ     0xfe00

;ScreenHeight            equ     0xfe04

;BytesPerScanLine        equ     0xfe08

;LFBAddress              equ     0xfe80

;ScreenBPP               equ     0xfbf1

;WinMapAddress           equ     0x460000

;*************************************************

; getpixel

;

; in:

; eax = x coordinate

; ebx = y coordinate

;

; ret:

; ecx = 00 RR GG BB

getpixel:

     push    eax ebx edx edi

     call    dword [GETPIXEL]

     pop     edi edx ebx eax

     ret

Vesa20_getpixel24:

; eax = x

; ebx = y

     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier

     lea     edi, [eax+eax*2] ; edi = x*3

     add     edi, ebx         ; edi = x*3+(y*y multiplier)

     add     edi, [LFBAddress]    ; ebx = where pixel is in memory

     mov     ecx, [edi]

     and     ecx, 0xffffff

     ret

Vesa20_getpixel32:

     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier

     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)

     add     edi, [LFBAddress]    ; ebx = where pixel is in memory

     mov     ecx, [edi]

     and     ecx, 0xffffff

     ret

;*************************************************

virtual at esp

 putimg:

   .real_sx        dd ?

   .real_sy        dd ?

   .image_sx       dd ?

   .image_sy       dd ?

   .image_cx       dd ?

   .image_cy       dd ?

   .pti            dd ?

   .abs_cx         dd ?

   .abs_cy         dd ?

   .line_increment dd ?

   .winmap_newline dd ?

   .screen_newline dd ?

   .stack_data = 4*12

   .edi         dd      ?

   .esi         dd      ?

   .ebp         dd      ?

   .esp         dd      ?

   .ebx         dd      ?

   .edx         dd      ?

   .ecx         dd      ?

   .eax         dd      ?

   .ret_addr    dd      ?

   .arg_0       dd      ?

end virtual

align 16

; ebx = pointer

; ecx = size [x|y]

; edx = coordinates [x|y]

; ebp = pointer to 'get' function

; esi = pointer to 'init' function

; edi = parameter for 'get' function

vesa20_putimage:

     pushad

     call    [disable_mouse]

     sub     esp, putimg.stack_data

; save pointer to image

     mov     [putimg.pti], ebx

; unpack the size

     mov     eax, ecx

     and     ecx, 0xFFFF

     shr     eax, 16

     mov     [putimg.image_sx], eax

     mov     [putimg.image_sy], ecx

; unpack the coordinates

     mov     eax, edx

     and     edx, 0xFFFF

     shr     eax, 16

     mov     [putimg.image_cx], eax

     mov     [putimg.image_cy], edx

; calculate absolute (i.e. screen) coordinates

     mov     eax, [TASK_BASE]

     mov     ebx, [eax-twdw + WDATA.box.left]

     add     ebx, [putimg.image_cx]

     mov     [putimg.abs_cx], ebx

     mov     ebx, [eax-twdw + WDATA.box.top]

     add     ebx, [putimg.image_cy]

     mov     [putimg.abs_cy], ebx

; real_sx = MIN(wnd_sx-image_cx, image_sx);

     mov     ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx

; \begin{diamond}[20.08.2006]

; note that WDATA.box.width is one pixel less than real window x-size

     inc     ebx

; \end{diamond}[20.08.2006]

     sub     ebx, [putimg.image_cx]

     ja      @f

     add     esp, putimg.stack_data

     popad

     ret

@@:

     cmp     ebx, [putimg.image_sx]

     jbe     .end_x

     mov     ebx, [putimg.image_sx]

.end_x:

     mov     [putimg.real_sx], ebx

; init real_sy

     mov     ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy

; \begin{diamond}[20.08.2006]

     inc     ebx

; \end{diamond}[20.08.2006]

     sub     ebx, [putimg.image_cy]

     ja      @f

     add     esp, putimg.stack_data

     popad

     ret

@@:

     cmp     ebx, [putimg.image_sy]

     jbe     .end_y

     mov     ebx, [putimg.image_sy]

.end_y:

     mov     [putimg.real_sy], ebx

; line increment

     mov     eax, [putimg.image_sx]

     sub     eax, [putimg.real_sx]

;;     imul    eax, [putimg.source_bpp]

;     lea     eax, [eax + eax * 2]

     call    esi

     add     eax, [putimg.arg_0]

     mov     [putimg.line_increment], eax

; winmap new line increment

     mov     eax, [ScreenWidth]

     inc     eax

     sub     eax, [putimg.real_sx]

     mov     [putimg.winmap_newline], eax

; screen new line increment

     mov     eax, [BytesPerScanLine]

     mov     ecx, [putimg.real_sx]

     movzx   ebx, byte [ScreenBPP]

     shr     ebx, 3

     imul    ecx, ebx

     sub     eax, ecx

     mov     [putimg.screen_newline], eax

; pointer to image

     mov     esi, [putimg.pti]

; pointer to screen

     mov     edx, [putimg.abs_cy]

     imul    edx, [BytesPerScanLine]

     mov     eax, [putimg.abs_cx]

     movzx   ebx, byte [ScreenBPP]

     shr     ebx, 3

     imul    eax, ebx

     add     edx, eax

     add     edx, [LFBAddress]

; pointer to pixel map

     mov     eax, [putimg.abs_cy]

     imul    eax, [ScreenWidth]

     add     eax, [putimg.abs_cy]

     add     eax, [putimg.abs_cx]

     add     eax, WinMapAddress

     xchg    eax, ebp

; get process number

     mov     ebx, [CURRENT_TASK]

     cmp     byte [ScreenBPP], 32

     je      put_image_end_32

;put_image_end_24:

     mov     edi, [putimg.real_sy]

align   4

.new_line:

     mov     ecx, [putimg.real_sx]

;     push    ebp edx

align   4

.new_x:

     push    [putimg.edi]

     mov     eax, [putimg.ebp+4]

     call    eax

     cmp     [ebp], bl

     jne     .skip

;     mov     eax, [esi]        ; eax = RRBBGGRR

     mov     [edx], ax

     shr     eax, 16

     mov     [edx+2], al

.skip:

;     add     esi, 3 ;[putimg.source_bpp]

     add     edx, 3

     inc     ebp

     dec     ecx

     jnz     .new_x

;     pop     edx ebp

     add     esi, [putimg.line_increment]

     add     edx, [putimg.screen_newline] ;[BytesPerScanLine]

     add     ebp, [putimg.winmap_newline] ;[ScreenWidth]

;     inc     ebp

     dec     edi

     jnz     .new_line

.finish:

     add     esp, putimg.stack_data

     popad

     ret