[NTVDM]
[reactos.git] / subsystems / ntvdm / vga.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: vga.c
5 * PURPOSE: VGA hardware emulation
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #define NDEBUG
12
13 #include "vga.h"
14 #include "bios.h"
15
16 /* PRIVATE VARIABLES **********************************************************/
17
18 static CONST DWORD MemoryBase[] = { 0xA0000, 0xA0000, 0xB0000, 0xB8000 };
19 static CONST DWORD MemoryLimit[] = { 0xAFFFF, 0xAFFFF, 0xB7FFF, 0xBFFFF };
20
21 static CONST COLORREF VgaDefaultPalette[VGA_MAX_COLORS] =
22 {
23 RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0xAA), RGB(0x00, 0xAA, 0x00), RGB(0x00, 0xAA, 0xAA),
24 RGB(0xAA, 0x00, 0x00), RGB(0xAA, 0x00, 0xAA), RGB(0xAA, 0x55, 0x00), RGB(0xAA, 0xAA, 0xAA),
25 RGB(0x55, 0x55, 0x55), RGB(0x55, 0x55, 0xFF), RGB(0x55, 0xFF, 0x55), RGB(0x55, 0xFF, 0xFF),
26 RGB(0xFF, 0x55, 0x55), RGB(0xFF, 0x55, 0xFF), RGB(0xFF, 0xFF, 0x55), RGB(0xFF, 0xFF, 0xFF),
27 RGB(0x00, 0x00, 0x00), RGB(0x10, 0x10, 0x10), RGB(0x20, 0x20, 0x20), RGB(0x35, 0x35, 0x35),
28 RGB(0x45, 0x45, 0x45), RGB(0x55, 0x55, 0x55), RGB(0x65, 0x65, 0x65), RGB(0x75, 0x75, 0x75),
29 RGB(0x8A, 0x8A, 0x8A), RGB(0x9A, 0x9A, 0x9A), RGB(0xAA, 0xAA, 0xAA), RGB(0xBA, 0xBA, 0xBA),
30 RGB(0xCA, 0xCA, 0xCA), RGB(0xDF, 0xDF, 0xDF), RGB(0xEF, 0xEF, 0xEF), RGB(0xFF, 0xFF, 0xFF),
31 RGB(0x00, 0x00, 0xFF), RGB(0x41, 0x00, 0xFF), RGB(0x82, 0x00, 0xFF), RGB(0xBE, 0x00, 0xFF),
32 RGB(0xFF, 0x00, 0xFF), RGB(0xFF, 0x00, 0xBE), RGB(0xFF, 0x00, 0x82), RGB(0xFF, 0x00, 0x41),
33 RGB(0xFF, 0x00, 0x00), RGB(0xFF, 0x41, 0x00), RGB(0xFF, 0x82, 0x00), RGB(0xFF, 0xBE, 0x00),
34 RGB(0xFF, 0xFF, 0x00), RGB(0xBE, 0xFF, 0x00), RGB(0x82, 0xFF, 0x00), RGB(0x41, 0xFF, 0x00),
35 RGB(0x00, 0xFF, 0x00), RGB(0x00, 0xFF, 0x41), RGB(0x00, 0xFF, 0x82), RGB(0x00, 0xFF, 0xBE),
36 RGB(0x00, 0xFF, 0xFF), RGB(0x00, 0xBE, 0xFF), RGB(0x00, 0x82, 0xFF), RGB(0x00, 0x41, 0xFF),
37 RGB(0x82, 0x82, 0xFF), RGB(0x9E, 0x82, 0xFF), RGB(0xBE, 0x82, 0xFF), RGB(0xDF, 0x82, 0xFF),
38 RGB(0xFF, 0x82, 0xFF), RGB(0xFF, 0x82, 0xDF), RGB(0xFF, 0x82, 0xBE), RGB(0xFF, 0x82, 0x9E),
39 RGB(0xFF, 0x82, 0x82), RGB(0xFF, 0x9E, 0x82), RGB(0xFF, 0xBE, 0x82), RGB(0xFF, 0xDF, 0x82),
40 RGB(0xFF, 0xFF, 0x82), RGB(0xDF, 0xFF, 0x82), RGB(0xBE, 0xFF, 0x82), RGB(0x9E, 0xFF, 0x82),
41 RGB(0x82, 0xFF, 0x82), RGB(0x82, 0xFF, 0x9E), RGB(0x82, 0xFF, 0xBE), RGB(0x82, 0xFF, 0xDF),
42 RGB(0x82, 0xFF, 0xFF), RGB(0x82, 0xDF, 0xFF), RGB(0x82, 0xBE, 0xFF), RGB(0x82, 0x9E, 0xFF),
43 RGB(0xBA, 0xBA, 0xFF), RGB(0xCA, 0xBA, 0xFF), RGB(0xDF, 0xBA, 0xFF), RGB(0xEF, 0xBA, 0xFF),
44 RGB(0xFF, 0xBA, 0xFF), RGB(0xFF, 0xBA, 0xEF), RGB(0xFF, 0xBA, 0xDF), RGB(0xFF, 0xBA, 0xCA),
45 RGB(0xFF, 0xBA, 0xBA), RGB(0xFF, 0xCA, 0xBA), RGB(0xFF, 0xDF, 0xBA), RGB(0xFF, 0xEF, 0xBA),
46 RGB(0xFF, 0xFF, 0xBA), RGB(0xEF, 0xFF, 0xBA), RGB(0xDF, 0xFF, 0xBA), RGB(0xCA, 0xFF, 0xBA),
47 RGB(0xBA, 0xFF, 0xBA), RGB(0xBA, 0xFF, 0xCA), RGB(0xBA, 0xFF, 0xDF), RGB(0xBA, 0xFF, 0xEF),
48 RGB(0xBA, 0xFF, 0xFF), RGB(0xBA, 0xEF, 0xFF), RGB(0xBA, 0xDF, 0xFF), RGB(0xBA, 0xCA, 0xFF),
49 RGB(0x00, 0x00, 0x71), RGB(0x1C, 0x00, 0x71), RGB(0x39, 0x00, 0x71), RGB(0x55, 0x00, 0x71),
50 RGB(0x71, 0x00, 0x71), RGB(0x71, 0x00, 0x55), RGB(0x71, 0x00, 0x39), RGB(0x71, 0x00, 0x1C),
51 RGB(0x71, 0x00, 0x00), RGB(0x71, 0x1C, 0x00), RGB(0x71, 0x39, 0x00), RGB(0x71, 0x55, 0x00),
52 RGB(0x71, 0x71, 0x00), RGB(0x55, 0x71, 0x00), RGB(0x39, 0x71, 0x00), RGB(0x1C, 0x71, 0x00),
53 RGB(0x00, 0x71, 0x00), RGB(0x00, 0x71, 0x1C), RGB(0x00, 0x71, 0x39), RGB(0x00, 0x71, 0x55),
54 RGB(0x00, 0x71, 0x71), RGB(0x00, 0x55, 0x71), RGB(0x00, 0x39, 0x71), RGB(0x00, 0x1C, 0x71),
55 RGB(0x39, 0x39, 0x71), RGB(0x45, 0x39, 0x71), RGB(0x55, 0x39, 0x71), RGB(0x61, 0x39, 0x71),
56 RGB(0x71, 0x39, 0x71), RGB(0x71, 0x39, 0x61), RGB(0x71, 0x39, 0x55), RGB(0x71, 0x39, 0x45),
57 RGB(0x71, 0x39, 0x39), RGB(0x71, 0x45, 0x39), RGB(0x71, 0x55, 0x39), RGB(0x71, 0x61, 0x39),
58 RGB(0x71, 0x71, 0x39), RGB(0x61, 0x71, 0x39), RGB(0x55, 0x71, 0x39), RGB(0x45, 0x71, 0x39),
59 RGB(0x39, 0x71, 0x39), RGB(0x39, 0x71, 0x45), RGB(0x39, 0x71, 0x55), RGB(0x39, 0x71, 0x61),
60 RGB(0x39, 0x71, 0x71), RGB(0x39, 0x61, 0x71), RGB(0x39, 0x55, 0x71), RGB(0x39, 0x45, 0x71),
61 RGB(0x51, 0x51, 0x71), RGB(0x59, 0x51, 0x71), RGB(0x61, 0x51, 0x71), RGB(0x69, 0x51, 0x71),
62 RGB(0x71, 0x51, 0x71), RGB(0x71, 0x51, 0x69), RGB(0x71, 0x51, 0x61), RGB(0x71, 0x51, 0x59),
63 RGB(0x71, 0x51, 0x51), RGB(0x71, 0x59, 0x51), RGB(0x71, 0x61, 0x51), RGB(0x71, 0x69, 0x51),
64 RGB(0x71, 0x71, 0x51), RGB(0x69, 0x71, 0x51), RGB(0x61, 0x71, 0x51), RGB(0x59, 0x71, 0x51),
65 RGB(0x51, 0x71, 0x51), RGB(0x51, 0x71, 0x59), RGB(0x51, 0x71, 0x61), RGB(0x51, 0x71, 0x69),
66 RGB(0x51, 0x71, 0x71), RGB(0x51, 0x69, 0x71), RGB(0x51, 0x61, 0x71), RGB(0x51, 0x59, 0x71),
67 RGB(0x00, 0x00, 0x41), RGB(0x10, 0x00, 0x41), RGB(0x20, 0x00, 0x41), RGB(0x31, 0x00, 0x41),
68 RGB(0x41, 0x00, 0x41), RGB(0x41, 0x00, 0x31), RGB(0x41, 0x00, 0x20), RGB(0x41, 0x00, 0x10),
69 RGB(0x41, 0x00, 0x00), RGB(0x41, 0x10, 0x00), RGB(0x41, 0x20, 0x00), RGB(0x41, 0x31, 0x00),
70 RGB(0x41, 0x41, 0x00), RGB(0x31, 0x41, 0x00), RGB(0x20, 0x41, 0x00), RGB(0x10, 0x41, 0x00),
71 RGB(0x00, 0x41, 0x00), RGB(0x00, 0x41, 0x10), RGB(0x00, 0x41, 0x20), RGB(0x00, 0x41, 0x31),
72 RGB(0x00, 0x41, 0x41), RGB(0x00, 0x31, 0x41), RGB(0x00, 0x20, 0x41), RGB(0x00, 0x10, 0x41),
73 RGB(0x20, 0x20, 0x41), RGB(0x28, 0x20, 0x41), RGB(0x31, 0x20, 0x41), RGB(0x39, 0x20, 0x41),
74 RGB(0x41, 0x20, 0x41), RGB(0x41, 0x20, 0x39), RGB(0x41, 0x20, 0x31), RGB(0x41, 0x20, 0x28),
75 RGB(0x41, 0x20, 0x20), RGB(0x41, 0x28, 0x20), RGB(0x41, 0x31, 0x20), RGB(0x41, 0x39, 0x20),
76 RGB(0x41, 0x41, 0x20), RGB(0x39, 0x41, 0x20), RGB(0x31, 0x41, 0x20), RGB(0x28, 0x41, 0x20),
77 RGB(0x20, 0x41, 0x20), RGB(0x20, 0x41, 0x28), RGB(0x20, 0x41, 0x31), RGB(0x20, 0x41, 0x39),
78 RGB(0x20, 0x41, 0x41), RGB(0x20, 0x39, 0x41), RGB(0x20, 0x31, 0x41), RGB(0x20, 0x28, 0x41),
79 RGB(0x2D, 0x2D, 0x41), RGB(0x31, 0x2D, 0x41), RGB(0x35, 0x2D, 0x41), RGB(0x3D, 0x2D, 0x41),
80 RGB(0x41, 0x2D, 0x41), RGB(0x41, 0x2D, 0x3D), RGB(0x41, 0x2D, 0x35), RGB(0x41, 0x2D, 0x31),
81 RGB(0x41, 0x2D, 0x2D), RGB(0x41, 0x31, 0x2D), RGB(0x41, 0x35, 0x2D), RGB(0x41, 0x3D, 0x2D),
82 RGB(0x41, 0x41, 0x2D), RGB(0x3D, 0x41, 0x2D), RGB(0x35, 0x41, 0x2D), RGB(0x31, 0x41, 0x2D),
83 RGB(0x2D, 0x41, 0x2D), RGB(0x2D, 0x41, 0x31), RGB(0x2D, 0x41, 0x35), RGB(0x2D, 0x41, 0x3D),
84 RGB(0x2D, 0x41, 0x41), RGB(0x2D, 0x3D, 0x41), RGB(0x2D, 0x35, 0x41), RGB(0x2D, 0x31, 0x41),
85 RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00),
86 RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00)
87 };
88
89 static BYTE VgaMemory[VGA_NUM_BANKS * VGA_BANK_SIZE];
90 static BYTE VgaLatchRegisters[VGA_NUM_BANKS] = {0, 0, 0, 0};
91 static BYTE VgaMiscRegister;
92 static BYTE VgaSeqIndex = VGA_SEQ_RESET_REG;
93 static BYTE VgaSeqRegisters[VGA_SEQ_MAX_REG];
94 static BYTE VgaGcIndex = VGA_GC_RESET_REG;
95 static BYTE VgaGcRegisters[VGA_GC_MAX_REG];
96 static BYTE VgaCrtcIndex = VGA_CRTC_HORZ_TOTAL_REG;
97 static BYTE VgaCrtcRegisters[VGA_CRTC_MAX_REG];
98 static BYTE VgaAcIndex = VGA_AC_PAL_0_REG;
99 static BOOLEAN VgaAcLatch = FALSE;
100 static BYTE VgaAcRegisters[VGA_AC_MAX_REG];
101 static WORD VgaDacIndex = 0;
102 static BOOLEAN VgaDacReadWrite = FALSE;
103 static BYTE VgaDacRegisters[VGA_PALETTE_SIZE];
104 static HPALETTE PaletteHandle = NULL;
105 static BOOLEAN InVerticalRetrace = FALSE;
106 static BOOLEAN InHorizontalRetrace = FALSE;
107 static HANDLE TextConsoleBuffer = NULL;
108 static HANDLE GraphicsConsoleBuffer = NULL;
109 static LPVOID ConsoleFramebuffer = NULL;
110 static HANDLE ConsoleMutex = NULL;
111 static BOOLEAN NeedsUpdate = FALSE;
112 static BOOLEAN ModeChanged = TRUE;
113 static BOOLEAN CursorMoved = FALSE;
114 static BOOLEAN PaletteChanged = FALSE;
115 static BOOLEAN TextMode = TRUE;
116 static SMALL_RECT UpdateRectangle = { 0, 0, 0, 0 };
117
118 /* PRIVATE FUNCTIONS **********************************************************/
119
120 static inline INT VgaGetAddressSize(VOID)
121 {
122 if (VgaCrtcRegisters[VGA_CRTC_UNDERLINE_REG] & VGA_CRTC_UNDERLINE_DWORD)
123 {
124 /* Double-word addressing */
125 return 4;
126 }
127
128 if (VgaCrtcRegisters[VGA_CRTC_MODE_CONTROL_REG] & VGA_CRTC_MODE_CONTROL_BYTE)
129 {
130 /* Byte addressing */
131 return 1;
132 }
133
134 /* Word addressing */
135 return 2;
136 }
137
138 static inline DWORD VgaTranslateReadAddress(DWORD Address)
139 {
140 DWORD Offset = Address - VgaGetVideoBaseAddress();
141 BYTE Plane;
142
143 /* Check for chain-4 and odd-even mode */
144 if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
145 {
146 /* The lowest two bits are the plane number */
147 Plane = Offset & 3;
148 Offset >>= 2;
149 }
150 else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
151 {
152 /* The LSB is the plane number */
153 Plane = Offset & 1;
154 Offset >>= 1;
155 }
156 else
157 {
158 /* Use the read mode */
159 Plane = VgaGcRegisters[VGA_GC_READ_MAP_SEL_REG] & 0x03;
160 }
161
162 /* Multiply the offset by the address size */
163 Offset *= VgaGetAddressSize();
164
165 return Offset + Plane * VGA_BANK_SIZE;
166 }
167
168 static inline DWORD VgaTranslateWriteAddress(DWORD Address)
169 {
170 DWORD Offset = Address - VgaGetVideoBaseAddress();
171
172 /* Check for chain-4 and odd-even mode */
173 if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
174 {
175 /* Shift the offset to the right by 2 */
176 Offset >>= 2;
177 }
178 else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
179 {
180 /* Shift the offset to the right by 1 */
181 Offset >>= 1;
182 }
183
184 /* Multiply the offset by the address size */
185 Offset *= VgaGetAddressSize();
186
187 /* Return the offset on plane 0 */
188 return Offset;
189 }
190
191 static inline BYTE VgaTranslateByteForWriting(BYTE Data, BYTE Plane)
192 {
193 BYTE WriteMode = VgaGcRegisters[VGA_GC_MODE_REG] & 3;
194 BYTE LogicalOperation = (VgaGcRegisters[VGA_GC_ROTATE_REG] >> 3) & 3;
195 BYTE RotateCount = VgaGcRegisters[VGA_GC_ROTATE_REG] & 7;
196 BYTE BitMask = VgaGcRegisters[VGA_GC_BITMASK_REG];
197
198 if (WriteMode == 1)
199 {
200 /* In write mode 1 just return the latch register */
201 return VgaLatchRegisters[Plane];
202 }
203
204 if (WriteMode != 2)
205 {
206 /* Write modes 0 and 3 rotate the data to the right first */
207 Data = LOBYTE(((DWORD)Data >> RotateCount) | ((DWORD)Data << (8 - RotateCount)));
208 }
209 else
210 {
211 /* Write mode 2 expands the appropriate bit to all 8 bits */
212 Data = (Data & (1 << Plane)) ? 0xFF : 0x00;
213 }
214
215 if (WriteMode == 0)
216 {
217 /*
218 * In write mode 0, the enable set/reset register decides if the
219 * set/reset bit should be expanded to all 8 bits.
220 */
221 if (VgaGcRegisters[VGA_GC_ENABLE_RESET_REG] & (1 << Plane))
222 {
223 /* Copy the bit from the set/reset register to all 8 bits */
224 Data = (VgaGcRegisters[VGA_GC_RESET_REG] & (1 << Plane)) ? 0xFF : 0x00;
225 }
226 }
227
228 if (WriteMode != 3)
229 {
230 /* Write modes 0 and 2 then perform a logical operation on the data and latch */
231 if (LogicalOperation == 1) Data &= VgaLatchRegisters[Plane];
232 else if (LogicalOperation == 2) Data |= VgaLatchRegisters[Plane];
233 else if (LogicalOperation == 3) Data ^= VgaLatchRegisters[Plane];
234 }
235 else
236 {
237 /* For write mode 3, we AND the bitmask with the data, which is used as the new bitmask */
238 BitMask &= Data;
239
240 /* Then we expand the bit in the set/reset field */
241 Data = (VgaGcRegisters[VGA_GC_RESET_REG] & (1 << Plane)) ? 0xFF : 0x00;
242 }
243
244 /* Bits cleared in the bitmask are replaced with latch register bits */
245 Data = (Data & BitMask) | (VgaLatchRegisters[Plane] & (~BitMask));
246
247 /* Return the byte */
248 return Data;
249 }
250
251 static inline VOID VgaMarkForUpdate(SHORT Row, SHORT Column)
252 {
253 DPRINT("VgaMarkForUpdate: Row %d, Column %d\n", Row, Column);
254
255 /* Check if this is the first time the rectangle is updated */
256 if (!NeedsUpdate)
257 {
258 UpdateRectangle.Left = UpdateRectangle.Top = SHRT_MAX;
259 UpdateRectangle.Right = UpdateRectangle.Bottom = SHRT_MIN;
260 }
261
262 /* Expand the rectangle to include the point */
263 UpdateRectangle.Left = min(UpdateRectangle.Left, Column);
264 UpdateRectangle.Right = max(UpdateRectangle.Right, Column);
265 UpdateRectangle.Top = min(UpdateRectangle.Top, Row);
266 UpdateRectangle.Bottom = max(UpdateRectangle.Bottom, Row);
267
268 /* Set the update request flag */
269 NeedsUpdate = TRUE;
270 }
271
272 static VOID VgaWriteSequencer(BYTE Data)
273 {
274 ASSERT(VgaSeqIndex < VGA_SEQ_MAX_REG);
275
276 /* Save the value */
277 VgaSeqRegisters[VgaSeqIndex] = Data;
278 }
279
280 static VOID VgaWriteGc(BYTE Data)
281 {
282 ASSERT(VgaGcIndex < VGA_GC_MAX_REG);
283
284 /* Save the value */
285 VgaGcRegisters[VgaGcIndex] = Data;
286
287 /* Check the index */
288 switch (VgaGcIndex)
289 {
290 case VGA_GC_MISC_REG:
291 {
292 /* The GC misc register decides if it's text or graphics mode */
293 ModeChanged = TRUE;
294
295 break;
296 }
297 }
298 }
299
300 static VOID VgaWriteCrtc(BYTE Data)
301 {
302 ASSERT(VgaGcIndex < VGA_CRTC_MAX_REG);
303
304 /* Save the value */
305 VgaCrtcRegisters[VgaCrtcIndex] = Data;
306
307 /* Check the index */
308 switch (VgaCrtcIndex)
309 {
310 case VGA_CRTC_END_HORZ_DISP_REG:
311 case VGA_CRTC_VERT_DISP_END_REG:
312 case VGA_CRTC_OVERFLOW_REG:
313 {
314 /* The video mode has changed */
315 ModeChanged = TRUE;
316
317 break;
318 }
319
320 case VGA_CRTC_CURSOR_LOC_LOW_REG:
321 case VGA_CRTC_CURSOR_LOC_HIGH_REG:
322 case VGA_CRTC_CURSOR_START_REG:
323 case VGA_CRTC_CURSOR_END_REG:
324 {
325 /* Set the cursor moved flag */
326 CursorMoved = TRUE;
327
328 break;
329 }
330 }
331 }
332
333 static VOID VgaWriteDac(BYTE Data)
334 {
335 INT PaletteIndex;
336 PALETTEENTRY Entry;
337
338 /* Set the value */
339 VgaDacRegisters[VgaDacIndex] = Data;
340
341 /* Find the palette index */
342 PaletteIndex = VgaDacIndex / 3;
343
344 /* Fill the entry structure */
345 Entry.peRed = VGA_DAC_TO_COLOR(VgaDacRegisters[PaletteIndex * 3]);
346 Entry.peGreen = VGA_DAC_TO_COLOR(VgaDacRegisters[PaletteIndex * 3 + 1]);
347 Entry.peBlue = VGA_DAC_TO_COLOR(VgaDacRegisters[PaletteIndex * 3 + 2]);
348 Entry.peFlags = 0;
349
350 /* Update the palette entry */
351 SetPaletteEntries(PaletteHandle, PaletteIndex, 1, &Entry);
352
353 /* Set the palette change flag */
354 PaletteChanged = TRUE;
355
356 /* Update the index */
357 VgaDacIndex++;
358 VgaDacIndex %= VGA_PALETTE_SIZE;
359 }
360
361 static VOID VgaWriteAc(BYTE Data)
362 {
363 ASSERT(VgaAcIndex < VGA_AC_MAX_REG);
364
365 /* Save the value */
366 VgaAcRegisters[VgaAcIndex] = Data;
367 }
368
369 static BOOL VgaEnterGraphicsMode(PCOORD Resolution)
370 {
371 DWORD i;
372 CONSOLE_GRAPHICS_BUFFER_INFO GraphicsBufferInfo;
373 BYTE BitmapInfoBuffer[VGA_BITMAP_INFO_SIZE];
374 LPBITMAPINFO BitmapInfo = (LPBITMAPINFO)BitmapInfoBuffer;
375 LPWORD PaletteIndex = (LPWORD)(BitmapInfo->bmiColors);
376
377 /* Fill the bitmap info header */
378 ZeroMemory(&BitmapInfo->bmiHeader, sizeof(BITMAPINFOHEADER));
379 BitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
380 BitmapInfo->bmiHeader.biWidth = Resolution->X;
381 BitmapInfo->bmiHeader.biHeight = Resolution->Y;
382 BitmapInfo->bmiHeader.biBitCount = 8;
383 BitmapInfo->bmiHeader.biPlanes = 1;
384 BitmapInfo->bmiHeader.biCompression = BI_RGB;
385 BitmapInfo->bmiHeader.biSizeImage = Resolution->X * Resolution->Y /* * 1 == biBitCount / 8 */;
386
387 /* Fill the palette data */
388 for (i = 0; i < (VGA_PALETTE_SIZE / 3); i++) PaletteIndex[i] = (WORD)i;
389
390 /* Fill the console graphics buffer info */
391 GraphicsBufferInfo.dwBitMapInfoLength = VGA_BITMAP_INFO_SIZE;
392 GraphicsBufferInfo.lpBitMapInfo = BitmapInfo;
393 GraphicsBufferInfo.dwUsage = DIB_PAL_COLORS;
394
395 /* Create the buffer */
396 GraphicsConsoleBuffer = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
397 FILE_SHARE_READ | FILE_SHARE_WRITE,
398 NULL,
399 CONSOLE_GRAPHICS_BUFFER,
400 &GraphicsBufferInfo);
401 if (GraphicsConsoleBuffer == INVALID_HANDLE_VALUE) return FALSE;
402
403 /* Save the framebuffer address and mutex */
404 ConsoleFramebuffer = GraphicsBufferInfo.lpBitMap;
405 ConsoleMutex = GraphicsBufferInfo.hMutex;
406
407 /* Clear the framebuffer */
408 ZeroMemory(ConsoleFramebuffer, BitmapInfo->bmiHeader.biSizeImage);
409
410 /* Set the active buffer */
411 SetConsoleActiveScreenBuffer(GraphicsConsoleBuffer);
412
413 /* Set the graphics mode palette */
414 SetConsolePalette(GraphicsConsoleBuffer,
415 PaletteHandle,
416 SYSPAL_NOSTATIC256);
417
418 /* Clear the text mode flag */
419 TextMode = FALSE;
420
421 return TRUE;
422 }
423
424 static VOID VgaLeaveGraphicsMode(VOID)
425 {
426 /* Release the console framebuffer mutex if needed */
427 ReleaseMutex(ConsoleMutex);
428
429 /* Switch back to the text buffer */
430 SetConsoleActiveScreenBuffer(TextConsoleBuffer);
431
432 /* Cleanup the video data */
433 CloseHandle(ConsoleMutex);
434 ConsoleMutex = NULL;
435 CloseHandle(GraphicsConsoleBuffer);
436 GraphicsConsoleBuffer = NULL;
437 }
438
439 static BOOL VgaEnterTextMode(PCOORD Resolution)
440 {
441 /* Resize the console */
442 SetConsoleScreenBufferSize(TextConsoleBuffer, *Resolution);
443
444 /* Allocate a framebuffer */
445 ConsoleFramebuffer = HeapAlloc(GetProcessHeap(),
446 HEAP_ZERO_MEMORY,
447 Resolution->X * Resolution->Y
448 * sizeof(CHAR_INFO));
449 if (ConsoleFramebuffer == NULL)
450 {
451 DisplayMessage(L"An unexpected error occurred!\n");
452 VdmRunning = FALSE;
453 return FALSE;
454 }
455
456 /* Set the text mode flag */
457 TextMode = TRUE;
458
459 return TRUE;
460 }
461
462 static VOID VgaLeaveTextMode(VOID)
463 {
464 /* Free the old framebuffer */
465 HeapFree(GetProcessHeap(), 0, ConsoleFramebuffer);
466 ConsoleFramebuffer = NULL;
467 }
468
469 static VOID VgaChangeMode(VOID)
470 {
471 COORD Resolution = VgaGetDisplayResolution();
472
473 /* Reset the mode change flag */
474 // ModeChanged = FALSE;
475
476 if (!TextMode)
477 {
478 /* Leave the current graphics mode */
479 VgaLeaveGraphicsMode();
480 }
481 else
482 {
483 /* Leave the current text mode */
484 VgaLeaveTextMode();
485 }
486
487 /* Check if the new mode is alphanumeric */
488 if (!(VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA))
489 {
490 /* Enter new text mode */
491 if (!VgaEnterTextMode(&Resolution))
492 {
493 DisplayMessage(L"An unexpected VGA error occurred while switching into text mode.");
494 VdmRunning = FALSE;
495 return;
496 }
497 }
498 else
499 {
500 /* Enter 8-bit graphics mode */
501 if (!VgaEnterGraphicsMode(&Resolution))
502 {
503 DisplayMessage(L"An unexpected VGA error occurred while switching into graphics mode.");
504 VdmRunning = FALSE;
505 return;
506 }
507 }
508
509 /* Trigger a full update of the screen */
510 NeedsUpdate = TRUE;
511 UpdateRectangle.Left = 0;
512 UpdateRectangle.Top = 0;
513 UpdateRectangle.Right = Resolution.X;
514 UpdateRectangle.Bottom = Resolution.Y;
515
516 /* Reset the mode change flag */
517 ModeChanged = FALSE;
518 }
519
520 static VOID VgaUpdateFramebuffer(VOID)
521 {
522 INT i, j, k;
523 COORD Resolution = VgaGetDisplayResolution();
524 INT AddressSize = VgaGetAddressSize();
525 DWORD Address = (VgaCrtcRegisters[VGA_CRTC_START_ADDR_HIGH_REG] << 8)
526 + VgaCrtcRegisters[VGA_CRTC_START_ADDR_LOW_REG];
527 DWORD ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
528
529 /*
530 * If console framebuffer is NULL, that means something went wrong
531 * earlier and this is the final display refresh.
532 */
533 if (ConsoleFramebuffer == NULL) return;
534
535 /* Check if this is text mode or graphics mode */
536 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
537 {
538 /* Graphics mode */
539 PBYTE GraphicsBuffer = (PBYTE)ConsoleFramebuffer;
540
541 /*
542 * Synchronize access to the graphics framebuffer
543 * with the console framebuffer mutex.
544 */
545 WaitForSingleObject(ConsoleMutex, INFINITE);
546
547 /* Loop through the scanlines */
548 for (i = 0; i < Resolution.Y; i++)
549 {
550 /* Loop through the pixels */
551 for (j = 0; j < Resolution.X; j++)
552 {
553 BYTE PixelData = 0;
554
555 /* Check the shifting mode */
556 if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_SHIFT256)
557 {
558 /* 4 bits shifted from each plane */
559
560 /* Check if this is 16 or 256 color mode */
561 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
562 {
563 /* One byte per pixel */
564 PixelData = VgaMemory[(j % VGA_NUM_BANKS) * VGA_BANK_SIZE
565 + (Address + (j / VGA_NUM_BANKS))
566 * AddressSize];
567 }
568 else
569 {
570 /* 4-bits per pixel */
571
572 PixelData = VgaMemory[(j % VGA_NUM_BANKS) * VGA_BANK_SIZE
573 + (Address + (j / (VGA_NUM_BANKS * 2)))
574 * AddressSize];
575
576 /* Check if we should use the highest 4 bits or lowest 4 */
577 if (((j / VGA_NUM_BANKS) % 2) == 0)
578 {
579 /* Highest 4 */
580 PixelData >>= 4;
581 }
582 else
583 {
584 /* Lowest 4 */
585 PixelData &= 0x0F;
586 }
587 }
588 }
589 else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_SHIFTREG)
590 {
591 /* Check if this is 16 or 256 color mode */
592 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
593 {
594 // TODO: NOT IMPLEMENTED
595 DPRINT1("8-bit interleaved mode is not implemented!\n");
596 }
597 else
598 {
599 /*
600 * 2 bits shifted from plane 0 and 2 for the first 4 pixels,
601 * then 2 bits shifted from plane 1 and 3 for the next 4
602 */
603 BYTE LowPlaneData = VgaMemory[((j / 4) % 2) * VGA_BANK_SIZE
604 + (Address + (j / 4)) * AddressSize];
605 BYTE HighPlaneData = VgaMemory[(((j / 4) % 2) + 2) * VGA_BANK_SIZE
606 + (Address + (j / 4)) * AddressSize];
607
608 /* Extract the two bits from each plane */
609 LowPlaneData = (LowPlaneData >> (6 - ((j % 4) * 2))) & 3;
610 HighPlaneData = (HighPlaneData >> (6 - ((j % 4) * 2))) & 3;
611
612 /* Combine them into the pixel */
613 PixelData = LowPlaneData | (HighPlaneData << 2);
614 }
615 }
616 else
617 {
618 /* 1 bit shifted from each plane */
619
620 /* Check if this is 16 or 256 color mode */
621 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
622 {
623 /* 8 bits per pixel, 2 on each plane */
624
625 for (k = 0; k < VGA_NUM_BANKS; k++)
626 {
627 /* The data is on plane k, 4 pixels per byte */
628 BYTE PlaneData = VgaMemory[k * VGA_BANK_SIZE
629 + (Address + (j / 4)) * AddressSize];
630
631 /* The mask of the first bit in the pair */
632 BYTE BitMask = 1 << (((3 - (j % 4)) * 2) + 1);
633
634 /* Bits 0, 1, 2 and 3 come from the first bit of the pair */
635 if (PlaneData & BitMask) PixelData |= 1 << k;
636
637 /* Bits 4, 5, 6 and 7 come from the second bit of the pair */
638 if (PlaneData & (BitMask >> 1)) PixelData |= 1 << (k + 4);
639 }
640 }
641 else
642 {
643 /* 4 bits per pixel, 1 on each plane */
644
645 for (k = 0; k < VGA_NUM_BANKS; k++)
646 {
647 BYTE PlaneData = VgaMemory[k * VGA_BANK_SIZE
648 + (Address + (j / 8)) * AddressSize];
649
650 /* If the bit on that plane is set, set it */
651 if (PlaneData & (1 << (7 - (j % 8)))) PixelData |= 1 << k;
652 }
653 }
654 }
655
656 if (!(VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT))
657 {
658 /* In 16 color mode, the value is an index to the AC registers */
659 PixelData = VgaAcRegisters[PixelData];
660 }
661
662 /* Now check if the resulting pixel data has changed */
663 if (GraphicsBuffer[i * Resolution.X + j] != PixelData)
664 {
665 /* Yes, write the new value */
666 GraphicsBuffer[i * Resolution.X + j] = PixelData;
667
668 /* Mark the specified pixel as changed */
669 VgaMarkForUpdate(i, j);
670 }
671 }
672
673 /* Move to the next scanline */
674 Address += ScanlineSize;
675 }
676
677 /*
678 * Release the console framebuffer mutex
679 * so that we allow for repainting.
680 */
681 ReleaseMutex(ConsoleMutex);
682 }
683 else
684 {
685 /* Text mode */
686 PCHAR_INFO CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
687
688 /* Loop through the scanlines */
689 for (i = 0; i < Resolution.Y; i++)
690 {
691 /* Loop through the characters */
692 for (j = 0; j < Resolution.X; j++)
693 {
694 DWORD CurrentAddr = LOWORD((Address + j) * AddressSize);
695 CHAR_INFO CharInfo;
696
697 /* Plane 0 holds the character itself */
698 CharInfo.Char.AsciiChar = VgaMemory[CurrentAddr];
699
700 /* Plane 1 holds the attribute */
701 CharInfo.Attributes = VgaMemory[CurrentAddr + VGA_BANK_SIZE];
702
703 /* Now check if the resulting character data has changed */
704 if ((CharBuffer[i * Resolution.X + j].Char.AsciiChar != CharInfo.Char.AsciiChar)
705 || (CharBuffer[i * Resolution.X + j].Attributes != CharInfo.Attributes))
706 {
707 /* Yes, write the new value */
708 CharBuffer[i * Resolution.X + j] = CharInfo;
709
710 /* Mark the specified cell as changed */
711 VgaMarkForUpdate(i, j);
712 }
713 }
714
715 /* Move to the next scanline */
716 Address += ScanlineSize;
717 }
718 }
719 }
720
721 static VOID VgaUpdateTextCursor(VOID)
722 {
723 COORD Position;
724 CONSOLE_CURSOR_INFO CursorInfo;
725 BYTE CursorStart = VgaCrtcRegisters[VGA_CRTC_CURSOR_START_REG] & 0x3F;
726 BYTE CursorEnd = VgaCrtcRegisters[VGA_CRTC_CURSOR_END_REG] & 0x1F;
727 DWORD ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
728 BYTE TextSize = 1 + (VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F);
729 WORD Location = MAKEWORD(VgaCrtcRegisters[VGA_CRTC_CURSOR_LOC_LOW_REG],
730 VgaCrtcRegisters[VGA_CRTC_CURSOR_LOC_HIGH_REG]);
731
732 if (CursorStart < CursorEnd)
733 {
734 /* Visible cursor */
735 CursorInfo.bVisible = TRUE;
736 CursorInfo.dwSize = (100 * (CursorEnd - CursorStart)) / TextSize;
737 }
738 else
739 {
740 /* No cursor */
741 CursorInfo.bVisible = FALSE;
742 CursorInfo.dwSize = 0;
743 }
744
745 /* Add the cursor skew to the location */
746 Location += (VgaCrtcRegisters[VGA_CRTC_CURSOR_END_REG] >> 5) & 3;
747
748 /* Find the coordinates of the new position */
749 Position.X = (WORD)(Location % ScanlineSize);
750 Position.Y = (WORD)(Location / ScanlineSize);
751
752 /* Update the physical cursor */
753 SetConsoleCursorInfo(TextConsoleBuffer, &CursorInfo);
754 SetConsoleCursorPosition(TextConsoleBuffer, Position);
755
756 /* Reset the cursor move flag */
757 CursorMoved = FALSE;
758 }
759
760 /* PUBLIC FUNCTIONS ***********************************************************/
761
762 DWORD VgaGetVideoBaseAddress(VOID)
763 {
764 return MemoryBase[(VgaGcRegisters[VGA_GC_MISC_REG] >> 2) & 0x03];
765 }
766
767 DWORD VgaGetVideoLimitAddress(VOID)
768 {
769 return MemoryLimit[(VgaGcRegisters[VGA_GC_MISC_REG] >> 2) & 0x03];
770 }
771
772 COORD VgaGetDisplayResolution(VOID)
773 {
774 COORD Resolution;
775 BYTE MaximumScanLine = 1 + (VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F);
776
777 /* The low 8 bits are in the display registers */
778 Resolution.X = VgaCrtcRegisters[VGA_CRTC_END_HORZ_DISP_REG];
779 Resolution.Y = VgaCrtcRegisters[VGA_CRTC_VERT_DISP_END_REG];
780
781 /* Set the top bits from the overflow register */
782 if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE8)
783 {
784 Resolution.Y |= 1 << 8;
785 }
786 if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE9)
787 {
788 Resolution.Y |= 1 << 9;
789 }
790
791 /* Increase the values by 1 */
792 Resolution.X++;
793 Resolution.Y++;
794
795 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
796 {
797 /* Multiply the horizontal resolution by the 9/8 dot mode */
798 Resolution.X *= (VgaSeqRegisters[VGA_SEQ_CLOCK_REG] & VGA_SEQ_CLOCK_98DM)
799 ? 8 : 9;
800
801 /* The horizontal resolution is halved in 8-bit mode */
802 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT) Resolution.X /= 2;
803 }
804
805 /* Divide the vertical resolution by the maximum scan line (== font size in text mode) */
806 Resolution.Y /= MaximumScanLine;
807
808 /* Return the resolution */
809 return Resolution;
810 }
811
812 VOID VgaRefreshDisplay(VOID)
813 {
814 COORD Resolution = VgaGetDisplayResolution();
815
816 DPRINT("VgaRefreshDisplay\n");
817
818 /* Change the display mode */
819 if (ModeChanged) VgaChangeMode();
820
821 /* Change the text cursor location */
822 if (CursorMoved) VgaUpdateTextCursor();
823
824 if (PaletteChanged)
825 {
826 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
827 {
828 /* Trigger a full update of the screen */
829 NeedsUpdate = TRUE;
830 UpdateRectangle.Left = 0;
831 UpdateRectangle.Top = 0;
832 UpdateRectangle.Right = Resolution.X;
833 UpdateRectangle.Bottom = Resolution.Y;
834 }
835
836 PaletteChanged = FALSE;
837 }
838
839 /* Update the contents of the framebuffer */
840 VgaUpdateFramebuffer();
841
842 /* Set the vertical retrace flag */
843 InVerticalRetrace = TRUE;
844
845 /* Ignore if there's nothing to update */
846 if (!NeedsUpdate) return;
847
848 DPRINT("Updating screen rectangle (%d, %d, %d, %d)\n",
849 UpdateRectangle.Left,
850 UpdateRectangle.Top,
851 UpdateRectangle.Right,
852 UpdateRectangle.Bottom);
853
854 /* Check if this is text mode or graphics mode */
855 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
856 {
857 /* Graphics mode */
858
859 /* Redraw the screen */
860 InvalidateConsoleDIBits(GraphicsConsoleBuffer, &UpdateRectangle);
861 }
862 else
863 {
864 /* Text mode */
865 COORD Origin = { UpdateRectangle.Left, UpdateRectangle.Top };
866
867 /* Write the data to the console */
868 WriteConsoleOutputA(TextConsoleBuffer,
869 (PCHAR_INFO)ConsoleFramebuffer,
870 Resolution,
871 Origin,
872 &UpdateRectangle);
873
874 }
875
876 /* Clear the update flag */
877 NeedsUpdate = FALSE;
878 }
879
880 VOID VgaHorizontalRetrace(VOID)
881 {
882 /* Set the flag */
883 InHorizontalRetrace = TRUE;
884 }
885
886 VOID VgaReadMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
887 {
888 DWORD i;
889 DWORD VideoAddress;
890
891 DPRINT("VgaReadMemory: Address 0x%08X, Size %lu\n",
892 Address,
893 Size);
894
895 /* Ignore if video RAM access is disabled */
896 if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
897
898 /* Loop through each byte */
899 for (i = 0; i < Size; i++)
900 {
901 VideoAddress = VgaTranslateReadAddress(Address + i);
902
903 /* Load the latch registers */
904 VgaLatchRegisters[0] = VgaMemory[LOWORD(VideoAddress)];
905 VgaLatchRegisters[1] = VgaMemory[VGA_BANK_SIZE + LOWORD(VideoAddress)];
906 VgaLatchRegisters[2] = VgaMemory[(2 * VGA_BANK_SIZE) + LOWORD(VideoAddress)];
907 VgaLatchRegisters[3] = VgaMemory[(3 * VGA_BANK_SIZE) + LOWORD(VideoAddress)];
908
909 /* Copy the value to the buffer */
910 Buffer[i] = VgaMemory[VideoAddress];
911 }
912 }
913
914 VOID VgaWriteMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
915 {
916 DWORD i, j;
917 DWORD VideoAddress;
918
919 DPRINT("VgaWriteMemory: Address 0x%08X, Size %lu\n",
920 Address,
921 Size);
922
923 /* Ignore if video RAM access is disabled */
924 if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
925
926 /* Also ignore if write access to all planes is disabled */
927 if ((VgaSeqRegisters[VGA_SEQ_MASK_REG] & 0x0F) == 0x00) return;
928
929 /* Loop through each byte */
930 for (i = 0; i < Size; i++)
931 {
932 VideoAddress = VgaTranslateWriteAddress(Address + i);
933
934 for (j = 0; j < VGA_NUM_BANKS; j++)
935 {
936 /* Make sure the page is writeable */
937 if (!(VgaSeqRegisters[VGA_SEQ_MASK_REG] & (1 << j))) continue;
938
939 /* Check if this is chain-4 mode */
940 if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
941 {
942 if (((Address + i) & 3) != j)
943 {
944 /* This plane will not be accessed */
945 continue;
946 }
947 }
948
949 /* Check if this is odd-even mode */
950 if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
951 {
952 if (((Address + i) & 1) != (j & 1))
953 {
954 /* This plane will not be accessed */
955 continue;
956 }
957 }
958
959 /* Copy the value to the VGA memory */
960 VgaMemory[VideoAddress + j * VGA_BANK_SIZE] = VgaTranslateByteForWriting(Buffer[i], j);
961 }
962 }
963 }
964
965 BYTE VgaReadPort(WORD Port)
966 {
967 DPRINT("VgaReadPort: Port 0x%04X\n", Port);
968
969 switch (Port)
970 {
971 case VGA_AC_INDEX:
972 {
973 return VgaAcIndex;
974 }
975
976 case VGA_AC_READ:
977 {
978 return VgaAcRegisters[VgaAcIndex];
979 }
980
981 case VGA_SEQ_INDEX:
982 {
983 return VgaSeqIndex;
984 }
985
986 case VGA_SEQ_DATA:
987 {
988 return VgaSeqRegisters[VgaSeqIndex];
989 }
990
991 case VGA_DAC_READ_INDEX:
992 {
993 /* This returns the read/write state */
994 return VgaDacReadWrite ? 0 : 3;
995 }
996
997 case VGA_DAC_WRITE_INDEX:
998 {
999 return VgaDacIndex / 3;
1000 }
1001
1002 case VGA_DAC_DATA:
1003 {
1004 /* Ignore reads in write mode */
1005 if (!VgaDacReadWrite)
1006 {
1007 BYTE Data = VgaDacRegisters[VgaDacIndex++];
1008 VgaDacIndex %= VGA_PALETTE_SIZE;
1009 return Data;
1010 }
1011
1012 break;
1013 }
1014
1015 case VGA_MISC_READ:
1016 {
1017 return VgaMiscRegister;
1018 }
1019
1020 case VGA_CRTC_INDEX:
1021 {
1022 return VgaCrtcIndex;
1023 }
1024
1025 case VGA_CRTC_DATA:
1026 {
1027 return VgaCrtcRegisters[VgaCrtcIndex];
1028 }
1029
1030 case VGA_GC_INDEX:
1031 {
1032 return VgaGcIndex;
1033 }
1034
1035 case VGA_GC_DATA:
1036 {
1037 return VgaGcRegisters[VgaGcIndex];
1038 }
1039
1040 case VGA_STAT_MONO:
1041 case VGA_STAT_COLOR:
1042 {
1043 BYTE Result = 0;
1044
1045 /* Reset the AC latch */
1046 VgaAcLatch = FALSE;
1047
1048 /* Set a flag if there is a vertical or horizontal retrace */
1049 if (InVerticalRetrace || InHorizontalRetrace) Result |= VGA_STAT_DD;
1050
1051 /* Set an additional flag if there was a vertical retrace */
1052 if (InVerticalRetrace) Result |= VGA_STAT_VRETRACE;
1053
1054 /* Clear the flags */
1055 InHorizontalRetrace = InVerticalRetrace = FALSE;
1056
1057 return Result;
1058 }
1059 }
1060
1061 return 0;
1062 }
1063
1064 VOID VgaWritePort(WORD Port, BYTE Data)
1065 {
1066 DPRINT("VgaWritePort: Port 0x%04X, Data 0x%02X\n", Port, Data);
1067
1068 switch (Port)
1069 {
1070 case VGA_AC_INDEX:
1071 {
1072 if (!VgaAcLatch)
1073 {
1074 /* Change the index */
1075 if (Data < VGA_AC_MAX_REG) VgaAcIndex = Data;
1076 }
1077 else
1078 {
1079 /* Write the data */
1080 VgaWriteAc(Data);
1081 }
1082
1083 /* Toggle the latch */
1084 VgaAcLatch = !VgaAcLatch;
1085
1086 break;
1087 }
1088
1089 case VGA_SEQ_INDEX:
1090 {
1091 /* Set the sequencer index register */
1092 if (Data < VGA_SEQ_MAX_REG) VgaSeqIndex = Data;
1093
1094 break;
1095 }
1096
1097 case VGA_SEQ_DATA:
1098 {
1099 /* Call the sequencer function */
1100 VgaWriteSequencer(Data);
1101
1102 break;
1103 }
1104
1105 case VGA_DAC_READ_INDEX:
1106 {
1107 VgaDacReadWrite = FALSE;
1108 VgaDacIndex = Data * 3;
1109
1110 break;
1111 }
1112
1113 case VGA_DAC_WRITE_INDEX:
1114 {
1115 VgaDacReadWrite = TRUE;
1116 VgaDacIndex = Data * 3;
1117
1118 break;
1119 }
1120
1121 case VGA_DAC_DATA:
1122 {
1123 /* Ignore writes in read mode */
1124 if (VgaDacReadWrite) VgaWriteDac(Data & 0x3F);
1125
1126 break;
1127 }
1128
1129 case VGA_MISC_WRITE:
1130 {
1131 VgaMiscRegister = Data;
1132
1133 break;
1134 }
1135
1136 case VGA_CRTC_INDEX:
1137 {
1138 /* Set the CRTC index register */
1139 if (Data < VGA_CRTC_MAX_REG) VgaCrtcIndex = Data;
1140
1141 break;
1142 }
1143
1144 case VGA_CRTC_DATA:
1145 {
1146 /* Call the CRTC function */
1147 VgaWriteCrtc(Data);
1148
1149 break;
1150 }
1151
1152 case VGA_GC_INDEX:
1153 {
1154 /* Set the GC index register */
1155 if (Data < VGA_GC_MAX_REG) VgaGcIndex = Data;
1156 break;
1157 }
1158
1159 case VGA_GC_DATA:
1160 {
1161 /* Call the GC function */
1162 VgaWriteGc(Data);
1163
1164 break;
1165 }
1166 }
1167 }
1168
1169 VOID VgaClearMemory(VOID)
1170 {
1171 ZeroMemory(VgaMemory, sizeof(VgaMemory));
1172 }
1173
1174 BOOLEAN VgaInitialize(HANDLE TextHandle)
1175 {
1176 INT i, j;
1177 COORD Resolution;
1178 INT AddressSize;
1179 DWORD ScanlineSize;
1180 COORD Origin = { 0, 0 };
1181 SMALL_RECT ScreenRect;
1182 PCHAR_INFO CharBuffer;
1183 DWORD Address = 0;
1184 DWORD CurrentAddr;
1185 LPLOGPALETTE Palette;
1186
1187 /* Set the global handle */
1188 TextConsoleBuffer = TextHandle;
1189
1190 /* Clear the VGA memory */
1191 VgaClearMemory();
1192
1193 /* Set the default video mode */
1194 BiosSetVideoMode(BIOS_DEFAULT_VIDEO_MODE);
1195 VgaChangeMode();
1196
1197 /* Get the data */
1198 Resolution = VgaGetDisplayResolution();
1199 CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
1200 AddressSize = VgaGetAddressSize();
1201 ScreenRect.Left = ScreenRect.Top = 0;
1202 ScreenRect.Right = Resolution.X;
1203 ScreenRect.Bottom = Resolution.Y;
1204 ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
1205
1206 /* Read the data from the console into the framebuffer */
1207 ReadConsoleOutputA(TextConsoleBuffer,
1208 CharBuffer,
1209 Resolution,
1210 Origin,
1211 &ScreenRect);
1212
1213 /* Loop through the scanlines */
1214 for (i = 0; i < Resolution.Y; i++)
1215 {
1216 /* Loop through the characters */
1217 for (j = 0; j < Resolution.X; j++)
1218 {
1219 CurrentAddr = LOWORD((Address + j) * AddressSize);
1220
1221 /* Store the character in plane 0 */
1222 VgaMemory[CurrentAddr] = CharBuffer[i * Resolution.X + j].Char.AsciiChar;
1223
1224 /* Store the attribute in plane 1 */
1225 VgaMemory[CurrentAddr + VGA_BANK_SIZE] = (BYTE)CharBuffer[i * Resolution.X + j].Attributes;
1226 }
1227
1228 /* Move to the next scanline */
1229 Address += ScanlineSize;
1230 }
1231
1232 /* Allocate storage space for the palette */
1233 Palette = (LPLOGPALETTE)HeapAlloc(GetProcessHeap(),
1234 HEAP_ZERO_MEMORY,
1235 sizeof(LOGPALETTE)
1236 + VGA_MAX_COLORS * sizeof(PALETTEENTRY));
1237 if (Palette == NULL) return FALSE;
1238
1239 /* Initialize the palette */
1240 Palette->palVersion = 0x0300;
1241 Palette->palNumEntries = VGA_MAX_COLORS;
1242
1243 /* Copy the colors of the default palette to the DAC and console palette */
1244 for (i = 0; i < VGA_MAX_COLORS; i++)
1245 {
1246 /* Set the palette entries */
1247 Palette->palPalEntry[i].peRed = GetRValue(VgaDefaultPalette[i]);
1248 Palette->palPalEntry[i].peGreen = GetGValue(VgaDefaultPalette[i]);
1249 Palette->palPalEntry[i].peBlue = GetBValue(VgaDefaultPalette[i]);
1250 Palette->palPalEntry[i].peFlags = 0;
1251
1252 /* Set the DAC registers */
1253 VgaDacRegisters[i * 3] = VGA_COLOR_TO_DAC(GetRValue(VgaDefaultPalette[i]));
1254 VgaDacRegisters[i * 3 + 1] = VGA_COLOR_TO_DAC(GetGValue(VgaDefaultPalette[i]));
1255 VgaDacRegisters[i * 3 + 2] = VGA_COLOR_TO_DAC(GetBValue(VgaDefaultPalette[i]));
1256 }
1257
1258 /* Create the palette */
1259 PaletteHandle = CreatePalette(Palette);
1260
1261 /* Free the palette */
1262 HeapFree(GetProcessHeap(), 0, Palette);
1263
1264 /* Return success if the palette was successfully created */
1265 return (PaletteHandle ? TRUE : FALSE);
1266 }
1267
1268 /* EOF */