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

 ;;                                                              ;;
 ;;  See file COPYING for details                                ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 914 $
+$Revision: 928 $
-; 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
+; If you're planning to write your own video driver I suggest
-;ScreenBPP               equ     0xfbf1
+; you replace the VESA12.INC file and see those instructions.
 ; ret:
 ; ecx = 00 RR GG BB
 getpixel:
      push    eax ebx edx edi
-     call    dword [GETPIXEL]
+     call    [get_pixel]
      pop     edi edx ebx eax
      ret
 Vesa20_getpixel24:
 ; eax = x
 ; ebx = y
      imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
+     lea     edi, [eax+eax*2] ; edi = x*3
-     lea     edi, [eax+eax*2] ; edi = x*3
+     add     edi, ebx         ; edi = x*3+(y*y multiplier)
+if SHADOWFB
-     add     edi, ebx         ; edi = x*3+(y*y multiplier)
+     mov     ecx, [SHADOWFB+edi]
+else
-     add     edi, [LFBAddress]    ; ebx = where pixel is in memory
+     mov     ecx, [LFB_BASE+edi]
-     mov     ecx, [edi]
+end if
      and     ecx, 0xffffff
      ret
+Vesa20_getpixel32:
-Vesa20_getpixel32:
+     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
+     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
-     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
+if SHADOWFB
+     mov     ecx, [SHADOWFB+edi]
-     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
+else
-     add     edi, [LFBAddress]    ; ebx = where pixel is in memory
+     mov     ecx, [LFB_BASE+edi]
-     mov     ecx, [edi]
+end if
      inc     eax
      sub     eax, [putimg.real_sx]
      mov     [putimg.winmap_newline], eax
 ; screen new line increment
      mov     eax, [BytesPerScanLine]
-     movzx   ebx, byte [ScreenBPP]
+     mov     ebx, [ScreenBPP]
      shr     ebx, 3
      imul    ecx, ebx
      sub     eax, ecx
      mov     [putimg.screen_newline], eax
 ; pointer to image
      mov     esi, [putimg.pti]
 ; pointer to screen
      mov     edx, [putimg.abs_cy]
      imul    edx, [BytesPerScanLine]
      mov     eax, [putimg.abs_cx]
-     movzx   ebx, byte [ScreenBPP]
+     mov     ebx, [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]
      mov     eax, [putimg.ebp+4]
      call    eax
      cmp     [ebp], bl
      jne     .skip
 ;     mov     eax, [esi]        ; eax = RRBBGGRR
+if SHADOWFB
+     mov     [SHADOWFB+edx], ax
+end if
-     mov     [edx], ax
+     mov     [LFB_BASE+edx], ax
      shr     eax, 16
+if SHADOWFB
+     mov     [SHADOWFB+edx+2], al
+end if
-     mov     [edx+2], al
+     mov     [LFB_BASE+edx+2], al
 .skip:
 ;     add     esi, 3 ;[putimg.source_bpp]
      add     edx, 3
      inc     ebp
      dec     ecx
      mov     eax, [putimg.ebp+4]
      call    eax
      cmp     [ebp], bl
      jne     .skip
 ;     mov     eax, [esi]        ; ecx = RRBBGGRR
+if SHADOWFB
+     mov     [SHADOWFB+edx], eax
+end if
-     mov     [edx], eax
+     mov     [LFB_BASE+edx], eax
 .skip:
 ;     add     esi, [putimg.source_bpp]
      add     edx, 4
      inc     ebp
      dec     ecx
      call  getpixel
      not   ecx
      mov   [esp+32-8],ecx
 .noneg:
 ; OK to set pixel
-     call  dword [PUTPIXEL]    ; call the real put_pixel function
+     call  [put_pixel]    ; call the real put_pixel function
 .exit:
      popad
      ret
 ; 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]
+if SHADOWFB
-     add     edi, ebx          ; ebx = where to put pixel in memory
+     mov     [SHADOWFB+ebx+edi], ax
+end if
-     mov     [edi], ax
+     mov     [LFB_BASE+ebx+edi], ax
      shr     eax, 16
