ddraw.c

来自「一个类似windows」· C语言 代码 · 共 1,138 行 · 第 1/3 页

/*
 * COPYRIGHT:        See COPYING in the top level directory
 * PROJECT:          ReactOS kernel
 * PURPOSE:          Native DirectDraw implementation
 * FILE:             subsys/win32k/ntddraw/ddraw.c
 * PROGRAMER:        Peter Bajusz ([e-mail])
 * REVISION HISTORY:
 *       25-10-2003  PB  Created
 */

#include <w32k.h>

#define NDEBUG
#include <debug.h>

/* swtich this off to get rid of all dx debug msg */
#define DX_DEBUG

#define DdHandleTable GdiHandleTable


/************************************************************************/
/* DIRECT DRAW OBJECT                                                   */
/************************************************************************/

BOOL INTERNAL_CALL
DD_Cleanup(PVOID ObjectBody)
{       
	PDD_DIRECTDRAW pDirectDraw = (PDD_DIRECTDRAW) ObjectBody;
#ifdef DX_DEBUG
	DPRINT1("DD_Cleanup\n");
#endif
	
	if (!pDirectDraw)
		return FALSE;
    
    if (pDirectDraw->Global.dhpdev == NULL)
        return FALSE;
        
    if (pDirectDraw->DrvDisableDirectDraw == NULL)
        return FALSE;
        
	pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev);
	return TRUE;
}

HANDLE STDCALL NtGdiDdCreateDirectDrawObject(
    HDC hdc
)
{
	DD_CALLBACKS callbacks;
	DD_SURFACECALLBACKS surface_callbacks;
	DD_PALETTECALLBACKS palette_callbacks;
    DC *pDC;
    BOOL success;
    HANDLE hDirectDraw;
    PDD_DIRECTDRAW pDirectDraw;
#ifdef DX_DEBUG
	DPRINT1("NtGdiDdCreateDirectDrawObject\n");
#endif

	RtlZeroMemory(&callbacks, sizeof(DD_CALLBACKS));
	callbacks.dwSize = sizeof(DD_CALLBACKS);
	RtlZeroMemory(&surface_callbacks, sizeof(DD_SURFACECALLBACKS));
	surface_callbacks.dwSize = sizeof(DD_SURFACECALLBACKS);
	RtlZeroMemory(&palette_callbacks, sizeof(DD_PALETTECALLBACKS));
	palette_callbacks.dwSize = sizeof(DD_PALETTECALLBACKS);

	/* FIXME hdc can be zero for d3d9 */
    /* we need create it, if in that case */
	if (hdc == NULL)
	{
	    return NULL;
    }
    
	pDC = DC_LockDc(hdc);
	if (!pDC)
		return NULL;

	if (!pDC->DriverFunctions.EnableDirectDraw)
	{
		// Driver doesn't support DirectDraw
		DC_UnlockDc(pDC);
		return NULL;
	}
	
	success = pDC->DriverFunctions.EnableDirectDraw(
		pDC->PDev, &callbacks, &surface_callbacks, &palette_callbacks);

	if (!success)
	{
#ifdef DX_DEBUG
        DPRINT1("DirectDraw creation failed\n"); 
#endif
		// DirectDraw creation failed
		DC_UnlockDc(pDC);
		return NULL;
	}

	hDirectDraw = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DIRECTDRAW);
	if (!hDirectDraw)
	{
		/* No more memmory */
#ifdef DX_DEBUG
		DPRINT1("No more memmory\n"); 
#endif
		DC_UnlockDc(pDC);
		return NULL;
	}

	pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
	if (!pDirectDraw)
	{
		/* invalid handle */
#ifdef DX_DEBUG
		DPRINT1("invalid handle\n"); 
#endif
		DC_UnlockDc(pDC);
		return NULL;
	}
	

	pDirectDraw->Global.dhpdev = pDC->PDev;
	pDirectDraw->Local.lpGbl = &pDirectDraw->Global;

	pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo;
	pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw;

    /* DD_CALLBACKS setup */	
	RtlMoveMemory(&pDirectDraw->DD, &callbacks, sizeof(DD_CALLBACKS));
	
   	/* DD_SURFACECALLBACKS  setup*/	
	RtlMoveMemory(&pDirectDraw->Surf, &surface_callbacks, sizeof(DD_SURFACECALLBACKS));

	/* DD_PALETTECALLBACKS setup*/	
	RtlMoveMemory(&pDirectDraw->Pal, &surface_callbacks, sizeof(DD_PALETTECALLBACKS));
	
	GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
	DC_UnlockDc(pDC);

	return hDirectDraw;
}

