![[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 / framebuf|
Return to screen.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / framebuf |
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,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,VARIABLE_PITCH | FF_DONTCARE,L"System"}
12: #define HELVE_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | FF_DONTCARE,L"MS Sans Serif"}
13: #define COURI_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | FF_DONTCARE, L"Courier"}
14:
15: // This is the basic devinfo for a default driver. This is used as a base and customized based
16: // on information passed back from the miniport driver.
17:
18: const DEVINFO gDevInfoFrameBuffer = {
19: (GCAPS_OPAQUERECT | GCAPS_MONO_DITHER), /* Graphics capabilities */
20: SYSTM_LOGFONT, /* Default font description */
21: HELVE_LOGFONT, /* ANSI variable font description */
22: COURI_LOGFONT, /* ANSI fixed font description */
23: 0, /* Count of device fonts */
24: 0, /* Preferred DIB format */
25: 8, /* Width of color dither */
26: 8, /* Height of color dither */
27: 0 /* Default palette to use for this device */
28: };
29:
30: /******************************Public*Routine******************************\
31: * bInitSURF
32: *
33: * Enables the surface. Maps the frame buffer into memory.
34: *
35: \**************************************************************************/
36:
37: BOOL bInitSURF(PPDEV ppdev, BOOL bFirst)
38: {
39: DWORD returnedDataLength;
40: DWORD MaxWidth, MaxHeight;
41: VIDEO_MEMORY videoMemory;
42: VIDEO_MEMORY_INFORMATION videoMemoryInformation;
43:
44: // Set the current mode into the hardware.
45: if (!DeviceIoControl(ppdev->hDriver,
46: IOCTL_VIDEO_SET_CURRENT_MODE,
47: &(ppdev->ulMode),
48: sizeof(ULONG),
49: NULL,
50: 0,
51: &returnedDataLength,
52: NULL))
53: {
54: RIP("DISP bInitSURF failed IOCTL_SET_MODE\n");
55: return(FALSE);
56: }
57:
58: // If this is the first time we enable the surface we need to map in the
59: // memory also.
60:
61: if (bFirst)
62: {
63: videoMemory.RequestedVirtualAddress = NULL;
64:
65: if (!DeviceIoControl(ppdev->hDriver,
66: IOCTL_VIDEO_MAP_VIDEO_MEMORY,
67: &videoMemory,
68: sizeof(VIDEO_MEMORY),
69: &videoMemoryInformation,
70: sizeof(VIDEO_MEMORY_INFORMATION),
71: &returnedDataLength,
72: NULL))
73: {
74: RIP("DISP bInitSURF failed IOCTL_VIDEO_MAP\n");
75: return(FALSE);
76: }
77:
78: ppdev->pjScreen = (PBYTE)(videoMemoryInformation.FrameBufferBase);
79:
80: // It's a hardware pointer; set up pointer attributes.
81:
82: MaxHeight = ppdev->PointerCapabilities.MaxHeight;
83:
84: // Allocate space for two DIBs (data/mask) for the pointer. If this
85: // device supports a color Pointer, we will allocate a larger bitmap.
86: // If this is a color bitmap we allocate for the largest possible
87: // bitmap because we have no idea of what the pixel depth might be.
88:
89: // Width rounded up to nearest byte multiple
90:
91: if (!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)) {
92: MaxWidth = (ppdev->PointerCapabilities.MaxWidth + 7) / 8;
93: } else {
94: MaxWidth = ppdev->PointerCapabilities.MaxWidth * sizeof(DWORD);
95: }
96:
97: ppdev->cjPointerAttributes =
98: sizeof(VIDEO_POINTER_ATTRIBUTES) +
99: ((sizeof(UCHAR) * MaxWidth * MaxHeight) * 2);
100:
101: ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES)
102: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
103: ppdev->cjPointerAttributes);
104:
105: if (ppdev->pPointerAttributes == NULL) {
106:
107: DISPDBG((0, "FRAMEBUF: bInitPointer LocalAlloc failed\n"));
108: return(FALSE);
109: }
110:
111: ppdev->pPointerAttributes->WidthInBytes = MaxWidth;
112: ppdev->pPointerAttributes->Width = ppdev->PointerCapabilities.MaxWidth;
113: ppdev->pPointerAttributes->Height = MaxHeight;
114: ppdev->pPointerAttributes->Column = 0;
115: ppdev->pPointerAttributes->Row = 0;
116: ppdev->pPointerAttributes->Enable = 0;
117: }
118:
119: return(TRUE);
120: }
121:
122: /******************************Public*Routine******************************\
123: * vDisableSURF
124: *
125: * Disable the surface. Un-Maps the frame in memory.
126: *
127: \**************************************************************************/
128:
129: VOID vDisableSURF(PPDEV ppdev)
130: {
131: DWORD returnedDataLength;
132: VIDEO_MEMORY videoMemory;
133:
134: videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
135:
136: if (!DeviceIoControl(ppdev->hDriver,
137: IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
138: &videoMemory,
139: sizeof(VIDEO_MEMORY),
140: NULL,
141: 0,
142: &returnedDataLength,
143: NULL))
144: {
145: RIP("DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n");
146: }
147:
148: // We must give up the display.
149: // Call the kernel driver to reset the device to a known state.
150:
151: if (!DeviceIoControl(ppdev->hDriver,
152: IOCTL_VIDEO_RESET_DEVICE,
153: NULL,
154: 0,
155: NULL,
156: 0,
157: &returnedDataLength,
158: NULL))
159: {
160: RIP("DISP vDisableSurf failed IOCTL_VIDEO_RESET_DEVICE");
161: }
162:
163: }
164:
165:
166: /******************************Public*Routine******************************\
167: * bInitPDEV
168: *
169: * Determine the mode we should be in based on the DEVMODE passed in.
170: * Query mini-port to get information needed to fill in the DevInfo and the
171: * GdiInfo .
172: *
173: \**************************************************************************/
174:
175: BOOL bInitPDEV(
176: PPDEV ppdev,
177: DEVMODEW *pDevMode,
178: GDIINFO *pGdiInfo,
179: DEVINFO *pDevInfo)
180: {
181: ULONG cModes;
182: PVIDEO_MODE_INFORMATION pVideoBuffer, pVideoModeSelected, pVideoTemp;
183: VIDEO_COLOR_CAPABILITIES colorCapabilities;
184: ULONG ulTemp;
185: BOOL bSelectDefault;
186: ULONG cbModeSize;
187:
188: //
189: // calls the miniport to get mode information.
190: //
191:
192: cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
193:
194: if (cModes == 0)
195: {
196: return(FALSE);
197: }
198:
199: //
200: // Determine if we are looking for a default mode.
201: //
202:
203: if ( ((pDevMode->dmPelsWidth) ||
204: (pDevMode->dmPelsHeight) ||
205: (pDevMode->dmBitsPerPel) ||
206: (pDevMode->dmDisplayFlags) ||
207: (pDevMode->dmDisplayFrequency)) == 0)
208: {
209: bSelectDefault = TRUE;
210: }
211: else
212: {
213: bSelectDefault = FALSE;
214: }
215:
216: //
217: // Now see if the requested mode has a match in that table.
218: //
219:
220: pVideoModeSelected = NULL;
221: pVideoTemp = pVideoBuffer;
222:
223: while (cModes--)
224: {
225: if (pVideoTemp->Length != 0)
226: {
227: if (bSelectDefault ||
228: ((pVideoTemp->VisScreenWidth == pDevMode->dmPelsWidth) &&
229: (pVideoTemp->VisScreenHeight == pDevMode->dmPelsHeight) &&
230: (pVideoTemp->BitsPerPlane *
231: pVideoTemp->NumberOfPlanes == pDevMode->dmBitsPerPel)) )
232: {
233: pVideoModeSelected = pVideoTemp;
234: DISPDBG((3, "framebuf: Found a match\n")) ;
235: break;
236: }
237: }
238:
239: pVideoTemp = (PVIDEO_MODE_INFORMATION)
240: (((PUCHAR)pVideoTemp) + cbModeSize);
241: }
242:
243: //
244: // If no mode has been found, return an error
245: //
246:
247: if (pVideoModeSelected == NULL)
248: {
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:
270: pGdiInfo->ulVersion = 0x1000; // Our driver is verion 1.000
271: pGdiInfo->ulTechnology = DT_RASDISPLAY;
272: pGdiInfo->ulHorzSize = pVideoModeSelected->XMillimeter;
273: pGdiInfo->ulVertSize = pVideoModeSelected->YMillimeter;
274:
275: pGdiInfo->ulHorzRes = ppdev->cxScreen;
276: pGdiInfo->ulVertRes = ppdev->cyScreen;
277: pGdiInfo->cBitsPixel = pVideoModeSelected->BitsPerPlane;
278: pGdiInfo->cPlanes = pVideoModeSelected->NumberOfPlanes;
279:
280: pGdiInfo->ulLogPixelsX = 96;
281: pGdiInfo->ulLogPixelsY = 96;
282:
283: #ifdef MIPS
284: if (ppdev->ulBitCount == 8)
285: pGdiInfo->flTextCaps = (TC_RA_ABLE | TC_SCROLLBLT);
286: else
287: #endif
288: pGdiInfo->flTextCaps = TC_RA_ABLE;
289:
290: pGdiInfo->flRaster = 0; // flRaster is reserved by DDI
291:
292: pGdiInfo->ulDACRed = pVideoModeSelected->NumberRedBits;
293: pGdiInfo->ulDACGreen = pVideoModeSelected->NumberGreenBits;
294: pGdiInfo->ulDACBlue = pVideoModeSelected->NumberBlueBits;
295:
296: pGdiInfo->ulAspectX = 0x24; // One-to-one aspect ratio
297: pGdiInfo->ulAspectY = 0x24;
298: pGdiInfo->ulAspectXY = 0x33;
299:
300: pGdiInfo->xStyleStep = 1; // A style unit is 3 pels
301: pGdiInfo->yStyleStep = 1;
302: pGdiInfo->denStyleStep = 3;
303:
304: pGdiInfo->ptlPhysOffset.x = 0;
305: pGdiInfo->ptlPhysOffset.y = 0;
306: pGdiInfo->szlPhysSize.cx = 0;
307: pGdiInfo->szlPhysSize.cy = 0;
308:
309: // RGB and CMY color info.
310:
311: // try to get it from the miniport.
312: // if the miniport doesn ot support this feature, use defaults.
313:
314: if (!DeviceIoControl(ppdev->hDriver,
315: IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES,
316: NULL,
317: 0,
318: &colorCapabilities,
319: sizeof(VIDEO_COLOR_CAPABILITIES),
320: &ulTemp,
321: NULL))
322: {
323:
324: DISPDBG((2, "FRAMEBUF getcolorCapabilities failed \n"));
325:
326: pGdiInfo->ciDevice.Red.x = 6700;
327: pGdiInfo->ciDevice.Red.y = 3300;
328: pGdiInfo->ciDevice.Red.Y = 0;
329: pGdiInfo->ciDevice.Green.x = 2100;
330: pGdiInfo->ciDevice.Green.y = 7100;
331: pGdiInfo->ciDevice.Green.Y = 0;
332: pGdiInfo->ciDevice.Blue.x = 1400;
333: pGdiInfo->ciDevice.Blue.y = 800;
334: pGdiInfo->ciDevice.Blue.Y = 0;
335: pGdiInfo->ciDevice.AlignmentWhite.x = 3127;
336: pGdiInfo->ciDevice.AlignmentWhite.y = 3290;
337: pGdiInfo->ciDevice.AlignmentWhite.Y = 0;
338:
339: pGdiInfo->ciDevice.RedGamma = 20000;
340: pGdiInfo->ciDevice.GreenGamma = 20000;
341: pGdiInfo->ciDevice.BlueGamma = 20000;
342:
343: }
344: else
345: {
346: pGdiInfo->ciDevice.Red.x = colorCapabilities.RedChromaticity_x;
347: pGdiInfo->ciDevice.Red.y = colorCapabilities.RedChromaticity_y;
348: pGdiInfo->ciDevice.Red.Y = 0;
349: pGdiInfo->ciDevice.Green.x = colorCapabilities.GreenChromaticity_x;
350: pGdiInfo->ciDevice.Green.y = colorCapabilities.GreenChromaticity_y;
351: pGdiInfo->ciDevice.Green.Y = 0;
352: pGdiInfo->ciDevice.Blue.x = colorCapabilities.BlueChromaticity_x;
353: pGdiInfo->ciDevice.Blue.y = colorCapabilities.BlueChromaticity_y;
354: pGdiInfo->ciDevice.Blue.Y = 0;
355: pGdiInfo->ciDevice.AlignmentWhite.x = colorCapabilities.WhiteChromaticity_x;
356: pGdiInfo->ciDevice.AlignmentWhite.y = colorCapabilities.WhiteChromaticity_y;
357: pGdiInfo->ciDevice.AlignmentWhite.Y = colorCapabilities.WhiteChromaticity_Y;
358:
359: // if we have a color device store the three color gamma values,
360: // otherwise store the unique gamma value in all three.
361:
362: if (colorCapabilities.AttributeFlags & VIDEO_DEVICE_COLOR)
363: {
364: pGdiInfo->ciDevice.RedGamma = colorCapabilities.RedGamma;
365: pGdiInfo->ciDevice.GreenGamma = colorCapabilities.GreenGamma;
366: pGdiInfo->ciDevice.BlueGamma = colorCapabilities.BlueGamma;
367: }
368: else
369: {
370: pGdiInfo->ciDevice.RedGamma = colorCapabilities.WhiteGamma;
371: pGdiInfo->ciDevice.GreenGamma = colorCapabilities.WhiteGamma;
372: pGdiInfo->ciDevice.BlueGamma = colorCapabilities.WhiteGamma;
373: }
374:
375: };
376:
377: pGdiInfo->ciDevice.Cyan.x = 0;
378: pGdiInfo->ciDevice.Cyan.y = 0;
379: pGdiInfo->ciDevice.Cyan.Y = 0;
380: pGdiInfo->ciDevice.Magenta.x = 0;
381: pGdiInfo->ciDevice.Magenta.y = 0;
382: pGdiInfo->ciDevice.Magenta.Y = 0;
383: pGdiInfo->ciDevice.Yellow.x = 0;
384: pGdiInfo->ciDevice.Yellow.y = 0;
385: pGdiInfo->ciDevice.Yellow.Y = 0;
386:
387: // No dye correction for raster displays.
388:
389: pGdiInfo->ciDevice.MagentaInCyanDye = 0;
390: pGdiInfo->ciDevice.YellowInCyanDye = 0;
391: pGdiInfo->ciDevice.CyanInMagentaDye = 0;
392: pGdiInfo->ciDevice.YellowInMagentaDye = 0;
393: pGdiInfo->ciDevice.CyanInYellowDye = 0;
394: pGdiInfo->ciDevice.MagentaInYellowDye = 0;
395:
396: pGdiInfo->ulDevicePelsDPI = 0; // For printers only
397: pGdiInfo->ulPrimaryOrder = PRIMARY_ORDER_CBA;
398:
399: // BUGBUG this should be modified to take into account the size
400: // of the display and the resolution.
401:
402: pGdiInfo->ulHTPatternSize = HT_PATSIZE_4x4_M;
403:
404: pGdiInfo->flHTFlags = HT_FLAG_ADDITIVE_PRIMS;
405:
406: // Fill in the basic devinfo structure
407:
408: *pDevInfo = gDevInfoFrameBuffer;
409:
410: // Fill in the rest of the devinfo and GdiInfo structures.
411:
412: if (ppdev->ulBitCount == 8)
413: {
414: // It is Palette Managed.
415:
416: pGdiInfo->ulNumColors = 20;
417: pGdiInfo->ulNumPalReg = 1 << ppdev->ulBitCount;
418:
419: pDevInfo->flGraphicsCaps |= (GCAPS_PALMANAGED | GCAPS_COLOR_DITHER);
420:
421: pGdiInfo->ulHTOutputFormat = HT_FORMAT_8BPP;
422: pDevInfo->iDitherFormat = BMF_8BPP;
423: }
424: else
425: {
426: pGdiInfo->ulNumColors = 2048;
427: pGdiInfo->ulNumPalReg = 0;
428:
429: if (ppdev->ulBitCount == 16)
430: {
431: pGdiInfo->ulHTOutputFormat = HT_FORMAT_16BPP;
432: pDevInfo->iDitherFormat = BMF_16BPP;
433: }
434: else if (ppdev->ulBitCount == 24)
435: {
436: pGdiInfo->ulHTOutputFormat = HT_FORMAT_24BPP;
437: pDevInfo->iDitherFormat = BMF_24BPP;
438: }
439: else
440: {
441: pGdiInfo->ulHTOutputFormat = HT_FORMAT_32BPP;
442: pDevInfo->iDitherFormat = BMF_32BPP;
443: }
444: }
445:
446: LocalFree(pVideoBuffer);
447:
448: return(TRUE);
449: }
450:
451:
452: /******************************Public*Routine******************************\
453: * getAvailableModes
454: *
455: * Calls the miniport to get the list of modes supported by the kernel driver,
456: * and returns the list of modes supported by the diplay driver among those
457: *
458: * returns the number of entries in the videomode buffer.
459: * 0 means no modes are supported by the miniport or that an error occured.
460: *
461: * NOTE: the buffer must be freed up by the caller.
462: *
463: \**************************************************************************/
464:
465: DWORD getAvailableModes(
466: HANDLE hDriver,
467: PVIDEO_MODE_INFORMATION *modeInformation,
468: DWORD *cbModeSize)
469: {
470: ULONG ulTemp;
471: VIDEO_NUM_MODES modes;
472: PVIDEO_MODE_INFORMATION pVideoTemp;
473:
474: //
475: // Get the number of modes supported by the mini-port
476: //
477:
478: if (!DeviceIoControl(hDriver,
479: IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
480: NULL,
481: 0,
482: &modes,
483: sizeof(VIDEO_NUM_MODES),
484: &ulTemp,
485: NULL))
486: {
487: DISPDBG((0, "framebuf.dll getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
488: return(0);
489: }
490:
491: *cbModeSize = modes.ModeInformationLength;
492:
493: //
494: // Allocate the buffer for the mini-port to write the modes in.
495: //
496:
497: *modeInformation = (PVIDEO_MODE_INFORMATION)
498: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
499: modes.NumModes *
500: modes.ModeInformationLength);
501:
502: if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL)
503: {
504: DISPDBG((0, "framebuf.dll getAvailableModes failed LocalAlloc\n"));
505:
506: return 0;
507: }
508:
509: //
510: // Ask the mini-port to fill in the available modes.
511: //
512:
513: if (!DeviceIoControl(hDriver,
514: IOCTL_VIDEO_QUERY_AVAIL_MODES,
515: NULL,
516: 0,
517: *modeInformation,
518: modes.NumModes * modes.ModeInformationLength,
519: &ulTemp,
520: NULL))
521: {
522:
523: DISPDBG((0, "framebuf.dll getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
524:
525: LocalFree(*modeInformation);
526: *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
527:
528: return(0);
529: }
530:
531: //
532: // Now see which of these modes are supported by the display driver.
533: // As an internal mechanism, set the length to 0 for the modes we
534: // DO NOT support.
535: //
536:
537: ulTemp = modes.NumModes;
538: pVideoTemp = *modeInformation;
539:
540: //
541: // Mode is rejected if it is not one plane, or not graphics, or is not
542: // one of 8, 16 or 32 bits per pel.
543: //
544:
545: while (ulTemp--)
546: {
547: if ((pVideoTemp->NumberOfPlanes != 1 ) ||
548: !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
549: ((pVideoTemp->BitsPerPlane != 8) &&
550: (pVideoTemp->BitsPerPlane != 16) &&
551: (pVideoTemp->BitsPerPlane != 24) &&
552: (pVideoTemp->BitsPerPlane != 32)))
553: {
554: pVideoTemp->Length = 0;
555: }
556:
557: pVideoTemp = (PVIDEO_MODE_INFORMATION)
558: (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
559: }
560:
561: return modes.NumModes;
562:
563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.