dd.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

    /* FIXME support for more that one surface */
    _SEH_TRY
    {
        ProbeForWrite(puSurfaceDescription,  sizeof(DDSURFACEDESC), 1);
        RtlCopyMemory( puSurfaceDescription, &phsurface->desc, sizeof( DDSURFACEDESC ) );
    }
    _SEH_HANDLE
    {
        Status = _SEH_GetExceptionCode();
    }
    _SEH_END;

    _SEH_TRY
    {
        ProbeForWrite(puCreateSurfaceData,  sizeof(DD_CREATESURFACEDATA), 1);
        puCreateSurfaceData->ddRVal =  CreateSurfaceData.ddRVal;
    }
    _SEH_HANDLE
    {
        Status = _SEH_GetExceptionCode();
    }
    _SEH_END;

    for (i = 0; i < CreateSurfaceData.dwSCnt; i++)
    {
        _SEH_TRY
        {
            ProbeForWrite(puSurfaceGlobalData,  sizeof(DD_SURFACE_GLOBAL), 1);
            RtlCopyMemory( puSurfaceGlobalData, &phsurface->Global, sizeof( DD_SURFACE_GLOBAL ) );
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;

        _SEH_TRY
        {
            ProbeForWrite(puSurfaceLocalData,  sizeof(DD_SURFACE_LOCAL), 1);
            RtlCopyMemory( puSurfaceLocalData, &phsurface->Local, sizeof( DD_SURFACE_LOCAL ) );
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;

        _SEH_TRY
        {
            ProbeForWrite(puSurfaceMoreData,  sizeof(DD_SURFACE_MORE), 1);
            RtlCopyMemory( puSurfaceMoreData, &phsurface->More, sizeof( DD_SURFACE_MORE ) );

            puSurfaceLocalData->lpGbl = puSurfaceGlobalData;
            puSurfaceLocalData->lpSurfMore = puSurfaceMoreData;
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;

        DPRINT1("GDIOBJ_UnlockObjByPtr\n");
        GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface);
        _SEH_TRY
        {
            ProbeForWrite(puhSurface, sizeof(HANDLE), 1);
            puhSurface[i] = myhSurface[i];
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;
    }


    /* FIXME fillin the return handler */
    DPRINT1("GDIOBJ_UnlockObjByPtr\n");
    GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);

    DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,CreateSurfaceData.ddRVal);
    return ddRVal;
}

/************************************************************************/
/* NtGdiDdWaitForVerticalBlank                                          */
/* status : OK working as it should                                     */
/************************************************************************/


DWORD STDCALL NtGdiDdWaitForVerticalBlank(
    HANDLE hDirectDrawLocal,
    PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
{
    DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
    PDD_DIRECTDRAW pDirectDraw = NULL;
    NTSTATUS Status = FALSE;
    DD_WAITFORVERTICALBLANKDATA WaitForVerticalBlankData;
    LPDDHAL_WAITFORVERTICALBLANKDATA pWaitForVerticalBlankData = (LPDDHAL_WAITFORVERTICALBLANKDATA)puWaitForVerticalBlankData;

    if ((hDirectDrawLocal) &&
        (puWaitForVerticalBlankData))
    {
        RtlZeroMemory(&WaitForVerticalBlankData,sizeof(DD_WAITFORVERTICALBLANKDATA));

        _SEH_TRY
        {
            ProbeForRead(pWaitForVerticalBlankData, sizeof(DDHAL_WAITFORVERTICALBLANKDATA), 1);
            WaitForVerticalBlankData.dwFlags = pWaitForVerticalBlankData->dwFlags;
            WaitForVerticalBlankData.bIsInVB = pWaitForVerticalBlankData->bIsInVB;
            WaitForVerticalBlankData.hEvent = pWaitForVerticalBlankData->hEvent;
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;

        if(NT_SUCCESS(Status))
        {
            pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);

            if (pDirectDraw != NULL) 
            {
                if (pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)
                {
                    WaitForVerticalBlankData.ddRVal = DDERR_GENERIC;
                    WaitForVerticalBlankData.lpDD =  &pDirectDraw->Global;;
                    ddRVal = pDirectDraw->DD.WaitForVerticalBlank(&WaitForVerticalBlankData);
                }
                _SEH_TRY
                {
                    ProbeForWrite(pWaitForVerticalBlankData,  sizeof(DDHAL_WAITFORVERTICALBLANKDATA), 1);
                    pWaitForVerticalBlankData->ddRVal  = WaitForVerticalBlankData.ddRVal;
                    pWaitForVerticalBlankData->bIsInVB = WaitForVerticalBlankData.bIsInVB;
                }
                _SEH_HANDLE
                {
                    Status = _SEH_GetExceptionCode();
                }
                _SEH_END;

                GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
            }
        }
    }
    return ddRVal;
}


/************************************************************************/
/* CanCreateSurface                                                     */
/* status : OK working as it should                                     */
/************************************************************************/

DWORD STDCALL NtGdiDdCanCreateSurface(
    HANDLE hDirectDrawLocal,
    PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
)
{
    DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
    


    if ((puCanCreateSurfaceData) && 
        (hDirectDrawLocal))
    {
        DDSURFACEDESC desc;
        DWORD descSize = 0;
        NTSTATUS Status = FALSE;
        PDD_DIRECTDRAW pDirectDraw = NULL;
        DD_CANCREATESURFACEDATA CanCreateSurfaceData;
        LPDDHAL_CANCREATESURFACEDATA pCanCreateSurfaceData = (LPDDHAL_CANCREATESURFACEDATA)puCanCreateSurfaceData;

        RtlZeroMemory(&CanCreateSurfaceData,sizeof(DDSURFACEDESC));
        RtlZeroMemory(&desc,sizeof(DDSURFACEDESC));

        _SEH_TRY
        {
            ProbeForRead(pCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1);
            CanCreateSurfaceData.bIsDifferentPixelFormat = pCanCreateSurfaceData->bIsDifferentPixelFormat;

            if (pCanCreateSurfaceData->lpDDSurfaceDesc)
            {
                ProbeForRead(pCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1);
                RtlCopyMemory(&desc,pCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC));

                /*if it was DDSURFACEDESC2 been pass down */
                descSize = desc.dwSize;
                desc.dwSize = sizeof(DDSURFACEDESC);
            }
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;

        if ((NT_SUCCESS(Status)) && 
            (desc.dwSize != 0))
        {
            pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
            if ((pDirectDraw) && 
                (pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
            {
                CanCreateSurfaceData.ddRVal = DDERR_GENERIC;
                CanCreateSurfaceData.lpDD = &pDirectDraw->Global;
                CanCreateSurfaceData.lpDDSurfaceDesc = &desc;
                ddRVal = pDirectDraw->DD.CanCreateSurface(&CanCreateSurfaceData);

                /*if it was DDSURFACEDESC2 been pass down */
                desc.dwSize = descSize;
                _SEH_TRY
                {
                     ProbeForWrite(puCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1);
                     puCanCreateSurfaceData->ddRVal = CanCreateSurfaceData.ddRVal;

                     ProbeForWrite(puCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1);
                     RtlCopyMemory(puCanCreateSurfaceData->lpDDSurfaceDesc,&desc, sizeof(DDSURFACEDESC));

                }
                _SEH_HANDLE
                {
                    Status = _SEH_GetExceptionCode();
                }
                _SEH_END;
            }
            GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
        }
    }
  return ddRVal;
}

/************************************************************************/
/* GetScanLine                                                          */
/* status : is now documented in MSDN and I checked the code it works   */
/*          like windows 2000                                           */
/************************************************************************/
DWORD STDCALL 
NtGdiDdGetScanLine( HANDLE hDirectDrawLocal, PDD_GETSCANLINEDATA puGetScanLineData)
{
    DWORD  ddRVal = DDHAL_DRIVER_NOTHANDLED;
    DD_GETSCANLINEDATA GetScanLineData;
    PDD_DIRECTDRAW pDirectDraw = NULL;
    NTSTATUS Status = FALSE;
    LPDDHAL_GETSCANLINEDATA ourpuGetScanLineData;

    if (hDirectDrawLocal)
    {
        pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);;
    }

    if (pDirectDraw != NULL)
    {
        DPRINT1("GetScanLine\n");
        if (pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE)
        {
            RtlZeroMemory(&GetScanLineData,sizeof(DD_GETSCANLINEDATA));
            GetScanLineData.ddRVal = DDERR_GENERIC;
            GetScanLineData.lpDD = &pDirectDraw->Global;
            ddRVal = pDirectDraw->DD.GetScanLine(&GetScanLineData);

            DPRINT1("GetScanLine\n");
            _SEH_TRY
            {
                ProbeForWrite(puGetScanLineData,  sizeof(DD_GETSCANLINEDATA), 1);
                ourpuGetScanLineData = (LPDDHAL_GETSCANLINEDATA)puGetScanLineData;
                ourpuGetScanLineData->dwScanLine = GetScanLineData.dwScanLine;
                ourpuGetScanLineData->ddRVal     = GetScanLineData.ddRVal;
            }
            _SEH_HANDLE
            {
                Status = _SEH_GetExceptionCode();
            }
            _SEH_END;

            if (!NT_SUCCESS(Status))
            {
                DPRINT1("GetScanLine\n");
                ddRVal = DDHAL_DRIVER_NOTHANDLED;
            }
        }

        GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
    }

  return ddRVal;
}