CLIPOBJ* FASTCALL
IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds)
{
CLIPGDI *Clip;
if(count > 1)
{
RECTL *dest;
Clip = EngAllocMem(0, sizeof(CLIPGDI) + ((count - 1) * sizeof(RECTL)), GDITAG_CLIPOBJ);
if(Clip != NULL)
{
Clip->EnumRects.c = count;
Clip->EnumOrder = CD_ANY;
for(dest = Clip->EnumRects.arcl;count > 0; count--, dest++, pRect++)
{
*dest = *pRect;
}
Clip->ClipObj.iDComplexity = DC_COMPLEX;
Clip->ClipObj.iFComplexity = ((Clip->EnumRects.c <= 4) ? FC_RECT4 : FC_COMPLEX);
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
return GDIToObj(Clip, CLIP);
}
}
else
{
Clip = EngAllocMem(0, sizeof(CLIPGDI), GDITAG_CLIPOBJ);
if(Clip != NULL)
{
Clip->EnumRects.c = 1;
Clip->EnumOrder = CD_ANY;
Clip->EnumRects.arcl[0] = *rcBounds;
Clip->ClipObj.iDComplexity = (((rcBounds->top == rcBounds->bottom) &&
(rcBounds->left == rcBounds->right))
? DC_TRIVIAL : DC_RECT);
Clip->ClipObj.iFComplexity = FC_RECT;
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
return GDIToObj(Clip, CLIP);
}
}
return NULL;
}
BOOL APIENTRY
IntSetPalette(
IN DHPDEV dhpdev,
IN PPALETTEENTRY ppalent,
IN ULONG iStart,
IN ULONG cColors)
{
PVIDEO_CLUT pClut;
ULONG ClutSize;
ClutSize = sizeof(VIDEO_CLUT) + (cColors * sizeof(ULONG));
pClut = EngAllocMem(0, ClutSize, ALLOC_TAG);
pClut->FirstEntry = iStart;
pClut->NumEntries = cColors;
memcpy(&pClut->LookupTable[0].RgbLong, ppalent, sizeof(ULONG) * cColors);
if (((PPDEV)dhpdev)->PaletteShift)
{
while (cColors--)
{
pClut->LookupTable[cColors].RgbArray.Red >>= ((PPDEV)dhpdev)->PaletteShift;
pClut->LookupTable[cColors].RgbArray.Green >>= ((PPDEV)dhpdev)->PaletteShift;
pClut->LookupTable[cColors].RgbArray.Blue >>= ((PPDEV)dhpdev)->PaletteShift;
pClut->LookupTable[cColors].RgbArray.Unused = 0;
}
}
else
{
while (cColors--)
PGDI_POOL
NTAPI
GdiPoolCreate(
ULONG cjAllocSize,
ULONG ulTag)
{
PGDI_POOL pPool;
/* Allocate a pool object */
pPool = EngAllocMem(0, sizeof(GDI_POOL), 'lopG');
if (!pPool) return NULL;
/* Initialize the object */
ExInitializePushLock(&pPool->pushlock);
InitializeListHead(&pPool->leInUseList);
InitializeListHead(&pPool->leReadyList);
InitializeListHead(&pPool->leEmptyList);
pPool->cEmptySections = 0;
pPool->cjAllocSize = cjAllocSize;
pPool->ulTag = ulTag;
pPool->cjSectionSize = GDI_POOL_ALLOCATION_GRANULARITY;
pPool->cSlotsPerSection = pPool->cjSectionSize / cjAllocSize;
DBG_INITLOG(&pPool->slhLog);
return pPool;
}
BOOL DrvEnableDriver(
ULONG iEngineVersion,
ULONG cj,
PDRVENABLEDATA pded)
{
iEngineVersion;
cj;
DbgPrint("DrvEnableDriver called\n");
pded->pdrvfn = gadrvfnTestFd;
pded->c = sizeof(gadrvfnTestFd) / sizeof(DRVFN);
pded->iDriverVersion = DDI_DRIVER_VERSION;
gpgset = (FD_GLYPHSET *)EngAllocMem(0, SZ_GLYPHSET(1, 1), EXFDTAG);
gpgset->cjThis = SZ_GLYPHSET(1, 1);
gpgset->flAccel = 0;
gpgset->cGlyphsSupported = 1;
gpgset->cRuns = 1;
gpgset->awcrun[0].wcLow = THEGLYPH;
gpgset->awcrun[0].cGlyphs = 1;
gpgset->awcrun[0].phg = (HGLYPH *)&gpgset->awcrun[1];
*(gpgset->awcrun[0].phg) = THEGLYPH;
return(TRUE);
}
/*
* @implemented
*/
PVOID APIENTRY
BRUSHOBJ_pvAllocRbrush(
IN BRUSHOBJ *pbo,
IN ULONG cj)
{
pbo->pvRbrush = EngAllocMem(0, cj, GDITAG_RBRUSH);
return pbo->pvRbrush;
}
FASTCALL
POLYGONFILL_MakeEdgeList(PPOINT Points, int Count)
{
int CurPt = 0;
FILL_EDGE_LIST* list = 0;
FILL_EDGE* e = 0;
if ( 0 == Points || 2 > Count )
return 0;
list = (FILL_EDGE_LIST*)EngAllocMem(FL_ZERO_MEMORY, sizeof(FILL_EDGE_LIST), FILL_EDGE_ALLOC_TAG);
if ( 0 == list )
goto fail;
list->Count = 0;
list->Edges = (FILL_EDGE**)EngAllocMem(FL_ZERO_MEMORY, Count*sizeof(FILL_EDGE*), FILL_EDGE_ALLOC_TAG);
if ( !list->Edges )
goto fail;
memset ( list->Edges, 0, Count * sizeof(FILL_EDGE*) );
for ( CurPt = 1; CurPt < Count; ++CurPt )
{
e = POLYGONFILL_MakeEdge ( Points[CurPt-1], Points[CurPt] );
if ( !e )
goto fail;
// if a straight horizontal line - who cares?
if ( !e->absdy )
EngFreeMem ( e );
else
list->Edges[list->Count++] = e;
}
e = POLYGONFILL_MakeEdge ( Points[CurPt-1], Points[0] );
if ( !e )
goto fail;
if ( !e->absdy )
EngFreeMem ( e );
else
list->Edges[list->Count++] = e;
return list;
fail:
DPRINT1("Out Of MEMORY!!\n");
POLYGONFILL_DestroyEdgeList ( list );
return 0;
}
FASTCALL
POLYGONFILL_MakeEdge(POINT From, POINT To)
{
FILL_EDGE* rc = (FILL_EDGE*)EngAllocMem(FL_ZERO_MEMORY, sizeof(FILL_EDGE), FILL_EDGE_ALLOC_TAG);
if (0 == rc)
return NULL;
//DPRINT1("Making Edge: (%d, %d) to (%d, %d)\n", From.x, From.y, To.x, To.y);
//Now Fill the struct.
if ( To.y < From.y )
{
rc->FromX = To.x;
rc->FromY = To.y;
rc->ToX = From.x;
rc->ToY = From.y;
rc->YDirection = -1;
// lines that go up get walked backwards, so need to be offset
// by -1 in order to make the walk identically on a pixel-level
rc->Error = -1;
}
else
{
rc->FromX = From.x;
rc->FromY = From.y;
rc->ToX = To.x;
rc->ToY = To.y;
rc->YDirection = 1;
rc->Error = 0;
}
rc->x = rc->FromX;
rc->y = rc->FromY;
rc->dx = rc->ToX - rc->FromX;
rc->dy = rc->ToY - rc->FromY;
rc->absdx = abs(rc->dx);
rc->absdy = abs(rc->dy);
rc->xmajor = rc->absdx > rc->absdy;
rc->ErrorMax = MAX(rc->absdx,rc->absdy);
rc->Error += rc->ErrorMax / 2;
rc->XDirection = (rc->dx < 0)?(-1):(1);
rc->pNext = 0;
DPRINT("MakeEdge (%i,%i)->(%i,%i) d=(%i,%i) dir=(%i,%i) err=%i max=%i\n",
From.x, From.y, To.x, To.y, rc->dx, rc->dy, rc->XDirection, rc->YDirection, rc->Error, rc->ErrorMax );
return rc;
}
HANDLE
OpenPlotFile(
LPWSTR pFileName
)
/*++
Routine Description:
Arguments:
Return Value:
Author:
24-Oct-1995 Tue 14:16:46 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PPLOTFILE pPF;
DWORD cbSize;
if ((pPF = (PPLOTFILE)EngAllocMem(FL_ZERO_MEMORY,
sizeof(PLOTFILE),
'tolp')) &&
(pPF->hModule = EngLoadModule((LPWSTR)pFileName)) &&
(pPF->pbBeg = EngMapModule(pPF->hModule, &cbSize))) {
pPF->pbEnd = (pPF->pbCur = pPF->pbBeg) + cbSize;
return((HANDLE)pPF);
}
if (pPF) {
EngFreeMem((PVOID)pPF);
}
return((HANDLE)INVALID_HANDLE_VALUE);
}
/*
* @implemented
*/
CLIPOBJ * APIENTRY
EngCreateClip(VOID)
{
CLIPGDI *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(CLIPGDI), GDITAG_CLIPOBJ);
if(Clip != NULL)
{
return GDIToObj(Clip, CLIP);
}
return NULL;
}
UCHAR *MCDDbgAlloc(UINT size)
{
UCHAR *pRet;
if (pRet = (UCHAR *)EngAllocMem(FL_ZERO_MEMORY, size + sizeof(ULONG),
MCD_ALLOC_TAG)) {
MCDrvAllocMemSize += size;
*((ULONG *)pRet) = size;
return (pRet + sizeof(ULONG));
} else
return (UCHAR *)NULL;
}
void *
malloc(size_t Size)
{
void *Object;
Object = EngAllocMem(0, sizeof(size_t) + Size, TAG_FREETYPE);
if (NULL != Object)
{
*((size_t *) Object) = Size;
Object = (void *)((size_t *) Object + 1);
}
return Object;
}
BOOL MoveAllSurfacesToRam(PDev *pdev)
{
UINT32 surface_id;
SurfaceInfo *surface_info;
SURFOBJ *surf_obj;
UINT8 *copy;
UINT8 *line0;
int size;
QXLPHYSICAL phys_mem;
for (surface_id = 1 ; surface_id < pdev->n_surfaces ; ++surface_id) {
surface_info = GetSurfaceInfo(pdev, surface_id);
if (!surface_info->draw_area.base_mem) {
continue;
}
surf_obj = surface_info->draw_area.surf_obj;
if (!surf_obj) {
DEBUG_PRINT((pdev, 3, "%s: %d: no surfobj, not copying\n", __FUNCTION__, surface_id));
continue;
}
size = surf_obj->sizlBitmap.cy * abs(surf_obj->lDelta);
copy = EngAllocMem(0, size, ALLOC_TAG);
DEBUG_PRINT((pdev, 3, "%s: %d: copying #%d to %p (%d)\n", __FUNCTION__, surface_id, size,
copy, surf_obj->lDelta));
RtlCopyMemory(copy, surface_info->draw_area.base_mem, size);
surface_info->copy = copy;
line0 = surf_obj->lDelta > 0 ? copy : copy + abs(surf_obj->lDelta) *
(surf_obj->sizlBitmap.cy - 1);
if (!EngModifySurface((HSURF)surface_info->hbitmap,
pdev->eng,
0, /* from the example: used to monitor memory HOOK_COPYBITS | HOOK_BITBLT, */
0, /* It's system-memory */
(DHSURF)surface_info,
line0,
surf_obj->lDelta,
NULL)) {
/* Send a create messsage for this surface - we previously did a destroy all. */
EngFreeMem(surface_info->copy);
surface_info->copy = NULL;
DEBUG_PRINT((pdev, 0, "%s: %d: EngModifySurface failed, sending create for %d-%d\n",
__FUNCTION__, surface_id, surface_id, pdev->n_surfaces - 1));
SendSurfaceRangeCreateCommand(pdev, surface_id, pdev->n_surfaces);
return FALSE;
}
QXLDelSurface(pdev, surface_info->draw_area.base_mem, DEVICE_BITMAP_ALLOCATION_TYPE_VRAM);
surface_info->draw_area.base_mem = copy;
FreeDrawArea(&surface_info->draw_area);
}
return TRUE;
}
APIENTRY
EngCreateClip(VOID)
{
XCLIPOBJ *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(XCLIPOBJ), GDITAG_CLIPOBJ);
if(Clip != NULL)
{
IntEngInitClipObj(Clip);
TRACE("Created Clip Obj %p.\n", Clip);
return &Clip->ClipObj;
}
ERR("Clip object allocation failed!\n");
return NULL;
}
PVOID
HackFixup(
PVOID pvView,
ULONG cjView)
{
CHAR *pc;
pc = EngAllocMem(0, cjView, 'tmp ');
memcpy(pc, pvView, cjView);
*pc = 0;
return pc;
}
OH* pohNewNode(
PDEV* ppdev)
{
LONG i;
LONG cOhs;
OHALLOC* poha;
OH* poh;
if (ppdev->heap.pohFreeList == NULL)
{
// We zero-init to initialize all the OH flags, and to help in
// debugging (we can afford to do this since we'll be doing this
// very infrequently):
poha = EngAllocMem(FL_ZERO_MEMORY, OH_ALLOC_SIZE, ALLOC_TAG);
if (poha == NULL)
return(NULL);
// Insert this OHALLOC at the begining of the OHALLOC chain:
poha->pohaNext = ppdev->heap.pohaChain;
ppdev->heap.pohaChain = poha;
// This has a '+ 1' because OHALLOC includes an extra OH in its
// structure declaration:
cOhs = (OH_ALLOC_SIZE - sizeof(OHALLOC)) / sizeof(OH) + 1;
// The big OHALLOC allocation is simply a container for a bunch of
// OH data structures in an array. The new OH data structures are
// linked together and added to the OH free list:
poh = &poha->aoh[0];
for (i = cOhs - 1; i != 0; i--)
{
poh->pohNext = poh + 1;
poh = poh + 1;
}
poh->pohNext = NULL;
ppdev->heap.pohFreeList = &poha->aoh[0];
}
poh = ppdev->heap.pohFreeList;
ppdev->heap.pohFreeList = poh->pohNext;
return(poh);
}
//***************************************************************************
// DrvEnablePDEV
//***************************************************************************
DHPDEV DrvEnablePDEV(DEVMODEW *pdevmode, // Driver data, Client FAXDEV
PWSTR pwstrPrtName, // Printer's name in CreateDC()
ULONG cPatterns, // Count of standard patterns
HSURF *phsurfPatterns, // Buffer for standard patterns
ULONG cjGdiInfo, // Size of buffer for GdiInfo
ULONG *pulGdiInfo, // Buffer for GDIINFO
ULONG cjDevInfo, // Number of bytes in devinfo
DEVINFO *pdevinfo, // Device info
HDEV hdev,
PWSTR pwstrDeviceName, // Device Name - "LaserJet II"
HANDLE hDriver // Printer handle for spooler access
)
{
LPFAXDEV lpCliFaxDev, lpSrvFaxDev = NULL;
LOGDEBUG(("WOWFAX!DrvEnablePDEV, pdevmode: %X, pwstrPrtName: %S\n", pdevmode, pwstrPrtName));
if (pdevmode) {
// Point to the end of the DEVMODE where the FAXDEV is located.
lpCliFaxDev = (LPFAXDEV) ((PBYTE)pdevmode + pdevmode->dmSize);
// Allocate a server side FAXDEV to be passed back to GDI. Copy the
// client side FAXDEV to the server side FAXDEV. Note all pointers in
// the client FAXDEV reference client side memory and cannot be
// dereferenced on the server side.
lpSrvFaxDev = (LPFAXDEV)EngAllocMem(0, sizeof(FAXDEV), FAXDEV_ID);
LOGDEBUG(("WOWFAX!DrvEnablePDEV, allocated lpSrvFaxDev: %X\n", lpSrvFaxDev));
if (InitPDEV(lpCliFaxDev, lpSrvFaxDev,
cPatterns, phsurfPatterns,
cjGdiInfo, pulGdiInfo,
cjDevInfo, pdevinfo)) {
lpSrvFaxDev->hDriver = hDriver;
return (DHPDEV)lpSrvFaxDev;
}
else {
LOGDEBUG(("WOWFAX!DrvEnablePDEV, failed\n"));
if (lpSrvFaxDev) {
EngFreeMem(lpSrvFaxDev);
lpSrvFaxDev = NULL;
}
}
}
return (DHPDEV)lpSrvFaxDev;
}
VOID
FASTCALL
IntEngUpdateClipRegion(
XCLIPOBJ* Clip,
ULONG count,
const RECTL* pRect,
const RECTL* rcBounds)
{
if(count > 1)
{
RECTL* NewRects = EngAllocMem(0, FIELD_OFFSET(ENUMRECTS, arcl[count]), GDITAG_CLIPOBJ);
if(NewRects != NULL)
{
Clip->RectCount = count;
Clip->EnumOrder = CD_ANY;
RtlCopyMemory(NewRects, pRect, count * sizeof(RECTL));
Clip->ClipObj.iDComplexity = DC_COMPLEX;
Clip->ClipObj.iFComplexity = ((Clip->RectCount <= 4) ? FC_RECT4 : FC_COMPLEX);
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
if (Clip->Rects != &Clip->ClipObj.rclBounds)
EngFreeMem(Clip->Rects);
Clip->Rects = NewRects;
}
}
else
{
Clip->EnumOrder = CD_ANY;
Clip->ClipObj.iDComplexity = (((rcBounds->top == rcBounds->bottom) &&
(rcBounds->left == rcBounds->right))
? DC_TRIVIAL : DC_RECT);
Clip->ClipObj.iFComplexity = FC_RECT;
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
Clip->RectCount = 1;
if (Clip->Rects != &Clip->ClipObj.rclBounds)
EngFreeMem(Clip->Rects);
Clip->Rects = &Clip->ClipObj.rclBounds;
}
}
static
PGDI_POOL_SECTION
GdiPoolAllocateSection(PGDI_POOL pPool)
{
PGDI_POOL_SECTION pSection;
PVOID pvBaseAddress;
SIZE_T cjSize;
NTSTATUS status;
/* Allocate a section object */
cjSize = sizeof(GDI_POOL_SECTION) + pPool->cSlotsPerSection / sizeof(ULONG);
pSection = EngAllocMem(0, cjSize, pPool->ulTag);
if (!pSection)
{
return NULL;
}
/* Reserve user mode memory */
cjSize = GDI_POOL_ALLOCATION_GRANULARITY;
pvBaseAddress = NULL;
status = ZwAllocateVirtualMemory(NtCurrentProcess(),
&pvBaseAddress,
0,
&cjSize,
MEM_RESERVE,
PAGE_READWRITE);
if (!NT_SUCCESS(status))
{
EngFreeMem(pSection);
return NULL;
}
/* Initialize the section */
pSection->pvBaseAddress = pvBaseAddress;
pSection->ulCommitBitmap = 0;
pSection->cAllocCount = 0;
RtlInitializeBitMap(&pSection->bitmap,
pSection->aulBits,
pPool->cSlotsPerSection);
RtlClearAllBits(&pSection->bitmap);
/* Return the section */
return pSection;
}
VOID
NTAPI
DbgLogEvent(PSLIST_HEADER pslh, LOG_EVENT_TYPE nEventType, LPARAM lParam)
{
PLOGENTRY pLogEntry;
/* Log a maximum of 100 events */
if (QueryDepthSList(pslh) >= 1000) return;
/* Allocate a logentry */
pLogEntry = EngAllocMem(0, sizeof(LOGENTRY), 'golG');
if (!pLogEntry) return;
/* Set type */
pLogEntry->nEventType = nEventType;
pLogEntry->ulUnique = InterlockedIncrement((LONG*)&gulLogUnique);
pLogEntry->dwProcessId = HandleToUlong(PsGetCurrentProcessId());
pLogEntry->dwThreadId = HandleToUlong(PsGetCurrentThreadId());
pLogEntry->lParam = lParam;
/* Capture a backtrace */
DbgCaptureStackBackTace(pLogEntry->apvBackTrace, 20);
switch (nEventType)
{
case EVENT_ALLOCATE:
case EVENT_CREATE_HANDLE:
case EVENT_REFERENCE:
case EVENT_DEREFERENCE:
case EVENT_LOCK:
case EVENT_UNLOCK:
case EVENT_DELETE:
case EVENT_FREE:
case EVENT_SET_OWNER:
default:
break;
}
/* Push it on the list */
InterlockedPushEntrySList(pslh, &pLogEntry->sleLink);
}
BOOL
IntInitDefaultPalette(
PPDEV ppdev,
PDEVINFO pDevInfo)
{
ULONG ColorLoop;
PPALETTEENTRY PaletteEntryPtr;
if (ppdev->BitsPerPixel > 8)
{
ppdev->DefaultPalette = pDevInfo->hpalDefault =
EngCreatePalette(PAL_BITFIELDS, 0, NULL,
ppdev->RedMask, ppdev->GreenMask, ppdev->BlueMask);
}
else
{
ppdev->PaletteEntries = EngAllocMem(0, sizeof(PALETTEENTRY) << 8, ALLOC_TAG);
if (ppdev->PaletteEntries == NULL)
{
return FALSE;
}
for (ColorLoop = 256, PaletteEntryPtr = ppdev->PaletteEntries;
ColorLoop != 0;
ColorLoop--, PaletteEntryPtr++)
{
PaletteEntryPtr->peRed = ((ColorLoop >> 5) & 7) * 255 / 7;
PaletteEntryPtr->peGreen = ((ColorLoop >> 3) & 3) * 255 / 3;
PaletteEntryPtr->peBlue = (ColorLoop & 7) * 255 / 7;
PaletteEntryPtr->peFlags = 0;
}
memcpy(ppdev->PaletteEntries, BASEPALETTE, 10 * sizeof(PALETTEENTRY));
memcpy(ppdev->PaletteEntries + 246, BASEPALETTE + 10, 10 * sizeof(PALETTEENTRY));
ppdev->DefaultPalette = pDevInfo->hpalDefault =
EngCreatePalette(PAL_INDEXED, 256, (PULONG)ppdev->PaletteEntries, 0, 0, 0);
}
return ppdev->DefaultPalette != NULL;
}
PVOID
NTAPI
EngCreateSection(
IN ULONG fl,
IN SIZE_T cjSize,
IN ULONG ulTag)
{
NTSTATUS Status;
PENGSECTION pSection;
PVOID pvSectionObject;
LARGE_INTEGER liSize;
/* Allocate a section object */
pSection = EngAllocMem(0, sizeof(ENGSECTION), 'stsU');
if (!pSection) return NULL;
liSize.QuadPart = cjSize;
Status = MmCreateSection(&pvSectionObject,
SECTION_ALL_ACCESS,
NULL,
&liSize,
PAGE_READWRITE,
SEC_COMMIT,
NULL,
NULL);
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to create a section Status=0x%x\n", Status);
EngFreeMem(pSection);
return NULL;
}
/* Set the fields of the section */
pSection->ulTag = ulTag;
pSection->pvSectionObject = pvSectionObject;
pSection->pvMappedBase = NULL;
pSection->cjViewSize = cjSize;
return pSection;
}
void *
realloc(void *Object, size_t Size)
{
void *NewObject;
size_t CopySize;
NewObject = EngAllocMem(0, sizeof(size_t) + Size, TAG_FREETYPE);
if (NULL != NewObject)
{
*((size_t *) NewObject) = Size;
NewObject = (void *)((size_t *) NewObject + 1);
CopySize = *((size_t *) Object - 1);
if (Size < CopySize)
{
CopySize = Size;
}
memcpy(NewObject, Object, CopySize);
EngFreeMem((size_t *) Object - 1);
}
return NewObject;
}
DHPDEV
TestFdEnablePDEV(
DEVMODEW* pdm,
PWSTR pwszLogAddr,
ULONG cPat,
HSURF* phsurfPatterns,
ULONG cjCaps,
ULONG* pdevcaps,
ULONG cjDevInfo,
DEVINFO* pdi,
HDEV hdev,
PWSTR pwszDeviceName,
HANDLE hDriver)
{
PVOID* ppdev;
pdm;
pwszLogAddr;
cPat;
phsurfPatterns;
cjCaps;
pdevcaps;
cjDevInfo;
pdi;
hdev;
pwszDeviceName;
hDriver;
//
// Allocate a four byte PDEV for now
// We can grow it if we ever need to put information in it.
//
ppdev = (PVOID*) EngAllocMem(0, sizeof(PVOID), EXFDTAG);
return ((DHPDEV) ppdev);
}
DHPDEV DrvEnablePDEV(
DEVMODEW *pDevmode, // Pointer to DEVMODE
PWSTR pwszLogAddress, // Logical address
ULONG cPatterns, // number of patterns
HSURF *ahsurfPatterns, // return standard patterns
ULONG cjGdiInfo, // Length of memory pointed to by pGdiInfo
ULONG *pGdiInfo, // Pointer to GdiInfo structure
ULONG cjDevInfo, // Length of following PDEVINFO structure
DEVINFO *pDevInfo, // physical device information structure
HDEV hdev, // HDEV, used for callbacks
PWSTR pwszDeviceName, // DeviceName - not used
HANDLE hDriver) // Handle to base driver
{
GDIINFO GdiInfo;
DEVINFO DevInfo;
PPDEV ppdev = (PPDEV) NULL;
UNREFERENCED_PARAMETER(pwszLogAddress);
UNREFERENCED_PARAMETER(pwszDeviceName);
// Allocate a physical device structure.
ppdev = (PPDEV) EngAllocMem(0, sizeof(PDEV), ALLOC_TAG);
if (ppdev == (PPDEV) NULL)
{
RIP("DISP DrvEnablePDEV failed EngAllocMem\n");
return((DHPDEV) 0);
}
memset(ppdev, 0, sizeof(PDEV));
// Save the screen handle in the PDEV.
ppdev->hDriver = hDriver;
// Get the current screen mode information. Set up device caps and devinfo.
if (!bInitPDEV(ppdev, pDevmode, &GdiInfo, &DevInfo))
{
DISPDBG((0,"DISP DrvEnablePDEV failed\n"));
goto error_free;
}
// eVb: 1.2 [VGARISC Change] - Disable hardware pointer support
#if 0
// Initialize the cursor information.
if (!bInitPointer(ppdev, &DevInfo))
{
// Not a fatal error...
DISPDBG((0, "DrvEnablePDEV failed bInitPointer\n"));
}
#endif
// eVb: 1.2 [END]
// Initialize palette information.
if (!bInitPaletteInfo(ppdev, &DevInfo))
{
RIP("DrvEnablePDEV failed bInitPalette\n");
goto error_free;
}
// Copy the devinfo into the engine buffer.
memcpy(pDevInfo, &DevInfo, min(sizeof(DEVINFO), cjDevInfo));
// Set the pdevCaps with GdiInfo we have prepared to the list of caps for this
// pdev.
memcpy(pGdiInfo, &GdiInfo, min(cjGdiInfo, sizeof(GDIINFO)));
return((DHPDEV) ppdev);
// Error case for failure.
error_free:
EngFreeMem(ppdev);
return((DHPDEV) 0);
}
static BOOL ssbCopy(SSB *pSSB, SURFOBJ *pso, RECTL *prcl, BOOL bToScreen)
{
BYTE *pSrc;
BYTE *pDst;
LONG lDeltaSrc;
LONG lDeltaDst;
ULONG cWidth;
ULONG cHeight;
int cbPixel = format2BytesPerPixel(pso);
LOGF(("pSSB = %p, pso = %p, prcl = %p, bToScreen = %d", pSSB, pso, prcl, bToScreen));
if (cbPixel == 0)
{
WARN(("unsupported pixel format!!!"));
return FALSE;
}
cWidth = prcl->right - prcl->left;
cHeight = prcl->bottom - prcl->top;
if (bToScreen)
{
if (pSSB->pBuffer == NULL)
{
WARN(("source buffer is NULL!!!"));
return FALSE;
}
pSrc = pSSB->pBuffer;
lDeltaSrc = cWidth * cbPixel;
pDst = (BYTE *)pso->pvScan0 +
pso->lDelta * prcl->top +
cbPixel * prcl->left;
lDeltaDst = pso->lDelta;
}
else
{
if (pSSB->pBuffer != NULL)
{
WARN(("source buffer is not NULL!!!"));
return FALSE;
}
pSSB->pBuffer = (BYTE *)EngAllocMem (0, cWidth * cHeight * cbPixel, MEM_ALLOC_TAG);
if (pSSB->pBuffer == NULL)
{
WARN(("Failed to allocate buffer!!!"));
return FALSE;
}
pDst = pSSB->pBuffer;
lDeltaDst = cWidth * cbPixel;
pSrc = (BYTE *)pso->pvScan0 +
pso->lDelta * prcl->top +
cbPixel * prcl->left;
lDeltaSrc = pso->lDelta;
}
LOG(("cHeight = %d, pDst = %p, pSrc = %p, lDeltaSrc = %d, lDeltaDst = %d",
cHeight, pDst, pSrc, lDeltaSrc, lDeltaDst));
while (cHeight--)
{
memcpy (pDst, pSrc, cWidth * cbPixel);
pDst += lDeltaDst;
pSrc += lDeltaSrc;
}
LOGF(("completed."));
return TRUE;
}
ULONG APIENTRY VBoxDispDrvEscape(SURFOBJ *pso, ULONG iEsc, ULONG cjIn, PVOID pvIn, ULONG cjOut, PVOID pvOut)
{
PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
LOGF_ENTER();
switch (iEsc)
{
#ifdef VBOX_WITH_CROGL
case OPENGL_GETINFO:
{
if (pvOut && cjOut >= sizeof(OPENGL_INFO))
{
POPENGL_INFO pInfo = (POPENGL_INFO)pvOut;
pInfo->dwVersion = 2;
pInfo->dwDriverVersion = 1;
pInfo->szDriverName[0] = 'V';
pInfo->szDriverName[1] = 'B';
pInfo->szDriverName[2] = 'o';
pInfo->szDriverName[3] = 'x';
pInfo->szDriverName[4] = 'O';
pInfo->szDriverName[5] = 'G';
pInfo->szDriverName[6] = 'L';
pInfo->szDriverName[7] = 0;
LOG(("OPENGL_GETINFO ok"));
return cjOut;
}
else
{
WARN(("OPENGL_GETINFO invalid parms"));
return 0;
}
}
case QUERYESCSUPPORT:
{
if (pvIn && cjIn == sizeof(DWORD))
{
DWORD nEscapeQuery = *(DWORD *)pvIn;
if (nEscapeQuery==OPENGL_GETINFO)
{
LOG(("QUERYESCSUPPORT OPENGL_GETINFO"));
return 1;
}
else
{
LOG(("QUERYESCSUPPORT unsupported query %d", nEscapeQuery));
return 0;
}
}
else
{
WARN(("QUERYESCSUPPORT invalid parms"));
return 0;
}
}
#endif
case VBOXESC_ISVRDPACTIVE:
{
if (pDev && pDev->vbvaCtx.pVBVA && pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents&VBVA_F_MODE_VRDP)
{
LOGF(("VBOXESC_ISVRDPACTIVE: 1"));
return 1;
}
LOGF(("VBOXESC_ISVRDPACTIVE: 0"));
return 0;
}
case VBOXESC_SETVISIBLEREGION:
{
LOGF(("VBOXESC_SETVISIBLEREGION"));
LPRGNDATA lpRgnData = (LPRGNDATA)pvIn;
DWORD cRects;
if ( cjIn >= sizeof(RGNDATAHEADER)
&& pvIn
&& lpRgnData->rdh.dwSize == sizeof(RGNDATAHEADER)
&& lpRgnData->rdh.iType == RDH_RECTANGLES
&& (cRects = lpRgnData->rdh.nCount) <= _1M
&& cjIn == cRects * (uint64_t)sizeof(RECT) + sizeof(RGNDATAHEADER))
{
/** @todo this whole conversion thing could maybe be skipped
* since RTRECT matches the RECT layout. */
#if 0
AssertCompile(sizeof(RTRECT) == sizeof(RECT));
AssertCompileMembersSameSizeAndOffset(RTRECT, xLeft, RECT, left);
AssertCompileMembersSameSizeAndOffset(RTRECT, xBottom, RECT, bottom);
AssertCompileMembersSameSizeAndOffset(RTRECT, xRight, RECT, right);
AssertCompileMembersSameSizeAndOffset(RTRECT, xTop, RECT, top);
rc = VBoxDispMPSetVisibleRegion(pDev->hDriver, (PRTRECT)&lpRgnData->Buffer[0], cRects);
VBOX_WARNRC(rc);
#else
DWORD i;
PRTRECT pRTRect;
int rc;
RECT *pRect = (RECT *)&lpRgnData->Buffer;
pRTRect = (PRTRECT) EngAllocMem(0, cRects*sizeof(RTRECT), MEM_ALLOC_TAG);
if (!pRTRect)
{
WARN(("failed to allocate %d bytes", cRects*sizeof(RTRECT)));
break;
}
for (i = 0; i < cRects; ++i)
{
LOG(("New visible rectangle (%d,%d) (%d,%d)",
pRect[i].left, pRect[i].bottom, pRect[i].right, pRect[i].top));
pRTRect[i].xLeft = pRect[i].left;
pRTRect[i].yBottom = pRect[i].bottom;
pRTRect[i].xRight = pRect[i].right;
pRTRect[i].yTop = pRect[i].top;
}
rc = VBoxDispMPSetVisibleRegion(pDev->hDriver, pRTRect, cRects);
VBOX_WARNRC(rc);
EngFreeMem(pRTRect);
#endif
if (RT_SUCCESS(rc))
{
LOGF_LEAVE();
return 1;
}
}
else
{
if (pvIn)
{
WARN(("check failed rdh.dwSize=%x iType=%d size=%d expected size=%d",
lpRgnData->rdh.dwSize, lpRgnData->rdh.iType, cjIn,
lpRgnData->rdh.nCount * sizeof(RECT) + sizeof(RGNDATAHEADER)));
}
}
break;
}
default:
{
LOG(("unsupported iEsc %#x", iEsc));
}
}
LOGF_LEAVE();
return 0;
}
/* First function which is called after entry point, provides info about device to GDI.
* Returns pointer to our driver private info structure which would be passed by GDI to our other callbacks.
*/
DHPDEV APIENTRY
VBoxDispDrvEnablePDEV(DEVMODEW *pdm, LPWSTR pwszLogAddress, ULONG cPat, HSURF *phsurfPatterns,
ULONG cjCaps, ULONG *pdevcaps,
ULONG cjDevInfo, DEVINFO *pdi,
HDEV hdev, PWSTR pwszDeviceName, HANDLE hDriver)
{
PVBOXDISPDEV pDev = NULL;
GDIINFO gdiInfo;
DEVINFO devInfo;
int rc;
/* Next 3 are only used for printer drivers */
NOREF(pwszLogAddress);
NOREF(cPat);
NOREF(phsurfPatterns);
NOREF(pwszDeviceName);
LOGF_ENTER();
pDev = (PVBOXDISPDEV) EngAllocMem(FL_ZERO_MEMORY, sizeof(VBOXDISPDEV), MEM_ALLOC_TAG);
if (!pDev)
{
WARN(("EngAllocMem failed!\n"));
return NULL;
}
pDev->hDriver = hDriver;
/* Initialize device structure and query miniport to fill device and gdi infos */
rc = VBoxDispInitDevice(pDev, pdm, &gdiInfo, &devInfo);
if (RT_FAILURE(rc))
{
VBOX_WARNRC(rc);
EngFreeMem(pDev);
return NULL;
}
/* Initialize mouse pointer caps */
rc = VBoxDispInitPointerCaps(pDev, &devInfo);
if (RT_FAILURE(rc))
{
VBOX_WARNRC(rc);
}
/* Initialize palette */
rc = VBoxDispInitPalette(pDev, &devInfo);
if (RT_FAILURE(rc))
{
VBOX_WARNRC(rc);
EngFreeMem(pDev);
return NULL;
}
if(g_EngineVersionDDI >= DDI_DRIVER_VERSION_NT5)
{
devInfo.flGraphicsCaps2 |= GCAPS2_RESERVED1;
}
/* Copy gathered info to supplied buffers */
memcpy(pdevcaps, &gdiInfo, min(sizeof(GDIINFO), cjCaps));
memcpy(pdi, &devInfo, min(sizeof(DEVINFO), cjDevInfo));
LOGF_LEAVE();
return (DHPDEV)pDev;
}
UCHAR *MCDAlloc(UINT size)
{
return (UCHAR *)EngAllocMem(FL_ZERO_MEMORY, size, MCD_ALLOC_TAG);
}
/* Returns list video modes supported by both miniport and display driver.
* Note: caller is resposible to free up ppModesTable.
*/
int VBoxDispMPGetVideoModes(HANDLE hDriver, PVIDEO_MODE_INFORMATION *ppModesTable, ULONG *pcModes)
{
DWORD dwrc;
VIDEO_NUM_MODES numModes;
ULONG cbReturned, i, j, cSupportedModes;
PVIDEO_MODE_INFORMATION pMiniportModes, pMode;
LOGF_ENTER();
/* Get number of video modes supported by miniport */
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES, NULL, 0,
&numModes, sizeof(VIDEO_NUM_MODES), &cbReturned);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
if (numModes.ModeInformationLength != sizeof(VIDEO_MODE_INFORMATION))
{
WARN(("sizeof(VIDEO_MODE_INFORMATION) differs for miniport and display drivers. "
"Check that both are compiled with same ddk version!"));
}
/* Allocate temp buffer */
pMiniportModes = (PVIDEO_MODE_INFORMATION)
EngAllocMem(0, numModes.NumModes*numModes.ModeInformationLength, MEM_ALLOC_TAG);
if (!pMiniportModes)
{
WARN(("not enough memory!"));
return VERR_NO_MEMORY;
}
/* Get video modes supported by miniport */
dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_QUERY_AVAIL_MODES, NULL, 0,
pMiniportModes, numModes.NumModes*numModes.ModeInformationLength, &cbReturned);
if (dwrc != NO_ERROR)
{
EngFreeMem(pMiniportModes);
VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
}
/* Check which of miniport modes are supprted by display driver.
* Note: size of VIDEO_MODE_INFORMATION is returned by miniport driver in numModes.ModeInformationLength,
* it might be different from the one we have here.
*/
cSupportedModes = 0;
pMode = pMiniportModes;
for (i=0; i<numModes.NumModes; ++i)
{
/*sanity check*/
if (pMode->Length != sizeof(VIDEO_MODE_INFORMATION))
{
WARN(("Unexpected mode len %i expected %i!", pMode->Length, sizeof(VIDEO_MODE_INFORMATION)));
}
if (VBoxDispVideoModeSupported(pMode))
{
cSupportedModes++;
}
else
{
pMode->Length = 0;
}
pMode = (PVIDEO_MODE_INFORMATION) (((PUCHAR)pMode)+numModes.ModeInformationLength);
}
*pcModes = cSupportedModes;
if (0==cSupportedModes)
{
WARN(("0 video modes supported!"));
EngFreeMem(pMiniportModes);
return VERR_NOT_SUPPORTED;
}
/* Allocate and zero output buffer */
*ppModesTable = (PVIDEO_MODE_INFORMATION)
EngAllocMem(FL_ZERO_MEMORY, cSupportedModes*sizeof(VIDEO_MODE_INFORMATION), MEM_ALLOC_TAG);
if (!*ppModesTable)
{
WARN(("not enough memory!"));
EngFreeMem(pMiniportModes);
return VERR_NO_MEMORY;
}
/* Copy supported modes to output buffer */
pMode = pMiniportModes;
for (j=0, i=0; i<numModes.NumModes; ++i)
{
if (pMode->Length != 0)
{
memcpy(&(*ppModesTable)[j], pMode, numModes.ModeInformationLength);
++j;
}
pMode = (PVIDEO_MODE_INFORMATION) (((PUCHAR)pMode)+numModes.ModeInformationLength);
}
Assert(j==cSupportedModes);
/* Free temp buffer */
EngFreeMem(pMiniportModes);
LOGF_LEAVE();
return VINF_SUCCESS;
}
BOOL bInitializePalette(
PDEV* ppdev,
DEVINFO* pdi)
{
PALETTEENTRY* ppal;
PALETTEENTRY* ppalTmp;
ULONG ulLoop;
BYTE jRed;
BYTE jGre;
BYTE jBlu;
HPALETTE hpal;
if (ppdev->iBitmapFormat == BMF_8BPP)
{
// Allocate our palette:
ppal = (PALETTEENTRY*)EngAllocMem(FL_ZERO_MEMORY,
(sizeof(PALETTEENTRY) * 256), ALLOC_TAG);
if (ppal == NULL)
goto ReturnFalse;
ppdev->pPal = ppal;
// Generate 256 (8*4*4) RGB combinations to fill the palette
jRed = 0;
jGre = 0;
jBlu = 0;
ppalTmp = ppal;
for (ulLoop = 256; ulLoop != 0; ulLoop--)
{
ppalTmp->peRed = jRed;
ppalTmp->peGreen = jGre;
ppalTmp->peBlue = jBlu;
ppalTmp->peFlags = 0;
ppalTmp++;
if (!(jRed += 32))
if (!(jGre += 32))
jBlu += 64;
}
// Fill in Windows reserved colours from the WIN 3.0 DDK
// The Window Manager reserved the first and last 10 colours for
// painting windows borders and for non-palette managed applications.
for (ulLoop = 0; ulLoop < 10; ulLoop++)
{
// First 10
ppal[ulLoop] = gapalBase[ulLoop];
// Last 10
ppal[246 + ulLoop] = gapalBase[ulLoop+10];
}
// Create handle for palette.
hpal = EngCreatePalette(PAL_INDEXED, 256, (ULONG*) ppal, 0, 0, 0);
}
else
{
ASSERTDD((ppdev->iBitmapFormat == BMF_16BPP) ||
(ppdev->iBitmapFormat == BMF_24BPP) ||
(ppdev->iBitmapFormat == BMF_32BPP),
"This case handles only 16, 24 or 32bpp");
hpal = EngCreatePalette(PAL_BITFIELDS, 0, NULL,
ppdev->flRed, ppdev->flGreen, ppdev->flBlue);
}
ppdev->hpalDefault = hpal;
pdi->hpalDefault = hpal;
if (hpal == 0)
goto ReturnFalse;
return(TRUE);
ReturnFalse:
DISPDBG((0, "Failed bInitializePalette"));
return(FALSE);
}