VirtualBox

Ignore:
Timestamp:
Jul 14, 2010 6:38:43 PM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: bugfixing, windbg extension to save mem buffer as bmp to clipboard, more debugging

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Display
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk

    r30518 r30855  
    106106endif
    107107
     108ifdef VBOXVIDEOWINDBG
     109DLLS += vbvdbg
     110vbvdbg_TEMPLATE = VBOXR3STATIC
     111vbvdbg_DEFS     = UNICODE _UNICODE
     112vbvdbg_SOURCES  = \
     113        wddm/dbg/VBoxVideoWinDbg.cpp \
     114        wddm/dbg/VBoxVideoWinDbg.def
     115vbvdbg_SDKS     = WINDDKWLH
     116endif
     117
    108118include $(KBUILD_PATH)/subfooter.kmk
    109119

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispCm.cpp

    r30541 r30855  
    234234            }
    235235            default:
    236                 AssertBreakpoint();
     236                Assert(0);
    237237                return E_FAIL;
    238238        }
    … …  
    240240
    241241    /* should never be here */
    242     AssertBreakpoint();
     242    Assert(0);
    243243    return E_FAIL;
    244244}

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

    r30795 r30855  
    10841084    PVBOXWDDMDISP_ALLOCATION pAlloc;
    10851085    UINT iBBuf = 0;
    1086     for (UINT i = iNewRTFB + 1; i < pRc->cAllocations; ++i, ++iBBuf)
    1087     {
    1088         pAlloc = &pRc->aAllocations[i];
    1089         Assert(i != iNewRTFB);
     1086    Assert(iNewRTFB < pRc->cAllocations);
     1087
     1088    for (UINT i = 1; i < pRc->cAllocations; ++i, ++iBBuf)
     1089    {
     1090        UINT iAlloc = (iNewRTFB + i) % pRc->cAllocations;
     1091        Assert(iAlloc != iNewRTFB);
     1092        pAlloc = &pRc->aAllocations[iAlloc];
    10901093        HRESULT tmpHr = vboxWddmRenderTargetUpdateSurface(pDevice, pAlloc, iBBuf);
    10911094        Assert(tmpHr == S_OK);
    10921095    }
    10931096
    1094     for (UINT i = 0; iBBuf < pRc->cAllocations-1; ++i, ++iBBuf)
    1095     {
    1096         Assert(i != iNewRTFB);
    1097         pAlloc = &pRc->aAllocations[i];
    1098         HRESULT tmpHr = vboxWddmRenderTargetUpdateSurface(pDevice, pAlloc, iBBuf);
    1099         Assert(tmpHr == S_OK);
    1100     }
    1101 
     1097    pAlloc = &pRc->aAllocations[iNewRTFB];
    11021098#ifdef VBOXWDDM_WITH_VISIBLE_FB
    1103     pAlloc = &pRc->aAllocations[iNewRTFB];
    11041099    HRESULT tmpHr = vboxWddmRenderTargetUpdateSurface(pDevice, pAlloc, ~0UL /* <- for the frontbuffer */);
    11051100    Assert(tmpHr == S_OK);
    11061101#else
    1107     pAlloc = &pRc->aAllocations[iNewRTFB];
    11081102    if (pAlloc->pD3DIf)
    11091103    {
    … …  
    11171111    {
    11181112        pAlloc = &pRc->aAllocations[i];
     1113        if (iNewRTFB == i)
     1114        {
     1115            Assert(!pAlloc->pD3DIf);
     1116        }
     1117
    11191118        for (UINT j = i+1; j < pRc->cAllocations; ++j)
    11201119        {
    … …  
    11261125    return S_OK;
    11271126}
     1127
     1128#ifdef DEBUG
     1129static void vboxWddmDbgRenderTargetUpdateCheckSurface(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, uint32_t iBBuf)
     1130{
     1131    IDirect3DSurface9 *pD3D9Surf;
     1132    Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
     1133    HRESULT hr = pDevice->pDevice9If->GetBackBuffer(0 /*UINT iSwapChain*/,
     1134            iBBuf, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
     1135    Assert(hr == S_OK);
     1136    if (hr == S_OK)
     1137    {
     1138        Assert(pD3D9Surf);
     1139        Assert(pD3D9Surf == pAlloc->pD3DIf);
     1140        pD3D9Surf->Release();
     1141    }
     1142}
     1143
     1144static void vboxWddmDbgRenderTargetCheck(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, uint32_t iNewRTFB)
     1145{
     1146    PVBOXWDDMDISP_ALLOCATION pAlloc;
     1147    UINT iBBuf = 0;
     1148    Assert(iNewRTFB < pRc->cAllocations);
     1149
     1150    for (UINT i = 1; i < pRc->cAllocations; ++i, ++iBBuf)
     1151    {
     1152        UINT iAlloc = (iNewRTFB + i) % pRc->cAllocations;
     1153        Assert(iAlloc != iNewRTFB);
     1154        pAlloc = &pRc->aAllocations[iAlloc];
     1155        vboxWddmDbgRenderTargetUpdateCheckSurface(pDevice, pAlloc, iBBuf);
     1156    }
     1157
     1158    pAlloc = &pRc->aAllocations[iNewRTFB];
     1159#ifdef VBOXWDDM_WITH_VISIBLE_FB
     1160    vboxWddmDbgRenderTargetUpdateCheckSurface(pDevice, pAlloc, ~0UL /* <- for the frontbuffer */);
     1161#else
     1162    Assert(pAlloc->pD3DIf == NULL);
     1163#endif
     1164
     1165    for (UINT i = 0; i < pRc->cAllocations; ++i)
     1166    {
     1167        pAlloc = &pRc->aAllocations[i];
     1168        if (iNewRTFB == i)
     1169        {
     1170            Assert(!pAlloc->pD3DIf);
     1171        }
     1172
     1173        for (UINT j = i+1; j < pRc->cAllocations; ++j)
     1174        {
     1175            PVBOXWDDMDISP_ALLOCATION pAllocJ = &pRc->aAllocations[j];
     1176            Assert(pAlloc->pD3DIf != pAllocJ->pD3DIf);
     1177        }
     1178    }
     1179}
     1180
     1181# define VBOXVDBG_RTGT_STATECHECK(_pDev) (vboxWddmDbgRenderTargetCheck((_pDev), (_pDev)->pRenderTargetRc, (_pDev)->iRenderTargetFrontBuf))
     1182#else
     1183# define VBOXVDBG_RTGT_STATECHECK(_pDev) do{}while(0)
     1184#endif
    11281185
    11291186static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)
    … …  
    11521209        return D3DPOOL_DEFAULT;
    11531210    default:
    1154         AssertBreakpoint();
     1211        Assert(0);
    11551212    }
    11561213    return D3DPOOL_DEFAULT;
    … …  
    12891346        case DLL_PROCESS_ATTACH:
    12901347        {
     1348#ifdef VBOXWDDMDISP_DEBUG
     1349            vboxVDbgVEHandlerRegister();
     1350#endif
    12911351            RTR3Init();
    12921352
    … …  
    13111371        case DLL_PROCESS_DETACH:
    13121372        {
     1373#ifdef VBOXWDDMDISP_DEBUG
     1374            vboxVDbgVEHandlerUnregister();
     1375#endif
    13131376            HRESULT hr;
    13141377#ifdef VBOXDISPMP_TEST
    … …  
    14321495            memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
    14331496#else
    1434             AssertBreakpoint();
     1497            Assert(0);
    14351498            memset(pData->pData, 0, pData->DataSize);
    14361499#endif
    … …  
    15251588        {
    15261589            Assert(pData->DataSize >= sizeof (D3DCAPS9));
    1527 //            AssertBreakpoint();
     1590//            Assert(0);
    15281591            if (pData->DataSize >= sizeof (D3DCAPS9))
    15291592            {
    … …  
    15791642                        else
    15801643                        {
    1581                             AssertBreakpoint();
     1644                            Assert(0);
    15821645                        }
    15831646#endif
    … …  
    16271690        case D3DDDICAPS_GETEXTENSIONCAPS:
    16281691            vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
    1629             AssertBreakpoint();
     1692            Assert(0);
    16301693            if (pData->pData && pData->DataSize)
    16311694                memset(pData->pData, 0, pData->DataSize);
    … …  
    16331696        default:
    16341697            vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
    1635             AssertBreakpoint();
     1698            Assert(0);
    16361699    }
    16371700
    … …  
    16631726{
    16641727    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1665     AssertBreakpoint();
     1728    Assert(0);
    16661729    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    16671730    return E_FAIL;
    … …  
    17581821//        if (pStreamData)
    17591822//        {
    1760 //            AssertBreakpoint();
     1823//            Assert(0);
    17611824//            /* @todo: impl! */
    17621825//        }
    … …  
    18411904        {
    18421905            /* todo: impl */
    1843             AssertBreakpoint();
     1906            Assert(0);
    18441907        }
    18451908    }
    … …  
    19432006                                    break;
    19442007                                default:
    1945                                     AssertBreakpoint();
     2008                                    Assert(0);
    19462009                                    cbType = 1;
    19472010                            }
    … …  
    19702033                                    break;
    19712034                                default:
    1972                                     AssertBreakpoint();
     2035                                    Assert(0);
    19732036                                    cVertexes = pData->PrimitiveCount;
    19742037                            }
    … …  
    20842147{
    20852148    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2086     AssertBreakpoint();
     2149    Assert(0);
    20872150    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    20882151    return E_FAIL;
    … …  
    20922155{
    20932156    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2094     AssertBreakpoint();
     2157    Assert(0);
    20952158    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    20962159    return E_FAIL;
    … …  
    21682231{
    21692232    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2170     AssertBreakpoint();
     2233    Assert(0);
    21712234    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    21722235    return E_FAIL;
    … …  
    21762239{
    21772240    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2178     AssertBreakpoint();
     2241    Assert(0);
    21792242    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    21802243    return E_FAIL;
    … …  
    21842247{
    21852248    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2186     AssertBreakpoint();
     2249    Assert(0);
    21872250    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    21882251    return E_FAIL;
    … …  
    22182281        else
    22192282        {
    2220             AssertBreakpoint();
     2283            Assert(0);
    22212284            /* @todo: impl */
    22222285        }
    … …  
    22242287    else
    22252288    {
    2226         AssertBreakpoint();
     2289        Assert(0);
    22272290        /* @todo: impl */
    22282291    }
    … …  
    22352298{
    22362299    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2237     AssertBreakpoint();
     2300    Assert(0);
    22382301    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    22392302    return E_FAIL;
    … …  
    22422305{
    22432306    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2244     AssertBreakpoint();
     2307    Assert(0);
    22452308    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    22462309    return E_FAIL;
    … …  
    22742337{
    22752338    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2276     AssertBreakpoint();
     2339    Assert(0);
    22772340    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    22782341    return E_FAIL;
    … …  
    22822345{
    22832346    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2284     AssertBreakpoint();
     2347    Assert(0);
    22852348    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    22862349    return E_FAIL;
    … …  
    23042367{
    23052368    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2306     AssertBreakpoint();
     2369    Assert(0);
    23072370    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23082371    return E_FAIL;
    … …  
    23112374{
    23122375    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2313     AssertBreakpoint();
     2376    Assert(0);
    23142377    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23152378    return E_FAIL;
    … …  
    23462409{
    23472410    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2348     AssertBreakpoint();
     2411    Assert(0);
    23492412    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23502413    return E_FAIL;
    … …  
    23532416{
    23542417    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2355     AssertBreakpoint();
     2418    Assert(0);
    23562419    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23572420    return E_FAIL;
    … …  
    23602423{
    23612424    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2362     AssertBreakpoint();
     2425    Assert(0);
    23632426    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23642427    return E_FAIL;
    … …  
    23672430{
    23682431    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2369     AssertBreakpoint();
     2432    Assert(0);
    23702433    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23712434    return E_FAIL;
    … …  
    23862449{
    23872450    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2388     AssertBreakpoint();
     2451    Assert(0);
    23892452    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    23902453    return E_NOTIMPL;
    … …  
    27082771        else
    27092772        {
    2710             AssertBreakpoint();
     2773            Assert(0);
    27112774        }
    27122775    }
    … …  
    27442807            {
    27452808                vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
    2746                 AssertBreakpoint();
     2809                Assert(0);
    27472810            }
    27482811            else
    … …  
    29062969        else
    29072970        {
    2908             AssertBreakpoint();
     2971            Assert(0);
    29092972        }
    29102973    }
    … …  
    29393002{
    29403003    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2941     AssertBreakpoint();
     3004    Assert(0);
    29423005    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    29433006    return E_FAIL;
    … …  
    29463009{
    29473010    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2948     AssertBreakpoint();
     3011    Assert(0);
    29493012    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    29503013    return E_FAIL;
    … …  
    29533016{
    29543017    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2955     AssertBreakpoint();
     3018    Assert(0);
    29563019    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    29573020    return E_FAIL;
    … …  
    30743137            if (pResource->Flags.SharedResource)
    30753138            {
    3076                 AssertBreakpoint(); /* <-- need to test that */
     3139                Assert(0); /* <-- need to test that */
    30773140                bIssueCreateResource = true;
    30783141            }
    … …  
    36453708        Assert(pDevice->pDevice9If);
    36463709#if 1
     3710        VBOXVDBG_RTGT_STATECHECK(pDevice);
     3711
    36473712        hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
    36483713                NULL, /* CONST RECT * pDestRect */
    … …  
    36653730            Assert(pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
    36663731            Assert(pRc->RcDesc.fFlags.RenderTarget);
    3667             uint32_t iNewRTFB = pDevice->iRenderTargetFrontBuf + 1;
    3668             if (iNewRTFB >= pRc->cAllocations)
    3669                 iNewRTFB = 0;
     3732            uint32_t iNewRTFB = (pDevice->iRenderTargetFrontBuf + 1) % pRc->cAllocations;
    36703733
    36713734            Assert(pDevice->iRenderTargetFrontBuf != iNewRTFB);
    … …  
    36763739            /* assign a new frontbuffer index */
    36773740            pDevice->iRenderTargetFrontBuf = iNewRTFB;
     3741
     3742            VBOXVDBG_RTGT_STATECHECK(pDevice);
    36783743        }
    36793744        D3DDDICB_PRESENT DdiPresent = {0};
    … …  
    39073972{
    39083973    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3909     AssertBreakpoint();
     3974    Assert(0);
    39103975    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    39113976    return E_FAIL;
    … …  
    39143979{
    39153980    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3916     AssertBreakpoint();
     3981    Assert(0);
    39173982    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    39183983    return E_FAIL;
    … …  
    39213986{
    39223987    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3923     AssertBreakpoint();
     3988    Assert(0);
    39243989    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    39253990    return E_FAIL;
    … …  
    39524017        }
    39534018        default:
    3954             AssertBreakpoint();
     4019            Assert(0);
    39554020            break;
    39564021    }
    … …  
    39804045        }
    39814046        default:
    3982             AssertBreakpoint();
     4047            Assert(0);
    39834048            hr = E_FAIL;
    39844049            break;
    … …  
    40174082        }
    40184083        default:
    4019             AssertBreakpoint();
     4084            Assert(0);
    40204085            hr = E_FAIL;
    40214086            break;
    … …  
    40234088    return hr;
    40244089}
     4090
     4091#ifdef DEBUG_misha
     4092static void vboxWddmDbgSurfData(PVBOXWDDMDISP_ALLOCATION pAlloc, IDirect3DSurface9 *pSurf)
     4093{
     4094    D3DLOCKED_RECT Lr;
     4095    HRESULT tmpHr = pSurf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
     4096    Assert(tmpHr == S_OK);
     4097    if (tmpHr == S_OK)
     4098    {
     4099        UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
     4100        Assert(bpp == pAlloc->SurfDesc.bpp);
     4101        Assert(pAlloc->SurfDesc.pitch == Lr.Pitch);
     4102        vboxVDbgPrintF(("!vbvdbg.ms 0x%p 0x%x 0x%x 0x%x 0x%x\n",
     4103                Lr.pBits, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, bpp, Lr.Pitch));
     4104        Assert(0);
     4105        tmpHr = pSurf->UnlockRect();
     4106    }
     4107}
     4108#endif
    40254109
    40264110static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
    … …  
    41064190            {
    41074191                Assert(pSrcSurfIf);
     4192
     4193#ifdef DEBUG_misha
     4194                {
     4195                    D3DLOCKED_RECT Lr;
     4196                    PVBOXWDDMDISP_ALLOCATION pAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
     4197                    HRESULT srcHr = pSrcSurfIf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
     4198                    Assert(srcHr == S_OK);
     4199                    if (srcHr == S_OK)
     4200                    {
     4201                        UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
     4202                        Assert(bpp == pAlloc->SurfDesc.bpp);
     4203                        Assert(pAlloc->SurfDesc.pitch == Lr.Pitch);
     4204                        vboxVDbgPrintF(("src: !vbvdbg.ms 0x%p 0x%x 0x%x 0x%x 0x%x\n",
     4205                                Lr.pBits, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, bpp, Lr.Pitch));
     4206                    }
     4207
     4208                    pAlloc = &pDstRc->aAllocations[pData->DstSubResourceIndex];
     4209                    HRESULT dstHr = pDstSurfIf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
     4210                    Assert(dstHr == S_OK);
     4211                    if (dstHr == S_OK)
     4212                    {
     4213                        UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
     4214                        Assert(bpp == pAlloc->SurfDesc.bpp);
     4215                        Assert(pAlloc->SurfDesc.pitch == Lr.Pitch);
     4216                        vboxVDbgPrintF(("dst: !vbvdbg.ms 0x%p 0x%x 0x%x 0x%x 0x%x\n",
     4217                                Lr.pBits, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, bpp, Lr.Pitch));
     4218                    }
     4219
     4220                    Assert(0);
     4221
     4222                    if (srcHr == S_OK)
     4223                    {
     4224                        srcHr = pSrcSurfIf->UnlockRect();
     4225                        Assert(srcHr == S_OK);
     4226                    }
     4227
     4228                    if (dstHr == S_OK)
     4229                    {
     4230                        dstHr = pDstSurfIf->UnlockRect();
     4231                        Assert(dstHr == S_OK);
     4232                    }
     4233                }
     4234#endif
    41084235                /* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
    41094236                Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001  | 0x00000002))) == 0);
    … …  
    41144241                                    vboxDDI2D3DBltFlags(pData->Flags));
    41154242                Assert(hr == S_OK);
     4243
     4244#ifdef DEBUG_misha
     4245                {
     4246                    D3DLOCKED_RECT Lr;
     4247                    PVBOXWDDMDISP_ALLOCATION pAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
     4248                    HRESULT srcHr = pSrcSurfIf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
     4249                    Assert(srcHr == S_OK);
     4250                    if (srcHr == S_OK)
     4251                    {
     4252                        UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
     4253                        Assert(bpp == pAlloc->SurfDesc.bpp);
     4254                        Assert(pAlloc->SurfDesc.pitch == Lr.Pitch);
     4255                        vboxVDbgPrintF(("src: !vbvdbg.ms 0x%p 0x%x 0x%x 0x%x 0x%x\n",
     4256                                Lr.pBits, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, bpp, Lr.Pitch));
     4257                    }
     4258
     4259                    pAlloc = &pDstRc->aAllocations[pData->DstSubResourceIndex];
     4260                    HRESULT dstHr = pDstSurfIf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
     4261                    Assert(dstHr == S_OK);
     4262                    if (dstHr == S_OK)
     4263                    {
     4264                        UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
     4265                        Assert(bpp == pAlloc->SurfDesc.bpp);
     4266                        Assert(pAlloc->SurfDesc.pitch == Lr.Pitch);
     4267                        vboxVDbgPrintF(("dst: !vbvdbg.ms 0x%p 0x%x 0x%x 0x%x 0x%x\n",
     4268                                Lr.pBits, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, bpp, Lr.Pitch));
     4269                    }
     4270
     4271                    Assert(0);
     4272
     4273                    if (srcHr == S_OK)
     4274                    {
     4275                        srcHr = pSrcSurfIf->UnlockRect();
     4276                        Assert(srcHr == S_OK);
     4277                    }
     4278
     4279                    if (dstHr == S_OK)
     4280                    {
     4281                        dstHr = pDstSurfIf->UnlockRect();
     4282                        Assert(dstHr == S_OK);
     4283                    }
     4284                }
     4285#endif
    41164286                pSrcSurfIf->Release();
    41174287            }
    … …  
    41244294    {
    41254295        /* todo: fallback to memcpy or whatever ? */
    4126         AssertBreakpoint();
     4296        Assert(0);
    41274297    }
    41284298
    … …  
    41824352            {
    41834353
    4184                 AssertBreakpoint();
     4354                Assert(0);
    41854355                /* @todo: impl */
    41864356            }
    … …  
    41884358        else
    41894359        {
    4190             AssertBreakpoint();
     4360            Assert(0);
    41914361            /* @todo: impl */
    41924362        }
    … …  
    42264396        else
    42274397        {
    4228             AssertBreakpoint();
     4398            Assert(0);
    42294399            /* @todo: impl */
    42304400        }
    … …  
    42384408{
    42394409    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4240     AssertBreakpoint();
     4410    Assert(0);
    42414411    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    42424412    return E_FAIL;
    … …  
    42454415{
    42464416    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4247     AssertBreakpoint();
     4417    Assert(0);
    42484418    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    42494419    return E_FAIL;
    … …  
    42524422{
    42534423    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4254     AssertBreakpoint();
     4424    Assert(0);
    42554425    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    42564426    return E_FAIL;
    … …  
    42594429{
    42604430    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4261     AssertBreakpoint();
     4431    Assert(0);
    42624432    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    42634433    return E_FAIL;
    … …  
    42664436{
    42674437    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4268     AssertBreakpoint();
     4438    Assert(0);
    42694439    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    42704440    return E_FAIL;
    … …  
    42734443{
    42744444    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4275     AssertBreakpoint();
     4445    Assert(0);
    42764446    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    42774447    return E_FAIL;
    … …  
    43334503{
    43344504    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4335     AssertBreakpoint();
     4505    Assert(0);
    43364506    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    43374507    return E_FAIL;
    … …  
    43924562{
    43934563    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4394     AssertBreakpoint();
     4564    Assert(0);
    43954565    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    43964566    return E_FAIL;
    … …  
    43994569{
    44004570    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4401     AssertBreakpoint();
     4571    Assert(0);
    44024572    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44034573    return E_FAIL;
    … …  
    44064576{
    44074577    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4408     AssertBreakpoint();
     4578    Assert(0);
    44094579    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44104580    return E_FAIL;
    … …  
    44134583{
    44144584    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4415     AssertBreakpoint();
     4585    Assert(0);
    44164586    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44174587    return E_FAIL;
    … …  
    44204590{
    44214591    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4422     AssertBreakpoint();
     4592    Assert(0);
    44234593    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44244594    return E_FAIL;
    … …  
    44274597{
    44284598    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4429     AssertBreakpoint();
     4599    Assert(0);
    44304600    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44314601    return E_FAIL;
    … …  
    44344604{
    44354605    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4436     AssertBreakpoint();
     4606    Assert(0);
    44374607    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44384608    return E_FAIL;
    … …  
    44414611{
    44424612    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4443     AssertBreakpoint();
     4613    Assert(0);
    44444614    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44454615    return E_FAIL;
    … …  
    44484618{
    44494619    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4450     AssertBreakpoint();
     4620    Assert(0);
    44514621    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44524622    return E_FAIL;
    … …  
    44554625{
    44564626    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4457     AssertBreakpoint();
     4627    Assert(0);
    44584628    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44594629    return E_FAIL;
    … …  
    44624632{
    44634633    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4464     AssertBreakpoint();
     4634    Assert(0);
    44654635    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44664636    return E_FAIL;
    … …  
    44694639{
    44704640    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4471     AssertBreakpoint();
     4641    Assert(0);
    44724642    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44734643    return E_FAIL;
    … …  
    44764646{
    44774647    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4478     AssertBreakpoint();
     4648    Assert(0);
    44794649    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44804650    return E_FAIL;
    … …  
    44834653{
    44844654    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4485     AssertBreakpoint();
     4655    Assert(0);
    44864656    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44874657    return E_FAIL;
    … …  
    44904660{
    44914661    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4492     AssertBreakpoint();
     4662    Assert(0);
    44934663    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    44944664    return E_FAIL;
    … …  
    44974667{
    44984668    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4499     AssertBreakpoint();
     4669    Assert(0);
    45004670    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    45014671    return E_FAIL;
    … …  
    46804850{
    46814851    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4682     AssertBreakpoint();
     4852    Assert(0);
    46834853    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    46844854    return E_FAIL;
    … …  
    46874857{
    46884858    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4689     AssertBreakpoint();
     4859    Assert(0);
    46904860    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    46914861    return E_FAIL;
    … …  
    47164886    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    47174887    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
    4718     AssertBreakpoint();
     4888    Assert(0);
    47194889    HRESULT hr = S_OK;
    47204890#if 0
    … …  
    48054975                        break;
    48064976                    default:
    4807                         AssertBreakpoint();
     4977                        Assert(0);
    48084978                        hr = E_INVALIDARG;
    48094979                }
    … …  
    48144984        else
    48154985        {
    4816             AssertBreakpoint(); /* <-- need to test that */
     4986            Assert(0); /* <-- need to test that */
    48174987
    48184988            /* this is a "generic" resource whose creation is initiaded by the UMD */
    … …  
    48595029{
    48605030    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4861     AssertBreakpoint();
     5031    Assert(0);
    48625032    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    48635033    return E_FAIL;
    … …  
    48675037{
    48685038    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    4869     AssertBreakpoint();
     5039    Assert(0);
    48705040    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    48715041    return E_FAIL;
    … …  
    48775047    vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
    48785048
    4879 //    AssertBreakpoint();
     5049//    Assert(0);
    48805050
    48815051    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
    … …  
    50445214    vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
    50455215
    5046 //    AssertBreakpoint();
     5216//    Assert(0);
    50475217
    50485218    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
    … …  
    51855355    OutputDebugStringA(szBuffer);
    51865356}
     5357
     5358static PVOID g_VBoxWDbgVEHandler = NULL;
     5359LONG WINAPI vboxVDbgVectoredHandler(struct _EXCEPTION_POINTERS *pExceptionInfo)
     5360{
     5361    PEXCEPTION_RECORD pExceptionRecord = pExceptionInfo->ExceptionRecord;
     5362    PCONTEXT pContextRecord = pExceptionInfo->ContextRecord;
     5363    switch (pExceptionRecord->ExceptionCode)
     5364    {
     5365        case 0x40010006: /* <- OutputDebugString exception, ignore */
     5366            break;
     5367        default:
     5368            Assert(0);
     5369            break;
     5370    }
     5371    return EXCEPTION_CONTINUE_SEARCH;
     5372}
     5373
     5374void vboxVDbgVEHandlerRegister()
     5375{
     5376    Assert(!g_VBoxWDbgVEHandler);
     5377    g_VBoxWDbgVEHandler = AddVectoredExceptionHandler(1,vboxVDbgVectoredHandler);
     5378    Assert(g_VBoxWDbgVEHandler);
     5379}
     5380
     5381void vboxVDbgVEHandlerUnregister()
     5382{
     5383    Assert(g_VBoxWDbgVEHandler);
     5384    ULONG uResult = RemoveVectoredExceptionHandler(g_VBoxWDbgVEHandler);
     5385    Assert(uResult);
     5386    g_VBoxWDbgVEHandler = NULL;
     5387}
     5388
    51875389#endif

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3DCmn.h

    r30657 r30855  
    3737#ifdef DEBUG
    3838# define VBOXWDDMDISP_DEBUG
     39# define VBOXWDDMDISP_DEBUG_FLOW
    3940#endif
    4041
    … …  
    5657#ifdef VBOXWDDMDISP_DEBUG
    5758VOID vboxVDbgDoPrint(LPCSTR szString, ...);
     59void vboxVDbgVEHandlerRegister();
     60void vboxVDbgVEHandlerUnregister();
    5861
    5962#define vboxVDbgBreak() AssertBreakpoint()
    … …  
    6366    } while (0)
    6467#define vboxVDbgPrintR vboxVDbgPrint
    65 #define vboxVDbgPrintF(_m)  do {} while (0)
     68#ifdef VBOXWDDMDISP_DEBUG_FLOW
     69# define vboxVDbgPrintF  vboxVDbgPrint
     70#else
     71# define vboxVDbgPrintF(_m)  do {} while (0)
     72#endif
    6673#else
    6774#define vboxVDbgBreak() do {} while (0)
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette