VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Display/screen.c@ 16684

Last change on this file since 16684 was 16615, checked in by vboxsync, 16 years ago

additional header updates
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 27.1 KB
Line 
1/******************************Module*Header*******************************\
2*
3* Copyright (C) 2006-2007 Sun Microsystems, Inc.
4*
5* This file is part of VirtualBox Open Source Edition (OSE), as
6* available from http://www.virtualbox.org. This file is free software;
7* you can redistribute it and/or modify it under the terms of the GNU
8* General Public License (GPL) as published by the Free Software
9* Foundation, in version 2 as it comes in the "COPYING" file of the
10* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
11* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
12*
13* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
14* Clara, CA 95054 USA or visit http://www.sun.com if you need
15* additional information or have any questions.
16*/
17/*
18* Based in part on Microsoft DDK sample code
19*
20* *******************
21* * GDI SAMPLE CODE *
22* *******************
23*
24* Module Name: screen.c
25*
26* Initializes the GDIINFO and DEVINFO structures for DrvEnablePDEV.
27*
28* Copyright (c) 1992-1998 Microsoft Corporation
29\**************************************************************************/
30
31#include "driver.h"
32
33#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"}
34#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"}
35#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"}
36
37// This is the basic devinfo for a default driver. This is used as a base and customized based
38// on information passed back from the miniport driver.
39
40const DEVINFO gDevInfoFrameBuffer = {
41 ( GCAPS_OPAQUERECT
42#ifdef VBOX_WITH_DDRAW
43 | GCAPS_DIRECTDRAW
44#endif
45 | GCAPS_MONO_DITHER
46 ), /* Graphics capabilities */
47 SYSTM_LOGFONT, /* Default font description */
48 HELVE_LOGFONT, /* ANSI variable font description */
49 COURI_LOGFONT, /* ANSI fixed font description */
50 0, /* Count of device fonts */
51 0, /* Preferred DIB format */
52 8, /* Width of color dither */
53 8, /* Height of color dither */
54 0 /* Default palette to use for this device */
55};
56
57static void vboxInitVBoxVideo (PPDEV ppdev, const VIDEO_MEMORY_INFORMATION *pMemoryInformation)
58{
59 ULONG cbAvailable = 0;
60
61 DWORD returnedDataLength;
62
63 QUERYDISPLAYINFORESULT DispInfo;
64 RtlZeroMemory(&DispInfo, sizeof (DispInfo));
65
66 ppdev->bVBoxVideoSupported = !EngDeviceIoControl(ppdev->hDriver,
67 IOCTL_VIDEO_QUERY_DISPLAY_INFO,
68 NULL,
69 0,
70 &DispInfo,
71 sizeof(DispInfo),
72 &returnedDataLength);
73
74 if (ppdev->bVBoxVideoSupported)
75 {
76 ppdev->iDevice = DispInfo.iDevice;
77
78 ppdev->layout.cbVRAM = pMemoryInformation->VideoRamLength;
79
80 ppdev->layout.offFrameBuffer = 0;
81 ppdev->layout.cbFrameBuffer = RT_ALIGN_32(pMemoryInformation->FrameBufferLength, 0x1000);
82
83 cbAvailable = ppdev->layout.cbVRAM - ppdev->layout.cbFrameBuffer;
84
85 if (cbAvailable <= DispInfo.u32DisplayInfoSize)
86 {
87 ppdev->bVBoxVideoSupported = FALSE;
88 }
89 else
90 {
91 ppdev->layout.offDisplayInformation = ppdev->layout.cbVRAM - DispInfo.u32DisplayInfoSize;
92 ppdev->layout.cbDisplayInformation = DispInfo.u32DisplayInfoSize;
93
94 cbAvailable -= ppdev->layout.cbDisplayInformation;
95
96 /* Use minimum 64K and maximum the cbFrameBuffer for the VBVA buffer. */
97 for (ppdev->layout.cbVBVABuffer = ppdev->layout.cbFrameBuffer;
98 ppdev->layout.cbVBVABuffer >= 0x10000;
99 ppdev->layout.cbVBVABuffer /= 2)
100 {
101 if (ppdev->layout.cbVBVABuffer < cbAvailable)
102 {
103 break;
104 }
105 }
106
107 if (ppdev->layout.cbVBVABuffer >= cbAvailable)
108 {
109 ppdev->bVBoxVideoSupported = FALSE;
110 }
111 else
112 {
113 /* Now the offscreen heap followed by the VBVA buffer. */
114 ppdev->layout.offDDRAWHeap = ppdev->layout.offFrameBuffer + ppdev->layout.cbFrameBuffer;
115
116 cbAvailable -= ppdev->layout.cbVBVABuffer;
117 ppdev->layout.cbDDRAWHeap = cbAvailable;
118
119 ppdev->layout.offVBVABuffer = ppdev->layout.offDDRAWHeap + ppdev->layout.cbDDRAWHeap;
120 }
121 }
122 }
123
124 if (!ppdev->bVBoxVideoSupported)
125 {
126 ppdev->iDevice = 0;
127
128 /* Setup a layout without both the VBVA buffer and the display information. */
129 ppdev->layout.cbVRAM = pMemoryInformation->VideoRamLength;
130
131 ppdev->layout.offFrameBuffer = 0;
132 ppdev->layout.cbFrameBuffer = RT_ALIGN_32(pMemoryInformation->FrameBufferLength, 0x1000);
133
134 ppdev->layout.offDDRAWHeap = ppdev->layout.offFrameBuffer + ppdev->layout.cbFrameBuffer;
135 ppdev->layout.cbDDRAWHeap = ppdev->layout.cbVRAM - ppdev->layout.offDDRAWHeap;
136
137 ppdev->layout.offVBVABuffer = ppdev->layout.offDDRAWHeap + ppdev->layout.cbDDRAWHeap;
138 ppdev->layout.cbVBVABuffer = 0;
139
140 ppdev->layout.offDisplayInformation = ppdev->layout.offVBVABuffer + ppdev->layout.cbVBVABuffer;
141 ppdev->layout.cbDisplayInformation = 0;
142 }
143
144 DISPDBG((0, "vboxInitVBoxVideo:\n"
145 " cbVRAM = 0x%X\n"
146 " offFrameBuffer = 0x%X\n"
147 " cbFrameBuffer = 0x%X\n"
148 " offDDRAWHeap = 0x%X\n"
149 " cbDDRAWHeap = 0x%X\n"
150 " offVBVABuffer = 0x%X\n"
151 " cbVBVABuffer = 0x%X\n"
152 " offDisplayInformation = 0x%X\n"
153 " cbDisplayInformation = 0x%X\n",
154 ppdev->layout.cbVRAM,
155 ppdev->layout.offFrameBuffer,
156 ppdev->layout.cbFrameBuffer,
157 ppdev->layout.offDDRAWHeap,
158 ppdev->layout.cbDDRAWHeap,
159 ppdev->layout.offVBVABuffer,
160 ppdev->layout.cbVBVABuffer,
161 ppdev->layout.offDisplayInformation,
162 ppdev->layout.cbDisplayInformation
163 ));
164}
165
166/* Setup display information after remapping. */
167static void vboxSetupDisplayInfo (PPDEV ppdev, VIDEO_MEMORY_INFORMATION *pMemoryInformation)
168{
169 VBOXDISPLAYINFO *pInfo;
170 uint8_t *pu8;
171
172 pu8 = (uint8_t *)ppdev->pjScreen + ppdev->layout.offDisplayInformation;
173
174 pInfo = (VBOXDISPLAYINFO *)pu8;
175 pu8 += sizeof (VBOXDISPLAYINFO);
176
177 pInfo->hdrLink.u8Type = VBOX_VIDEO_INFO_TYPE_LINK;
178 pInfo->hdrLink.u8Reserved = 0;
179 pInfo->hdrLink.u16Length = sizeof (VBOXVIDEOINFOLINK);
180 pInfo->link.i32Offset = 0;
181
182 pInfo->hdrScreen.u8Type = VBOX_VIDEO_INFO_TYPE_SCREEN;
183 pInfo->hdrScreen.u8Reserved = 0;
184 pInfo->hdrScreen.u16Length = sizeof (VBOXVIDEOINFOSCREEN);
185 DISPDBG((1, "Setup: %d,%d\n", ppdev->ptlDevOrg.x, ppdev->ptlDevOrg.y));
186 pInfo->screen.xOrigin = ppdev->ptlDevOrg.x;
187 pInfo->screen.yOrigin = ppdev->ptlDevOrg.y;
188 pInfo->screen.u32LineSize = 0;
189 pInfo->screen.u16Width = 0;
190 pInfo->screen.u16Height = 0;
191 pInfo->screen.bitsPerPixel = 0;
192 pInfo->screen.u8Flags = VBOX_VIDEO_INFO_SCREEN_F_NONE;
193
194 pInfo->hdrHostEvents.u8Type = VBOX_VIDEO_INFO_TYPE_HOST_EVENTS;
195 pInfo->hdrHostEvents.u8Reserved = 0;
196 pInfo->hdrHostEvents.u16Length = sizeof (VBOXVIDEOINFOHOSTEVENTS);
197 pInfo->hostEvents.fu32Events = VBOX_VIDEO_INFO_HOST_EVENTS_F_NONE;
198
199 pInfo->hdrEnd.u8Type = VBOX_VIDEO_INFO_TYPE_END;
200 pInfo->hdrEnd.u8Reserved = 0;
201 pInfo->hdrEnd.u16Length = 0;
202
203 ppdev->pInfo = pInfo;
204}
205
206
207static void vboxUpdateDisplayInfo (PPDEV ppdev)
208{
209 if (ppdev->pInfo)
210 {
211 ppdev->pInfo->screen.u32LineSize = ppdev->lDeltaScreen;
212 ppdev->pInfo->screen.u16Width = (uint16_t)ppdev->cxScreen;
213 ppdev->pInfo->screen.u16Height = (uint16_t)ppdev->cyScreen;
214 ppdev->pInfo->screen.bitsPerPixel = (uint8_t)ppdev->ulBitCount;
215 ppdev->pInfo->screen.u8Flags = VBOX_VIDEO_INFO_SCREEN_F_ACTIVE;
216
217 DISPDBG((1, "Update: %d,%d\n", ppdev->ptlDevOrg.x, ppdev->ptlDevOrg.y));
218 VBoxProcessDisplayInfo(ppdev);
219 }
220}
221
222
223/******************************Public*Routine******************************\
224* bInitSURF
225*
226* Enables the surface. Maps the frame buffer into memory.
227*
228\**************************************************************************/
229
230BOOL bInitSURF(PPDEV ppdev, BOOL bFirst)
231{
232 DWORD returnedDataLength;
233 DWORD MaxWidth, MaxHeight;
234 VIDEO_MEMORY videoMemory;
235 VIDEO_MEMORY_INFORMATION videoMemoryInformation;
236 ULONG RemappingNeeded = 0;
237
238 //
239 // Set the current mode into the hardware.
240 //
241
242 if (EngDeviceIoControl(ppdev->hDriver,
243 IOCTL_VIDEO_SET_CURRENT_MODE,
244 &(ppdev->ulMode),
245 sizeof(ULONG),
246 &RemappingNeeded,
247 sizeof(ULONG),
248 &returnedDataLength))
249 {
250 DISPDBG((1, "DISP bInitSURF failed IOCTL_SET_MODE\n"));
251 return(FALSE);
252 }
253
254 //
255 // If this is the first time we enable the surface we need to map in the
256 // memory also.
257 //
258
259 if (bFirst || RemappingNeeded)
260 {
261 videoMemory.RequestedVirtualAddress = NULL;
262
263 if (EngDeviceIoControl(ppdev->hDriver,
264 IOCTL_VIDEO_MAP_VIDEO_MEMORY,
265 &videoMemory,
266 sizeof(VIDEO_MEMORY),
267 &videoMemoryInformation,
268 sizeof(VIDEO_MEMORY_INFORMATION),
269 &returnedDataLength))
270 {
271 DISPDBG((1, "DISP bInitSURF failed IOCTL_VIDEO_MAP\n"));
272 return(FALSE);
273 }
274
275 ppdev->pjScreen = (PBYTE)(videoMemoryInformation.FrameBufferBase);
276
277 if (videoMemoryInformation.FrameBufferBase !=
278 videoMemoryInformation.VideoRamBase)
279 {
280 DISPDBG((0, "VideoRamBase does not correspond to FrameBufferBase\n"));
281 }
282
283 //
284 // Make sure we can access this video memory
285 //
286
287 *(PULONG)(ppdev->pjScreen) = 0xaa55aa55;
288
289 if (*(PULONG)(ppdev->pjScreen) != 0xaa55aa55) {
290
291 DISPDBG((1, "Frame buffer memory is not accessible.\n"));
292 return(FALSE);
293 }
294
295 //
296 // Initialize the head of the offscreen list to NULL.
297 //
298
299 ppdev->pOffscreenList = NULL;
300
301 // It's a hardware pointer; set up pointer attributes.
302
303 MaxHeight = ppdev->PointerCapabilities.MaxHeight;
304
305 // Allocate space for two DIBs (data/mask) for the pointer. If this
306 // device supports a color Pointer, we will allocate a larger bitmap.
307 // If this is a color bitmap we allocate for the largest possible
308 // bitmap because we have no idea of what the pixel depth might be.
309
310 // Width rounded up to nearest byte multiple
311
312 if (!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER))
313 {
314 MaxWidth = (ppdev->PointerCapabilities.MaxWidth + 7) / 8;
315 }
316 else
317 {
318 MaxWidth = ppdev->PointerCapabilities.MaxWidth * sizeof(DWORD);
319 }
320
321 ppdev->cjPointerAttributes =
322 sizeof(VIDEO_POINTER_ATTRIBUTES) +
323 ((sizeof(UCHAR) * MaxWidth * MaxHeight) * 2);
324
325 ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES)
326 EngAllocMem(0, ppdev->cjPointerAttributes, ALLOC_TAG);
327
328 if (ppdev->pPointerAttributes == NULL) {
329
330 DISPDBG((0, "bInitPointer EngAllocMem failed\n"));
331 return(FALSE);
332 }
333
334 ppdev->pPointerAttributes->Flags = ppdev->PointerCapabilities.Flags;
335 ppdev->pPointerAttributes->WidthInBytes = MaxWidth;
336 ppdev->pPointerAttributes->Width = ppdev->PointerCapabilities.MaxWidth;
337 ppdev->pPointerAttributes->Height = MaxHeight;
338 ppdev->pPointerAttributes->Column = 0;
339 ppdev->pPointerAttributes->Row = 0;
340 ppdev->pPointerAttributes->Enable = 0;
341
342 vboxInitVBoxVideo (ppdev, &videoMemoryInformation);
343
344 if (ppdev->bVBoxVideoSupported)
345 {
346 /* Setup the display information. */
347 vboxSetupDisplayInfo (ppdev, &videoMemoryInformation);
348 }
349 }
350
351
352 DISPDBG((1, "DISP bInitSURF: ppdev->ulBitCount %d\n", ppdev->ulBitCount));
353
354 if ( ppdev->ulBitCount == 16
355 || ppdev->ulBitCount == 24
356 || ppdev->ulBitCount == 32)
357 {
358 if (ppdev->pInfo) /* Do not use VBVA on old hosts. */
359 {
360 /* Enable VBVA for this video mode. */
361 vboxVbvaEnable (ppdev);
362 }
363 }
364
365 DISPDBG((1, "DISP bInitSURF success\n"));
366
367 /* Update the display information. */
368 vboxUpdateDisplayInfo (ppdev);
369
370 return(TRUE);
371}
372
373/******************************Public*Routine******************************\
374* vDisableSURF
375*
376* Disable the surface. Un-Maps the frame in memory.
377*
378\**************************************************************************/
379
380VOID vDisableSURF(PPDEV ppdev)
381{
382 DWORD returnedDataLength;
383 VIDEO_MEMORY videoMemory;
384
385 videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
386
387 if (EngDeviceIoControl(ppdev->hDriver,
388 IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
389 &videoMemory,
390 sizeof(VIDEO_MEMORY),
391 NULL,
392 0,
393 &returnedDataLength))
394 {
395 DISPDBG((0, "DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n"));
396 }
397}
398
399
400/******************************Public*Routine******************************\
401* bInitPDEV
402*
403* Determine the mode we should be in based on the DEVMODE passed in.
404* Query mini-port to get information needed to fill in the DevInfo and the
405* GdiInfo .
406*
407\**************************************************************************/
408
409BOOL bInitPDEV(
410PPDEV ppdev,
411DEVMODEW *pDevMode,
412GDIINFO *pGdiInfo,
413DEVINFO *pDevInfo)
414{
415 ULONG cModes;
416 PVIDEO_MODE_INFORMATION pVideoBuffer, pVideoModeSelected, pVideoTemp;
417 VIDEO_COLOR_CAPABILITIES colorCapabilities;
418 ULONG ulTemp;
419 BOOL bSelectDefault;
420 ULONG cbModeSize;
421
422 //
423 // calls the miniport to get mode information.
424 //
425
426 cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
427
428 if (cModes == 0)
429 {
430 return(FALSE);
431 }
432
433 //
434 // Now see if the requested mode has a match in that table.
435 //
436
437 pVideoModeSelected = NULL;
438 pVideoTemp = pVideoBuffer;
439
440 if ((pDevMode->dmPelsWidth == 0) &&
441 (pDevMode->dmPelsHeight == 0) &&
442 (pDevMode->dmBitsPerPel == 0) &&
443 (pDevMode->dmDisplayFrequency == 0))
444 {
445 DISPDBG((2, "Default mode requested"));
446 bSelectDefault = TRUE;
447 }
448 else
449 {
450 DISPDBG((2, "Requested mode...\n"));
451 DISPDBG((2, " Screen width -- %li\n", pDevMode->dmPelsWidth));
452 DISPDBG((2, " Screen height -- %li\n", pDevMode->dmPelsHeight));
453 DISPDBG((2, " Bits per pel -- %li\n", pDevMode->dmBitsPerPel));
454 DISPDBG((2, " Frequency -- %li\n", pDevMode->dmDisplayFrequency));
455
456 bSelectDefault = FALSE;
457 }
458
459 while (cModes--)
460 {
461 if (pVideoTemp->Length != 0)
462 {
463 if (bSelectDefault ||
464 ((pVideoTemp->VisScreenWidth == pDevMode->dmPelsWidth) &&
465 (pVideoTemp->VisScreenHeight == pDevMode->dmPelsHeight) &&
466 (pVideoTemp->BitsPerPlane *
467 pVideoTemp->NumberOfPlanes == pDevMode->dmBitsPerPel) &&
468 (pVideoTemp->Frequency == pDevMode->dmDisplayFrequency)))
469 {
470 pVideoModeSelected = pVideoTemp;
471 DISPDBG((3, "Found a match\n")) ;
472 break;
473 }
474 }
475
476 pVideoTemp = (PVIDEO_MODE_INFORMATION)
477 (((PUCHAR)pVideoTemp) + cbModeSize);
478 }
479
480 //
481 // If no mode has been found, return an error
482 //
483
484 if (pVideoModeSelected == NULL)
485 {
486 EngFreeMem(pVideoBuffer);
487 DISPDBG((0,"DISP bInitPDEV failed - no valid modes\n"));
488 return(FALSE);
489 }
490
491 //
492 // Fill in the GDIINFO data structure with the information returned from
493 // the kernel driver.
494 //
495
496 ppdev->ulMode = pVideoModeSelected->ModeIndex;
497 ppdev->cxScreen = pVideoModeSelected->VisScreenWidth;
498 ppdev->cyScreen = pVideoModeSelected->VisScreenHeight;
499 ppdev->ulBitCount = pVideoModeSelected->BitsPerPlane *
500 pVideoModeSelected->NumberOfPlanes;
501 ppdev->lDeltaScreen = pVideoModeSelected->ScreenStride;
502
503 ppdev->flRed = pVideoModeSelected->RedMask;
504 ppdev->flGreen = pVideoModeSelected->GreenMask;
505 ppdev->flBlue = pVideoModeSelected->BlueMask;
506
507
508 if (g_bOnNT40)
509 {
510 DISPDBG((0,"DISP bInitPDEV pGdiInfo->ulVersion = %x\n", GDI_DRIVER_VERSION));
511 pGdiInfo->ulVersion = GDI_DRIVER_VERSION; /* 0x4000 -> NT4 */
512 }
513 else
514 {
515 DISPDBG((0,"DISP bInitPDEV pGdiInfo->ulVersion = %x\n", 0x5000));
516 pGdiInfo->ulVersion = 0x5000;
517 }
518
519 pGdiInfo->ulTechnology = DT_RASDISPLAY;
520 pGdiInfo->ulHorzSize = pVideoModeSelected->XMillimeter;
521 pGdiInfo->ulVertSize = pVideoModeSelected->YMillimeter;
522
523 pGdiInfo->ulHorzRes = ppdev->cxScreen;
524 pGdiInfo->ulVertRes = ppdev->cyScreen;
525 pGdiInfo->ulPanningHorzRes = ppdev->cxScreen;
526 pGdiInfo->ulPanningVertRes = ppdev->cyScreen;
527 pGdiInfo->cBitsPixel = pVideoModeSelected->BitsPerPlane;
528 pGdiInfo->cPlanes = pVideoModeSelected->NumberOfPlanes;
529 pGdiInfo->ulVRefresh = pVideoModeSelected->Frequency;
530 /* bit block transfers are accelerated */
531 pGdiInfo->ulBltAlignment = 0;
532
533 pGdiInfo->ulLogPixelsX = pDevMode->dmLogPixels;
534 pGdiInfo->ulLogPixelsY = pDevMode->dmLogPixels;
535
536#ifdef MIPS
537 if (ppdev->ulBitCount == 8)
538 pGdiInfo->flTextCaps = (TC_RA_ABLE | TC_SCROLLBLT);
539 else
540#endif
541 pGdiInfo->flTextCaps = TC_RA_ABLE;
542
543 pGdiInfo->flRaster = 0; // flRaster is reserved by DDI
544
545 pGdiInfo->ulDACRed = pVideoModeSelected->NumberRedBits;
546 pGdiInfo->ulDACGreen = pVideoModeSelected->NumberGreenBits;
547 pGdiInfo->ulDACBlue = pVideoModeSelected->NumberBlueBits;
548
549 pGdiInfo->ulAspectX = 0x24; // One-to-one aspect ratio
550 pGdiInfo->ulAspectY = 0x24;
551 pGdiInfo->ulAspectXY = 0x33;
552
553 pGdiInfo->xStyleStep = 1; // A style unit is 3 pels
554 pGdiInfo->yStyleStep = 1;
555 pGdiInfo->denStyleStep = 3;
556
557 pGdiInfo->ptlPhysOffset.x = 0;
558 pGdiInfo->ptlPhysOffset.y = 0;
559 pGdiInfo->szlPhysSize.cx = 0;
560 pGdiInfo->szlPhysSize.cy = 0;
561
562 // RGB and CMY color info.
563
564 //
565 // try to get it from the miniport.
566 // if the miniport doesn ot support this feature, use defaults.
567 //
568
569 if (EngDeviceIoControl(ppdev->hDriver,
570 IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES,
571 NULL,
572 0,
573 &colorCapabilities,
574 sizeof(VIDEO_COLOR_CAPABILITIES),
575 &ulTemp))
576 {
577
578 DISPDBG((2, "getcolorCapabilities failed \n"));
579
580 pGdiInfo->ciDevice.Red.x = 6700;
581 pGdiInfo->ciDevice.Red.y = 3300;
582 pGdiInfo->ciDevice.Red.Y = 0;
583 pGdiInfo->ciDevice.Green.x = 2100;
584 pGdiInfo->ciDevice.Green.y = 7100;
585 pGdiInfo->ciDevice.Green.Y = 0;
586 pGdiInfo->ciDevice.Blue.x = 1400;
587 pGdiInfo->ciDevice.Blue.y = 800;
588 pGdiInfo->ciDevice.Blue.Y = 0;
589 pGdiInfo->ciDevice.AlignmentWhite.x = 3127;
590 pGdiInfo->ciDevice.AlignmentWhite.y = 3290;
591 pGdiInfo->ciDevice.AlignmentWhite.Y = 0;
592
593 pGdiInfo->ciDevice.RedGamma = 20000;
594 pGdiInfo->ciDevice.GreenGamma = 20000;
595 pGdiInfo->ciDevice.BlueGamma = 20000;
596
597 }
598 else
599 {
600 pGdiInfo->ciDevice.Red.x = colorCapabilities.RedChromaticity_x;
601 pGdiInfo->ciDevice.Red.y = colorCapabilities.RedChromaticity_y;
602 pGdiInfo->ciDevice.Red.Y = 0;
603 pGdiInfo->ciDevice.Green.x = colorCapabilities.GreenChromaticity_x;
604 pGdiInfo->ciDevice.Green.y = colorCapabilities.GreenChromaticity_y;
605 pGdiInfo->ciDevice.Green.Y = 0;
606 pGdiInfo->ciDevice.Blue.x = colorCapabilities.BlueChromaticity_x;
607 pGdiInfo->ciDevice.Blue.y = colorCapabilities.BlueChromaticity_y;
608 pGdiInfo->ciDevice.Blue.Y = 0;
609 pGdiInfo->ciDevice.AlignmentWhite.x = colorCapabilities.WhiteChromaticity_x;
610 pGdiInfo->ciDevice.AlignmentWhite.y = colorCapabilities.WhiteChromaticity_y;
611 pGdiInfo->ciDevice.AlignmentWhite.Y = colorCapabilities.WhiteChromaticity_Y;
612
613 // if we have a color device store the three color gamma values,
614 // otherwise store the unique gamma value in all three.
615
616 if (colorCapabilities.AttributeFlags & VIDEO_DEVICE_COLOR)
617 {
618 pGdiInfo->ciDevice.RedGamma = colorCapabilities.RedGamma;
619 pGdiInfo->ciDevice.GreenGamma = colorCapabilities.GreenGamma;
620 pGdiInfo->ciDevice.BlueGamma = colorCapabilities.BlueGamma;
621 }
622 else
623 {
624 pGdiInfo->ciDevice.RedGamma = colorCapabilities.WhiteGamma;
625 pGdiInfo->ciDevice.GreenGamma = colorCapabilities.WhiteGamma;
626 pGdiInfo->ciDevice.BlueGamma = colorCapabilities.WhiteGamma;
627 }
628
629 };
630
631 pGdiInfo->ciDevice.Cyan.x = 0;
632 pGdiInfo->ciDevice.Cyan.y = 0;
633 pGdiInfo->ciDevice.Cyan.Y = 0;
634 pGdiInfo->ciDevice.Magenta.x = 0;
635 pGdiInfo->ciDevice.Magenta.y = 0;
636 pGdiInfo->ciDevice.Magenta.Y = 0;
637 pGdiInfo->ciDevice.Yellow.x = 0;
638 pGdiInfo->ciDevice.Yellow.y = 0;
639 pGdiInfo->ciDevice.Yellow.Y = 0;
640
641 // No dye correction for raster displays.
642
643 pGdiInfo->ciDevice.MagentaInCyanDye = 0;
644 pGdiInfo->ciDevice.YellowInCyanDye = 0;
645 pGdiInfo->ciDevice.CyanInMagentaDye = 0;
646 pGdiInfo->ciDevice.YellowInMagentaDye = 0;
647 pGdiInfo->ciDevice.CyanInYellowDye = 0;
648 pGdiInfo->ciDevice.MagentaInYellowDye = 0;
649
650 pGdiInfo->ulDevicePelsDPI = 0; // For printers only
651 pGdiInfo->ulPrimaryOrder = PRIMARY_ORDER_CBA;
652
653 // Note: this should be modified later to take into account the size
654 // of the display and the resolution.
655
656 pGdiInfo->ulHTPatternSize = HT_PATSIZE_4x4_M;
657
658 pGdiInfo->flHTFlags = HT_FLAG_ADDITIVE_PRIMS;
659
660 // Fill in the basic devinfo structure
661
662 *pDevInfo = gDevInfoFrameBuffer;
663
664 // Fill in the rest of the devinfo and GdiInfo structures.
665
666 if (ppdev->ulBitCount == 8)
667 {
668 // It is Palette Managed.
669
670 pGdiInfo->ulNumColors = 20;
671 pGdiInfo->ulNumPalReg = 1 << ppdev->ulBitCount;
672
673 pDevInfo->flGraphicsCaps |= (GCAPS_PALMANAGED | GCAPS_COLOR_DITHER);
674
675 pGdiInfo->ulHTOutputFormat = HT_FORMAT_8BPP;
676 pDevInfo->iDitherFormat = BMF_8BPP;
677
678 // Assuming palette is orthogonal - all colors are same size.
679
680 ppdev->cPaletteShift = 8 - pGdiInfo->ulDACRed;
681 }
682 else
683 {
684 pGdiInfo->ulNumColors = (ULONG) (-1);
685 pGdiInfo->ulNumPalReg = 0;
686
687 if (ppdev->ulBitCount == 16)
688 {
689 pGdiInfo->ulHTOutputFormat = HT_FORMAT_16BPP;
690 pDevInfo->iDitherFormat = BMF_16BPP;
691 }
692 else if (ppdev->ulBitCount == 24)
693 {
694 pGdiInfo->ulHTOutputFormat = HT_FORMAT_24BPP;
695 pDevInfo->iDitherFormat = BMF_24BPP;
696 }
697 else
698 {
699 pGdiInfo->ulHTOutputFormat = HT_FORMAT_32BPP;
700 pDevInfo->iDitherFormat = BMF_32BPP;
701 }
702 }
703
704 EngFreeMem(pVideoBuffer);
705
706 return(TRUE);
707}
708
709
710/******************************Public*Routine******************************\
711* getAvailableModes
712*
713* Calls the miniport to get the list of modes supported by the kernel driver,
714* and returns the list of modes supported by the diplay driver among those
715*
716* returns the number of entries in the videomode buffer.
717* 0 means no modes are supported by the miniport or that an error occured.
718*
719* NOTE: the buffer must be freed up by the caller.
720*
721\**************************************************************************/
722
723DWORD getAvailableModes(
724HANDLE hDriver,
725PVIDEO_MODE_INFORMATION *modeInformation,
726DWORD *cbModeSize)
727{
728 ULONG ulTemp;
729 VIDEO_NUM_MODES modes;
730 PVIDEO_MODE_INFORMATION pVideoTemp;
731
732 //
733 // Get the number of modes supported by the mini-port
734 //
735
736 if (EngDeviceIoControl(hDriver,
737 IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
738 NULL,
739 0,
740 &modes,
741 sizeof(VIDEO_NUM_MODES),
742 &ulTemp))
743 {
744 DISPDBG((0, "getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
745 return(0);
746 }
747
748 *cbModeSize = modes.ModeInformationLength;
749
750 //
751 // Allocate the buffer for the mini-port to write the modes in.
752 //
753
754 *modeInformation = (PVIDEO_MODE_INFORMATION)
755 EngAllocMem(0, modes.NumModes *
756 modes.ModeInformationLength, ALLOC_TAG);
757
758 if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL)
759 {
760 DISPDBG((0, "getAvailableModes failed EngAllocMem\n"));
761
762 return 0;
763 }
764
765 //
766 // Ask the mini-port to fill in the available modes.
767 //
768
769 if (EngDeviceIoControl(hDriver,
770 IOCTL_VIDEO_QUERY_AVAIL_MODES,
771 NULL,
772 0,
773 *modeInformation,
774 modes.NumModes * modes.ModeInformationLength,
775 &ulTemp))
776 {
777
778 DISPDBG((0, "getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
779
780 EngFreeMem(*modeInformation);
781 *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
782
783 return(0);
784 }
785
786 //
787 // Now see which of these modes are supported by the display driver.
788 // As an internal mechanism, set the length to 0 for the modes we
789 // DO NOT support.
790 //
791
792 ulTemp = modes.NumModes;
793 pVideoTemp = *modeInformation;
794
795 //
796 // Mode is rejected if it is not one plane, or not graphics, or is not
797 // one of 8, 16 or 32 bits per pel.
798 //
799
800 while (ulTemp--)
801 {
802 if ((pVideoTemp->NumberOfPlanes != 1 ) ||
803 !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
804 (pVideoTemp->AttributeFlags & VIDEO_MODE_BANKED) ||
805 ((pVideoTemp->BitsPerPlane != 8) &&
806 (pVideoTemp->BitsPerPlane != 16) &&
807 (pVideoTemp->BitsPerPlane != 24) &&
808 (pVideoTemp->BitsPerPlane != 32)))
809 {
810 pVideoTemp->Length = 0;
811 }
812
813 pVideoTemp = (PVIDEO_MODE_INFORMATION)
814 (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
815 }
816
817 return modes.NumModes;
818
819}
820
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette