#include <dxg_int.h>

Include dependency graph for ddhmg.c:

Functions
BOOL FASTCALL	VerifyObjectOwner (PDD_ENTRY pEntry)

BOOL FASTCALL	DdHmgCreate (VOID)

BOOL FASTCALL	DdHmgDestroy (VOID)

PVOID FASTCALL	DdHmgLock (HANDLE DdHandle, UCHAR ObjectType, BOOLEAN LockOwned)

PVOID FASTCALL	DdAllocateObject (ULONG objSize, UCHAR objType, BOOLEAN objZeroMemory)

VOID FASTCALL	DdFreeObject (PVOID pObject)

HANDLE FASTCALL	DdGetFreeHandle (UCHAR objType)

HANDLE FASTCALL	DdHmgAlloc (ULONG objSize, CHAR objType, BOOLEAN objLock)

VOID FASTCALL	DdHmgFree (HANDLE DdHandle)

Variables
ULONG	gcSizeDdHmgr = 1024

PDD_ENTRY	gpentDdHmgr = NULL

ULONG	gcMaxDdHmgr = 0

PDD_ENTRY	gpentDdHmgrLast = NULL

ULONG	ghFreeDdHmgr = 0

HSEMAPHORE	ghsemHmgr = NULL

Function Documentation

◆ DdAllocateObject()

PVOID FASTCALL DdAllocateObject	(	ULONG	objSize,
		UCHAR	objType,
		BOOLEAN	objZeroMemory
	)

Definition at line 203 of file ddhmg.c.

{
    PVOID pObject = NULL;
 
    if (objZeroMemory)
        pObject = EngAllocMem(FL_ZERO_MEMORY, objSize, ((ULONG)objType << 24) + TAG_DH_0);
    else
        pObject = EngAllocMem(0, objSize, ((ULONG)objType << 24) + TAG_DH_0);
 
    if (!pObject)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }
 
    return pObject;
}

Referenced by DdHmgAlloc().

◆ DdFreeObject()

VOID FASTCALL DdFreeObject ( PVOID pObject )

Definition at line 235 of file ddhmg.c.

{
    EngFreeMem(pObject);
}

Referenced by DdHmgAlloc(), and DdHmgFree().

◆ DdGetFreeHandle()

HANDLE FASTCALL DdGetFreeHandle ( UCHAR objType )

Definition at line 259 of file ddhmg.c.

{
    PVOID mAllocMem = NULL;
    ULONG mAllocEntries = 0;
    PDD_ENTRY pEntry = NULL;
    ULONG_PTR retVal;
    ULONG index;
 
    // check if memory is allocated
    if (!gpentDdHmgr)
        return 0;
 
    // check if we reached maximum handle index
    if (gcMaxDdHmgr == DDHMG_HANDLE_LIMIT)
        return 0;
 
    // check if we have free handle to reuse
    if (ghFreeDdHmgr)
    {
       index = ghFreeDdHmgr;
       pEntry = (PDD_ENTRY)((PBYTE)gpentDdHmgr + (sizeof(DD_ENTRY) * index));
 
       // put next free index to our global variable
       ghFreeDdHmgr = pEntry->NextFree;             
 
       // build handle 
       pEntry->FullUnique = objType | 8;
       retVal = (pEntry->FullUnique << 21) | index;
       return (HANDLE)retVal;
    }
 
    // if all pre-allocated memory is already used then allocate more
    if (gcSizeDdHmgr == gcMaxDdHmgr)
    {
        // allocate buffer for next 1024 handles
        mAllocEntries = gcSizeDdHmgr + 1024;
        mAllocMem = EngAllocMem(FL_ZERO_MEMORY, sizeof(DD_ENTRY) * (mAllocEntries), TAG_THDD);
        if (!mAllocMem)
            return 0;
 
        memmove(&mAllocMem, gpentDdHmgr, sizeof(DD_ENTRY) * gcSizeDdHmgr);
        gcSizeDdHmgr = mAllocEntries;
        gpentDdHmgrLast = gpentDdHmgr;
        EngFreeMem(gpentDdHmgr);
        gpentDdHmgr = mAllocMem;
    }
 
    pEntry = (PDD_ENTRY)((PBYTE)gpentDdHmgr + (sizeof(DD_ENTRY) * gcMaxDdHmgr));
 
    // build handle 
    pEntry->FullUnique = objType | 8;
    retVal = (pEntry->FullUnique << 21) | gcMaxDdHmgr;
    gcMaxDdHmgr = gcMaxDdHmgr + 1;
 
    return (HANDLE)retVal;
}

Referenced by DdHmgAlloc().

◆ DdHmgAlloc()

HANDLE FASTCALL DdHmgAlloc	(	ULONG	objSize,
		CHAR	objType,
		BOOLEAN	objLock
	)

Definition at line 340 of file ddhmg.c.

{
    PVOID pObject = NULL;
    HANDLE DdHandle = NULL;
    PDD_ENTRY pEntry = NULL;
    DWORD Index;
 
    pObject = DdAllocateObject(objSize, objType, TRUE);
    if (!pObject)
        return 0;
 
    EngAcquireSemaphore(ghsemHmgr);
 
    /* Get next free handle */
    DdHandle = DdGetFreeHandle(objType);
 
    if (DdHandle)
    {
        Index = DDHMG_HTOI(DdHandle);
 
        pEntry = (PDD_ENTRY)((PBYTE)gpentDdHmgr + (sizeof(DD_ENTRY) * Index));
 
        pEntry->pobj = pObject;
        pEntry->Objt = objType;
 
        pEntry->Pid = (HANDLE)(((ULONG_PTR)PsGetCurrentProcessId() & 0xFFFFFFFC) | ((ULONG_PTR)(pEntry->Pid) & 1));
 
        if (objLock)
        {
            InterlockedIncrement((VOID*)&pEntry->pobj->cExclusiveLock);
            pEntry->pobj->Tid = KeGetCurrentThread();
        }
        pEntry->pobj->hHmgr = DdHandle;
        
        EngReleaseSemaphore(ghsemHmgr);
 
        /* Return handle if object not locked */
        if (!objLock)
           return DdHandle;
 
        return (HANDLE)pEntry;
    }
 
    EngReleaseSemaphore(ghsemHmgr);
    DdFreeObject(pObject);
    return 0;
}