+if SHADOWFB
+     mov     [SHADOWFB+ebx+edi+2], al
+end if
-     mov     [edi+2], al
+     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)
-     lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
+     mov     eax, [esp+32-8+4] ; eax = color
+if SHADOWFB
-     mov     eax, [esp+32-8+4] ; eax = color
+     mov     [SHADOWFB+edi], eax
-     add     edi, [LFBAddress]     ; ebx = where to put pixel in memory
+end if
-     mov     [edi], eax
+     mov     [LFB_BASE+edi], eax
      ret
      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]
+     mov     ebx, [ScreenBPP]
      shr     ebx, 3
      imul    eax, ebx
      neg     eax
      add     eax, [BytesPerScanLine]
      mov     [drbar.line_inc_scr], eax
 ; pointer to screen
      mov     edx, [drbar.abs_cy]
      imul    edx, [BytesPerScanLine]
      mov     eax, [drbar.abs_cx]
-;     movzx   ebx, byte [ScreenBPP]
+;     mov    ebx, [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]
      mov     edi, [drbar.real_sx]
 align   4
 .new_x:
      cmp     byte [ebp], bl
      jne     .skip
+if SHADOWFB
-     mov     [edx], bh
+     mov     [SHADOWFB+edx], bh
-     mov     [edx + 1], ax
+     mov     [SHADOWFB+edx + 1], ax
+end if
+     mov     [LFB_BASE+edx], bh
+     mov     [LFB_BASE+edx + 1], ax
 .skip:
 ; add pixel
      add     edx, 3
      inc     ebp
      dec     edi
      mov     edi, [drbar.real_sx]
 align   4
 .new_x:
      cmp     byte [ebp], bl
      jne     .skip
+if SHADOWFB
+     mov     [SHADOWFB+edx], eax
+end if
-     mov     [edx], eax
+     mov     [LFB_BASE+edx], eax
 .skip:
 ; add pixel
      add     edx, 4
      inc     ebp
      dec     edi
      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,display_data ; -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,display_data
-;        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]
         mul     ebx
         xchg    ebp, eax
         add     ebp, eax
         add     ebp, eax
         add     ebp, eax
-        cmp     [ScreenBPP], byte 24    ; 24 or 32 bpp ? - x size
+        cmp     byte [ScreenBPP], 24    ; 24 or 32 bpp ? - x size
         jz      @f
         add     ebp, eax
 @@:
-        add     ebp, [LFBAddress]
+       ; add     ebp, LFB_BASE
 ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
         call    calculate_edi
         xchg    edi, ebp
         jmp     @f
 nbgp:
         add     esi, 3
         add     edi, 3
 @@:
-        cmp     [ScreenBPP], byte 25    ; 24 or 32 bpp?
+        cmp     byte [ScreenBPP], 25    ; 24 or 32 bpp?
         sbb     edi, -1         ; +1 for 32 bpp
 ; I do not use 'inc eax' because this is slightly slower then 'add eax,1'
         add     ebp, edx
         add     eax, edx
         cmp     eax, [draw_data+32+RECT.right]
         mul     ebx
         xchg    ebp, eax
         add     ebp, eax
         add     ebp, eax
         add     ebp, eax
-        cmp     [ScreenBPP], byte 24    ; 24 or 32 bpp ? - x size
+        cmp     byte [ScreenBPP], 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 display_data
         push    ebx
         test    ecx, ecx
         jz      .novert
         mov     ebx, [bgr_next_line+esi]
         call    [overlapping_of_points_ptr]
 .novert:
+if SHADOWFB
+        mov     [SHADOWFB+edi], ax
+end if
-        mov     [edi], ax
+        mov     [LFB_BASE+edi], ax
         shr     eax, 16
+if SHADOWFB
+        mov     [SHADOWFB+edi+2], al
+end if
-        mov     [edi+2], al
+        mov     [LFB_BASE+edi+2], al
 snbgp:
-        cmp     [ScreenBPP], byte 25
+        cmp     byte [ScreenBPP], 25
         sbb     edi, -4
         add     ebp, 1
         mov     eax, [esp+20]
         add     eax, 1
         mov     [esp+20], eax
         add     ebp, [Screen_Max_X]
         add     ebp, 1
         sub     edi, eax
         sub     edi, eax
         sub     edi, eax
-        cmp     [ScreenBPP], byte 24
+        cmp     byte [ScreenBPP], 24
         jz      @f
         sub     edi, eax
 @@:
         add     edi, [BytesPerScanLine]
 ; restore ecx,edx; advance esi to next background line

Subversion Repositories Kolibri OS

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