}

    // =============== DDEVENT_PREDOSBOX =================
    RtlZeroMemory(&ddRegisterCallback, sizeof(ddRegisterCallback));
    RtlZeroMemory(&ddOut, sizeof(ddOut));

    ddRegisterCallback.hDirectDraw = pStrmEx->KernelDirectDrawHandle;
    ddRegisterCallback.dwEvents = DDEVENT_PREDOSBOX;
    ddRegisterCallback.pfnCallback = DirectDrawEventCallback;
    ddRegisterCallback.pContext = pStrmEx;

    DxApi(DD_DXAPI_REGISTER_CALLBACK, &ddRegisterCallback, sizeof(ddRegisterCallback), &ddOut, sizeof(ddOut));

    if (ddOut != DD_OK) {
        DbgLogInfo(("Testcap: DD_DXAPI_REGISTER_CALLBACK failed.\n"));
        TRAP;
        return FALSE;
    }

    // =============== DDEVENT_POSTDOSBOX ================
    RtlZeroMemory(&ddRegisterCallback, sizeof(ddRegisterCallback));
    RtlZeroMemory(&ddOut, sizeof(ddOut));

    ddRegisterCallback.hDirectDraw = pStrmEx->KernelDirectDrawHandle;
    ddRegisterCallback.dwEvents = DDEVENT_POSTDOSBOX;
    ddRegisterCallback.pfnCallback = DirectDrawEventCallback;
    ddRegisterCallback.pContext = pStrmEx;

    DxApi(DD_DXAPI_REGISTER_CALLBACK, &ddRegisterCallback, sizeof(ddRegisterCallback), &ddOut, sizeof(ddOut));

    if (ddOut != DD_OK) {
        DbgLogInfo(("Testcap: DD_DXAPI_REGISTER_CALLBACK failed.\n"));
        TRAP;
        return FALSE;
    }
    pStrmEx->KernelDirectDrawRegistered = TRUE;

    return TRUE;
}


BOOL
UnregisterForDirectDrawEvents (
    PSTREAMEX pStrmEx
    )
{
    PHW_DEVICE_EXTENSION    pHwDevExt = pStrmEx->pHwDevExt;
    int StreamNumber = pStrmEx->pStreamObject->StreamNumber;
    DDREGISTERCALLBACK ddRegisterCallback;
    DWORD ddOut;

    DbgLogInfo(("Testcap: Stream %d UNregistering for DirectDraw events\n", StreamNumber));

    // =============== DDEVENT_PRERESCHANGE ===============
    RtlZeroMemory(&ddRegisterCallback, sizeof(ddRegisterCallback));
    RtlZeroMemory(&ddOut, sizeof(ddOut));

    ddRegisterCallback.hDirectDraw = pStrmEx->KernelDirectDrawHandle;
    ddRegisterCallback.dwEvents = DDEVENT_PRERESCHANGE ;
    ddRegisterCallback.pfnCallback = DirectDrawEventCallback;
    ddRegisterCallback.pContext = pStrmEx;

    DxApi(DD_DXAPI_UNREGISTER_CALLBACK, &ddRegisterCallback, sizeof(ddRegisterCallback), &ddOut, sizeof(ddOut));

    if (ddOut != DD_OK) {
        DbgLogInfo(("Testcap: DD_DXAPI_UNREGISTER_CALLBACK failed.\n"));
        TRAP;
        return FALSE;
    }

    // =============== DDEVENT_POSTRESCHANGE ==============
    RtlZeroMemory(&ddRegisterCallback, sizeof(ddRegisterCallback));
    RtlZeroMemory(&ddOut, sizeof(ddOut));

    ddRegisterCallback.hDirectDraw = pStrmEx->KernelDirectDrawHandle;
    ddRegisterCallback.dwEvents = DDEVENT_POSTRESCHANGE;
    ddRegisterCallback.pfnCallback = DirectDrawEventCallback;
    ddRegisterCallback.pContext = pStrmEx;

    DxApi(DD_DXAPI_UNREGISTER_CALLBACK, &ddRegisterCallback, sizeof(ddRegisterCallback), &ddOut, sizeof(ddOut));

    if (ddOut != DD_OK) {
        DbgLogInfo(("Testcap: DD_DXAPI_UNREGISTER_CALLBACK failed.\n"));
        TRAP;
        return FALSE;
    }

    // =============== DDEVENT_PREDOSBOX ==================
    RtlZeroMemory(&ddRegisterCallback, sizeof(ddRegisterCallback));
    RtlZeroMemory(&ddOut, sizeof(ddOut));

    ddRegisterCallback.hDirectDraw = pStrmEx->KernelDirectDrawHandle;
    ddRegisterCallback.dwEvents = DDEVENT_PREDOSBOX;
    ddRegisterCallback.pfnCallback = DirectDrawEventCallback;
    ddRegisterCallback.pContext = pStrmEx;

    DxApi(DD_DXAPI_UNREGISTER_CALLBACK, &ddRegisterCallback, sizeof(ddRegisterCallback), &ddOut, sizeof(ddOut));

    if (ddOut != DD_OK) {
        DbgLogInfo(("Testcap: DD_DXAPI_UNREGISTER_CALLBACK failed.\n"));
        TRAP;
        return FALSE;
    }

    // =============== DDEVENT_POSTDOSBOX =================
    RtlZeroMemory(&ddRegisterCallback, sizeof(ddRegisterCallback));
    RtlZeroMemory(&ddOut, sizeof(ddOut));

    ddRegisterCallback.hDirectDraw = pStrmEx->KernelDirectDrawHandle;
    ddRegisterCallback.dwEvents = DDEVENT_POSTDOSBOX;
    ddRegisterCallback.pfnCallback = DirectDrawEventCallback;
    ddRegisterCallback.pContext = pStrmEx;

    DxApi(DD_DXAPI_UNREGISTER_CALLBACK, &ddRegisterCallback, sizeof(ddRegisterCallback), &ddOut, sizeof(ddOut));

    if (ddOut != DD_OK) {
        DbgLogInfo(("Testcap: DD_DXAPI_UNREGISTER_CALLBACK failed.\n"));
        TRAP;
        return FALSE;
    }
    pStrmEx->KernelDirectDrawRegistered = FALSE;

    return TRUE;
}


BOOL
OpenKernelDirectDraw (
    PSTREAMEX pStrmEx
    )
{
    PHW_DEVICE_EXTENSION    pHwDevExt = pStrmEx->pHwDevExt;
    int StreamNumber = pStrmEx->pStreamObject->StreamNumber;

    if (pStrmEx->UserDirectDrawHandle != 0) {
        DDOPENDIRECTDRAWIN  ddOpenIn;
        DDOPENDIRECTDRAWOUT ddOpenOut;

        ASSERT (pStrmEx->KernelDirectDrawHandle == 0);

        DbgLogInfo(("Testcap: Stream %d getting Kernel ddraw handle\n", StreamNumber));

        RtlZeroMemory(&ddOpenIn, sizeof(ddOpenIn));
        RtlZeroMemory(&ddOpenOut, sizeof(ddOpenOut));

        ddOpenIn.dwDirectDrawHandle = (DWORD_PTR) pStrmEx->UserDirectDrawHandle;
        ddOpenIn.pfnDirectDrawClose = DirectDrawEventCallback;
        ddOpenIn.pContext = pStrmEx;

        DxApi(DD_DXAPI_OPENDIRECTDRAW,
                &ddOpenIn,
                sizeof(ddOpenIn),
                &ddOpenOut,
                sizeof(ddOpenOut));

        if (ddOpenOut.ddRVal != DD_OK) {
            DbgLogInfo(("Testcap: DD_DXAPI_OPENDIRECTDRAW failed.\n"));
        }
        else {
            pStrmEx->KernelDirectDrawHandle = ddOpenOut.hDirectDraw;
            return TRUE;
        }
    }

    return FALSE;
}


BOOL
CloseKernelDirectDraw (
    PSTREAMEX pStrmEx
    )
{
    PHW_DEVICE_EXTENSION pHwDevExt = pStrmEx->pHwDevExt;
    int StreamNumber = pStrmEx->pStreamObject->StreamNumber;

    if (pStrmEx->KernelDirectDrawHandle != 0) {
        DWORD ddOut;
        DDCLOSEHANDLE ddClose;

        DbgLogInfo(("Testcap: Stream %d CloseKernelDirectDraw\n", StreamNumber));

        ddClose.hHandle = pStrmEx->KernelDirectDrawHandle;

        DxApi(DD_DXAPI_CLOSEHANDLE,
                &ddClose,
                sizeof(ddClose),
                &ddOut,
                sizeof(ddOut));

        pStrmEx->KernelDirectDrawHandle = 0;

        if (ddOut != DD_OK) {
            DbgLogInfo(("Testcap: CloseKernelDirectDraw FAILED.\n"));
            TRAP;
            return FALSE;
        }
    }
    return TRUE;
}