Referenced by intDdCreateDirectDrawLocal(), and intDdCreateNewSurfaceObject().

◆ DdHmgCreate()

BOOL FASTCALL DdHmgCreate ( VOID )

Definition at line 49 of file ddhmg.c.

{
    gpentDdHmgr = EngAllocMem(FL_ZERO_MEMORY, gcSizeDdHmgr * sizeof(DD_ENTRY), TAG_THDD);
    ghFreeDdHmgr = 0;
    gcMaxDdHmgr = 1;
 
    if (gpentDdHmgr)
    {
        ghsemHmgr = EngCreateSemaphore();
 
        if (ghsemHmgr)
        {
            gpLockShortDelay = EngAllocMem(FL_ZERO_MEMORY | FL_NONPAGED_MEMORY, sizeof(LARGE_INTEGER), TAG_GINI);
 
            if (gpLockShortDelay)
            {
                gpLockShortDelay->HighPart = -1;
                return TRUE;
            }
 
            EngDeleteSemaphore(ghsemHmgr);
            ghsemHmgr = NULL;
        }
 
        EngFreeMem(gpentDdHmgr);
        gpentDdHmgr = NULL;
    }
 
    return FALSE;
}

Referenced by DxDdStartupDxGraphics().

◆ DdHmgDestroy()

BOOL FASTCALL DdHmgDestroy ( VOID )

Definition at line 95 of file ddhmg.c.

{
    gcMaxDdHmgr = 0;
    gcSizeDdHmgr = 0;
    ghFreeDdHmgr = 0;
    gpentDdHmgrLast = NULL;
 
    if (gpentDdHmgr)
    {
        EngFreeMem(gpentDdHmgr);
        gpentDdHmgr = NULL;
    }
 
    if (ghsemHmgr)
    {
        EngDeleteSemaphore(ghsemHmgr);
        ghsemHmgr = NULL;
    }
 
    return TRUE;
}

Referenced by DxDdCleanupDxGraphics(), and DxDdStartupDxGraphics().

◆ DdHmgFree()

VOID FASTCALL DdHmgFree ( HANDLE DdHandle )

Definition at line 403 of file ddhmg.c.

{
    PDD_ENTRY pEntry = NULL;
 
    DWORD Index = DDHMG_HTOI(DdHandle);
 
    EngAcquireSemaphore(ghsemHmgr);
 
    pEntry = (PDD_ENTRY)((PBYTE)gpentDdHmgr + (sizeof(DD_ENTRY) * Index));
 
    // check if we have object that should be freed
    if (pEntry->pobj)
        DdFreeObject(pEntry->pobj);
 
    pEntry->NextFree = ghFreeDdHmgr;
 
    // reset process ID
    pEntry->Pid = (HANDLE)((DWORD_PTR)pEntry->Pid & 1);
    ghFreeDdHmgr = Index;
 
    EngReleaseSemaphore(ghsemHmgr);
}

◆ DdHmgLock()

PVOID FASTCALL DdHmgLock	(	HANDLE	DdHandle,
		UCHAR	ObjectType,
		BOOLEAN	LockOwned
	)

Definition at line 147 of file ddhmg.c.

{
    DWORD Index = DDHMG_HTOI(DdHandle);
 
    PDD_ENTRY pEntry = NULL;
    PVOID Object = NULL;
 
    if ( !LockOwned )
    {
        EngAcquireSemaphore(ghsemHmgr);
    }
 
    if ( Index < gcMaxDdHmgr )
    {
        pEntry = (PDD_ENTRY)((PBYTE)gpentDdHmgr + (sizeof(DD_ENTRY) * Index));
 
        if ( VerifyObjectOwner(pEntry) )
        {
            if ( ( pEntry->Objt == ObjectType ) &&
                 ( pEntry->FullUnique == (((ULONG_PTR)DdHandle >> 21) & 0x7FF) ) &&
                 ( !pEntry->pobj->cExclusiveLock ) )
            {
                InterlockedIncrement((VOID*)&pEntry->pobj->cExclusiveLock);
                pEntry->pobj->Tid = KeGetCurrentThread();
                Object = pEntry->pobj;
            }
        }
    }
 
    if ( !LockOwned )
    {
        EngReleaseSemaphore(ghsemHmgr);
    }
 
    return Object;
}

Referenced by DxDdCanCreateD3DBuffer(), DxDdCanCreateSurface(), DxDdCreateSurfaceObject(), DxDdGetDriverInfo(), DxDdLock(), DxDdLockDirectDrawSurface(), DxDdQueryDirectDrawObject(), DxDdReenableDirectDrawObject(), intDdCreateNewSurfaceObject(), and intDdCreateSurfaceOrBuffer().

◆ VerifyObjectOwner()

BOOL FASTCALL VerifyObjectOwner ( PDD_ENTRY pEntry )

Definition at line 27 of file ddhmg.c.

{
    DWORD Pid = (DWORD)(DWORD_PTR)PsGetCurrentProcessId() & 0xFFFFFFFC;
    DWORD check = (DWORD_PTR)pEntry->Pid & 0xFFFFFFFE;
    return ( (check == Pid) || (!check));
}