BOOL STDCALL NtGdiDdDeleteDirectDrawObject(
    HANDLE hDirectDrawLocal
)
{
#ifdef DX_DEBUG
    DPRINT1("NtGdiDdDeleteDirectDrawObject\n");
#endif
	return GDIOBJ_FreeObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
}

BOOL STDCALL NtGdiDdQueryDirectDrawObject(
    HANDLE hDirectDrawLocal,
    DD_HALINFO  *pHalInfo,
    DWORD *pCallBackFlags,
    LPD3DNTHAL_CALLBACKS puD3dCallbacks,
    LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
    PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
    LPDDSURFACEDESC puD3dTextureFormats,
    DWORD *puNumHeaps,
    VIDEOMEMORY *puvmList,
    DWORD *puNumFourCC,
    DWORD *puFourCC
)
{
#ifdef DX_DEBUG
    PDD_DIRECTDRAW pDirectDraw;
    BOOL success;
    DPRINT1("NtGdiDdQueryDirectDrawObject\n");
#endif

    /* Check for NULL pointer to prevent any one doing a mistake */

    if (hDirectDrawLocal == NULL)
    {
#ifdef DX_DEBUG
       DPRINT1("warning hDirectDraw handler is NULL, the handler is  DDRAWI_DIRECTDRAW_GBL.hDD\n");
       DPRINT1("and it is NtGdiDdCreateDirectDrawObject return value\n");
#endif
       return FALSE;
    }


    if (pHalInfo == NULL)
    {
#ifdef DX_DEBUG
       DPRINT1("warning pHalInfo buffer is NULL \n");
#endif
       return FALSE;
    }

    if ( pCallBackFlags == NULL)
    {
#ifdef DX_DEBUG
       DPRINT1("warning pCallBackFlags s NULL, the size must be 3*DWORD in follow order \n");
       DPRINT1("pCallBackFlags[0] = flags in DD_CALLBACKS\n");
       DPRINT1("pCallBackFlags[1] = flags in DD_SURFACECALLBACKS\n");
       DPRINT1("pCallBackFlags[2] = flags in DD_PALETTECALLBACKS\n");
#endif
       return FALSE;
    }
   
    
	pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
	
	
	if (!pDirectDraw)
	{
        /* Fail to Lock DirectDraw handle */
#ifdef DX_DEBUG
        DPRINT1(" Fail to Lock DirectDraw handle \n");        
#endif
		return FALSE;
    }

	success = pDirectDraw->DrvGetDirectDrawInfo(
		pDirectDraw->Global.dhpdev,
		pHalInfo,
		puNumHeaps,
		puvmList,
		puNumFourCC,
		puFourCC);

	if (!success)
	{
#ifdef DX_DEBUG
        DPRINT1(" Fail to get DirectDraw driver info \n");
#endif
		GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
		return FALSE;
	}

      
    /* rest the flag so we do not need do it later */
    pCallBackFlags[0]=0;
    pCallBackFlags[1]=0;
    pCallBackFlags[2]=0;

	if (pHalInfo)
	{       
      
          {
             DDHALINFO* pHalInfo2 = ((DDHALINFO*) pHalInfo);
#ifdef DX_DEBUG
             DPRINT1("Found DirectDraw CallBack for 2D and 3D Hal\n");
#endif
             RtlMoveMemory(&pDirectDraw->Hal, pHalInfo2, sizeof(DDHALINFO));

             if (pHalInfo2->lpDDExeBufCallbacks)
	         {
#ifdef DX_DEBUG
                 DPRINT1("Found DirectDraw CallBack for 3D Hal Bufffer  \n");                                
#endif
                 /* msdn DDHAL_D3DBUFCALLBACKS = DD_D3DBUFCALLBACKS */
                 RtlMoveMemory(puD3dBufferCallbacks, pHalInfo2->lpDDExeBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
             }
              
#ifdef DX_DEBUG               
             DPRINT1("Do not support CallBack for 3D Hal\n");
#endif
             /* FIXME we need D3DHAL be include 

             if (pHalInfo2->lpD3DHALCallbacks )
	         {    
#ifdef DX_DEBUG
                    DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
#endif
		            RtlMoveMemory(puD3dCallbacks, (ULONG *)pHalInfo2->lpD3DHALCallbacks, sizeof( D3DHAL_CALLBACKS ));		
	         } 
             */              


             /* msdn say D3DHAL_GLOBALDRIVERDATA and D3DNTHAL_GLOBALDRIVERDATA are not same 
                but if u compare these in msdn it is exacly same */

	         if (pHalInfo->lpD3DGlobalDriverData)
	         {
#ifdef DX_DEBUG
                   DPRINT1("Found DirectDraw CallBack for 3D Hal Private  \n");
#endif
		           RtlMoveMemory(puD3dDriverData, (ULONG *)pHalInfo2->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
	         }
              
             /* build the flag */
               
             if (pHalInfo2->lpDDCallbacks!=NULL)
             {
#ifdef DX_DEBUG
                    DPRINT1("Dectect DirectDraw lpDDCallbacks for 2D Hal flag = %d\n",pHalInfo2->lpDDCallbacks->dwFlags);
#endif
                    pCallBackFlags[0] = pHalInfo2->lpDDCallbacks->dwFlags;
             }
     
             if (pHalInfo2->lpDDCallbacks!=NULL)
             {
#ifdef DX_DEBUG
                   DPRINT1("Dectect DirectDraw lpDDSurfaceCallbacks for 2D Hal flag = %d\n",pHalInfo2->lpDDSurfaceCallbacks->dwFlags);
#endif
                   pCallBackFlags[1] = pHalInfo2->lpDDSurfaceCallbacks->dwFlags;
             }
       
             if (pHalInfo2->lpDDCallbacks!=NULL)
             {
#ifdef DX_DEBUG
                   DPRINT1("Dectect DirectDraw lpDDCallbacks for 2D Hal flag = %d\n",pHalInfo2->lpDDPaletteCallbacks->dwFlags);
#endif
                   pCallBackFlags[2] = pHalInfo2->lpDDPaletteCallbacks->dwFlags;
             }

          }
             
#ifdef DX_DEBUG
          DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
#endif
          RtlMoveMemory(&pDirectDraw->Hal, pHalInfo, sizeof(DD_HALINFO));

          if (pHalInfo->lpD3DBufCallbacks)
	      {
#ifdef DX_DEBUG
                   DPRINT1("Found DirectDraw CallBack for 3D Hal Bufffer  \n");
#endif
		           RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
	      }

          if (pHalInfo->lpD3DHALCallbacks)
	      {
#ifdef DX_DEBUG
                   DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
#endif
		           RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));		
	      }

	      if (pHalInfo->lpD3DGlobalDriverData)
	      {
#ifdef DX_DEBUG
                   DPRINT1("Found DirectDraw CallBack for 3D Hal Private  \n");
#endif
		           RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
	      }
          
#ifdef DX_DEBUG
          DPRINT1("Unkown DirectX driver interface\n");
#endif
                            	   	          	   	                           	   	
	   }

#ifdef DX_DEBUG
     else
	 {
	   DPRINT1("No DirectDraw Hal info have been found, it did not fail, it did gather some other info \n");
    }
#endif
        
	GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);

	return TRUE;
}


DWORD STDCALL NtGdiDdGetDriverInfo(
    HANDLE hDirectDrawLocal,
    PDD_GETDRIVERINFODATA puGetDriverInfoData)

{
	DWORD  ddRVal = 0;

	PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
#ifdef DX_DEBUG
	DPRINT1("NtGdiDdGetDriverInfo\n");
#endif
	
	if (pDirectDraw == NULL) 
	{
#ifdef DX_DEBUG
        DPRINT1("Can not lock DirectDraw handle \n");
#endif
		return DDHAL_DRIVER_NOTHANDLED;
    }