VirtualBox

Ignore:
Timestamp:
Jul 15, 2010 8:56:09 PM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: more debugging

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

Legend:

Unmodified
Added
Removed

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

    r30855 r30865  
    18851885    HRESULT hr = S_OK;
    18861886
     1887#ifdef DEBUG_misha
     1888    uint32_t iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
     1889    vboxVDbgDumpSurfData((pDevice, ">>>DrawPrimitive:\n", pDevice->pRenderTargetRc, iBackBuf,
     1890            NULL, (IDirect3DSurface9*)pDevice->pRenderTargetRc->aAllocations[iBackBuf].pD3DIf, "\n"));
     1891#endif
     1892
    18871893    if (!pDevice->cStreamSources)
    18881894    {
    … …  
    19001906                                      pDevice->aStreamSourceUm[0].cbStride);
    19011907            Assert(hr == S_OK);
     1908
     1909            vboxVDbgMpPrint((pDevice, __FUNCTION__": DrawPrimitiveUP\n"));
    19021910        }
    19031911        else
    … …  
    19091917    else
    19101918    {
     1919
     1920#ifdef DEBUG
     1921            for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
     1922            {
     1923                Assert(!pDevice->aStreamSourceUm[i].pvBuffer);
     1924            }
     1925
     1926            uint32_t cStreams = 0;
     1927            for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSource); ++i)
     1928            {
     1929                if (pDevice->aStreamSource[i])
     1930                {
     1931                    ++cStreams;
     1932                    Assert(!pDevice->aStreamSource[i]->LockInfo.cLocks);
     1933                }
     1934            }
     1935
     1936            Assert(cStreams);
     1937            Assert(cStreams == pDevice->cStreamSources);
     1938#endif
    19111939        hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
    19121940                                                pData->VStart,
    19131941                                                pData->PrimitiveCount);
    19141942        Assert(hr == S_OK);
     1943
     1944        vboxVDbgMpPrint((pDevice, __FUNCTION__": DrawPrimitive\n"));
    19151945#if 0
    19161946        IDirect3DVertexDeclaration9* pDecl;
    … …  
    21212151#endif
    21222152    }
     2153
     2154#ifdef DEBUG_misha
     2155    iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
     2156    vboxVDbgDumpSurfData((pDevice, "<<<DrawPrimitive:\n", pDevice->pRenderTargetRc, iBackBuf,
     2157            NULL, (IDirect3DSurface9*)pDevice->pRenderTargetRc->aAllocations[iBackBuf].pD3DIf, "\n"));
     2158#endif
     2159
    21232160    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    21242161    return hr;
    … …  
    21312168    Assert(pDevice);
    21322169    Assert(pDevice->pDevice9If);
     2170#ifdef DEBUG_misha
     2171    uint32_t iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
     2172    vboxVDbgDumpSurfData((pDevice, ">>>DrawIndexedPrimitive:\n", pDevice->pRenderTargetRc, iBackBuf,
     2173            NULL, (IDirect3DSurface9*)pDevice->pRenderTargetRc->aAllocations[iBackBuf].pD3DIf, "\n"));
     2174#endif
     2175
     2176#ifdef DEBUG
     2177            for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
     2178            {
     2179                Assert(!pDevice->aStreamSourceUm[i].pvBuffer);
     2180            }
     2181
     2182            Assert(pDevice->pIndicesAlloc);
     2183            Assert(!pDevice->pIndicesAlloc->LockInfo.cLocks);
     2184
     2185            uint32_t cStreams = 0;
     2186            for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSource); ++i)
     2187            {
     2188                if (pDevice->aStreamSource[i])
     2189                {
     2190                    ++cStreams;
     2191                    Assert(!pDevice->aStreamSource[i]->LockInfo.cLocks);
     2192                }
     2193            }
     2194
     2195            Assert(cStreams);
     2196            Assert(cStreams == pDevice->cStreamSources);
     2197#endif
     2198
    21332199    HRESULT hr = pDevice->pDevice9If->DrawIndexedPrimitive(
    21342200            pData->PrimitiveType,
    … …  
    21392205            pData->PrimitiveCount);
    21402206    Assert(hr == S_OK);
     2207
     2208#ifdef DEBUG_misha
     2209    iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
     2210    vboxVDbgDumpSurfData((pDevice, "<<<DrawIndexedPrimitive:\n", pDevice->pRenderTargetRc, iBackBuf,
     2211            NULL, (IDirect3DSurface9*)pDevice->pRenderTargetRc->aAllocations[iBackBuf].pD3DIf, "\n"));
     2212#endif
     2213
    21412214
    21422215    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    … …  
    21972270    hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
    21982271#else
     2272#ifdef DEBUG_misha
     2273    uint32_t iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
     2274    vboxVDbgDumpSurfData((pDevice, ">>>DrawPrimitive2:\n", pDevice->pRenderTargetRc, iBackBuf,
     2275            NULL, (IDirect3DSurface9*)pDevice->pRenderTargetRc->aAllocations[iBackBuf].pD3DIf, "\n"));
     2276#endif
     2277
     2278#ifdef DEBUG
     2279    uint32_t cStreams = 0;
     2280#endif
     2281
    21992282    int stream;
    22002283    for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
    … …  
    22022285        if (pDevice->aStreamSource[stream])
    22032286        {
     2287#ifdef DEBUG
     2288            ++cStreams;
     2289#endif
    22042290            Assert(stream==0); /*only stream 0 should be accessed here*/
    22052291            Assert(pDevice->StreamSourceInfo[stream].uiStride!=0);
    … …  
    22082294            if (pDevice->aStreamSource[stream]->LockInfo.cLocks)
    22092295            {
     2296                vboxVDbgMpPrint((pDevice, __FUNCTION__": DrawPrimitiveUP\n"));
     2297
    22102298                Assert(pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard || pLock->fFlags.NoOverwrite));
    22112299                hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType, pData->PrimitiveCount,
    … …  
    22142302                Assert(hr == S_OK);
    22152303                hr = pDevice->pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
     2304                Assert(hr == S_OK);
    22162305            }
    22172306            else
    22182307            {
     2308                vboxVDbgMpPrint((pDevice, __FUNCTION__": DrawPrimitive\n"));
     2309
    22192310                hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
    2220             }
    2221         }
    2222     }
     2311                Assert(hr == S_OK);
     2312            }
     2313        }
     2314    }
     2315
     2316#ifdef DEBUG
     2317    Assert(cStreams);
     2318    Assert(cStreams == pDevice->cStreamSources);
     2319#endif
     2320#endif
     2321
     2322#ifdef DEBUG_misha
     2323    iBackBuf = (pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations;
     2324    vboxVDbgDumpSurfData((pDevice, "<<<DrawPrimitive2:\n", pDevice->pRenderTargetRc, iBackBuf,
     2325            NULL, (IDirect3DSurface9*)pDevice->pRenderTargetRc->aAllocations[iBackBuf].pD3DIf, "\n"));
    22232326#endif
    22242327
    … …  
    22602363    PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
    22612364    PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
     2365    /* requirements for D3DDevice9::UpdateTexture */
     2366    Assert(pSrcRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
     2367    Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
    22622368    IDirect3DTexture9 *pD3DIfSrcTex = (IDirect3DTexture9*)pSrcRc->aAllocations[0].pD3DIf;
    22632369    IDirect3DTexture9 *pD3DIfDstTex = (IDirect3DTexture9*)pDstRc->aAllocations[0].pD3DIf;
    … …  
    40894195}
    40904196
    4091 #ifdef DEBUG_misha
    4092 static 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
    4109 
    41104197static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
    41114198{
    … …  
    41184205    Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
    41194206    Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
     4207//    Assert(pSrcRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
     4208    /* @todo: use UpdateRect in case of Src is a D3DDDIPOOL_SYSTEMMEM */
     4209    Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
    41204210    Assert(pDstRc != pDevice->pRenderTargetRc || pDevice->iRenderTargetFrontBuf != pData->DstSubResourceIndex);
    41214211    HRESULT hr = S_OK;
    … …  
    41914281                Assert(pSrcSurfIf);
    41924282
    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
     4283//#ifdef DEBUG_misha
     4284//                vboxVDbgDumpSurfData((pDevice, "Blt-pre Src:\n", pSrcRc, pData->SrcSubResourceIndex, &pData->SrcRect, pSrcSurfIf, "\n"));
     4285//                vboxVDbgDumpSurfData((pDevice, "Blt-pre Dst:\n", pDstRc, pData->DstSubResourceIndex, &pData->DstRect, pDstSurfIf, "\n"));
     4286//#endif
    42354287                /* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
    42364288                Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001  | 0x00000002))) == 0);
    … …  
    42424294                Assert(hr == S_OK);
    42434295
    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
     4296//#ifdef DEBUG_misha
     4297//                vboxVDbgDumpSurfData((pDevice, "Blt-post Src:\n", pSrcRc, pData->SrcSubResourceIndex, &pData->SrcRect, pSrcSurfIf, "\n"));
     4298//                vboxVDbgDumpSurfData((pDevice, "Blt-post Dst:\n", pDstRc, pData->DstSubResourceIndex, &pData->DstRect, pDstSurfIf, "\n"));
     4299//#endif
    42864300                pSrcSurfIf->Release();
    42874301            }
    … …  
    44564470    Assert(pRc);
    44574471    Assert(pData->SubResourceIndex < pRc->cAllocations);
     4472    Assert(pRc == pDevice->pRenderTargetRc);
     4473    if (pRc == pDevice->pRenderTargetRc)
     4474    {
     4475        /* backbuffer */
     4476        Assert(pData->SubResourceIndex == ((pDevice->iRenderTargetFrontBuf + 1) % pDevice->pRenderTargetRc->cAllocations));
     4477    }
     4478
    44584479    HRESULT hr = S_OK;
    44594480    IDirect3DSurface9 *pD3D9Surf;
    … …  
    53455366
    53465367#ifdef VBOXWDDMDISP_DEBUG
     5368VOID vboxVDbgDoDumpSurfData(const PVBOXWDDMDISP_DEVICE pDevice, const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const RECT *pRect, IDirect3DSurface9 *pSurf, const char* pSuffix)
     5369{
     5370    if (pPrefix)
     5371    {
     5372        vboxVDbgMpPrint((pDevice, "%s", pPrefix));
     5373    }
     5374
     5375    Assert(pRc->cAllocations > iAlloc);
     5376    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[iAlloc];
     5377
     5378    vboxVDbgMpPrintAlloc((pDevice, "allocation info:\n", pRc, iAlloc, "\n"));
     5379
     5380    D3DLOCKED_RECT Lr;
     5381    if (pRect)
     5382    {
     5383        Assert(pRect->right > pRect->left);
     5384        Assert(pRect->bottom > pRect->top);
     5385        vboxVDbgMpPrintRect((pDevice, "rect: ", pRect, "\n"));
     5386    }
     5387    HRESULT srcHr = pSurf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
     5388    Assert(srcHr == S_OK);
     5389    if (srcHr == S_OK)
     5390    {
     5391        UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
     5392//        Assert(bpp == pAlloc->SurfDesc.bpp);
     5393//        Assert(pAlloc->SurfDesc.pitch == Lr.Pitch);
     5394        vboxVDbgMpPrint((pDevice, "<?dml?><exec cmd=\"!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d\">surface info</exec>\n",
     5395                Lr.pBits, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, bpp, Lr.Pitch));
     5396        if (pRect)
     5397        {
     5398            vboxVDbgMpPrint((pDevice, "<?dml?><exec cmd=\"!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d\">rect info</exec>\n",
     5399                    ((uint8_t*)Lr.pBits) + (pRect->top * Lr.Pitch) + ((pRect->left * bpp) >> 3),
     5400                    pRect->right - pRect->left, pRect->bottom - pRect->top, bpp, Lr.Pitch));
     5401        }
     5402        Assert(0);
     5403
     5404        srcHr = pSurf->UnlockRect();
     5405        Assert(srcHr == S_OK);
     5406    }
     5407    if (pSuffix)
     5408    {
     5409        vboxVDbgMpPrint((pDevice, "%s\n", pSuffix));
     5410    }
     5411}
     5412
     5413void vboxVDbgDoMpPrintAlloc(const PVBOXWDDMDISP_DEVICE pDevice, const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char * pSuffix)
     5414{
     5415    Assert(pRc->cAllocations > iAlloc);
     5416    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[iAlloc];
     5417    vboxVDbgDoMpPrintF(pDevice, "%s width(%d), height(%d), format(%d), usage(%s), %s", pPrefix,
     5418            pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format,
     5419            pRc == pDevice->pRenderTargetRc ?
     5420                    (iAlloc == pDevice->iRenderTargetFrontBuf ? "Front Buffer" : "Back Buffer")
     5421                    : "?Everage? Alloc",
     5422            pSuffix);
     5423}
     5424
     5425void vboxVDbgDoMpPrintRect(const PVBOXWDDMDISP_DEVICE pDevice, const char * pPrefix, const RECT *pRect, const char * pSuffix)
     5426{
     5427    vboxVDbgDoMpPrintF(pDevice, "%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix);
     5428}
     5429
     5430VOID vboxVDbgDoMpPrint(const PVBOXWDDMDISP_DEVICE pDevice, LPCSTR szString)
     5431{
     5432    uint32_t cbString = strlen(szString) + 1;
     5433    uint32_t cbCmd = RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[cbString]);
     5434    PVBOXDISPIFESCAPE_DBGPRINT pCmd = (PVBOXDISPIFESCAPE_DBGPRINT)RTMemAllocZ(cbCmd);
     5435    Assert(pCmd);
     5436    if (pCmd)
     5437    {
     5438        pCmd->EscapeHdr.escapeCode = VBOXESC_DBGPRINT;
     5439        memcpy(pCmd->aStringBuf, szString, cbString);
     5440
     5441        D3DDDICB_ESCAPE DdiEscape = {0};
     5442        DdiEscape.hContext = NULL;
     5443        DdiEscape.hDevice = NULL;
     5444        DdiEscape.Flags.Value = 0;
     5445        DdiEscape.pPrivateDriverData = pCmd;
     5446        DdiEscape.PrivateDriverDataSize = cbCmd;
     5447
     5448        HRESULT hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
     5449        Assert(hr == S_OK);
     5450
     5451        RTMemFree(pCmd);
     5452    }
     5453}
     5454VOID vboxVDbgDoMpPrintF(const PVBOXWDDMDISP_DEVICE pDevice, LPCSTR szString, ...)
     5455{
     5456    char szBuffer[4096] = {0};
     5457    va_list pArgList;
     5458    va_start(pArgList, szString);
     5459    _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
     5460    va_end(pArgList);
     5461
     5462    if (pDevice)
     5463    {
     5464        vboxVDbgDoMpPrint(pDevice, szBuffer);
     5465    }
     5466    else
     5467    {
     5468        OutputDebugStringA(szBuffer);
     5469    }
     5470}
    53475471VOID vboxVDbgDoPrint(LPCSTR szString, ...)
    53485472{

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

    r30855 r30865  
    5656
    5757#ifdef VBOXWDDMDISP_DEBUG
     58VOID vboxVDbgDoDumpSurfData(const PVBOXWDDMDISP_DEVICE pDevice, const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const RECT *pRect, IDirect3DSurface9 *pSurf, const char* pSuffix);
     59void vboxVDbgDoMpPrintRect(const PVBOXWDDMDISP_DEVICE pDevice, const char * pPrefix, const RECT *pRect, const char * pSuffix);
     60void vboxVDbgDoMpPrintAlloc(const PVBOXWDDMDISP_DEVICE pDevice, const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char * pSuffix);
    5861VOID vboxVDbgDoPrint(LPCSTR szString, ...);
     62VOID vboxVDbgDoMpPrintF(const PVBOXWDDMDISP_DEVICE pDevice, LPCSTR szString, ...);
    5963void vboxVDbgVEHandlerRegister();
    6064void vboxVDbgVEHandlerUnregister();
    … …  
    6670    } while (0)
    6771#define vboxVDbgPrintR vboxVDbgPrint
     72#define vboxVDbgMpPrint(_m) \
     73    do { \
     74        vboxVDbgDoMpPrintF _m ; \
     75    } while (0)
     76#define vboxVDbgMpPrintRect(_m) \
     77    do { \
     78        vboxVDbgDoMpPrintRect _m ; \
     79    } while (0)
     80#define vboxVDbgMpPrintAlloc(_m) \
     81    do { \
     82        vboxVDbgDoMpPrintAlloc _m ; \
     83    } while (0)
     84#define vboxVDbgDumpSurfData(_m) \
     85    do { \
     86        vboxVDbgDoDumpSurfData _m ; \
     87    } while (0)
    6888#ifdef VBOXWDDMDISP_DEBUG_FLOW
    6989# define vboxVDbgPrintF  vboxVDbgPrint
    … …  
    7292#endif
    7393#else
     94#define vboxVDbgMpPrint(_m) do {} while (0)
     95#define vboxVDbgMpPrintRect(_m) do {} while (0)
     96#define vboxVDbgMpPrintAlloc(_m) do {} while (0)
     97#define vboxVDbgDumpSurfData(_m) do {} while (0)
    7498#define vboxVDbgBreak() do {} while (0)
    7599#define vboxVDbgPrint(_m)  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