自学教程：C++ EngAllocMem函数代码示例

CLIPOBJ* FASTCALLIntEngCreateClipRegion(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 APIENTRYIntSetPalette(   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_POOLNTAPIGdiPoolCreate(    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 APIENTRYBRUSHOBJ_pvAllocRbrush(    IN BRUSHOBJ *pbo,    IN ULONG cj){    pbo->pvRbrush = EngAllocMem(0, cj, GDITAG_RBRUSH);    return pbo->pvRbrush;}

FASTCALLPOLYGONFILL_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;}

FASTCALLPOLYGONFILL_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;}

HANDLEOpenPlotFile(    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 * APIENTRYEngCreateClip(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;}

APIENTRYEngCreateClip(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;}

PVOIDHackFixup(    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;}

VOIDFASTCALLIntEngUpdateClipRegion(    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;    }}

staticPGDI_POOL_SECTIONGdiPoolAllocateSection(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;}

VOIDNTAPIDbgLogEvent(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);}

BOOLIntInitDefaultPalette(   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;}

PVOIDNTAPIEngCreateSection(    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;}

DHPDEVTestFdEnablePDEV(    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 DEVMODEPWSTR       pwszLogAddress, // Logical addressULONG       cPatterns,      // number of patternsHSURF      *ahsurfPatterns, // return standard patternsULONG       cjGdiInfo,      // Length of memory pointed to by pGdiInfoULONG      *pGdiInfo,       // Pointer to GdiInfo structureULONG       cjDevInfo,      // Length of following PDEVINFO structureDEVINFO    *pDevInfo,       // physical device information structureHDEV        hdev,           // HDEV, used for callbacksPWSTR       pwszDeviceName, // DeviceName - not usedHANDLE      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)//.........这里部分代码省略.........

/* 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 APIENTRYVBoxDispDrvEnablePDEV(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;}

/* 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);//.........这里部分代码省略.........

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);}