![[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 / jz484|
Return to screen.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / jz484 |
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) 1991-1993 Microsoft Corporation. All rights reserved.
7: \**************************************************************************/
8:
9: #include "driver.h"
10: #include "jzvxl484.h"
11:
12: //
13: // Define forward referenced prototypes.
14: //
15:
16:
17: BOOL
18: DrvpSetGammaColorPalette(
19: IN PPDEV ppdev,
20: IN WORD NumberOfEntries,
21: IN LDECI4 GammaRed,
22: IN LDECI4 GammaGreen,
23: IN LDECI4 GammaBlue
24: );
25:
26: VIDEO_JAGUAR_INFO JaguarInfo;
27:
28: extern PJAGUAR_FIFO FifoRegs;
29: extern PJAGUAR_REGISTERS Jaguar;
30:
31: #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"}
32: #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"}
33: #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"}
34:
35: //
36: // This is the basic devinfo for a default driver. This is used as a base and customized based
37: // on information passed back from the miniport driver.
38: //
39:
40: const DEVINFO gDevInfoFrameBuffer = {
41: (GCAPS_OPAQUERECT | GCAPS_MONO_DITHER), // Graphics capabilities
42: SYSTM_LOGFONT, // Default font description
43: HELVE_LOGFONT, // ANSI variable font description
44: COURI_LOGFONT, // ANSI fixed font description
45: 0, // Count of device fonts
46: 0, // Preferred DIB format
47: 8, // Width of color dither
48: 8, // Height of color dither
49: 0 // Default palette to use for this device
50: };
51:
52: /******************************Public*Routine******************************\
53: * bInitSURF
54: *
55: * Enables the surface. Maps the frame buffer into memory.
56: *
57: \**************************************************************************/
58:
59: BOOL bInitSURF(PPDEV ppdev, BOOL bFirst)
60: {
61: DWORD returnedDataLength;
62: VIDEO_MEMORY videoMemory;
63: VIDEO_MEMORY_INFORMATION videoMemoryInformation;
64: RECTL Rectl;
65: ULONG Index;
66: ULONG MaxHeight,MaxWidth;
67: //
68: // Set the current mode into the hardware.
69: //
70:
71: if (!DeviceIoControl(ppdev->hDriver,
72: IOCTL_VIDEO_SET_CURRENT_MODE,
73: &(ppdev->ulMode),
74: sizeof(ULONG),
75: NULL,
76: 0,
77: &returnedDataLength,
78: NULL))
79: {
80: DISPDBG((0, "DISP bInitSURF failed IOCTL_SET_MODE\n"));
81: return(FALSE);
82: }
83:
84: //
85: // If this is the first time we enable the surface we need to map in the
86: // memory also.
87: //
88:
89: if (bFirst)
90: {
91: videoMemory.RequestedVirtualAddress = NULL;
92:
93: if (!DeviceIoControl(ppdev->hDriver,
94: IOCTL_VIDEO_MAP_VIDEO_MEMORY,
95: &videoMemory,
96: sizeof(VIDEO_MEMORY),
97: &videoMemoryInformation,
98: sizeof(VIDEO_MEMORY_INFORMATION),
99: &returnedDataLength,
100: NULL))
101: {
102: DISPDBG((0, "DISP bInitSURF failed IOCTL_VIDEO_MAP\n"));
103: return(FALSE);
104: }
105:
106: ppdev->pjScreen = (PBYTE)(videoMemoryInformation.FrameBufferBase);
107:
108:
109: //
110: // Call the video miniport driver to get virtual address of JAGUAR registers
111: //
112:
113: if (!DeviceIoControl(ppdev->hDriver,
114: IOCTL_VIDEO_QUERY_JAGUAR,
115: NULL,
116: 0,
117: &JaguarInfo,
118: sizeof(VIDEO_JAGUAR_INFO),
119: &returnedDataLength,NULL)) {
120:
121: DISPDBG((0, " Get Jaguar information failed\n"));
122: return(FALSE);
123:
124: }
125:
126: //
127: // Initialize variables.
128: //
129:
130: Jaguar = (PJAGUAR_REGISTERS)JaguarInfo.VideoControlVirtualBase;
131: FifoRegs = (PJAGUAR_FIFO)JaguarInfo.FifoVirtualBase;
132:
133: Vxl.ScreenBase = (ULONG) videoMemoryInformation.FrameBufferBase;
134: Vxl.MemorySize = JaguarInfo.VideoMemoryLength;
135: Vxl.FontCacheBase = (PULONG) (Vxl.ScreenBase + Vxl.FontCacheOffset);
136:
137: //
138: // Determine how much off-screen memory is available for a font cache
139: //
140:
141: while (Vxl.CacheSize*GlyphEntrySize > (Vxl.MemorySize - Vxl.FontCacheOffset)) {
142: Vxl.CacheSize >>= 1;
143: Vxl.CacheIndexMask >>= 1;
144: }
145:
146: //
147: // Allocate and initialize the font cache structure
148: //
149:
150: Vxl.CacheTag = (PFONTCACHEINFO) LocalAlloc(LMEM_FIXED,sizeof(FONTCACHEINFO)*Vxl.CacheSize);
151:
152: if (Vxl.CacheTag == (PFONTCACHEINFO) NULL) {
153: DISPDBG((0, "Cache Tag allocation error\n"));
154: return(FALSE);
155: }
156:
157: //
158: // Initialize the tags to invalid.
159: //
160:
161: for (Index = 0; Index < Vxl.CacheSize; Index++) {
162: Vxl.CacheTag[Index].FontId = FreeTag;
163: Vxl.CacheTag[Index].GlyphHandle = FreeTag;
164: }
165:
166: //
167: // It's a hardware pointer; set up pointer attributes.
168: //
169: // Allocate space for two DIBs (data/mask) for the pointer.
170: //
171:
172: MaxHeight = ppdev->PointerCapabilities.MaxHeight;
173: MaxWidth = (ppdev->PointerCapabilities.MaxWidth + 7) / 8;
174:
175: ppdev->cjPointerAttributes =
176: sizeof(VIDEO_POINTER_ATTRIBUTES) +
177: ((sizeof(UCHAR) * MaxWidth * MaxHeight) * 2);
178:
179: ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES)
180: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
181: ppdev->cjPointerAttributes);
182:
183: if (ppdev->pPointerAttributes == NULL) {
184: DISPDBG((0, "VXL bInitPointer LocalAlloc failed\n"));
185: return(FALSE);
186: }
187:
188: ppdev->pPointerAttributes->WidthInBytes = MaxWidth;
189: ppdev->pPointerAttributes->Width = ppdev->PointerCapabilities.MaxWidth;
190: ppdev->pPointerAttributes->Height = MaxHeight;
191: ppdev->pPointerAttributes->Column = 0;
192: ppdev->pPointerAttributes->Row = 0;
193: ppdev->pPointerAttributes->Enable = 0;
194: }
195:
196: //
197: // Send a command to the fifo to clear the screen.
198: //
199: Rectl.top = Rectl.left = 0;
200: Rectl.right = Vxl.ScreenX;
201: Rectl.bottom = Vxl.ScreenY;
202: DrvpFillRectangle(&Rectl,0);
203:
204: return(TRUE);
205: }
206:
207: /******************************Public*Routine******************************\
208: * vDisableSURF
209: *
210: * Disable the surface. Un-Maps the frame in memory.
211: *
212: \**************************************************************************/
213:
214: VOID vDisableSURF(PPDEV ppdev)
215: {
216: DWORD returnedDataLength;
217: VIDEO_MEMORY videoMemory;
218:
219: videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
220:
221: if (!DeviceIoControl(ppdev->hDriver,
222: IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
223: &videoMemory,
224: sizeof(VIDEO_MEMORY),
225: NULL,
226: 0,
227: &returnedDataLength,
228: NULL))
229: {
230: DISPDBG((0, "DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n"));
231: }
232: }
233:
234:
235: /******************************Public*Routine******************************\
236: * bInitPDEV
237: *
238: * Determine the mode we should be in based on the DEVMODE passed in.
239: * Query mini-port to get information needed to fill in the DevInfo and the
240: * GdiInfo .
241: *
242: * BUGBUG Copy this routine from the other display drivers !!! HACK
243: *
244: \**************************************************************************/
245:
246: BOOL
247: bInitPDEV(
248: PPDEV ppdev,
249: PDEVMODEW pDevMode,
250: GDIINFO *pGdiInfo,
251: DEVINFO *pDevInfo
252: )
253:
254: {
255: ULONG cModes, ulTemp;
256: PVIDEO_MODE_INFORMATION pVideoBuffer, pVideoTemp, pVideoModeInformation;
257: PVIDEO_MODE_INFORMATION pVideoModeDefault , pVideoModeSelected;
258: VIDEO_MODE_INFORMATION VideoModeInformation;
259: VIDEO_COLOR_CAPABILITIES colorCapabilities;
260: PDEVMODEW DevMode = (PDEVMODEW) pDevMode;
261: ULONG cbModeSize;
262:
263: //
264: // Get the enumeration of available modes from the miniport
265: //
266:
267: cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
268:
269: if (cModes == 0)
270: {
271: return(FALSE);
272: }
273:
274: //
275: // Now see if the mini-port has a match for the mode we are requesting.
276: // If not default to the first mode provided by the mini-port.
277: //
278:
279: pVideoModeDefault = NULL;
280: pVideoModeSelected = NULL;
281: pVideoModeInformation = pVideoTemp = pVideoBuffer;
282:
283: //
284: // search the mode table for a matching mode. If no match is found then
285: // use the last entry as the default.
286: //
287:
288: while (cModes--) {
289: if (pVideoTemp->Length != 0) {
290: pVideoModeDefault = pVideoTemp;
291:
292: if ((pVideoTemp->VisScreenWidth == pDevMode->dmPelsWidth) &&
293: (pVideoTemp->VisScreenHeight == pDevMode->dmPelsHeight) &&
294: (pVideoTemp->BitsPerPlane == pDevMode->dmBitsPerPel) &&
295: (pVideoTemp->Frequency == pDevMode->dmDisplayFrequency)) {
296:
297: pVideoModeSelected = pVideoTemp;
298: break;
299: }
300: }
301:
302: pVideoTemp = (PVIDEO_MODE_INFORMATION)
303: (((PUCHAR)pVideoTemp) + cbModeSize);
304: }
305:
306: if (pVideoModeSelected == NULL)
307: {
308: if (pVideoModeDefault == NULL)
309: {
310: DISPDBG((0, "DISP bInitPDEV no supported mode available"));
311: LocalFree(pVideoBuffer);
312:
313: return(FALSE);
314: }
315: pVideoModeSelected = pVideoModeDefault;
316: }
317:
318:
319: //
320: // Set up screen information
321: //
322:
323: VideoModeInformation = *pVideoModeSelected;
324:
325: //
326: // Fill in gdi structures
327: //
328:
329: ppdev->ulMode = VideoModeInformation.ModeIndex;
330: ppdev->cxScreen = VideoModeInformation.VisScreenWidth;
331: ppdev->cyScreen = VideoModeInformation.VisScreenHeight;
332: ppdev->ulBitCount = VideoModeInformation.BitsPerPlane;
333: ppdev->lDeltaScreen = VideoModeInformation.ScreenStride;
334:
335: ppdev->flRed = VideoModeInformation.RedMask;
336: ppdev->flGreen = VideoModeInformation.GreenMask;
337: ppdev->flBlue = VideoModeInformation.BlueMask;
338:
339: //
340: // Fill in the GDIINFO data structure with the information returned from the
341: // kernel driver.
342: //
343:
344: pGdiInfo->ulVersion = 0x1000; // Our driver is version 1.000
345: pGdiInfo->ulTechnology = DT_RASDISPLAY;
346: pGdiInfo->ulHorzSize = VideoModeInformation.XMillimeter;
347: pGdiInfo->ulVertSize = VideoModeInformation.YMillimeter;
348:
349: pGdiInfo->ulHorzRes = ppdev->cxScreen;
350: pGdiInfo->ulVertRes = ppdev->cyScreen;
351: pGdiInfo->cBitsPixel = ppdev->ulBitCount;
352: pGdiInfo->cPlanes = 1;
353:
354: //
355: // Fill in the VXL specific data structure.
356: //
357:
358: Vxl.ScreenY = VideoModeInformation.VisScreenHeight;
359: Vxl.ScreenX = VideoModeInformation.VisScreenWidth;
360: Vxl.JaguarScreenX = VideoModeInformation.ScreenStride;
361:
362: // !!!
363: // The following is a trick:
364: // For 8 Bpp, we want 0, 16Bpp we want 1 and 24/32 Bpp 2.
365: // (Vxl.JaguarScreenX / Vxl.ScreenX) has values of 1, 2 and 4
366: // respectively for the three possibilities.
367: // So shifting by 1 will give us a good result.
368: //
369:
370: Vxl.ColorModeShift = (Vxl.JaguarScreenX / Vxl.ScreenX) >> 1;
371:
372: //
373: // Init Font Cache variables
374: //
375:
376: Vxl.FontCacheOffset = (Vxl.ScreenX*Vxl.ScreenY) << Vxl.ColorModeShift;
377: Vxl.CacheIndexMask = MAX_FONT_CACHE_SIZE-1;
378: Vxl.CacheSize = MAX_FONT_CACHE_SIZE;
379:
380: pGdiInfo->flRaster = 0; // DDI reserves flRaster
381:
382: pGdiInfo->ulLogPixelsX = 96;
383: pGdiInfo->ulLogPixelsY = 96;
384:
385: pGdiInfo->flTextCaps = TC_RA_ABLE;
386:
387: pGdiInfo->ulDACRed = pVideoModeSelected->NumberRedBits;
388: pGdiInfo->ulDACGreen = pVideoModeSelected->NumberGreenBits;
389: pGdiInfo->ulDACBlue = pVideoModeSelected->NumberBlueBits;
390:
391: pGdiInfo->ulAspectX = 0x24; // One-to-one aspect ratio
392: pGdiInfo->ulAspectY = 0x24;
393: pGdiInfo->ulAspectXY = 0x33;
394:
395: pGdiInfo->xStyleStep = 1; // A style unit is 3 pels
396: pGdiInfo->yStyleStep = 1;
397: pGdiInfo->denStyleStep = 3;
398:
399: pGdiInfo->ptlPhysOffset.x = 0;
400: pGdiInfo->ptlPhysOffset.y = 0;
401: pGdiInfo->szlPhysSize.cx = 0;
402: pGdiInfo->szlPhysSize.cy = 0;
403:
404: //
405: // RGB and CMY color info.
406: //
407:
408: pGdiInfo->ciDevice.Red.x = 6700;
409: pGdiInfo->ciDevice.Red.y = 3300;
410: pGdiInfo->ciDevice.Red.Y = 0;
411: pGdiInfo->ciDevice.Green.x = 2100;
412: pGdiInfo->ciDevice.Green.y = 7100;
413: pGdiInfo->ciDevice.Green.Y = 0;
414: pGdiInfo->ciDevice.Blue.x = 1400;
415: pGdiInfo->ciDevice.Blue.y = 800;
416: pGdiInfo->ciDevice.Blue.Y = 0;
417: pGdiInfo->ciDevice.Cyan.x = 1750;
418: pGdiInfo->ciDevice.Cyan.y = 3950;
419: pGdiInfo->ciDevice.Cyan.Y = 0;
420: pGdiInfo->ciDevice.Magenta.x = 4050;
421: pGdiInfo->ciDevice.Magenta.y = 2050;
422: pGdiInfo->ciDevice.Magenta.Y = 0;
423: pGdiInfo->ciDevice.Yellow.x = 4400;
424: pGdiInfo->ciDevice.Yellow.y = 5200;
425: pGdiInfo->ciDevice.Yellow.Y = 0;
426: pGdiInfo->ciDevice.AlignmentWhite.x = 3127;
427: pGdiInfo->ciDevice.AlignmentWhite.y = 3290;
428: pGdiInfo->ciDevice.AlignmentWhite.Y = 0;
429:
430: //
431: // Color Gamma adjustment values.
432: //
433:
434: pGdiInfo->ciDevice.RedGamma = 20000;
435: pGdiInfo->ciDevice.GreenGamma = 20000;
436: pGdiInfo->ciDevice.BlueGamma = 20000;
437:
438: //
439: // No dye correction for raster displays.
440: //
441:
442: pGdiInfo->ciDevice.MagentaInCyanDye =
443: pGdiInfo->ciDevice.YellowInCyanDye =
444: pGdiInfo->ciDevice.CyanInMagentaDye =
445: pGdiInfo->ciDevice.YellowInMagentaDye =
446: pGdiInfo->ciDevice.CyanInYellowDye =
447: pGdiInfo->ciDevice.MagentaInYellowDye = 0;
448:
449: pGdiInfo->ulDevicePelsDPI = (pGdiInfo->ulHorzRes * 254) / 3300;
450: pGdiInfo->ulPrimaryOrder = PRIMARY_ORDER_CBA;
451: pGdiInfo->ulHTPatternSize = HT_PATSIZE_4x4_M;
452: pGdiInfo->ulHTOutputFormat = HT_FORMAT_8BPP;
453: pGdiInfo->flHTFlags = HT_FLAG_ADDITIVE_PRIMS;
454:
455: *(pDevInfo) = gDevInfoFrameBuffer;
456:
457: //
458: // Initialize the color mode dependent fields.
459: // Set the gamma corrected palette for 16/32 bits per pixel
460: //
461:
462: switch (ppdev->ulBitCount)
463: {
464:
465: case 8:
466:
467: //
468: // It is Palette Managed.
469: //
470: pDevInfo->flGraphicsCaps |= (GCAPS_PALMANAGED | GCAPS_COLOR_DITHER);
471: pGdiInfo->ulNumColors = 20;
472: pGdiInfo->ulNumPalReg = 256;
473: pDevInfo->iDitherFormat = BMF_8BPP;
474: break;
475:
476: case 16:
477:
478: pGdiInfo->ulNumColors = 2048;
479: pGdiInfo->ulNumPalReg = 0;
480:
481: pDevInfo->iDitherFormat = BMF_16BPP;
482: pGdiInfo->ulHTPatternSize = HT_PATSIZE_2x2_M;
483: pGdiInfo->ulHTOutputFormat = HT_FORMAT_16BPP;
484:
485: //
486: // 16 bpp mode is really 5 red,5 green and 5 blue
487: //
488:
489: DrvpSetGammaColorPalette(ppdev,
490: 32,
491: pGdiInfo->ciDevice.RedGamma,
492: pGdiInfo->ciDevice.GreenGamma,
493: pGdiInfo->ciDevice.BlueGamma
494: );
495: break;
496:
497: case 24:
498: case 32:
499:
500: pGdiInfo->ulNumColors = 2048;
501: pGdiInfo->ulNumPalReg = 0;
502:
503: //
504: // Reset the bit count to 32 since we are really in 32 bits wide
505: //
506:
507: pGdiInfo->cBitsPixel = ppdev->ulBitCount = 32;
508:
509: pDevInfo->iDitherFormat = BMF_32BPP;
510:
511: DrvpSetGammaColorPalette(ppdev,
512: 256,
513: pGdiInfo->ciDevice.RedGamma,
514: pGdiInfo->ciDevice.GreenGamma,
515: pGdiInfo->ciDevice.BlueGamma
516: );
517:
518: break;
519:
520: default:
521:
522: break;
523: }
524:
525: //
526: // Free video buffer from get mode info
527: //
528:
529: LocalFree(pVideoBuffer);
530:
531: return(TRUE);
532: }
533:
534:
535: /******************************Public*Routine******************************\
536: * getAvailableModes
537: *
538: * Calls the miniport to get the list of modes supported by the kernel driver,
539: * and returns the list of modes supported by the diplay driver among those
540: *
541: * returns the number of entries in the videomode buffer.
542: * 0 means no modes are supported by the miniport or that an error occured.
543: *
544: * NOTE: the buffer must be freed up by the caller.
545: *
546: \**************************************************************************/
547:
548: DWORD getAvailableModes(
549: HANDLE hDriver,
550: PVIDEO_MODE_INFORMATION *modeInformation,
551: DWORD *cbModeSize)
552: {
553: ULONG ulTemp;
554: VIDEO_NUM_MODES modes;
555: PVIDEO_MODE_INFORMATION pVideoTemp;
556:
557: //
558: // Get the number of modes supported by the mini-port
559: //
560:
561: if (!DeviceIoControl(hDriver,
562: IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
563: NULL,
564: 0,
565: &modes,
566: sizeof(VIDEO_NUM_MODES),
567: &ulTemp,
568: NULL))
569: {
570: DISPDBG((0, "jzvxl484.dll getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
571: return(0);
572: }
573:
574: *cbModeSize = modes.ModeInformationLength;
575:
576: //
577: // Allocate the buffer for the mini-port to write the modes in.
578: //
579:
580: *modeInformation = (PVIDEO_MODE_INFORMATION)
581: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
582: modes.NumModes *
583: modes.ModeInformationLength);
584:
585: if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL)
586: {
587: DISPDBG((0, "jzvxl484.dll getAvailableModes failed LocalAlloc\n"));
588:
589: return 0;
590: }
591:
592: //
593: // Ask the mini-port to fill in the available modes.
594: //
595:
596: if (!DeviceIoControl(hDriver,
597: IOCTL_VIDEO_QUERY_AVAIL_MODES,
598: NULL,
599: 0,
600: *modeInformation,
601: modes.NumModes * modes.ModeInformationLength,
602: &ulTemp,
603: NULL))
604: {
605:
606: DISPDBG((0, "jzvxl484.dll getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
607:
608: LocalFree(*modeInformation);
609: *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
610:
611: return(0);
612: }
613:
614: //
615: // Now see which of these modes are supported by the display driver.
616: // As an internal mechanism, set the length to 0 for the modes we
617: // DO NOT support.
618: //
619:
620: ulTemp = modes.NumModes;
621: pVideoTemp = *modeInformation;
622:
623: //
624: // Mode is rejected if it is not one plane, or not graphics, or is not
625: // one of 8, 16, 24 or 32 bits per pel.
626: //
627:
628: while (ulTemp--)
629: {
630: if ((pVideoTemp->NumberOfPlanes != 1 ) ||
631: !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
632: ((pVideoTemp->BitsPerPlane != 8) &&
633: (pVideoTemp->BitsPerPlane != 16) &&
634: (pVideoTemp->BitsPerPlane != 24) &&
635: (pVideoTemp->BitsPerPlane != 32)))
636: {
637: pVideoTemp->Length = 0;
638: }
639:
640: pVideoTemp = (PVIDEO_MODE_INFORMATION)
641: (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
642: }
643:
644: return modes.NumModes;
645:
646: }
647:
648:
649: BOOL
650: DrvpSetGammaColorPalette(
651: IN PPDEV ppdev,
652: IN WORD NumberOfEntries,
653: IN LDECI4 GammaRed,
654: IN LDECI4 GammaGreen,
655: IN LDECI4 GammaBlue
656: )
657: /*++
658:
659: Routine Description:
660:
661: This function will set the device palette to a gamma correctec palette for
662: 16 or 24 bit per pixel operation
663:
664: Arguments:
665:
666: ppdev - device mode structure
667: NumberOfEntries - Bits per pixel: the number of color map entries needed
668: GammaRed - Gamma value for red gun from devmode structure
669: GammaGreen - Gamma value for green gun from devmode structure
670: GammaBlue - Gamma value for blue gun from devmode structure
671:
672: Return Value:
673:
674: A value of TRUE is returned if the gamma corrected palette is set
675: A value of FALSE is returned if there is an error attempting to set the palette.
676:
677: --*/
678:
679:
680: {
681: ULONG Index,ByteIndex;
682: LONG GammaReturn;
683: PVIDEO_CLUT pVideoClut;
684: ULONG ClutSize;
685: DWORD DNumberOfEntries;
686: PBYTE pGammaTable;
687:
688: //
689: // Allocate the gamma table used for return data from HT_
690: //
691:
692: pGammaTable = (PBYTE)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,sizeof(BYTE) * 3 * NumberOfEntries);
693:
694: if (pGammaTable == NULL) {
695: DISPDBG((0, "DrvpSetGammaColorPalette() failed LocalAlloc\n"));
696: return(FALSE);
697: }
698:
699: //
700: // Gamma values come in UDECI4 format as described in ht.h. This format is a
701: // fractional integer format with four decimal places ie: 00020000 = 2.0000
702: //
703:
704: GammaReturn = HT_ComputeRGBGammaTable(NumberOfEntries,
705: 0,
706: GammaRed,
707: GammaGreen,
708: GammaBlue,
709: pGammaTable);
710:
711: if (GammaReturn != NumberOfEntries) {
712: DISPDBG((0, "DrvpSetGammaColorPalette() failed HT_ComputeGammaTable\n"));
713: return(FALSE);
714: }
715:
716: //
717: // Allocate the PalatteEntry to call IOCTL
718: //
719:
720: pVideoClut = (PVIDEO_CLUT)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,MAX_CLUT_SIZE);
721:
722: if (pVideoClut == NULL) {
723: DISPDBG((0, "DrvpSetGammaColorPalette() failed LocalAlloc\n"));
724: return(FALSE);
725: }
726:
727: //
728: // Translate into paletteentry data
729: // Print the results
730: //
731:
732: ByteIndex = 0;
733:
734: for (Index = 0;Index < NumberOfEntries;Index++ ) {
735: pVideoClut->LookupTable[Index].RgbArray.Red = pGammaTable[ByteIndex++];
736: pVideoClut->LookupTable[Index].RgbArray.Green = pGammaTable[ByteIndex++];
737: pVideoClut->LookupTable[Index].RgbArray.Blue = pGammaTable[ByteIndex++];
738:
739: }
740:
741: //
742: // Set the other ScreenClut values
743: //
744:
745: pVideoClut->NumEntries = NumberOfEntries;
746: pVideoClut->FirstEntry = 0;
747:
748: //
749: // Set this palette through the IOCTL
750: //
751:
752: if (!DeviceIoControl(ppdev->hDriver,
753: IOCTL_VIDEO_SET_COLOR_REGISTERS,
754: pVideoClut,
755: MAX_CLUT_SIZE,
756: NULL,
757: 0,
758: &DNumberOfEntries,
759: NULL))
760: {
761: DISPDBG((0, "jzvxl484 DrvSetPalette failed DeviceIoControl\n"));
762: return(FALSE);
763: }
764:
765: //
766: // free memory buffers
767: //
768:
769: LocalFree(pVideoClut);
770: LocalFree(pGammaTable);
771:
772: return(TRUE);
773: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.