2 * VGA hardware emulation
4 * Copyright 1998 Ove Kåven (with some help from Marcus Meissner)
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(ddraw
);
39 static IDirectDraw
*lpddraw
= NULL
;
40 static IDirectDrawSurface
*lpddsurf
;
41 static IDirectDrawPalette
*lpddpal
;
42 static DDSURFACEDESC sdesc
;
44 static BOOL vga_retrace_vertical
;
45 static BOOL vga_retrace_horizontal
;
48 * Size and location of VGA controller window to framebuffer.
50 * Note: We support only single window even though some
51 * controllers support two. This should not be changed unless
52 * there are programs that depend on having two windows.
54 #define VGA_WINDOW_SIZE (64 * 1024)
55 #define VGA_WINDOW_START ((char *)0xa0000)
58 * VGA controller memory is emulated using linear framebuffer.
59 * This frambuffer also acts as an interface
60 * between VGA controller emulation and DirectDraw.
62 * vga_fb_width: Display width in pixels. Can be modified when
63 * display mode is changed.
64 * vga_fb_height: Display height in pixels. Can be modified when
65 * display mode is changed.
66 * vga_fb_depth: Number of bits used to store single pixel color information.
67 * Each pixel uses (vga_fb_depth+7)/8 bytes because
68 * 1-16 color modes are mapped to 256 color mode.
69 * Can be modified when display mode is changed.
70 * vga_fb_pitch: How many bytes to add to pointer in order to move
71 * from one row to another. This is fixed in VGA modes,
72 * but can be modified in SVGA modes.
73 * vga_fb_offset: Offset added to framebuffer start address in order
74 * to find the display origin. Programs use this to do
75 * double buffering and to scroll display. The value can
76 * be modified in VGA and SVGA modes.
77 * vga_fb_size: How many bytes are allocated to framebuffer.
78 * VGA framebuffers are always larger than display size and
79 * SVGA framebuffers may also be.
80 * vga_fb_data: Pointer to framebuffer start.
81 * vga_fb_window: Offset of 64k window 0xa0000 in bytes from framebuffer start.
82 * This value is >= 0, if mode uses linear framebuffer and
83 * -1, if mode uses color planes. This value is fixed
84 * in all modes except 0x13 (256 color VGA) where
85 * 0 means normal mode and -1 means Mode-X (unchained mode).
87 static int vga_fb_width
;
88 static int vga_fb_height
;
89 static int vga_fb_depth
;
90 static int vga_fb_pitch
;
91 static int vga_fb_offset
;
92 static int vga_fb_size
= 0;
93 static char *vga_fb_data
= 0;
94 static int vga_fb_window
= 0;
99 * vga_text_attr: Current active attribute.
100 * vga_text_old: Last data sent to console.
101 * This is used to optimize console updates.
102 * vga_text_width: Width of the text display in characters.
103 * vga_text_height: Height of the text display in characters.
104 * vga_text_x: Current cursor X-position. Starts from zero.
105 * vga_text_y: Current cursor Y-position. Starts from zero.
106 * vga_text_console: TRUE if stdout is console,
107 * FALSE if it is regular file.
109 static BYTE vga_text_attr
;
110 static char *vga_text_old
= NULL
;
111 static BYTE vga_text_width
;
112 static BYTE vga_text_height
;
113 static BYTE vga_text_x
;
114 static BYTE vga_text_y
;
115 static BOOL vga_text_console
;
118 * VGA controller ports 0x3c0, 0x3c4, 0x3ce and 0x3d4 are
119 * indexed registers. These ports are used to select VGA controller
120 * subregister that can be written to or read from using ports 0x3c1,
121 * 0x3c5, 0x3cf or 0x3d5. Selected subregister indexes are
122 * stored in variables vga_index_*.
124 * Port 0x3c0 is special because it is both index and
125 * data-write register. Flip-flop vga_address_3c0 tells whether
126 * the port acts currently as an address register. Reading from port
127 * 0x3da resets the flip-flop to address mode.
129 static BYTE vga_index_3c0
;
130 static BYTE vga_index_3c4
;
131 static BYTE vga_index_3ce
;
132 static BYTE vga_index_3d4
;
133 static BOOL vga_address_3c0
= TRUE
;
136 * This mutex is used to protect VGA state during asynchronous
137 * screen updates (see VGA_Poll). It makes sure that VGA state changes
138 * are atomic and the user interface is protected from flicker and
141 * The mutex actually serializes VGA operations and the screen update.
142 * Which means that whenever VGA_Poll occurs, application stalls if it
143 * tries to modify VGA state. This is not how real VGA adapters work,
144 * but it makes timing and correctness issues much easier to deal with.
146 static CRITICAL_SECTION vga_lock
;
147 static CRITICAL_SECTION_DEBUG critsect_debug
=
150 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
151 0, 0, { 0, (DWORD
)(__FILE__
": vga_lock") }
153 static CRITICAL_SECTION vga_lock
= { &critsect_debug
, -1, 0, 0, 0, 0 };
155 typedef HRESULT (WINAPI
*DirectDrawCreateProc
)(LPGUID
,LPDIRECTDRAW
*,LPUNKNOWN
);
156 static DirectDrawCreateProc pDirectDrawCreate
;
158 static void CALLBACK
VGA_Poll( LPVOID arg
, DWORD low
, DWORD high
);
160 static HWND vga_hwnd
= NULL
;
163 * For simplicity, I'm creating a second palette.
164 * 16 color accesses will use these pointers and insert
165 * entries from the 64-color palette into the default
166 * palette. --Robert 'Admiral' Coeyman
169 static char vga_16_palette
[17]={
170 0x00, /* 0 - Black */
172 0x02, /* 2 - Green */
175 0x05, /* 5 - Magenta */
176 0x14, /* 6 - Brown */
177 0x07, /* 7 - Light gray */
178 0x38, /* 8 - Dark gray */
179 0x39, /* 9 - Light blue */
180 0x3a, /* A - Light green */
181 0x3b, /* B - Light cyan */
182 0x3c, /* C - Light red */
183 0x3d, /* D - Light magenta */
184 0x3e, /* E - Yellow */
185 0x3f, /* F - White */
186 0x00 /* Border Color */
189 static PALETTEENTRY vga_def_palette
[256]={
191 {0x00, 0x00, 0x00}, /* 0 - Black */
192 {0x00, 0x00, 0x80}, /* 1 - Blue */
193 {0x00, 0x80, 0x00}, /* 2 - Green */
194 {0x00, 0x80, 0x80}, /* 3 - Cyan */
195 {0x80, 0x00, 0x00}, /* 4 - Red */
196 {0x80, 0x00, 0x80}, /* 5 - Magenta */
197 {0x80, 0x80, 0x00}, /* 6 - Brown */
198 {0xC0, 0xC0, 0xC0}, /* 7 - Light gray */
199 {0x80, 0x80, 0x80}, /* 8 - Dark gray */
200 {0x00, 0x00, 0xFF}, /* 9 - Light blue */
201 {0x00, 0xFF, 0x00}, /* A - Light green */
202 {0x00, 0xFF, 0xFF}, /* B - Light cyan */
203 {0xFF, 0x00, 0x00}, /* C - Light red */
204 {0xFF, 0x00, 0xFF}, /* D - Light magenta */
205 {0xFF, 0xFF, 0x00}, /* E - Yellow */
206 {0xFF, 0xFF, 0xFF}, /* F - White */
207 {0,0,0} /* FIXME: a series of continuous rainbow hues should follow */
211 * This palette is the dos default, converted from 18 bit color to 24.
212 * It contains only 64 entries of colors--all others are zeros.
213 * --Robert 'Admiral' Coeyman
215 static PALETTEENTRY vga_def64_palette
[256]={
217 {0x00, 0x00, 0x00}, /* 0x00 Black */
218 {0x00, 0x00, 0xaa}, /* 0x01 Blue */
219 {0x00, 0xaa, 0x00}, /* 0x02 Green */
220 {0x00, 0xaa, 0xaa}, /* 0x03 Cyan */
221 {0xaa, 0x00, 0x00}, /* 0x04 Red */
222 {0xaa, 0x00, 0xaa}, /* 0x05 Magenta */
223 {0xaa, 0xaa, 0x00}, /* 0x06 */
224 {0xaa, 0xaa, 0xaa}, /* 0x07 Light Gray */
225 {0x00, 0x00, 0x55}, /* 0x08 */
226 {0x00, 0x00, 0xff}, /* 0x09 */
227 {0x00, 0xaa, 0x55}, /* 0x0a */
228 {0x00, 0xaa, 0xff}, /* 0x0b */
229 {0xaa, 0x00, 0x55}, /* 0x0c */
230 {0xaa, 0x00, 0xff}, /* 0x0d */
231 {0xaa, 0xaa, 0x55}, /* 0x0e */
232 {0xaa, 0xaa, 0xff}, /* 0x0f */
233 {0x00, 0x55, 0x00}, /* 0x10 */
234 {0x00, 0x55, 0xaa}, /* 0x11 */
235 {0x00, 0xff, 0x00}, /* 0x12 */
236 {0x00, 0xff, 0xaa}, /* 0x13 */
237 {0xaa, 0x55, 0x00}, /* 0x14 Brown */
238 {0xaa, 0x55, 0xaa}, /* 0x15 */
239 {0xaa, 0xff, 0x00}, /* 0x16 */
240 {0xaa, 0xff, 0xaa}, /* 0x17 */
241 {0x00, 0x55, 0x55}, /* 0x18 */
242 {0x00, 0x55, 0xff}, /* 0x19 */
243 {0x00, 0xff, 0x55}, /* 0x1a */
244 {0x00, 0xff, 0xff}, /* 0x1b */
245 {0xaa, 0x55, 0x55}, /* 0x1c */
246 {0xaa, 0x55, 0xff}, /* 0x1d */
247 {0xaa, 0xff, 0x55}, /* 0x1e */
248 {0xaa, 0xff, 0xff}, /* 0x1f */
249 {0x55, 0x00, 0x00}, /* 0x20 */
250 {0x55, 0x00, 0xaa}, /* 0x21 */
251 {0x55, 0xaa, 0x00}, /* 0x22 */
252 {0x55, 0xaa, 0xaa}, /* 0x23 */
253 {0xff, 0x00, 0x00}, /* 0x24 */
254 {0xff, 0x00, 0xaa}, /* 0x25 */
255 {0xff, 0xaa, 0x00}, /* 0x26 */
256 {0xff, 0xaa, 0xaa}, /* 0x27 */
257 {0x55, 0x00, 0x55}, /* 0x28 */
258 {0x55, 0x00, 0xff}, /* 0x29 */
259 {0x55, 0xaa, 0x55}, /* 0x2a */
260 {0x55, 0xaa, 0xff}, /* 0x2b */
261 {0xff, 0x00, 0x55}, /* 0x2c */
262 {0xff, 0x00, 0xff}, /* 0x2d */
263 {0xff, 0xaa, 0x55}, /* 0x2e */
264 {0xff, 0xaa, 0xff}, /* 0x2f */
265 {0x55, 0x55, 0x00}, /* 0x30 */
266 {0x55, 0x55, 0xaa}, /* 0x31 */
267 {0x55, 0xff, 0x00}, /* 0x32 */
268 {0x55, 0xff, 0xaa}, /* 0x33 */
269 {0xff, 0x55, 0x00}, /* 0x34 */
270 {0xff, 0x55, 0xaa}, /* 0x35 */
271 {0xff, 0xff, 0x00}, /* 0x36 */
272 {0xff, 0xff, 0xaa}, /* 0x37 */
273 {0x55, 0x55, 0x55}, /* 0x38 Dark Gray */
274 {0x55, 0x55, 0xff}, /* 0x39 Light Blue */
275 {0x55, 0xff, 0x55}, /* 0x3a Light Green */
276 {0x55, 0xff, 0xff}, /* 0x3b Light Cyan */
277 {0xff, 0x55, 0x55}, /* 0x3c Light Red */
278 {0xff, 0x55, 0xff}, /* 0x3d Light Magenta */
279 {0xff, 0xff, 0x55}, /* 0x3e Yellow */
280 {0xff, 0xff, 0xff}, /* 0x3f White */
281 {0,0,0} /* The next 192 entries are all zeros */
284 static HANDLE VGA_timer
;
285 static HANDLE VGA_timer_thread
;
287 /* set the timer rate; called in the polling thread context */
288 static void CALLBACK
set_timer_rate( ULONG_PTR arg
)
292 when
.u
.LowPart
= when
.u
.HighPart
= 0;
293 SetWaitableTimer( VGA_timer
, &when
, arg
, VGA_Poll
, 0, FALSE
);
296 static DWORD CALLBACK
VGA_TimerThread( void *dummy
)
298 for (;;) SleepEx( INFINITE
, TRUE
);
301 static void VGA_DeinstallTimer(void)
303 if (VGA_timer_thread
)
306 * Make sure the update thread is not holding
307 * system resources when we kill it.
309 * Now, we only need to worry about update thread
310 * getting terminated while in EnterCriticalSection
311 * or WaitForMultipleObjectsEx.
313 * FIXME: Is this a problem?
315 EnterCriticalSection(&vga_lock
);
317 CancelWaitableTimer( VGA_timer
);
318 CloseHandle( VGA_timer
);
319 TerminateThread( VGA_timer_thread
, 0 );
320 CloseHandle( VGA_timer_thread
);
321 VGA_timer_thread
= 0;
323 LeaveCriticalSection(&vga_lock
);
326 * Synchronize display. This makes sure that
327 * changes to display become visible even if program
328 * terminates before update thread had time to run.
334 static void VGA_InstallTimer(unsigned Rate
)
336 if (!VGA_timer_thread
)
338 VGA_timer
= CreateWaitableTimerA( NULL
, FALSE
, NULL
);
339 VGA_timer_thread
= CreateThread( NULL
, 0, VGA_TimerThread
, NULL
, 0, NULL
);
341 QueueUserAPC( set_timer_rate
, VGA_timer_thread
, (ULONG_PTR
)Rate
);
344 static BOOL
VGA_IsTimerRunning(void)
346 return VGA_timer_thread
? TRUE
: FALSE
;
349 HANDLE
VGA_AlphaConsole(void)
351 /* this assumes that no Win32 redirection has taken place, but then again,
352 * only 16-bit apps are likely to use this part of Wine... */
353 return GetStdHandle(STD_OUTPUT_HANDLE
);
356 char*VGA_AlphaBuffer(void)
358 return (char *)0xb8000;
361 /*** GRAPHICS MODE ***/
364 unsigned Xres
, Yres
, Depth
;
369 /**********************************************************************
372 * Copy VGA window into framebuffer (if argument is TRUE) or
373 * part of framebuffer into VGA window (if argument is FALSE).
375 static void VGA_SyncWindow( BOOL target_is_fb
)
377 int size
= VGA_WINDOW_SIZE
;
379 /* Window does not overlap framebuffer. */
380 if (vga_fb_window
>= vga_fb_size
)
383 /* Check if window overlaps framebuffer only partially. */
384 if (vga_fb_size
- vga_fb_window
< VGA_WINDOW_SIZE
)
385 size
= vga_fb_size
- vga_fb_window
;
388 memmove( vga_fb_data
+ vga_fb_window
, VGA_WINDOW_START
, size
);
390 memmove( VGA_WINDOW_START
, vga_fb_data
+ vga_fb_window
, size
);
394 static void WINAPI
VGA_DoExit(ULONG_PTR arg
)
396 VGA_DeinstallTimer();
397 IDirectDrawSurface_SetPalette(lpddsurf
,NULL
);
398 IDirectDrawSurface_Release(lpddsurf
);
400 IDirectDrawPalette_Release(lpddpal
);
402 IDirectDraw_Release(lpddraw
);
406 static void WINAPI
VGA_DoSetMode(ULONG_PTR arg
)
409 ModeSet
*par
= (ModeSet
*)arg
;
412 if (lpddraw
) VGA_DoExit(0);
414 if (!pDirectDrawCreate
)
416 HMODULE hmod
= LoadLibraryA( "ddraw.dll" );
417 if (hmod
) pDirectDrawCreate
= (DirectDrawCreateProc
)GetProcAddress( hmod
, "DirectDrawCreate" );
418 if (!pDirectDrawCreate
) {
419 ERR("Can't lookup DirectDrawCreate from ddraw.dll.\n");
423 res
= pDirectDrawCreate(NULL
,&lpddraw
,NULL
);
425 ERR("DirectDraw is not available (res = %lx)\n",res
);
429 vga_hwnd
= CreateWindowExA(0,"STATIC","WINEDOS VGA",
430 WS_POPUP
|WS_VISIBLE
|SS_NOTIFY
,0,0,
431 par
->Xres
,par
->Yres
,0,0,0,NULL
);
433 ERR("Failed to create user window.\n");
434 IDirectDraw_Release(lpddraw
);
440 SetWindowPos(vga_hwnd
,0,0,0,par
->Xres
,par
->Yres
,SWP_NOMOVE
|SWP_NOZORDER
);
442 if ((res
=IDirectDraw_SetCooperativeLevel(lpddraw
,vga_hwnd
,DDSCL_FULLSCREEN
|DDSCL_EXCLUSIVE
))) {
443 ERR("Could not set cooperative level to exclusive (%lx)\n",res
);
446 if ((res
=IDirectDraw_SetDisplayMode(lpddraw
,par
->Xres
,par
->Yres
,par
->Depth
))) {
447 ERR("DirectDraw does not support requested display mode (%dx%dx%d), res = %lx!\n",par
->Xres
,par
->Yres
,par
->Depth
,res
);
448 IDirectDraw_Release(lpddraw
);
453 res
=IDirectDraw_CreatePalette(lpddraw
,DDPCAPS_8BIT
,NULL
,&lpddpal
,NULL
);
455 ERR("Could not create palette (res = %lx)\n",res
);
456 IDirectDraw_Release(lpddraw
);
460 if ((res
=IDirectDrawPalette_SetEntries(lpddpal
,0,0,256,vga_def_palette
))) {
461 ERR("Could not set default palette entries (res = %lx)\n", res
);
464 memset(&sdesc
,0,sizeof(sdesc
));
465 sdesc
.dwSize
=sizeof(sdesc
);
466 sdesc
.dwFlags
= DDSD_CAPS
;
467 sdesc
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
;
468 if (IDirectDraw_CreateSurface(lpddraw
,&sdesc
,&lpddsurf
,NULL
)||(!lpddsurf
)) {
469 ERR("DirectDraw surface is not available\n");
470 IDirectDraw_Release(lpddraw
);
474 IDirectDrawSurface_SetPalette(lpddsurf
,lpddpal
);
475 vga_retrace_vertical
= vga_retrace_horizontal
= FALSE
;
476 /* poll every 20ms (50fps should provide adequate responsiveness) */
477 VGA_InstallTimer(20);
483 int VGA_SetMode(unsigned Xres
,unsigned Yres
,unsigned Depth
)
489 vga_fb_height
= Yres
;
490 vga_fb_depth
= Depth
;
492 vga_fb_pitch
= Xres
* ((Depth
+ 7) / 8);
494 newSize
= Xres
* Yres
* ((Depth
+ 7) / 8);
495 if(newSize
< 256 * 1024)
496 newSize
= 256 * 1024;
498 if(vga_fb_size
< newSize
) {
500 HeapFree(GetProcessHeap(), 0, vga_fb_data
);
501 vga_fb_data
= HeapAlloc(GetProcessHeap(), 0, newSize
);
502 vga_fb_size
= newSize
;
505 if(Xres
>= 640 || Yres
>= 480) {
513 VGA_SetWindowStart((Depth
< 8) ? -1 : 0);
515 par
.Depth
= (Depth
< 8) ? 8 : Depth
;
517 MZ_RunInThread(VGA_DoSetMode
, (ULONG_PTR
)&par
);
521 int VGA_GetMode(unsigned*Height
,unsigned*Width
,unsigned*Depth
)
523 if (!lpddraw
) return 1;
524 if (!lpddsurf
) return 1;
525 if (Height
) *Height
=sdesc
.dwHeight
;
526 if (Width
) *Width
=sdesc
.dwWidth
;
527 if (Depth
) *Depth
=sdesc
.ddpfPixelFormat
.u1
.dwRGBBitCount
;
533 if (lpddraw
) MZ_RunInThread(VGA_DoExit
, 0);
536 void VGA_SetPalette(PALETTEENTRY
*pal
,int start
,int len
)
538 if (!lpddraw
) return;
539 IDirectDrawPalette_SetEntries(lpddpal
,0,start
,len
,pal
);
542 /* set a single [char wide] color in 16 color mode. */
543 void VGA_SetColor16(int reg
,int color
)
547 if (!lpddraw
) return;
548 pal
= &vga_def64_palette
[color
];
549 IDirectDrawPalette_SetEntries(lpddpal
,0,reg
,1,pal
);
550 vga_16_palette
[reg
]=(char)color
;
553 /* Get a single [char wide] color in 16 color mode. */
554 char VGA_GetColor16(int reg
)
557 if (!lpddraw
) return 0;
558 return (char)vga_16_palette
[reg
];
561 /* set all 17 [char wide] colors at once in 16 color mode. */
562 void VGA_Set16Palette(char *Table
)
567 if (!lpddraw
) return; /* return if we're in text only mode */
568 memcpy( Table
, &vga_16_palette
, 17 ); /* copy the entries into the table */
570 for (c
=0; c
<17; c
++) { /* 17 entries */
571 pal
= &vga_def64_palette
[(int)vga_16_palette
[c
]]; /* get color */
572 IDirectDrawPalette_SetEntries(lpddpal
,0,c
,1,pal
); /* set entry */
573 TRACE("Palette register %d set to %d\n",c
,(int)vga_16_palette
[c
]);
574 } /* end of the counting loop */
577 /* Get all 17 [ char wide ] colors at once in 16 color mode. */
578 void VGA_Get16Palette(char *Table
)
581 if (!lpddraw
) return; /* return if we're in text only mode */
582 memcpy( &vga_16_palette
, Table
, 17 ); /* copy the entries into the table */
585 void VGA_SetQuadPalette(RGBQUAD
*color
,int start
,int len
)
587 PALETTEENTRY pal
[256];
590 if (!lpddraw
) return;
591 for (c
=0; c
<len
; c
++) {
592 pal
[c
].peRed
=color
[c
].rgbRed
;
593 pal
[c
].peGreen
=color
[c
].rgbGreen
;
594 pal
[c
].peBlue
=color
[c
].rgbBlue
;
597 IDirectDrawPalette_SetEntries(lpddpal
,0,start
,len
,pal
);
600 LPSTR
VGA_Lock(unsigned*Pitch
,unsigned*Height
,unsigned*Width
,unsigned*Depth
)
602 if (!lpddraw
) return NULL
;
603 if (!lpddsurf
) return NULL
;
604 if (IDirectDrawSurface_Lock(lpddsurf
,NULL
,&sdesc
,0,0)) {
605 ERR("could not lock surface!\n");
608 if (Pitch
) *Pitch
=sdesc
.u1
.lPitch
;
609 if (Height
) *Height
=sdesc
.dwHeight
;
610 if (Width
) *Width
=sdesc
.dwWidth
;
611 if (Depth
) *Depth
=sdesc
.ddpfPixelFormat
.u1
.dwRGBBitCount
;
612 return sdesc
.lpSurface
;
615 void VGA_Unlock(void)
617 IDirectDrawSurface_Unlock(lpddsurf
,sdesc
.lpSurface
);
621 * Set start of 64k window at 0xa0000 in bytes.
622 * If value is -1, initialize color plane support.
623 * If value is >= 0, window contains direct copy of framebuffer.
625 void VGA_SetWindowStart(int start
)
627 if(start
== vga_fb_window
)
630 EnterCriticalSection(&vga_lock
);
632 if(vga_fb_window
== -1)
633 FIXME("Remove VGA memory emulation.\n");
635 VGA_SyncWindow( TRUE
);
637 vga_fb_window
= start
;
639 if(vga_fb_window
== -1)
640 FIXME("Install VGA memory emulation.\n");
642 VGA_SyncWindow( FALSE
);
644 LeaveCriticalSection(&vga_lock
);
648 * Get start of 64k window at 0xa0000 in bytes.
649 * Value is -1 in color plane modes.
651 int VGA_GetWindowStart()
653 return vga_fb_window
;
657 /**********************************************************************
660 * Callback for VGA_ShowMouse.
662 static WINAPI
void VGA_DoShowMouse( ULONG_PTR show
)
668 rv
= ShowCursor( show
);
670 while( show
? (rv
< 0) : (rv
>= 0) );
674 /**********************************************************************
677 * If argument is TRUE, unconditionally show mouse cursor.
678 * If argument is FALSE, unconditionally hide mouse cursor.
679 * This only works in graphics mode.
681 void VGA_ShowMouse( BOOL show
)
684 MZ_RunInThread( VGA_DoShowMouse
, (ULONG_PTR
)show
);
690 /* prepare the text mode video memory copy that is used to only
691 * update the video memory line that did get updated. */
692 void VGA_PrepareVideoMemCopy(unsigned Xres
, unsigned Yres
)
698 * Allocate space for char + attr.
702 vga_text_old
= HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
703 vga_text_old
, Xres
* Yres
* 2 );
705 vga_text_old
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
707 p
= VGA_AlphaBuffer();
710 /* make sure the video mem copy contains the exact opposite of our
711 * actual text mode memory area to make sure the screen
712 * does get updated fully initially */
713 for (i
=0; i
< Xres
*Yres
*2; i
++)
714 *p2
++ = *p
++ ^ 0xff; /* XOR it */
717 /**********************************************************************
720 * Set VGA emulation to text mode.
722 void VGA_SetAlphaMode(unsigned Xres
,unsigned Yres
)
725 VGA_DeinstallTimer();
727 VGA_PrepareVideoMemCopy(Xres
, Yres
);
728 vga_text_width
= Xres
;
729 vga_text_height
= Yres
;
731 if (vga_text_x
>= vga_text_width
|| vga_text_y
>= vga_text_height
)
732 VGA_SetCursorPos(0,0);
734 if(vga_text_console
) {
738 SetConsoleScreenBufferSize( VGA_AlphaConsole(), size
);
740 /* poll every 30ms (33fps should provide adequate responsiveness) */
741 VGA_InstallTimer(30);
745 /**********************************************************************
748 * Initialize VGA text mode handling and return default text mode.
749 * This function does not set VGA emulation to text mode.
751 void VGA_InitAlphaMode(unsigned*Xres
,unsigned*Yres
)
753 CONSOLE_SCREEN_BUFFER_INFO info
;
755 if(GetConsoleScreenBufferInfo( VGA_AlphaConsole(), &info
))
757 vga_text_console
= TRUE
;
758 vga_text_x
= info
.dwCursorPosition
.X
;
759 vga_text_y
= info
.dwCursorPosition
.Y
;
760 vga_text_attr
= info
.wAttributes
;
761 *Xres
= info
.dwSize
.X
;
762 *Yres
= info
.dwSize
.Y
;
766 vga_text_console
= FALSE
;
769 vga_text_attr
= 0x0f;
775 /**********************************************************************
778 * Get current text mode. Returns TRUE and sets resolution if
779 * any VGA text mode has been initialized.
781 BOOL
VGA_GetAlphaMode(unsigned*Xres
,unsigned*Yres
)
783 if (vga_text_width
!= 0 && vga_text_height
!= 0) {
784 *Xres
= vga_text_width
;
785 *Yres
= vga_text_height
;
791 void VGA_SetCursorShape(unsigned char start_options
, unsigned char end
)
793 CONSOLE_CURSOR_INFO cci
;
795 /* standard cursor settings:
796 * 0x0607 == CGA, 0x0b0c == monochrome, 0x0d0e == EGA/VGA */
798 /* calculate percentage from bottom - assuming VGA (bottom 0x0e) */
799 cci
.dwSize
= ((end
& 0x1f) - (start_options
& 0x1f))/0x0e * 100;
800 if (!cci
.dwSize
) cci
.dwSize
++; /* NULL cursor would make SCCI() fail ! */
801 cci
.bVisible
= ((start_options
& 0x60) != 0x20); /* invisible ? */
803 SetConsoleCursorInfo(VGA_AlphaConsole(),&cci
);
806 void VGA_SetCursorPos(unsigned X
,unsigned Y
)
812 void VGA_GetCursorPos(unsigned*X
,unsigned*Y
)
814 if (X
) *X
= vga_text_x
;
815 if (Y
) *Y
= vga_text_y
;
818 static void VGA_PutCharAt(unsigned x
, unsigned y
, BYTE ascii
, int attr
)
820 char *dat
= VGA_AlphaBuffer() + ((vga_text_width
* y
+ x
) * 2);
826 void VGA_WriteChars(unsigned X
,unsigned Y
,unsigned ch
,int attr
,int count
)
828 EnterCriticalSection(&vga_lock
);
831 VGA_PutCharAt(X
+ count
, Y
, ch
, attr
);
833 LeaveCriticalSection(&vga_lock
);
836 void VGA_PutChar(BYTE ascii
)
838 EnterCriticalSection(&vga_lock
);
845 VGA_PutCharAt(vga_text_x
, vga_text_y
, ' ', 0);
850 vga_text_x
+= ((vga_text_x
+ 8) & ~7) - vga_text_x
;
866 VGA_PutCharAt(vga_text_x
, vga_text_y
, ascii
, vga_text_attr
);
870 if (vga_text_x
>= vga_text_width
)
876 if (vga_text_y
>= vga_text_height
)
878 vga_text_y
= vga_text_height
- 1;
879 VGA_ScrollUpText( 0, 0,
880 vga_text_height
- 1, vga_text_width
- 1,
885 * If we don't have a console, write directly to standard output.
887 if(!vga_text_console
)
888 WriteFile(VGA_AlphaConsole(), &ascii
, 1, NULL
, NULL
);
890 LeaveCriticalSection(&vga_lock
);
893 void VGA_SetTextAttribute(BYTE attr
)
895 vga_text_attr
= attr
;
898 void VGA_ClearText(unsigned row1
, unsigned col1
,
899 unsigned row2
, unsigned col2
,
904 EnterCriticalSection(&vga_lock
);
906 for(y
=row1
; y
<=row2
; y
++)
907 for(x
=col1
; x
<=col2
; x
++)
908 VGA_PutCharAt(x
, y
, 0x20, attr
);
910 LeaveCriticalSection(&vga_lock
);
913 void VGA_ScrollUpText(unsigned row1
, unsigned col1
,
914 unsigned row2
, unsigned col2
,
915 unsigned lines
, BYTE attr
)
917 char *buffer
= VGA_AlphaBuffer();
920 EnterCriticalSection(&vga_lock
);
925 for (y
= row1
; y
<= row2
- lines
; y
++)
926 memmove( buffer
+ col1
+ y
* vga_text_width
* 2,
927 buffer
+ col1
+ (y
+ lines
) * vga_text_width
* 2,
928 (col2
- col1
+ 1) * 2 );
931 * Fill exposed lines.
933 for (y
= max(row1
, row2
- lines
+ 1); y
<= row2
; y
++)
934 VGA_WriteChars( col1
, y
, ' ', attr
, col2
- col1
+ 1 );
936 LeaveCriticalSection(&vga_lock
);
939 void VGA_ScrollDownText(unsigned row1
, unsigned col1
,
940 unsigned row2
, unsigned col2
,
941 unsigned lines
, BYTE attr
)
943 char *buffer
= VGA_AlphaBuffer();
946 EnterCriticalSection(&vga_lock
);
951 for (y
= row2
; y
>= row1
+ lines
; y
--)
952 memmove( buffer
+ col1
+ y
* vga_text_width
* 2,
953 buffer
+ col1
+ (y
- lines
) * vga_text_width
* 2,
954 (col2
- col1
+ 1) * 2 );
957 * Fill exposed lines.
959 for (y
= row1
; y
<= min(row1
+ lines
- 1, row2
); y
++)
960 VGA_WriteChars( col1
, y
, ' ', attr
, col2
- col1
+ 1 );
962 LeaveCriticalSection(&vga_lock
);
965 void VGA_GetCharacterAtCursor(BYTE
*ascii
, BYTE
*attr
)
969 dat
= VGA_AlphaBuffer() + ((vga_text_width
* vga_text_y
+ vga_text_x
) * 2);
978 /* FIXME: optimize by doing this only if the data has actually changed
979 * (in a way similar to DIBSection, perhaps) */
980 static void VGA_Poll_Graphics(void)
982 unsigned int Pitch
, Height
, Width
, X
, Y
;
984 char *dat
= vga_fb_data
+ vga_fb_offset
;
985 int bpp
= (vga_fb_depth
+ 7) / 8;
987 surf
= VGA_Lock(&Pitch
,&Height
,&Width
,NULL
);
991 * Synchronize framebuffer contents.
993 if (vga_fb_window
!= -1)
994 VGA_SyncWindow( TRUE
);
997 * Double VGA framebuffer (320x200 -> 640x400), if needed.
999 if(Height
>= 2 * vga_fb_height
&& Width
>= 2 * vga_fb_width
&& bpp
== 1)
1000 for (Y
=0; Y
<vga_fb_height
; Y
++,surf
+=Pitch
*2,dat
+=vga_fb_pitch
)
1001 for (X
=0; X
<vga_fb_width
; X
++) {
1002 BYTE value
= dat
[X
];
1004 surf
[X
*2+1] = value
;
1005 surf
[X
*2+Pitch
] = value
;
1006 surf
[X
*2+Pitch
+1] = value
;
1009 for (Y
=0; Y
<vga_fb_height
; Y
++,surf
+=Pitch
,dat
+=vga_fb_pitch
)
1010 memcpy(surf
, dat
, vga_fb_width
* bpp
);
1015 static void VGA_Poll_Text(void)
1017 char *dat
, *old
, *p_line
;
1019 CHAR_INFO ch
[256]; /* that should suffice for the largest text width */
1022 HANDLE con
= VGA_AlphaConsole();
1023 BOOL linechanged
= FALSE
; /* video memory area differs from stored copy? */
1025 /* Synchronize cursor position. */
1028 SetConsoleCursorPosition(con
,off
);
1030 dat
= VGA_AlphaBuffer();
1031 old
= vga_text_old
; /* pointer to stored video mem copy */
1032 siz
.X
= vga_text_width
; siz
.Y
= 1;
1033 off
.X
= 0; off
.Y
= 0;
1035 /* copy from virtual VGA frame buffer to console */
1036 for (Y
=0; Y
<vga_text_height
; Y
++) {
1037 linechanged
= memcmp(dat
, old
, vga_text_width
*2);
1040 /*TRACE("line %d changed\n", Y);*/
1042 for (X
=0; X
<vga_text_width
; X
++) {
1043 ch
[X
].Char
.AsciiChar
= *p_line
++;
1044 /* WriteConsoleOutputA doesn't like "dead" chars */
1045 if (ch
[X
].Char
.AsciiChar
== '\0')
1046 ch
[X
].Char
.AsciiChar
= ' ';
1047 ch
[X
].Attributes
= *p_line
++;
1049 dest
.Top
=Y
; dest
.Bottom
=Y
;
1050 dest
.Left
=0; dest
.Right
=vga_text_width
+1;
1051 WriteConsoleOutputA(con
, ch
, siz
, off
, &dest
);
1052 memcpy(old
, dat
, vga_text_width
*2);
1054 /* advance to next text line */
1055 dat
+= vga_text_width
*2;
1056 old
+= vga_text_width
*2;
1060 static void CALLBACK
VGA_Poll( LPVOID arg
, DWORD low
, DWORD high
)
1062 EnterCriticalSection(&vga_lock
);
1065 VGA_Poll_Graphics();
1070 * Fake start of retrace.
1072 vga_retrace_vertical
= TRUE
;
1074 LeaveCriticalSection(&vga_lock
);
1077 static BYTE palreg
,palcnt
;
1078 static PALETTEENTRY paldat
;
1080 void VGA_ioport_out( WORD port
, BYTE val
)
1084 if (vga_address_3c0
)
1085 vga_index_3c0
= val
;
1087 FIXME("Unsupported index, register 0x3c0: 0x%02x (value 0x%02x)\n",
1088 vga_index_3c0
, val
);
1089 vga_address_3c0
= !vga_address_3c0
;
1092 vga_index_3c4
= val
;
1095 switch(vga_index_3c4
) {
1096 case 0x04: /* Sequencer: Memory Mode Register */
1097 if(vga_fb_depth
== 8)
1098 VGA_SetWindowStart((val
& 8) ? 0 : -1);
1100 FIXME("Memory Mode Register not supported in this mode.\n");
1103 FIXME("Unsupported index, register 0x3c4: 0x%02x (value 0x%02x)\n",
1104 vga_index_3c4
, val
);
1108 palreg
=val
; palcnt
=0; break;
1110 ((BYTE
*)&paldat
)[palcnt
++]=val
<< 2;
1112 VGA_SetPalette(&paldat
,palreg
++,1);
1117 vga_index_3ce
= val
;
1120 FIXME("Unsupported index, register 0x3ce: 0x%02x (value 0x%02x)\n",
1121 vga_index_3ce
, val
);
1124 vga_index_3d4
= val
;
1127 FIXME("Unsupported index, register 0x3d4: 0x%02x (value 0x%02x)\n",
1128 vga_index_3d4
, val
);
1131 FIXME("Unsupported VGA register: 0x%04x (value 0x%02x)\n", port
, val
);
1135 BYTE
VGA_ioport_in( WORD port
)
1141 FIXME("Unsupported index, register 0x3c0: 0x%02x\n",
1145 switch(vga_index_3c4
) {
1146 case 0x04: /* Sequencer: Memory Mode Register */
1147 return (VGA_GetWindowStart() == -1) ? 0xf7 : 0xff;
1149 FIXME("Unsupported index, register 0x3c4: 0x%02x\n",
1154 FIXME("Unsupported index, register 0x3ce: 0x%02x\n",
1158 FIXME("Unsupported index, register 0x3d4: 0x%02x\n",
1164 * Read from this register resets register 0x3c0 address flip-flop.
1166 vga_address_3c0
= TRUE
;
1169 * Read from this register returns following bits:
1170 * xxxx1xxx = Vertical retrace in progress if set.
1171 * xxxxx1xx = Light pen switched on.
1172 * xxxxxx1x = Light pen trigger set.
1173 * xxxxxxx1 = Either vertical or horizontal retrace
1174 * in progress if set.
1177 if (vga_retrace_vertical
)
1179 if (vga_retrace_horizontal
)
1183 * If VGA mode has been set, vertical retrace is
1184 * turned on once a frame and cleared after each read.
1185 * This might cause applications that synchronize with
1186 * vertical retrace to actually skip one frame but that
1187 * is probably not a problem.
1189 * If no VGA mode has been set, vertical retrace is faked
1190 * by toggling the value after every read.
1192 if (VGA_IsTimerRunning())
1193 vga_retrace_vertical
= FALSE
;
1195 vga_retrace_vertical
= !vga_retrace_vertical
;
1198 * Toggle horizontal retrace.
1200 vga_retrace_horizontal
= !vga_retrace_horizontal
;
1205 FIXME("Unsupported VGA register: 0x%04x\n", port
);
1210 void VGA_Clean(void)
1213 VGA_DeinstallTimer();