![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256|
Return to screen.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: screen.c
3: *
4: * Initializes the GDIINFO and DEVINFO structures for DrvEnablePDEV.
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8:
9: #include "driver.h"
10:
11: #define SYSTM_LOGFONT {16,7,0,0,700,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS, \
12: CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,VARIABLE_PITCH | \
13: FF_DONTCARE,L"System"}
14: #define HELVE_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS, \
15: CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | \
16: FF_DONTCARE,L"MS Sans Serif"}
17: #define COURI_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS, \
18: CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | \
19: FF_DONTCARE, L"Courier"}
20:
21: // This is the basic devinfo for a default driver. This is used as a base and customized based
22: // on information passed back from the miniport driver.
23:
24: const DEVINFO gDevInfoFrameBuffer = {
25: (GCAPS_OPAQUERECT | // Graphics capabilities
26: GCAPS_PALMANAGED |
27: GCAPS_ALTERNATEFILL |
28: GCAPS_WINDINGFILL |
29: GCAPS_MONO_DITHER |
30: GCAPS_COLOR_DITHER |
31: GCAPS_TRAPPAINT),
32:
33: // Should also implement GCAPS_HORIZSTRIKE so that the underlines
34: // aren't drawn using DrvBitBlt
35:
36: SYSTM_LOGFONT, // Default font description
37: HELVE_LOGFONT, // ANSI variable font description
38: COURI_LOGFONT, // ANSI fixed font description
39: 0, // Count of device fonts
40: BMF_8BPP, // Preferred DIB format
41: 8, // Width of color dither
42: 8, // Height of color dither
43: 0 // Default palette to use for this device
44: };
45:
46: /******************************Public*Routine******************************\
47: * bInitSURF
48: *
49: * Enables the surface. Maps the frame buffer into memory.
50: *
51: \**************************************************************************/
52:
53: BOOL bInitSURF(PPDEV ppdev, BOOL bFirst)
54: {
55: VIDEO_MEMORY VideoMemory;
56: VIDEO_MEMORY_INFORMATION VideoMemoryInfo;
57: DWORD ReturnedDataLength;
58:
59: // Set the mode.
60:
61: if (!DeviceIoControl(ppdev->hDriver,
62: IOCTL_VIDEO_SET_CURRENT_MODE,
63: (LPVOID) &ppdev->ulMode, // input buffer
64: sizeof(DWORD),
65: NULL,
66: 0,
67: &ReturnedDataLength,
68: NULL))
69: {
70: RIP("Failed SET_CURRENT_MODE");
71: return(FALSE);
72: }
73:
74: if (bFirst)
75: {
76: // Get the linear memory address range.
77:
78: VideoMemory.RequestedVirtualAddress = NULL;
79:
80: if (!DeviceIoControl(ppdev->hDriver,
81: IOCTL_VIDEO_MAP_VIDEO_MEMORY,
82: (PVOID) &VideoMemory, // input buffer
83: sizeof (VIDEO_MEMORY),
84: (PVOID) &VideoMemoryInfo, // output buffer
85: sizeof (VideoMemoryInfo),
86: &ReturnedDataLength,
87: NULL))
88: {
89: RIP("Failed MAP_VIDEO_MEMORY");
90: return(FALSE);
91: }
92: }
93:
94: // Record the Frame Buffer Linear Address.
95:
96: if (bFirst)
97: {
98: ppdev->pjScreen = (PBYTE) VideoMemoryInfo.FrameBufferBase;
99: }
100:
101: // Set the various write mode values, so we don't have to read before write
102: // later on
103:
104: vSetWriteModes(&ppdev->ulrm0_wmX);
105:
106: // Initialize the VGA registers to their default states, so that we
107: // can be sure of drawing properly even when the miniport didn't
108: // happen to set them the way we like them:
109:
110: vInitRegs(ppdev);
111:
112: // Since we just did a mode-set, we'll be in non-planar mode. And make
113: // sure we reset the bank manager (otherwise, after a switch from full-
114: // screen, we may think we've got one bank mapped in, when in fact there's
115: // a different one mapped in, and bad things would happen...).
116:
117: ppdev->flBank &= ~BANK_PLANAR;
118:
119: ppdev->rcl1WindowClip.bottom = -1;
120: ppdev->rcl2WindowClip[0].bottom = -1;
121: ppdev->rcl2WindowClip[1].bottom = -1;
122:
123: ppdev->rcl1PlanarClip.bottom = -1;
124: ppdev->rcl2PlanarClip[0].bottom = -1;
125: ppdev->rcl2PlanarClip[1].bottom = -1;
126:
127: return(TRUE);
128: }
129:
130: /******************************Public*Routine******************************\
131: * vDisableSURF
132: *
133: * Disable the surface. Un-Maps the frame in memory.
134: *
135: \**************************************************************************/
136:
137: VOID vDisableSURF(PPDEV ppdev)
138: {
139: DWORD returnedDataLength;
140: VIDEO_MEMORY videoMemory;
141:
142: videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
143:
144: if (!DeviceIoControl(ppdev->hDriver,
145: IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
146: (LPVOID) &videoMemory,
147: sizeof(VIDEO_MEMORY),
148: NULL,
149: 0,
150: &returnedDataLength,
151: NULL))
152: {
153: RIP("Failed UNMAP_VIDEO_MEMORY");
154: }
155: }
156:
157: /******************************Public*Routine******************************\
158: * bInitPDEV
159: *
160: * Determine the mode we should be in based on the DEVMODE passed in.
161: * Query mini-port to get information needed to fill in the DevInfo and the
162: * GdiInfo .
163: *
164: \**************************************************************************/
165:
166: BOOL bInitPDEV(
167: PPDEV ppdev,
168: DEVMODEW *pDevMode)
169: {
170: GDIINFO *pGdiInfo;
171: ULONG cModes;
172: PVIDEO_MODE_INFORMATION pVideoBuffer, pVideoModeSelected, pVideoTemp;
173: VIDEO_COLOR_CAPABILITIES colorCapabilities;
174: ULONG ulTemp;
175: BOOL bSelectDefault;
176: ULONG cbModeSize;
177:
178: pGdiInfo = ppdev->pGdiInfo;
179:
180: //
181: // calls the miniport to get mode information.
182: //
183:
184: cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
185:
186: if (cModes == 0)
187: {
188: DISPDBG((0, "vga256.dll: no available modes\n"));
189: return(FALSE);
190: }
191:
192: //
193: // Determine if we are looking for a default mode.
194: //
195:
196: if ( ((pDevMode->dmPelsWidth) ||
197: (pDevMode->dmPelsHeight) ||
198: (pDevMode->dmBitsPerPel) ||
199: (pDevMode->dmDisplayFlags) ||
200: (pDevMode->dmDisplayFrequency)) == 0)
201: {
202: bSelectDefault = TRUE;
203: }
204: else
205: {
206: bSelectDefault = FALSE;
207: }
208:
209: //
210: // Now see if the requested mode has a match in that table.
211: //
212:
213: pVideoModeSelected = NULL;
214: pVideoTemp = pVideoBuffer;
215:
216: while (cModes--)
217: {
218: if (pVideoTemp->Length != 0)
219: {
220: if (bSelectDefault ||
221: ((pVideoTemp->VisScreenWidth == pDevMode->dmPelsWidth) &&
222: (pVideoTemp->VisScreenHeight == pDevMode->dmPelsHeight) &&
223: (pVideoTemp->BitsPerPlane *
224: pVideoTemp->NumberOfPlanes == pDevMode->dmBitsPerPel) &&
225: ((pVideoTemp->Frequency == pDevMode->dmDisplayFrequency) ||
226: (pDevMode->dmDisplayFrequency == 0)) &&
227: (((pVideoTemp->AttributeFlags &
228: VIDEO_MODE_INTERLACED) ? 1:0) ==
229: ((pDevMode->dmDisplayFlags & DM_INTERLACED) ? 1:0)) ) )
230:
231: {
232: pVideoModeSelected = pVideoTemp;
233: DISPDBG((2, "vga256: Found a match\n")) ;
234: break;
235: }
236: }
237:
238: pVideoTemp = (PVIDEO_MODE_INFORMATION)
239: (((PUCHAR)pVideoTemp) + cbModeSize);
240: }
241:
242: //
243: // If no mode has been found, return an error
244: //
245:
246: if (pVideoModeSelected == NULL)
247: {
248: DISPDBG((0, "vga256.dll: no valid modes\n"));
249: LocalFree(pVideoBuffer);
250: return(FALSE);
251: }
252:
253: //
254: // Fill in the GDIINFO data structure with the information returned from
255: // the kernel driver.
256: //
257:
258: ppdev->ulMode = pVideoModeSelected->ModeIndex;
259: ppdev->cxScreen = pVideoModeSelected->VisScreenWidth;
260: ppdev->cyScreen = pVideoModeSelected->VisScreenHeight;
261: ppdev->ulBitCount = pVideoModeSelected->BitsPerPlane *
262: pVideoModeSelected->NumberOfPlanes;
263: ppdev->lDeltaScreen = pVideoModeSelected->ScreenStride;
264:
265: ppdev->flRed = pVideoModeSelected->RedMask;
266: ppdev->flGreen = pVideoModeSelected->GreenMask;
267: ppdev->flBlue = pVideoModeSelected->BlueMask;
268:
269: if (!(pVideoModeSelected->AttributeFlags & VIDEO_MODE_NO_OFF_SCREEN))
270: {
271: ppdev->fl |= DRIVER_USE_OFFSCREEN;
272: }
273:
274: pGdiInfo->ulVersion = 0x1000; // Our driver is version 1.000
275: pGdiInfo->ulTechnology = DT_RASDISPLAY;
276: pGdiInfo->ulHorzSize = pVideoModeSelected->XMillimeter;
277: pGdiInfo->ulVertSize = pVideoModeSelected->YMillimeter;
278:
279: pGdiInfo->ulHorzRes = ppdev->cxScreen;
280: pGdiInfo->ulVertRes = ppdev->cyScreen;
281: pGdiInfo->cBitsPixel = pVideoModeSelected->BitsPerPlane;
282: pGdiInfo->cPlanes = pVideoModeSelected->NumberOfPlanes;
283:
284: pGdiInfo->ulLogPixelsX = 96;
285: pGdiInfo->ulLogPixelsY = 96;
286:
287: pGdiInfo->flTextCaps = TC_RA_ABLE | TC_SCROLLBLT;
288: pGdiInfo->flRaster = 0; // DDI reservers flRaster
289:
290: pGdiInfo->ulDACRed = pVideoModeSelected->NumberRedBits;
291: pGdiInfo->ulDACGreen = pVideoModeSelected->NumberGreenBits;
292: pGdiInfo->ulDACBlue = pVideoModeSelected->NumberBlueBits;
293:
294: pGdiInfo->ulAspectX = 0x24; // One-to-one aspect ratio
295: pGdiInfo->ulAspectY = 0x24;
296: pGdiInfo->ulAspectXY = 0x33;
297:
298: pGdiInfo->xStyleStep = 1; // A style unit is 3 pels
299: pGdiInfo->yStyleStep = 1;
300: pGdiInfo->denStyleStep = 3;
301:
302: pGdiInfo->ptlPhysOffset.x = 0;
303: pGdiInfo->ptlPhysOffset.y = 0;
304: pGdiInfo->szlPhysSize.cx = 0;
305: pGdiInfo->szlPhysSize.cy = 0;
306:
307: // RGB and CMY color info.
308:
309: // try to get it from the miniport.
310: // if the miniport doesn ot support this feature, use defaults.
311:
312: if (!DeviceIoControl(ppdev->hDriver,
313: IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES,
314: NULL,
315: 0,
316: &colorCapabilities,
317: sizeof(VIDEO_COLOR_CAPABILITIES),
318: &ulTemp,
319: NULL))
320: {
321: DISPDBG((1, "vga256 DISP getcolorCapabilities failed \n"));
322:
323: pGdiInfo->ciDevice.Red.x = 6700;
324: pGdiInfo->ciDevice.Red.y = 3300;
325: pGdiInfo->ciDevice.Red.Y = 0;
326: pGdiInfo->ciDevice.Green.x = 2100;
327: pGdiInfo->ciDevice.Green.y = 7100;
328: pGdiInfo->ciDevice.Green.Y = 0;
329: pGdiInfo->ciDevice.Blue.x = 1400;
330: pGdiInfo->ciDevice.Blue.y = 800;
331: pGdiInfo->ciDevice.Blue.Y = 0;
332: pGdiInfo->ciDevice.AlignmentWhite.x = 3127;
333: pGdiInfo->ciDevice.AlignmentWhite.y = 3290;
334: pGdiInfo->ciDevice.AlignmentWhite.Y = 0;
335:
336: pGdiInfo->ciDevice.RedGamma = 20000;
337: pGdiInfo->ciDevice.GreenGamma = 20000;
338: pGdiInfo->ciDevice.BlueGamma = 20000;
339:
340: }
341: else
342: {
343:
344: pGdiInfo->ciDevice.Red.x = colorCapabilities.RedChromaticity_x;
345: pGdiInfo->ciDevice.Red.y = colorCapabilities.RedChromaticity_y;
346: pGdiInfo->ciDevice.Red.Y = 0;
347: pGdiInfo->ciDevice.Green.x = colorCapabilities.GreenChromaticity_x;
348: pGdiInfo->ciDevice.Green.y = colorCapabilities.GreenChromaticity_y;
349: pGdiInfo->ciDevice.Green.Y = 0;
350: pGdiInfo->ciDevice.Blue.x = colorCapabilities.BlueChromaticity_x;
351: pGdiInfo->ciDevice.Blue.y = colorCapabilities.BlueChromaticity_y;
352: pGdiInfo->ciDevice.Blue.Y = 0;
353: pGdiInfo->ciDevice.AlignmentWhite.x = colorCapabilities.WhiteChromaticity_x;
354: pGdiInfo->ciDevice.AlignmentWhite.y = colorCapabilities.WhiteChromaticity_y;
355: pGdiInfo->ciDevice.AlignmentWhite.Y = colorCapabilities.WhiteChromaticity_Y;
356:
357: // if we have a color device store the three color gamma values,
358: // otherwise store the unique gamma value in all three.
359:
360: if (colorCapabilities.AttributeFlags & VIDEO_DEVICE_COLOR)
361: {
362: pGdiInfo->ciDevice.RedGamma = colorCapabilities.RedGamma;
363: pGdiInfo->ciDevice.GreenGamma = colorCapabilities.GreenGamma;
364: pGdiInfo->ciDevice.BlueGamma = colorCapabilities.BlueGamma;
365: }
366: else
367: {
368: pGdiInfo->ciDevice.RedGamma = colorCapabilities.WhiteGamma;
369: pGdiInfo->ciDevice.GreenGamma = colorCapabilities.WhiteGamma;
370: pGdiInfo->ciDevice.BlueGamma = colorCapabilities.WhiteGamma;
371: }
372:
373: };
374:
375: pGdiInfo->ciDevice.Cyan.x = 0;
376: pGdiInfo->ciDevice.Cyan.y = 0;
377: pGdiInfo->ciDevice.Cyan.Y = 0;
378: pGdiInfo->ciDevice.Magenta.x = 0;
379: pGdiInfo->ciDevice.Magenta.y = 0;
380: pGdiInfo->ciDevice.Magenta.Y = 0;
381: pGdiInfo->ciDevice.Yellow.x = 0;
382: pGdiInfo->ciDevice.Yellow.y = 0;
383: pGdiInfo->ciDevice.Yellow.Y = 0;
384:
385: // No dye correction for raster displays.
386:
387: pGdiInfo->ciDevice.MagentaInCyanDye = 0;
388: pGdiInfo->ciDevice.YellowInCyanDye = 0;
389: pGdiInfo->ciDevice.CyanInMagentaDye = 0;
390: pGdiInfo->ciDevice.YellowInMagentaDye = 0;
391: pGdiInfo->ciDevice.CyanInYellowDye = 0;
392: pGdiInfo->ciDevice.MagentaInYellowDye = 0;
393:
394: // Fill in the rest of the devinfo and GdiInfo structures.
395:
396: pGdiInfo->ulNumColors = 20;
397: pGdiInfo->ulNumPalReg = 1 << ppdev->ulBitCount;
398:
399: pGdiInfo->ulDevicePelsDPI = 0; // For printers only
400: pGdiInfo->ulPrimaryOrder = PRIMARY_ORDER_CBA;
401: pGdiInfo->ulHTPatternSize = HT_PATSIZE_4x4_M;
402: pGdiInfo->ulHTOutputFormat = HT_FORMAT_8BPP;
403: pGdiInfo->flHTFlags = HT_FLAG_ADDITIVE_PRIMS;
404:
405: // Fill in the basic devinfo structure
406:
407: *(ppdev->pDevInfo) = gDevInfoFrameBuffer;
408:
409: LocalFree(pVideoBuffer);
410:
411: return(TRUE);
412: }
413:
414: /******************************Public*Routine******************************\
415: * VOID vInitBrushCache(ppdev)
416: *
417: * Initializes various brush cache structures. Must be done after bank
418: * initialization.
419: *
420: \**************************************************************************/
421:
422: VOID vInitBrushCache(PPDEV ppdev)
423: {
424: LONG cCacheBrushesPerScan = ppdev->lNextScan / BRUSH_SIZE;
425: LONG cCacheScans = ppdev->cTotalScans - ppdev->cyScreen;
426: LONG cCacheEntries;
427: LONG i;
428: LONG j;
429: BRUSHCACHEENTRY* pbce;
430: BRUSHCACHEENTRY* pbceEnd;
431:
432: cCacheEntries = min(cCacheScans*cCacheBrushesPerScan, BRUSH_MAX_CACHE_SIZE);
433:
434: if (cCacheEntries <= 0)
435: {
436: goto InitFailed;
437: }
438:
439: ppdev->pbceCache = (BRUSHCACHEENTRY*) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
440: cCacheEntries * sizeof(BRUSHCACHEENTRY));
441: if (ppdev->pbceCache == NULL)
442: {
443: goto InitFailed;
444: }
445:
446: // We successfully managed to allocate all our data structures for looking
447: // after off-screen memory, so set the flag saying that we can use it
448: // (note that if ppdev->fl's DRIVER_USE_OFFSCREEN hasn't been set, the
449: // memory cannot be used for long-term storage):
450:
451: ppdev->fl |= DRIVER_HAS_OFFSCREEN;
452:
453: ppdev->iCache = 0; // 0 is a reserved index
454: ppdev->iCacheLast = cCacheEntries - 1;
455:
456: // Initialize our cache entry array:
457:
458: pbce = &ppdev->pbceCache[0];
459: pbceEnd = &ppdev->pbceCache[cCacheEntries];
460:
461: for (i = ppdev->cyScreen; i < ppdev->cTotalScans; i++)
462: {
463: for (j = 0; j < cCacheBrushesPerScan; j++)
464: {
465: // Bitmap offset is in planar format, where every byte is one
466: // quadpixel:
467:
468: pbce->yCache = i;
469: pbce->ulCache = (i * ppdev->lNextScan + j * BRUSH_SIZE) / 4;
470:
471: // This verification pointer doesn't actually have to be
472: // initialized, but we do so for debugging purposes:
473:
474: pbce->prbVerifyRealization = NULL;
475:
476: pbce++;
477: if (pbce >= pbceEnd)
478: return;
479: }
480: }
481:
482: RIP("Shouldn't get here");
483:
484: InitFailed:
485: ppdev->fl &= ~(DRIVER_USE_OFFSCREEN | DRIVER_HAS_OFFSCREEN);
486: return;
487: }
488:
489: /******************************Public*Routine******************************\
490: * VOID vResetBrushCache(ppdev)
491: *
492: * Blows away the brush cache entries -- this is useful when switching
493: * out of full-screen mode, where anyone could have written over the video
494: * memory where we cache our brushes.
495: *
496: \**************************************************************************/
497:
498: VOID vResetBrushCache(PPDEV ppdev)
499: {
500: BRUSHCACHEENTRY* pbce;
501: LONG i;
502:
503: // Make sure we actually have a brush cache before we try to reset it:
504:
505: if (ppdev->fl & DRIVER_HAS_OFFSCREEN)
506: {
507: pbce = &ppdev->pbceCache[0];
508: for (i = ppdev->iCacheLast; i >= 0; i--)
509: {
510: pbce->prbVerifyRealization = NULL;
511: pbce++;
512: }
513: }
514: }
515:
516: /******************************Public*Routine******************************\
517: * VOID vDisableBrushCache(ppdev)
518: *
519: * Frees various brush cache structures.
520: *
521: \**************************************************************************/
522:
523: VOID vDisableBrushCache(PPDEV ppdev)
524: {
525: if (ppdev->pbceCache != NULL)
526: {
527: LocalFree(ppdev->pbceCache);
528: }
529: }
530:
531: /******************************Public*Routine******************************\
532: * getAvailableModes
533: *
534: * Calls the miniport to get the list of modes supported by the kernel driver,
535: * and returns the list of modes supported by the diplay driver among those
536: *
537: * returns the number of entries in the videomode buffer.
538: * 0 means no modes are supported by the miniport or that an error occured.
539: *
540: * NOTE: the buffer must be freed up by the caller.
541: *
542: \**************************************************************************/
543:
544: DWORD getAvailableModes(
545: HANDLE hDriver,
546: PVIDEO_MODE_INFORMATION *modeInformation,
547: DWORD *cbModeSize)
548: {
549: ULONG ulTemp;
550: VIDEO_NUM_MODES modes;
551: PVIDEO_MODE_INFORMATION pVideoTemp;
552:
553: //
554: // Get the number of modes supported by the mini-port
555: //
556:
557: if (!DeviceIoControl(hDriver,
558: IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
559: NULL,
560: 0,
561: &modes,
562: sizeof(VIDEO_NUM_MODES),
563: &ulTemp,
564: NULL))
565: {
566: DISPDBG((0, "vga256 getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
567: return(0);
568: }
569:
570: *cbModeSize = modes.ModeInformationLength;
571:
572: //
573: // Allocate the buffer for the mini-port to write the modes in.
574: //
575:
576: *modeInformation = (PVIDEO_MODE_INFORMATION)
577: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
578: modes.NumModes *
579: modes.ModeInformationLength);
580:
581: if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL)
582: {
583: DISPDBG((0, "vga256 getAvailableModes failed LocalAlloc\n"));
584:
585: return 0;
586: }
587:
588: //
589: // Ask the mini-port to fill in the available modes.
590: //
591:
592: if (!DeviceIoControl(hDriver,
593: IOCTL_VIDEO_QUERY_AVAIL_MODES,
594: NULL,
595: 0,
596: *modeInformation,
597: modes.NumModes * modes.ModeInformationLength,
598: &ulTemp,
599: NULL))
600: {
601:
602: DISPDBG((0, "vga256 getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
603:
604: LocalFree(*modeInformation);
605: *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
606:
607: return(0);
608: }
609:
610: //
611: // Now see which of these modes are supported by the display driver.
612: // As an internal mechanism, set the length to 0 for the modes we
613: // DO NOT support.
614: //
615:
616: ulTemp = modes.NumModes;
617: pVideoTemp = *modeInformation;
618:
619: //
620: // Mode is rejected if it is not one plane, or not graphics, or is not
621: // one of 8 bits per pel (that is all the vga 256 currently supports)
622: //
623:
624: while (ulTemp--)
625: {
626: if ((pVideoTemp->NumberOfPlanes != 1 ) ||
627: !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
628: (pVideoTemp->BitsPerPlane != 8))
629: {
630: pVideoTemp->Length = 0;
631: }
632:
633: pVideoTemp = (PVIDEO_MODE_INFORMATION)
634: (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
635: }
636:
637: return modes.NumModes;
638:
639: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.