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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
34 #include "wine/debug.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(ddraw
);
38 static IDirectDraw
*lpddraw
= NULL
;
39 static IDirectDrawSurface
*lpddsurf
;
40 static IDirectDrawPalette
*lpddpal
;
41 static DDSURFACEDESC sdesc
;
43 static BOOL vga_retrace_vertical
;
44 static BOOL vga_retrace_horizontal
;
47 * Size and location of VGA controller window to framebuffer.
49 * Note: We support only single window even though some
50 * controllers support two. This should not be changed unless
51 * there are programs that depend on having two windows.
53 #define VGA_WINDOW_SIZE (64 * 1024)
54 #define VGA_WINDOW_START ((char *)0xa0000)
57 * VGA controller memory is emulated using linear framebuffer.
58 * This frambuffer also acts as an interface
59 * between VGA controller emulation and DirectDraw.
61 * vga_fb_width: Display width in pixels. Can be modified when
62 * display mode is changed.
63 * vga_fb_height: Display height in pixels. Can be modified when
64 * display mode is changed.
65 * vga_fb_depth: Number of bits used to store single pixel color information.
66 * Each pixel uses (vga_fb_depth+7)/8 bytes because
67 * 1-16 color modes are mapped to 256 color mode.
68 * Can be modified when display mode is changed.
69 * vga_fb_pitch: How many bytes to add to pointer in order to move
70 * from one row to another. This is fixed in VGA modes,
71 * but can be modified in SVGA modes.
72 * vga_fb_offset: Offset added to framebuffer start address in order
73 * to find the display origin. Programs use this to do
74 * double buffering and to scroll display. The value can
75 * be modified in VGA and SVGA modes.
76 * vga_fb_size: How many bytes are allocated to framebuffer.
77 * VGA framebuffers are always larger than display size and
78 * SVGA framebuffers may also be.
79 * vga_fb_data: Pointer to framebuffer start.
80 * vga_fb_window: Offset of 64k window 0xa0000 in bytes from framebuffer start.
81 * This value is >= 0, if mode uses linear framebuffer and
82 * -1, if mode uses color planes. This value is fixed
83 * in all modes except 0x13 (256 color VGA) where
84 * 0 means normal mode and -1 means Mode-X (unchained mode).
86 static int vga_fb_width
;
87 static int vga_fb_height
;
88 static int vga_fb_depth
;
89 static int vga_fb_pitch
;
90 static int vga_fb_offset
;
91 static int vga_fb_size
= 0;
92 static char *vga_fb_data
= 0;
93 static int vga_fb_window
= 0;
98 * vga_text_attr: Current active attribute.
99 * vga_text_old: Last data sent to console.
100 * This is used to optimize console updates.
101 * vga_text_width: Width of the text display in characters.
102 * vga_text_height: Height of the text display in characters.
103 * vga_text_x: Current cursor X-position. Starts from zero.
104 * vga_text_y: Current cursor Y-position. Starts from zero.
105 * vga_text_console: TRUE if stdout is console,
106 * FALSE if it is regular file.
108 static BYTE vga_text_attr
;
109 static char *vga_text_old
= NULL
;
110 static BYTE vga_text_width
;
111 static BYTE vga_text_height
;
112 static BYTE vga_text_x
;
113 static BYTE vga_text_y
;
114 static BOOL vga_text_console
;
117 * VGA controller ports 0x3c0, 0x3c4, 0x3ce and 0x3d4 are
118 * indexed registers. These ports are used to select VGA controller
119 * subregister that can be written to or read from using ports 0x3c1,
120 * 0x3c5, 0x3cf or 0x3d5. Selected subregister indexes are
121 * stored in variables vga_index_*.
123 * Port 0x3c0 is special because it is both index and
124 * data-write register. Flip-flop vga_address_3c0 tells whether
125 * the port acts currently as an address register. Reading from port
126 * 0x3da resets the flip-flop to address mode.
128 static BYTE vga_index_3c0
;
129 static BYTE vga_index_3c4
;
130 static BYTE vga_index_3ce
;
131 static BYTE vga_index_3d4
;
132 static BOOL vga_address_3c0
= TRUE
;
135 * This mutex is used to protect VGA state during asynchronous
136 * screen updates (see VGA_Poll). It makes sure that VGA state changes
137 * are atomic and the user interface is protected from flicker and
140 * The mutex actually serializes VGA operations and the screen update.
141 * Which means that whenever VGA_Poll occurs, application stalls if it
142 * tries to modify VGA state. This is not how real VGA adapters work,
143 * but it makes timing and correctness issues much easier to deal with.
145 static CRITICAL_SECTION vga_lock
;
146 static CRITICAL_SECTION_DEBUG critsect_debug
=
149 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
150 0, 0, { (DWORD_PTR
)(__FILE__
": vga_lock") }
152 static CRITICAL_SECTION vga_lock
= { &critsect_debug
, -1, 0, 0, 0, 0 };
154 typedef HRESULT (WINAPI
*DirectDrawCreateProc
)(LPGUID
,LPDIRECTDRAW
*,LPUNKNOWN
);
155 static DirectDrawCreateProc pDirectDrawCreate
;
157 static void CALLBACK
VGA_Poll( LPVOID arg
, DWORD low
, DWORD high
);
159 static HWND vga_hwnd
= NULL
;
162 * For simplicity, I'm creating a second palette.
163 * 16 color accesses will use these pointers and insert
164 * entries from the 64-color palette into the default
165 * palette. --Robert 'Admiral' Coeyman
168 static char vga_16_palette
[17]={
169 0x00, /* 0 - Black */
171 0x02, /* 2 - Green */
174 0x05, /* 5 - Magenta */
175 0x14, /* 6 - Brown */
176 0x07, /* 7 - Light gray */
177 0x38, /* 8 - Dark gray */
178 0x39, /* 9 - Light blue */
179 0x3a, /* A - Light green */
180 0x3b, /* B - Light cyan */
181 0x3c, /* C - Light red */
182 0x3d, /* D - Light magenta */
183 0x3e, /* E - Yellow */
184 0x3f, /* F - White */
185 0x00 /* Border Color */
188 static PALETTEENTRY vga_def_palette
[256]={
190 {0x00, 0x00, 0x00}, /* 0 - Black */
191 {0x00, 0x00, 0x80}, /* 1 - Blue */
192 {0x00, 0x80, 0x00}, /* 2 - Green */
193 {0x00, 0x80, 0x80}, /* 3 - Cyan */
194 {0x80, 0x00, 0x00}, /* 4 - Red */
195 {0x80, 0x00, 0x80}, /* 5 - Magenta */
196 {0x80, 0x80, 0x00}, /* 6 - Brown */
197 {0xC0, 0xC0, 0xC0}, /* 7 - Light gray */
198 {0x80, 0x80, 0x80}, /* 8 - Dark gray */
199 {0x00, 0x00, 0xFF}, /* 9 - Light blue */
200 {0x00, 0xFF, 0x00}, /* A - Light green */
201 {0x00, 0xFF, 0xFF}, /* B - Light cyan */
202 {0xFF, 0x00, 0x00}, /* C - Light red */
203 {0xFF, 0x00, 0xFF}, /* D - Light magenta */
204 {0xFF, 0xFF, 0x00}, /* E - Yellow */
205 {0xFF, 0xFF, 0xFF}, /* F - White */
206 {0,0,0} /* FIXME: a series of continuous rainbow hues should follow */
210 * This palette is the dos default, converted from 18 bit color to 24.
211 * It contains only 64 entries of colors--all others are zeros.
212 * --Robert 'Admiral' Coeyman
214 static PALETTEENTRY vga_def64_palette
[256]={
216 {0x00, 0x00, 0x00}, /* 0x00 Black */
217 {0x00, 0x00, 0xaa}, /* 0x01 Blue */
218 {0x00, 0xaa, 0x00}, /* 0x02 Green */
219 {0x00, 0xaa, 0xaa}, /* 0x03 Cyan */
220 {0xaa, 0x00, 0x00}, /* 0x04 Red */
221 {0xaa, 0x00, 0xaa}, /* 0x05 Magenta */
222 {0xaa, 0xaa, 0x00}, /* 0x06 */
223 {0xaa, 0xaa, 0xaa}, /* 0x07 Light Gray */
224 {0x00, 0x00, 0x55}, /* 0x08 */
225 {0x00, 0x00, 0xff}, /* 0x09 */
226 {0x00, 0xaa, 0x55}, /* 0x0a */
227 {0x00, 0xaa, 0xff}, /* 0x0b */
228 {0xaa, 0x00, 0x55}, /* 0x0c */
229 {0xaa, 0x00, 0xff}, /* 0x0d */
230 {0xaa, 0xaa, 0x55}, /* 0x0e */
231 {0xaa, 0xaa, 0xff}, /* 0x0f */
232 {0x00, 0x55, 0x00}, /* 0x10 */
233 {0x00, 0x55, 0xaa}, /* 0x11 */
234 {0x00, 0xff, 0x00}, /* 0x12 */
235 {0x00, 0xff, 0xaa}, /* 0x13 */
236 {0xaa, 0x55, 0x00}, /* 0x14 Brown */
237 {0xaa, 0x55, 0xaa}, /* 0x15 */
238 {0xaa, 0xff, 0x00}, /* 0x16 */
239 {0xaa, 0xff, 0xaa}, /* 0x17 */
240 {0x00, 0x55, 0x55}, /* 0x18 */
241 {0x00, 0x55, 0xff}, /* 0x19 */
242 {0x00, 0xff, 0x55}, /* 0x1a */
243 {0x00, 0xff, 0xff}, /* 0x1b */
244 {0xaa, 0x55, 0x55}, /* 0x1c */
245 {0xaa, 0x55, 0xff}, /* 0x1d */
246 {0xaa, 0xff, 0x55}, /* 0x1e */
247 {0xaa, 0xff, 0xff}, /* 0x1f */
248 {0x55, 0x00, 0x00}, /* 0x20 */
249 {0x55, 0x00, 0xaa}, /* 0x21 */
250 {0x55, 0xaa, 0x00}, /* 0x22 */
251 {0x55, 0xaa, 0xaa}, /* 0x23 */
252 {0xff, 0x00, 0x00}, /* 0x24 */
253 {0xff, 0x00, 0xaa}, /* 0x25 */
254 {0xff, 0xaa, 0x00}, /* 0x26 */
255 {0xff, 0xaa, 0xaa}, /* 0x27 */
256 {0x55, 0x00, 0x55}, /* 0x28 */
257 {0x55, 0x00, 0xff}, /* 0x29 */
258 {0x55, 0xaa, 0x55}, /* 0x2a */
259 {0x55, 0xaa, 0xff}, /* 0x2b */
260 {0xff, 0x00, 0x55}, /* 0x2c */
261 {0xff, 0x00, 0xff}, /* 0x2d */
262 {0xff, 0xaa, 0x55}, /* 0x2e */
263 {0xff, 0xaa, 0xff}, /* 0x2f */
264 {0x55, 0x55, 0x00}, /* 0x30 */
265 {0x55, 0x55, 0xaa}, /* 0x31 */
266 {0x55, 0xff, 0x00}, /* 0x32 */
267 {0x55, 0xff, 0xaa}, /* 0x33 */
268 {0xff, 0x55, 0x00}, /* 0x34 */
269 {0xff, 0x55, 0xaa}, /* 0x35 */
270 {0xff, 0xff, 0x00}, /* 0x36 */
271 {0xff, 0xff, 0xaa}, /* 0x37 */
272 {0x55, 0x55, 0x55}, /* 0x38 Dark Gray */
273 {0x55, 0x55, 0xff}, /* 0x39 Light Blue */
274 {0x55, 0xff, 0x55}, /* 0x3a Light Green */
275 {0x55, 0xff, 0xff}, /* 0x3b Light Cyan */
276 {0xff, 0x55, 0x55}, /* 0x3c Light Red */
277 {0xff, 0x55, 0xff}, /* 0x3d Light Magenta */
278 {0xff, 0xff, 0x55}, /* 0x3e Yellow */
279 {0xff, 0xff, 0xff}, /* 0x3f White */
280 {0,0,0} /* The next 192 entries are all zeros */
283 static HANDLE VGA_timer
;
284 static HANDLE VGA_timer_thread
;
286 /* set the timer rate; called in the polling thread context */
287 static void CALLBACK
set_timer_rate( ULONG_PTR arg
)
291 when
.u
.LowPart
= when
.u
.HighPart
= 0;
292 SetWaitableTimer( VGA_timer
, &when
, arg
, VGA_Poll
, 0, FALSE
);
295 static DWORD CALLBACK
VGA_TimerThread( void *dummy
)
297 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 static 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 static 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 = 0x%x)\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 res
=IDirectDraw_SetCooperativeLevel(lpddraw
,vga_hwnd
,DDSCL_FULLSCREEN
|DDSCL_EXCLUSIVE
);
444 ERR("Could not set cooperative level to exclusive (0x%x)\n",res
);
447 res
=IDirectDraw_SetDisplayMode(lpddraw
,par
->Xres
,par
->Yres
,par
->Depth
);
449 ERR("DirectDraw does not support requested display mode (%dx%dx%d), res = 0x%x!\n",par
->Xres
,par
->Yres
,par
->Depth
,res
);
450 IDirectDraw_Release(lpddraw
);
455 res
=IDirectDraw_CreatePalette(lpddraw
,DDPCAPS_8BIT
,NULL
,&lpddpal
,NULL
);
457 ERR("Could not create palette (res = 0x%x)\n",res
);
458 IDirectDraw_Release(lpddraw
);
462 res
=IDirectDrawPalette_SetEntries(lpddpal
,0,0,256,vga_def_palette
);
464 ERR("Could not set default palette entries (res = 0x%x)\n", res
);
467 memset(&sdesc
,0,sizeof(sdesc
));
468 sdesc
.dwSize
=sizeof(sdesc
);
469 sdesc
.dwFlags
= DDSD_CAPS
;
470 sdesc
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
;
471 res
=IDirectDraw_CreateSurface(lpddraw
,&sdesc
,&lpddsurf
,NULL
);
472 if (res
!= S_OK
|| !lpddsurf
) {
473 ERR("DirectDraw surface is not available\n");
474 IDirectDraw_Release(lpddraw
);
478 IDirectDrawSurface_SetPalette(lpddsurf
,lpddpal
);
479 vga_retrace_vertical
= vga_retrace_horizontal
= FALSE
;
480 /* poll every 20ms (50fps should provide adequate responsiveness) */
481 VGA_InstallTimer(20);
487 int VGA_SetMode(unsigned Xres
,unsigned Yres
,unsigned Depth
)
493 vga_fb_height
= Yres
;
494 vga_fb_depth
= Depth
;
496 vga_fb_pitch
= Xres
* ((Depth
+ 7) / 8);
498 newSize
= Xres
* Yres
* ((Depth
+ 7) / 8);
499 if(newSize
< 256 * 1024)
500 newSize
= 256 * 1024;
502 if(vga_fb_size
< newSize
) {
503 HeapFree(GetProcessHeap(), 0, vga_fb_data
);
504 vga_fb_data
= HeapAlloc(GetProcessHeap(), 0, newSize
);
505 vga_fb_size
= newSize
;
508 if(Xres
>= 640 || Yres
>= 480) {
516 VGA_SetWindowStart((Depth
< 8) ? -1 : 0);
518 par
.Depth
= (Depth
< 8) ? 8 : Depth
;
520 MZ_RunInThread(VGA_DoSetMode
, (ULONG_PTR
)&par
);
524 int VGA_GetMode(unsigned*Height
,unsigned*Width
,unsigned*Depth
)
526 if (!lpddraw
) return 1;
527 if (!lpddsurf
) return 1;
528 if (Height
) *Height
=sdesc
.dwHeight
;
529 if (Width
) *Width
=sdesc
.dwWidth
;
530 if (Depth
) *Depth
=sdesc
.ddpfPixelFormat
.u1
.dwRGBBitCount
;
534 static void VGA_Exit(void)
536 if (lpddraw
) MZ_RunInThread(VGA_DoExit
, 0);
539 void VGA_SetPalette(PALETTEENTRY
*pal
,int start
,int len
)
541 if (!lpddraw
) return;
542 IDirectDrawPalette_SetEntries(lpddpal
,0,start
,len
,pal
);
545 /* set a single [char wide] color in 16 color mode. */
546 void VGA_SetColor16(int reg
,int color
)
550 if (!lpddraw
) return;
551 pal
= &vga_def64_palette
[color
];
552 IDirectDrawPalette_SetEntries(lpddpal
,0,reg
,1,pal
);
553 vga_16_palette
[reg
]=(char)color
;
556 /* Get a single [char wide] color in 16 color mode. */
557 char VGA_GetColor16(int reg
)
560 if (!lpddraw
) return 0;
561 return vga_16_palette
[reg
];
564 /* set all 17 [char wide] colors at once in 16 color mode. */
565 void VGA_Set16Palette(char *Table
)
570 if (!lpddraw
) return; /* return if we're in text only mode */
571 memcpy( Table
, vga_16_palette
, 17 ); /* copy the entries into the table */
573 for (c
=0; c
<17; c
++) { /* 17 entries */
574 pal
= &vga_def64_palette
[(int)vga_16_palette
[c
]]; /* get color */
575 IDirectDrawPalette_SetEntries(lpddpal
,0,c
,1,pal
); /* set entry */
576 TRACE("Palette register %d set to %d\n",c
,(int)vga_16_palette
[c
]);
577 } /* end of the counting loop */
580 /* Get all 17 [ char wide ] colors at once in 16 color mode. */
581 void VGA_Get16Palette(char *Table
)
584 if (!lpddraw
) return; /* return if we're in text only mode */
585 memcpy( vga_16_palette
, Table
, 17 ); /* copy the entries into the table */
588 void VGA_SetQuadPalette(RGBQUAD
*color
,int start
,int len
)
590 PALETTEENTRY pal
[256];
593 if (!lpddraw
) return;
594 for (c
=0; c
<len
; c
++) {
595 pal
[c
].peRed
=color
[c
].rgbRed
;
596 pal
[c
].peGreen
=color
[c
].rgbGreen
;
597 pal
[c
].peBlue
=color
[c
].rgbBlue
;
600 IDirectDrawPalette_SetEntries(lpddpal
,0,start
,len
,pal
);
603 static LPSTR
VGA_Lock(unsigned*Pitch
,unsigned*Height
,unsigned*Width
,unsigned*Depth
)
605 if (!lpddraw
) return NULL
;
606 if (!lpddsurf
) return NULL
;
607 if (IDirectDrawSurface_Lock(lpddsurf
,NULL
,&sdesc
,0,0) != S_OK
) {
608 ERR("could not lock surface!\n");
611 if (Pitch
) *Pitch
=sdesc
.u1
.lPitch
;
612 if (Height
) *Height
=sdesc
.dwHeight
;
613 if (Width
) *Width
=sdesc
.dwWidth
;
614 if (Depth
) *Depth
=sdesc
.ddpfPixelFormat
.u1
.dwRGBBitCount
;
615 return sdesc
.lpSurface
;
618 static void VGA_Unlock(void)
620 IDirectDrawSurface_Unlock(lpddsurf
,sdesc
.lpSurface
);
624 * Set start of 64k window at 0xa0000 in bytes.
625 * If value is -1, initialize color plane support.
626 * If value is >= 0, window contains direct copy of framebuffer.
628 void VGA_SetWindowStart(int start
)
630 if(start
== vga_fb_window
)
633 EnterCriticalSection(&vga_lock
);
635 if(vga_fb_window
== -1)
636 FIXME("Remove VGA memory emulation.\n");
638 VGA_SyncWindow( TRUE
);
640 vga_fb_window
= start
;
642 if(vga_fb_window
== -1)
643 FIXME("Install VGA memory emulation.\n");
645 VGA_SyncWindow( FALSE
);
647 LeaveCriticalSection(&vga_lock
);
651 * Get start of 64k window at 0xa0000 in bytes.
652 * Value is -1 in color plane modes.
654 int VGA_GetWindowStart(void)
656 return vga_fb_window
;
660 /**********************************************************************
663 * Callback for VGA_ShowMouse.
665 static void WINAPI
VGA_DoShowMouse( ULONG_PTR show
)
671 rv
= ShowCursor( show
);
673 while( show
? (rv
< 0) : (rv
>= 0) );
677 /**********************************************************************
680 * If argument is TRUE, unconditionally show mouse cursor.
681 * If argument is FALSE, unconditionally hide mouse cursor.
682 * This only works in graphics mode.
684 void VGA_ShowMouse( BOOL show
)
687 MZ_RunInThread( VGA_DoShowMouse
, (ULONG_PTR
)show
);
693 /* prepare the text mode video memory copy that is used to only
694 * update the video memory line that did get updated. */
695 static void VGA_PrepareVideoMemCopy(unsigned Xres
, unsigned Yres
)
701 * Allocate space for char + attr.
705 vga_text_old
= HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
706 vga_text_old
, Xres
* Yres
* 2 );
708 vga_text_old
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
710 p
= VGA_AlphaBuffer();
713 /* make sure the video mem copy contains the exact opposite of our
714 * actual text mode memory area to make sure the screen
715 * does get updated fully initially */
716 for (i
=0; i
< Xres
*Yres
*2; i
++)
717 *p2
++ = *p
++ ^ 0xff; /* XOR it */
720 /**********************************************************************
723 * Set VGA emulation to text mode.
725 void VGA_SetAlphaMode(unsigned Xres
,unsigned Yres
)
728 VGA_DeinstallTimer();
730 VGA_PrepareVideoMemCopy(Xres
, Yres
);
731 vga_text_width
= Xres
;
732 vga_text_height
= Yres
;
734 if (vga_text_x
>= vga_text_width
|| vga_text_y
>= vga_text_height
)
735 VGA_SetCursorPos(0,0);
737 if(vga_text_console
) {
741 SetConsoleScreenBufferSize( VGA_AlphaConsole(), size
);
743 /* poll every 30ms (33fps should provide adequate responsiveness) */
744 VGA_InstallTimer(30);
748 /**********************************************************************
751 * Initialize VGA text mode handling and return default text mode.
752 * This function does not set VGA emulation to text mode.
754 void VGA_InitAlphaMode(unsigned*Xres
,unsigned*Yres
)
756 CONSOLE_SCREEN_BUFFER_INFO info
;
758 if(GetConsoleScreenBufferInfo( VGA_AlphaConsole(), &info
))
760 vga_text_console
= TRUE
;
761 vga_text_x
= info
.dwCursorPosition
.X
;
762 vga_text_y
= info
.dwCursorPosition
.Y
;
763 vga_text_attr
= info
.wAttributes
;
764 *Xres
= info
.dwSize
.X
;
765 *Yres
= info
.dwSize
.Y
;
769 vga_text_console
= FALSE
;
772 vga_text_attr
= 0x0f;
778 /**********************************************************************
781 * Get current text mode. Returns TRUE and sets resolution if
782 * any VGA text mode has been initialized.
784 BOOL
VGA_GetAlphaMode(unsigned*Xres
,unsigned*Yres
)
786 if (vga_text_width
!= 0 && vga_text_height
!= 0) {
787 *Xres
= vga_text_width
;
788 *Yres
= vga_text_height
;
794 void VGA_SetCursorShape(unsigned char start_options
, unsigned char end
)
796 CONSOLE_CURSOR_INFO cci
;
798 /* standard cursor settings:
799 * 0x0607 == CGA, 0x0b0c == monochrome, 0x0d0e == EGA/VGA */
801 /* calculate percentage from bottom - assuming VGA (bottom 0x0e) */
802 cci
.dwSize
= ((end
& 0x1f) - (start_options
& 0x1f))/0x0e * 100;
803 if (!cci
.dwSize
) cci
.dwSize
++; /* NULL cursor would make SCCI() fail ! */
804 cci
.bVisible
= ((start_options
& 0x60) != 0x20); /* invisible ? */
806 SetConsoleCursorInfo(VGA_AlphaConsole(),&cci
);
809 void VGA_SetCursorPos(unsigned X
,unsigned Y
)
815 void VGA_GetCursorPos(unsigned*X
,unsigned*Y
)
817 if (X
) *X
= vga_text_x
;
818 if (Y
) *Y
= vga_text_y
;
821 static void VGA_PutCharAt(unsigned x
, unsigned y
, BYTE ascii
, int attr
)
823 char *dat
= VGA_AlphaBuffer() + ((vga_text_width
* y
+ x
) * 2);
829 void VGA_WriteChars(unsigned X
,unsigned Y
,unsigned ch
,int attr
,int count
)
831 EnterCriticalSection(&vga_lock
);
834 VGA_PutCharAt(X
+ count
, Y
, ch
, attr
);
836 LeaveCriticalSection(&vga_lock
);
839 void VGA_PutChar(BYTE ascii
)
843 EnterCriticalSection(&vga_lock
);
850 VGA_PutCharAt(vga_text_x
, vga_text_y
, ' ', 0);
855 vga_text_x
+= ((vga_text_x
+ 8) & ~7) - vga_text_x
;
871 VGA_PutCharAt(vga_text_x
, vga_text_y
, ascii
, vga_text_attr
);
875 if (vga_text_x
>= vga_text_width
)
881 if (vga_text_y
>= vga_text_height
)
883 vga_text_y
= vga_text_height
- 1;
884 VGA_ScrollUpText( 0, 0,
885 vga_text_height
- 1, vga_text_width
- 1,
890 * If we don't have a console, write directly to standard output.
892 if(!vga_text_console
)
893 WriteFile(VGA_AlphaConsole(), &ascii
, 1, &w
, NULL
);
895 LeaveCriticalSection(&vga_lock
);
898 void VGA_SetTextAttribute(BYTE attr
)
900 vga_text_attr
= attr
;
903 void VGA_ClearText(unsigned row1
, unsigned col1
,
904 unsigned row2
, unsigned col2
,
909 EnterCriticalSection(&vga_lock
);
911 for(y
=row1
; y
<=row2
; y
++)
912 for(x
=col1
; x
<=col2
; x
++)
913 VGA_PutCharAt(x
, y
, 0x20, attr
);
915 LeaveCriticalSection(&vga_lock
);
918 void VGA_ScrollUpText(unsigned row1
, unsigned col1
,
919 unsigned row2
, unsigned col2
,
920 unsigned lines
, BYTE attr
)
922 char *buffer
= VGA_AlphaBuffer();
925 EnterCriticalSection(&vga_lock
);
930 for (y
= row1
; y
<= row2
- lines
; y
++)
931 memmove( buffer
+ col1
+ y
* vga_text_width
* 2,
932 buffer
+ col1
+ (y
+ lines
) * vga_text_width
* 2,
933 (col2
- col1
+ 1) * 2 );
936 * Fill exposed lines.
938 for (y
= max(row1
, row2
- lines
+ 1); y
<= row2
; y
++)
939 VGA_WriteChars( col1
, y
, ' ', attr
, col2
- col1
+ 1 );
941 LeaveCriticalSection(&vga_lock
);
944 void VGA_ScrollDownText(unsigned row1
, unsigned col1
,
945 unsigned row2
, unsigned col2
,
946 unsigned lines
, BYTE attr
)
948 char *buffer
= VGA_AlphaBuffer();
951 EnterCriticalSection(&vga_lock
);
956 for (y
= row2
; y
>= row1
+ lines
; y
--)
957 memmove( buffer
+ col1
+ y
* vga_text_width
* 2,
958 buffer
+ col1
+ (y
- lines
) * vga_text_width
* 2,
959 (col2
- col1
+ 1) * 2 );
962 * Fill exposed lines.
964 for (y
= row1
; y
<= min(row1
+ lines
- 1, row2
); y
++)
965 VGA_WriteChars( col1
, y
, ' ', attr
, col2
- col1
+ 1 );
967 LeaveCriticalSection(&vga_lock
);
970 void VGA_GetCharacterAtCursor(BYTE
*ascii
, BYTE
*attr
)
974 dat
= VGA_AlphaBuffer() + ((vga_text_width
* vga_text_y
+ vga_text_x
) * 2);
983 /* FIXME: optimize by doing this only if the data has actually changed
984 * (in a way similar to DIBSection, perhaps) */
985 static void VGA_Poll_Graphics(void)
987 unsigned int Pitch
, Height
, Width
, X
, Y
;
989 char *dat
= vga_fb_data
+ vga_fb_offset
;
990 int bpp
= (vga_fb_depth
+ 7) / 8;
992 surf
= VGA_Lock(&Pitch
,&Height
,&Width
,NULL
);
996 * Synchronize framebuffer contents.
998 if (vga_fb_window
!= -1)
999 VGA_SyncWindow( TRUE
);
1002 * Double VGA framebuffer (320x200 -> 640x400), if needed.
1004 if(Height
>= 2 * vga_fb_height
&& Width
>= 2 * vga_fb_width
&& bpp
== 1)
1005 for (Y
=0; Y
<vga_fb_height
; Y
++,surf
+=Pitch
*2,dat
+=vga_fb_pitch
)
1006 for (X
=0; X
<vga_fb_width
; X
++) {
1007 BYTE value
= dat
[X
];
1009 surf
[X
*2+1] = value
;
1010 surf
[X
*2+Pitch
] = value
;
1011 surf
[X
*2+Pitch
+1] = value
;
1014 for (Y
=0; Y
<vga_fb_height
; Y
++,surf
+=Pitch
,dat
+=vga_fb_pitch
)
1015 memcpy(surf
, dat
, vga_fb_width
* bpp
);
1020 static void VGA_Poll_Text(void)
1022 char *dat
, *old
, *p_line
;
1024 CHAR_INFO ch
[256]; /* that should suffice for the largest text width */
1027 HANDLE con
= VGA_AlphaConsole();
1028 BOOL linechanged
= FALSE
; /* video memory area differs from stored copy? */
1030 /* Synchronize cursor position. */
1033 SetConsoleCursorPosition(con
,off
);
1035 dat
= VGA_AlphaBuffer();
1036 old
= vga_text_old
; /* pointer to stored video mem copy */
1037 siz
.X
= vga_text_width
; siz
.Y
= 1;
1038 off
.X
= 0; off
.Y
= 0;
1040 /* copy from virtual VGA frame buffer to console */
1041 for (Y
=0; Y
<vga_text_height
; Y
++) {
1042 linechanged
= memcmp(dat
, old
, vga_text_width
*2);
1045 /*TRACE("line %d changed\n", Y);*/
1047 for (X
=0; X
<vga_text_width
; X
++) {
1048 ch
[X
].Char
.AsciiChar
= *p_line
++;
1049 /* WriteConsoleOutputA doesn't like "dead" chars */
1050 if (ch
[X
].Char
.AsciiChar
== '\0')
1051 ch
[X
].Char
.AsciiChar
= ' ';
1052 ch
[X
].Attributes
= *p_line
++;
1054 dest
.Top
=Y
; dest
.Bottom
=Y
;
1055 dest
.Left
=0; dest
.Right
=vga_text_width
+1;
1056 WriteConsoleOutputA(con
, ch
, siz
, off
, &dest
);
1057 memcpy(old
, dat
, vga_text_width
*2);
1059 /* advance to next text line */
1060 dat
+= vga_text_width
*2;
1061 old
+= vga_text_width
*2;
1065 static void CALLBACK
VGA_Poll( LPVOID arg
, DWORD low
, DWORD high
)
1067 EnterCriticalSection(&vga_lock
);
1070 VGA_Poll_Graphics();
1075 * Fake start of retrace.
1077 vga_retrace_vertical
= TRUE
;
1079 LeaveCriticalSection(&vga_lock
);
1082 static BYTE palreg
,palcnt
;
1083 static PALETTEENTRY paldat
;
1085 void VGA_ioport_out( WORD port
, BYTE val
)
1089 if (vga_address_3c0
)
1090 vga_index_3c0
= val
;
1092 FIXME("Unsupported index, register 0x3c0: 0x%02x (value 0x%02x)\n",
1093 vga_index_3c0
, val
);
1094 vga_address_3c0
= !vga_address_3c0
;
1097 vga_index_3c4
= val
;
1100 switch(vga_index_3c4
) {
1101 case 0x04: /* Sequencer: Memory Mode Register */
1102 if(vga_fb_depth
== 8)
1103 VGA_SetWindowStart((val
& 8) ? 0 : -1);
1105 FIXME("Memory Mode Register not supported in this mode.\n");
1108 FIXME("Unsupported index, register 0x3c4: 0x%02x (value 0x%02x)\n",
1109 vga_index_3c4
, val
);
1113 palreg
=val
; palcnt
=0; break;
1115 ((BYTE
*)&paldat
)[palcnt
++]=val
<< 2;
1117 VGA_SetPalette(&paldat
,palreg
++,1);
1122 vga_index_3ce
= val
;
1125 FIXME("Unsupported index, register 0x3ce: 0x%02x (value 0x%02x)\n",
1126 vga_index_3ce
, val
);
1129 vga_index_3d4
= val
;
1132 FIXME("Unsupported index, register 0x3d4: 0x%02x (value 0x%02x)\n",
1133 vga_index_3d4
, val
);
1136 FIXME("Unsupported VGA register: 0x%04x (value 0x%02x)\n", port
, val
);
1140 BYTE
VGA_ioport_in( WORD port
)
1146 FIXME("Unsupported index, register 0x3c0: 0x%02x\n",
1150 switch(vga_index_3c4
) {
1151 case 0x04: /* Sequencer: Memory Mode Register */
1152 return (VGA_GetWindowStart() == -1) ? 0xf7 : 0xff;
1154 FIXME("Unsupported index, register 0x3c4: 0x%02x\n",
1159 FIXME("Unsupported index, register 0x3ce: 0x%02x\n",
1163 FIXME("Unsupported index, register 0x3d4: 0x%02x\n",
1169 * Read from this register resets register 0x3c0 address flip-flop.
1171 vga_address_3c0
= TRUE
;
1174 * Read from this register returns following bits:
1175 * xxxx1xxx = Vertical retrace in progress if set.
1176 * xxxxx1xx = Light pen switched on.
1177 * xxxxxx1x = Light pen trigger set.
1178 * xxxxxxx1 = Either vertical or horizontal retrace
1179 * in progress if set.
1182 if (vga_retrace_vertical
)
1184 if (vga_retrace_horizontal
)
1188 * If VGA mode has been set, vertical retrace is
1189 * turned on once a frame and cleared after each read.
1190 * This might cause applications that synchronize with
1191 * vertical retrace to actually skip one frame but that
1192 * is probably not a problem.
1194 * If no VGA mode has been set, vertical retrace is faked
1195 * by toggling the value after every read.
1197 if (VGA_IsTimerRunning())
1198 vga_retrace_vertical
= FALSE
;
1200 vga_retrace_vertical
= !vga_retrace_vertical
;
1203 * Toggle horizontal retrace.
1205 vga_retrace_horizontal
= !vga_retrace_horizontal
;
1210 FIXME("Unsupported VGA register: 0x%04x\n", port
);
1215 void VGA_Clean(void)
1218 VGA_DeinstallTimer();