28a157ffa9742933847c25c5014f7123b5e80760
[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 BYTE 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)) return;
492 }
493 else
494 {
495 /* Enter 8-bit graphics mode */
496 if (!VgaEnterGraphicsMode(&Resolution)) return;
497 }
498
499 /* Trigger a full update of the screen */
500 NeedsUpdate = TRUE;
501 UpdateRectangle.Left = 0;
502 UpdateRectangle.Top = 0;
503 UpdateRectangle.Right = Resolution.X;
504 UpdateRectangle.Bottom = Resolution.Y;
505
506 /* Reset the mode change flag */
507 ModeChanged = FALSE;
508 }
509
510 static VOID VgaUpdateFramebuffer(VOID)
511 {
512 INT i, j, k;
513 COORD Resolution = VgaGetDisplayResolution();
514 INT AddressSize = VgaGetAddressSize();
515 DWORD Address = (VgaCrtcRegisters[VGA_CRTC_START_ADDR_HIGH_REG] << 8)
516 + VgaCrtcRegisters[VGA_CRTC_START_ADDR_LOW_REG];
517 DWORD ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
518
519 /* Check if this is text mode or graphics mode */
520 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
521 {
522 /* Graphics mode */
523 PBYTE GraphicsBuffer = (PBYTE)ConsoleFramebuffer;
524
525 /*
526 * Synchronize access to the graphics framebuffer
527 * with the console framebuffer mutex.
528 */
529 WaitForSingleObject(ConsoleMutex, INFINITE);
530
531 /* Loop through the scanlines */
532 for (i = 0; i < Resolution.Y; i++)
533 {
534 /* Loop through the pixels */
535 for (j = 0; j < Resolution.X; j++)
536 {
537 BYTE PixelData = 0;
538
539 /* Check the shifting mode */
540 if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_SHIFT256)
541 {
542 /* 4 bits shifted from each plane */
543
544 /* Check if this is 16 or 256 color mode */
545 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
546 {
547 /* One byte per pixel */
548 PixelData = VgaMemory[(j % VGA_NUM_BANKS) * VGA_BANK_SIZE
549 + (Address + (j / VGA_NUM_BANKS))
550 * AddressSize];
551 }
552 else
553 {
554 /* 4-bits per pixel */
555
556 PixelData = VgaMemory[(j % VGA_NUM_BANKS) * VGA_BANK_SIZE
557 + (Address + (j / (VGA_NUM_BANKS * 2)))
558 * AddressSize];
559
560 /* Check if we should use the highest 4 bits or lowest 4 */
561 if (((j / VGA_NUM_BANKS) % 2) == 0)
562 {
563 /* Highest 4 */
564 PixelData >>= 4;
565 }
566 else
567 {
568 /* Lowest 4 */
569 PixelData &= 0x0F;
570 }
571 }
572 }
573 else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_SHIFTREG)
574 {
575 /*
576 * 2 bits shifted from plane 0 and 2 for the first 4 pixels,
577 * then 2 bits shifted from plane 1 and 3 for the next 4
578 */
579
580 // TODO: NOT IMPLEMENTED!
581 DPRINT1("Interleaved shift mode is not implemented!\n");
582 }
583 else
584 {
585 /* 1 bit shifted from each plane */
586
587 /* Check if this is 16 or 256 color mode */
588 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
589 {
590 /* 8 bits per pixel, 2 on each plane */
591
592 for (k = 0; k < VGA_NUM_BANKS; k++)
593 {
594 /* The data is on plane k, 4 pixels per byte */
595 BYTE PlaneData = VgaMemory[k * VGA_BANK_SIZE
596 + (Address + (j / 4)) * AddressSize];
597
598 /* The mask of the first bit in the pair */
599 BYTE BitMask = 1 << (((3 - (j % 4)) * 2) + 1);
600
601 /* Bits 0, 1, 2 and 3 come from the first bit of the pair */
602 if (PlaneData & BitMask) PixelData |= 1 << k;
603
604 /* Bits 4, 5, 6 and 7 come from the second bit of the pair */
605 if (PlaneData & (BitMask >> 1)) PixelData |= 1 << (k + 4);
606 }
607 }
608 else
609 {
610 /* 4 bits per pixel, 1 on each plane */
611
612 for (k = 0; k < VGA_NUM_BANKS; k++)
613 {
614 BYTE PlaneData = VgaMemory[k * VGA_BANK_SIZE
615 + (Address + (j / 8)) * AddressSize];
616
617 /* If the bit on that plane is set, set it */
618 if (PlaneData & (1 << (7 - (j % 8)))) PixelData |= 1 << k;
619 }
620 }
621 }
622
623 /* Now check if the resulting pixel data has changed */
624 if (GraphicsBuffer[i * Resolution.X + j] != PixelData)
625 {
626 /* Yes, write the new value */
627 GraphicsBuffer[i * Resolution.X + j] = PixelData;
628
629 /* Mark the specified pixel as changed */
630 VgaMarkForUpdate(i, j);
631 }
632 }
633
634 /* Move to the next scanline */
635 Address += ScanlineSize;
636 }
637
638 /*
639 * Release the console framebuffer mutex
640 * so that we allow for repainting.
641 */
642 ReleaseMutex(ConsoleMutex);
643 }
644 else
645 {
646 /* Text mode */
647 PCHAR_INFO CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
648
649 /* Loop through the scanlines */
650 for (i = 0; i < Resolution.Y; i++)
651 {
652 /* Loop through the characters */
653 for (j = 0; j < Resolution.X; j++)
654 {
655 DWORD CurrentAddr = LOWORD((Address + j) * AddressSize);
656 CHAR_INFO CharInfo;
657
658 /* Plane 0 holds the character itself */
659 CharInfo.Char.AsciiChar = VgaMemory[CurrentAddr];
660
661 /* Plane 1 holds the attribute */
662 CharInfo.Attributes = VgaMemory[CurrentAddr + VGA_BANK_SIZE];
663
664 /* Now check if the resulting character data has changed */
665 if ((CharBuffer[i * Resolution.X + j].Char.AsciiChar != CharInfo.Char.AsciiChar)
666 || (CharBuffer[i * Resolution.X + j].Attributes != CharInfo.Attributes))
667 {
668 /* Yes, write the new value */
669 CharBuffer[i * Resolution.X + j] = CharInfo;
670
671 /* Mark the specified pixel as changed */
672 VgaMarkForUpdate(i, j);
673 }
674 }
675
676 /* Move to the next scanline */
677 Address += ScanlineSize;
678 }
679 }
680 }
681
682 static VOID VgaUpdateTextCursor(VOID)
683 {
684 COORD Position;
685 CONSOLE_CURSOR_INFO CursorInfo;
686 BYTE CursorStart = VgaCrtcRegisters[VGA_CRTC_CURSOR_START_REG] & 0x3F;
687 BYTE CursorEnd = VgaCrtcRegisters[VGA_CRTC_CURSOR_END_REG] & 0x1F;
688 DWORD ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
689 BYTE TextSize = 1 + (VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F);
690 WORD Location = MAKEWORD(VgaCrtcRegisters[VGA_CRTC_CURSOR_LOC_LOW_REG],
691 VgaCrtcRegisters[VGA_CRTC_CURSOR_LOC_HIGH_REG]);
692
693 if (CursorStart < CursorEnd)
694 {
695 /* Visible cursor */
696 CursorInfo.bVisible = TRUE;
697 CursorInfo.dwSize = (100 * (CursorEnd - CursorStart)) / TextSize;
698 }
699 else
700 {
701 /* No cursor */
702 CursorInfo.bVisible = FALSE;
703 CursorInfo.dwSize = 0;
704 }
705
706 /* Add the cursor skew to the location */
707 Location += (VgaCrtcRegisters[VGA_CRTC_CURSOR_END_REG] >> 5) & 3;
708
709 /* Find the coordinates of the new position */
710 Position.X = (WORD)(Location % ScanlineSize);
711 Position.Y = (WORD)(Location / ScanlineSize);
712
713 /* Update the physical cursor */
714 SetConsoleCursorInfo(TextConsoleBuffer, &CursorInfo);
715 SetConsoleCursorPosition(TextConsoleBuffer, Position);
716
717 /* Reset the cursor move flag */
718 CursorMoved = FALSE;
719 }
720
721 /* PUBLIC FUNCTIONS ***********************************************************/
722
723 DWORD VgaGetVideoBaseAddress(VOID)
724 {
725 return MemoryBase[(VgaGcRegisters[VGA_GC_MISC_REG] >> 2) & 0x03];
726 }
727
728 DWORD VgaGetVideoLimitAddress(VOID)
729 {
730 return MemoryLimit[(VgaGcRegisters[VGA_GC_MISC_REG] >> 2) & 0x03];
731 }
732
733 COORD VgaGetDisplayResolution(VOID)
734 {
735 COORD Resolution;
736 BYTE MaximumScanLine = 1 + (VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F);
737
738 /* The low 8 bits are in the display registers */
739 Resolution.X = VgaCrtcRegisters[VGA_CRTC_END_HORZ_DISP_REG];
740 Resolution.Y = VgaCrtcRegisters[VGA_CRTC_VERT_DISP_END_REG];
741
742 /* Set the top bits from the overflow register */
743 if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE8)
744 {
745 Resolution.Y |= 1 << 8;
746 }
747 if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE9)
748 {
749 Resolution.Y |= 1 << 9;
750 }
751
752 /* Increase the values by 1 */
753 Resolution.X++;
754 Resolution.Y++;
755
756 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
757 {
758 /* Multiply the horizontal resolution by the 9/8 dot mode */
759 Resolution.X *= (VgaSeqRegisters[VGA_SEQ_CLOCK_REG] & VGA_SEQ_CLOCK_98DM)
760 ? 8 : 9;
761
762 /* The horizontal resolution is halved in 8-bit mode */
763 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT) Resolution.X /= 2;
764 }
765
766 /* Divide the vertical resolution by the maximum scan line (== font size in text mode) */
767 Resolution.Y /= MaximumScanLine;
768
769 /* Return the resolution */
770 return Resolution;
771 }
772
773 VOID VgaRefreshDisplay(VOID)
774 {
775 COORD Resolution = VgaGetDisplayResolution();
776
777 DPRINT("VgaRefreshDisplay\n");
778
779 /* Change the display mode */
780 if (ModeChanged) VgaChangeMode();
781
782 /* Change the text cursor location */
783 if (CursorMoved) VgaUpdateTextCursor();
784
785 if (PaletteChanged)
786 {
787 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
788 {
789 /* Set the graphics mode palette */
790 //SetConsolePalette(GraphicsConsoleBuffer,
791 // PaletteHandle,
792 // SYSPAL_NOSTATIC256);
793
794 /* Trigger a full update of the screen */
795 NeedsUpdate = TRUE;
796 UpdateRectangle.Left = 0;
797 UpdateRectangle.Top = 0;
798 UpdateRectangle.Right = Resolution.X;
799 UpdateRectangle.Bottom = Resolution.Y;
800 }
801
802 PaletteChanged = FALSE;
803 }
804
805 /* Update the contents of the framebuffer */
806 VgaUpdateFramebuffer();
807
808 /* Set the vertical retrace flag */
809 InVerticalRetrace = TRUE;
810
811 /* Ignore if there's nothing to update */
812 if (!NeedsUpdate) return;
813
814 DPRINT("Updating screen rectangle (%d, %d, %d, %d)\n",
815 UpdateRectangle.Left,
816 UpdateRectangle.Top,
817 UpdateRectangle.Right,
818 UpdateRectangle.Bottom);
819
820 /* Check if this is text mode or graphics mode */
821 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
822 {
823 /* Graphics mode */
824
825 /* Redraw the screen */
826 InvalidateConsoleDIBits(GraphicsConsoleBuffer, &UpdateRectangle);
827 }
828 else
829 {
830 /* Text mode */
831 COORD Origin = { UpdateRectangle.Left, UpdateRectangle.Top };
832
833 /* Write the data to the console */
834 WriteConsoleOutputA(TextConsoleBuffer,
835 (PCHAR_INFO)ConsoleFramebuffer,
836 Resolution,
837 Origin,
838 &UpdateRectangle);
839
840 }
841
842 /* Clear the update flag */
843 NeedsUpdate = FALSE;
844 }
845
846 VOID VgaHorizontalRetrace(VOID)
847 {
848 /* Set the flag */
849 InHorizontalRetrace = TRUE;
850 }
851
852 VOID VgaReadMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
853 {
854 DWORD i;
855 DWORD VideoAddress;
856
857 DPRINT("VgaReadMemory: Address 0x%08X, Size %lu\n",
858 Address,
859 Size);
860
861 /* Ignore if video RAM access is disabled */
862 if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
863
864 /* Loop through each byte */
865 for (i = 0; i < Size; i++)
866 {
867 VideoAddress = VgaTranslateReadAddress(Address + i);
868
869 /* Load the latch registers */
870 VgaLatchRegisters[0] = VgaMemory[LOWORD(VideoAddress)];
871 VgaLatchRegisters[1] = VgaMemory[VGA_BANK_SIZE + LOWORD(VideoAddress)];
872 VgaLatchRegisters[2] = VgaMemory[(2 * VGA_BANK_SIZE) + LOWORD(VideoAddress)];
873 VgaLatchRegisters[3] = VgaMemory[(3 * VGA_BANK_SIZE) + LOWORD(VideoAddress)];
874
875 /* Copy the value to the buffer */
876 Buffer[i] = VgaMemory[VideoAddress];
877 }
878 }
879
880 VOID VgaWriteMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
881 {
882 DWORD i, j;
883 DWORD VideoAddress;
884
885 DPRINT("VgaWriteMemory: Address 0x%08X, Size %lu\n",
886 Address,
887 Size);
888
889 /* Ignore if video RAM access is disabled */
890 if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
891
892 /* Also ignore if write access to all planes is disabled */
893 if ((VgaSeqRegisters[VGA_SEQ_MASK_REG] & 0x0F) == 0x00) return;
894
895 /* Loop through each byte */
896 for (i = 0; i < Size; i++)
897 {
898 VideoAddress = VgaTranslateWriteAddress(Address + i);
899
900 for (j = 0; j < VGA_NUM_BANKS; j++)
901 {
902 /* Make sure the page is writeable */
903 if (!(VgaSeqRegisters[VGA_SEQ_MASK_REG] & (1 << j))) continue;
904
905 /* Check if this is chain-4 mode */
906 if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
907 {
908 if (((Address + i) & 3) != j)
909 {
910 /* This plane will not be accessed */
911 continue;
912 }
913 }
914
915 /* Check if this is odd-even mode */
916 if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
917 {
918 if (((Address + i) & 1) != (j & 1))
919 {
920 /* This plane will not be accessed */
921 continue;
922 }
923 }
924
925 /* Copy the value to the VGA memory */
926 VgaMemory[VideoAddress + j * VGA_BANK_SIZE] = VgaTranslateByteForWriting(Buffer[i], j);
927 }
928 }
929 }
930
931 BYTE VgaReadPort(WORD Port)
932 {
933 DPRINT("VgaReadPort: Port 0x%04X\n", Port);
934
935 switch (Port)
936 {
937 case VGA_AC_INDEX:
938 {
939 return VgaAcIndex;
940 }
941
942 case VGA_AC_READ:
943 {
944 return VgaAcRegisters[VgaAcIndex];
945 }
946
947 case VGA_SEQ_INDEX:
948 {
949 return VgaSeqIndex;
950 }
951
952 case VGA_SEQ_DATA:
953 {
954 return VgaSeqRegisters[VgaSeqIndex];
955 }
956
957 case VGA_DAC_READ_INDEX:
958 {
959 /* This returns the read/write state */
960 return VgaDacReadWrite ? 0 : 3;
961 }
962
963 case VGA_DAC_WRITE_INDEX:
964 {
965 return VgaDacIndex;
966 }
967
968 case VGA_DAC_DATA:
969 {
970 /* Ignore reads in write mode */
971 if (!VgaDacReadWrite)
972 {
973 BYTE Data = VgaDacRegisters[VgaDacIndex++];
974 VgaDacIndex %= VGA_PALETTE_SIZE;
975 return Data;
976 }
977
978 break;
979 }
980
981 case VGA_MISC_READ:
982 {
983 return VgaMiscRegister;
984 }
985
986 case VGA_CRTC_INDEX:
987 {
988 return VgaCrtcIndex;
989 }
990
991 case VGA_CRTC_DATA:
992 {
993 return VgaCrtcRegisters[VgaCrtcIndex];
994 }
995
996 case VGA_GC_INDEX:
997 {
998 return VgaGcIndex;
999 }
1000
1001 case VGA_GC_DATA:
1002 {
1003 return VgaGcRegisters[VgaGcIndex];
1004 }
1005
1006 case VGA_STAT_MONO:
1007 case VGA_STAT_COLOR:
1008 {
1009 BYTE Result = 0;
1010
1011 /* Reset the AC latch */
1012 VgaAcLatch = FALSE;
1013
1014 /* Set a flag if there is a vertical or horizontal retrace */
1015 if (InVerticalRetrace || InHorizontalRetrace) Result |= VGA_STAT_DD;
1016
1017 /* Set an additional flag if there was a vertical retrace */
1018 if (InVerticalRetrace) Result |= VGA_STAT_VRETRACE;
1019
1020 /* Clear the flags */
1021 InHorizontalRetrace = InVerticalRetrace = FALSE;
1022
1023 return Result;
1024 }
1025 }
1026
1027 return 0;
1028 }
1029
1030 VOID VgaWritePort(WORD Port, BYTE Data)
1031 {
1032 DPRINT("VgaWritePort: Port 0x%04X, Data 0x%02X\n", Port, Data);
1033
1034 switch (Port)
1035 {
1036 case VGA_AC_INDEX:
1037 {
1038 if (!VgaAcLatch)
1039 {
1040 /* Change the index */
1041 if (Data < VGA_AC_MAX_REG) VgaAcIndex = Data;
1042 }
1043 else
1044 {
1045 /* Write the data */
1046 VgaWriteAc(Data);
1047 }
1048
1049 /* Toggle the latch */
1050 VgaAcLatch = !VgaAcLatch;
1051
1052 break;
1053 }
1054
1055 case VGA_SEQ_INDEX:
1056 {
1057 /* Set the sequencer index register */
1058 if (Data < VGA_SEQ_MAX_REG) VgaSeqIndex = Data;
1059
1060 break;
1061 }
1062
1063 case VGA_SEQ_DATA:
1064 {
1065 /* Call the sequencer function */
1066 VgaWriteSequencer(Data);
1067
1068 break;
1069 }
1070
1071 case VGA_DAC_READ_INDEX:
1072 {
1073 VgaDacReadWrite = FALSE;
1074 VgaDacIndex = Data % VGA_PALETTE_SIZE;
1075
1076 break;
1077 }
1078
1079 case VGA_DAC_WRITE_INDEX:
1080 {
1081 VgaDacReadWrite = TRUE;
1082 VgaDacIndex = Data % VGA_PALETTE_SIZE;
1083
1084 break;
1085 }
1086
1087 case VGA_DAC_DATA:
1088 {
1089 /* Ignore writes in read mode */
1090 if (VgaDacReadWrite) VgaWriteDac(Data & 0x3F);
1091
1092 break;
1093 }
1094
1095 case VGA_MISC_WRITE:
1096 {
1097 VgaMiscRegister = Data;
1098
1099 break;
1100 }
1101
1102 case VGA_CRTC_INDEX:
1103 {
1104 /* Set the CRTC index register */
1105 if (Data < VGA_CRTC_MAX_REG) VgaCrtcIndex = Data;
1106
1107 break;
1108 }
1109
1110 case VGA_CRTC_DATA:
1111 {
1112 /* Call the CRTC function */
1113 VgaWriteCrtc(Data);
1114
1115 break;
1116 }
1117
1118 case VGA_GC_INDEX:
1119 {
1120 /* Set the GC index register */
1121 if (Data < VGA_GC_MAX_REG) VgaGcIndex = Data;
1122 break;
1123 }
1124
1125 case VGA_GC_DATA:
1126 {
1127 /* Call the GC function */
1128 VgaWriteGc(Data);
1129
1130 break;
1131 }
1132 }
1133 }
1134
1135 VOID VgaClearMemory(VOID)
1136 {
1137 ZeroMemory(VgaMemory, sizeof(VgaMemory));
1138 }
1139
1140 BOOLEAN VgaInitialize(HANDLE TextHandle)
1141 {
1142 INT i, j;
1143 COORD Resolution;
1144 INT AddressSize;
1145 DWORD ScanlineSize;
1146 COORD Origin = { 0, 0 };
1147 SMALL_RECT ScreenRect;
1148 PCHAR_INFO CharBuffer;
1149 DWORD Address = 0;
1150 DWORD CurrentAddr;
1151 LPLOGPALETTE Palette;
1152
1153 /* Set the global handle */
1154 TextConsoleBuffer = TextHandle;
1155
1156 /* Clear the VGA memory */
1157 ZeroMemory(VgaMemory, VGA_NUM_BANKS * VGA_BANK_SIZE);
1158
1159 /* Set the default video mode */
1160 BiosSetVideoMode(BIOS_DEFAULT_VIDEO_MODE);
1161 VgaChangeMode();
1162
1163 /* Get the data */
1164 Resolution = VgaGetDisplayResolution();
1165 CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
1166 AddressSize = VgaGetAddressSize();
1167 ScreenRect.Left = ScreenRect.Top = 0;
1168 ScreenRect.Right = Resolution.X;
1169 ScreenRect.Bottom = Resolution.Y;
1170 ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
1171
1172 /* Read the data from the console into the framebuffer */
1173 ReadConsoleOutputA(TextConsoleBuffer,
1174 CharBuffer,
1175 Resolution,
1176 Origin,
1177 &ScreenRect);
1178
1179 /* Loop through the scanlines */
1180 for (i = 0; i < Resolution.Y; i++)
1181 {
1182 /* Loop through the characters */
1183 for (j = 0; j < Resolution.X; j++)
1184 {
1185 CurrentAddr = LOWORD((Address + j) * AddressSize);
1186
1187 /* Store the character in plane 0 */
1188 VgaMemory[CurrentAddr] = CharBuffer[i * Resolution.X + j].Char.AsciiChar;
1189
1190 /* Store the attribute in plane 1 */
1191 VgaMemory[CurrentAddr + VGA_BANK_SIZE] = (BYTE)CharBuffer[i * Resolution.X + j].Attributes;
1192 }
1193
1194 /* Move to the next scanline */
1195 Address += ScanlineSize;
1196 }
1197
1198 /* Allocate storage space for the palette */
1199 Palette = (LPLOGPALETTE)HeapAlloc(GetProcessHeap(),
1200 HEAP_ZERO_MEMORY,
1201 sizeof(LOGPALETTE)
1202 + VGA_MAX_COLORS * sizeof(PALETTEENTRY));
1203 if (Palette == NULL) return FALSE;
1204
1205 /* Initialize the palette */
1206 Palette->palVersion = 0x0300;
1207 Palette->palNumEntries = VGA_MAX_COLORS;
1208
1209 /* Copy the colors of the default palette to the DAC and console palette */
1210 for (i = 0; i < VGA_MAX_COLORS; i++)
1211 {
1212 /* Set the palette entries */
1213 Palette->palPalEntry[i].peRed = GetRValue(VgaDefaultPalette[i]);
1214 Palette->palPalEntry[i].peGreen = GetGValue(VgaDefaultPalette[i]);
1215 Palette->palPalEntry[i].peBlue = GetBValue(VgaDefaultPalette[i]);
1216 Palette->palPalEntry[i].peFlags = 0;
1217
1218 /* Set the DAC registers */
1219 VgaDacRegisters[i * 3] = VGA_COLOR_TO_DAC(GetRValue(VgaDefaultPalette[i]));
1220 VgaDacRegisters[i * 3 + 1] = VGA_COLOR_TO_DAC(GetGValue(VgaDefaultPalette[i]));
1221 VgaDacRegisters[i * 3 + 2] = VGA_COLOR_TO_DAC(GetBValue(VgaDefaultPalette[i]));
1222 }
1223
1224 /* Create the palette */
1225 PaletteHandle = CreatePalette(Palette);
1226
1227 /* Free the palette */
1228 HeapFree(GetProcessHeap(), 0, Palette);
1229
1230 /* Return success if the palette was successfully created */
1231 return (PaletteHandle ? TRUE : FALSE);
1232 }
1233
1234 /* EOF */