BOOL
IsKernelLockAndFlipAvailable (
    PSTREAMEX pStrmEx
    )
{
    PHW_DEVICE_EXTENSION pHwDevExt = pStrmEx->pHwDevExt;
    int StreamNumber = pStrmEx->pStreamObject->StreamNumber;

    if (pStrmEx->KernelDirectDrawHandle != 0) {
        DDGETKERNELCAPSOUT ddGetKernelCapsOut;

        DbgLogInfo(("Testcap: Stream %d getting Kernel Caps\n", StreamNumber));

        RtlZeroMemory(&ddGetKernelCapsOut, sizeof(ddGetKernelCapsOut));

        DxApi(DD_DXAPI_GETKERNELCAPS,
                &pStrmEx->KernelDirectDrawHandle,
                sizeof(pStrmEx->KernelDirectDrawHandle),
                &ddGetKernelCapsOut,
                sizeof(ddGetKernelCapsOut));

        if (ddGetKernelCapsOut.ddRVal != DD_OK) {
            DbgLogInfo(("Testcap: DDGETKERNELCAPSOUT failed.\n"));
        }
        else {
            DbgLogInfo(("Testcap: Stream %d KernelCaps = %x\n",
                    StreamNumber, ddGetKernelCapsOut.dwCaps));

            if ((ddGetKernelCapsOut.dwCaps & (DDKERNELCAPS_LOCK | DDKERNELCAPS_FLIPOVERLAY)) ==
                                             (DDKERNELCAPS_LOCK | DDKERNELCAPS_FLIPOVERLAY)) {
                // TODO: Check where we may need to set up for kernel flipping
            }
            return TRUE;
        }
    }
    return FALSE;
}


BOOL
OpenKernelDDrawSurfaceHandle(
     IN PHW_STREAM_REQUEST_BLOCK pSrb
    )
{
    PHW_DEVICE_EXTENSION    pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
    PSTREAMEX               pStrmEx = (PSTREAMEX)pSrb->StreamObject->HwStreamExtension;
    int                     StreamNumber = pStrmEx->pStreamObject->StreamNumber;
    PSRB_EXTENSION          pSrbExt = (PSRB_EXTENSION)pSrb->SRBExtension;

    ASSERT (pStrmEx->KernelDirectDrawHandle != 0);
    ASSERT (pSrbExt->UserSurfaceHandle != 0);

    if (pSrbExt->UserSurfaceHandle == 0) {
        DDOPENSURFACEIN ddOpenSurfaceIn;
        DDOPENSURFACEOUT ddOpenSurfaceOut;

        DbgLogInfo(("Testcap: Stream %d getting Kernel surface handle\n", StreamNumber));

        RtlZeroMemory(&ddOpenSurfaceIn, sizeof(ddOpenSurfaceIn));
        RtlZeroMemory(&ddOpenSurfaceOut, sizeof(ddOpenSurfaceOut));

        ddOpenSurfaceIn.hDirectDraw = pStrmEx->UserDirectDrawHandle;
        ddOpenSurfaceIn.pfnSurfaceClose = DirectDrawEventCallback;
        ddOpenSurfaceIn.pContext = pSrb;

        ddOpenSurfaceIn.dwSurfaceHandle = (DWORD_PTR) pSrbExt->UserSurfaceHandle;

        DxApi(DD_DXAPI_OPENSURFACE,
                    &ddOpenSurfaceIn,
                    sizeof(ddOpenSurfaceIn),
                    &ddOpenSurfaceOut,
                    sizeof(ddOpenSurfaceOut));

        if (ddOpenSurfaceOut.ddRVal != DD_OK) {
            pSrbExt->KernelSurfaceHandle = 0;
            DbgLogInfo(("Testcap: DD_DXAPI_OPENSURFACE failed.\n"));
            TRAP;
        }
        else {
            pSrbExt->KernelSurfaceHandle = ddOpenSurfaceOut.hSurface;
            return TRUE;
        }
    }
    return FALSE;
}


BOOL
CloseKernelDDrawSurfaceHandle (
    IN PHW_STREAM_REQUEST_BLOCK pSrb
    )
{
    PHW_DEVICE_EXTENSION    pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
    PSTREAMEX               pStrmEx = (PSTREAMEX)pSrb->StreamObject->HwStreamExtension;
    int                     StreamNumber = pStrmEx->pStreamObject->StreamNumber;
    PSRB_EXTENSION          pSrbExt = (PSRB_EXTENSION)pSrb->SRBExtension;

    ASSERT (pStrmEx->KernelDirectDrawHandle != 0);
    ASSERT (pSrbExt->UserSurfaceHandle != 0);
    ASSERT (pSrbExt->KernelSurfaceHandle != 0);

    if (pSrbExt->KernelSurfaceHandle != 0) {
        DWORD ddOut;
        DDCLOSEHANDLE ddClose;

        DbgLogInfo(("Testcap: Stream %d ReleaseKernelDDrawSurfaceHandle\n", StreamNumber));

        ddClose.hHandle = pSrbExt->KernelSurfaceHandle;

        DxApi(DD_DXAPI_CLOSEHANDLE, &ddClose, sizeof(ddClose), &ddOut, sizeof(ddOut));

        pSrbExt->KernelSurfaceHandle = 0;  // what else can we do?

        if (ddOut != DD_OK) {
            DbgLogInfo(("Testcap: ReleaseKernelDDrawSurfaceHandle FAILED.\n"));
            TRAP;
            return FALSE;
        }
        else {
            return TRUE;
        }
    }

    return FALSE;
}