Changeset 43236 in vbox
- Timestamp:
- Sep 7, 2012 9:32:42 AM (12 years ago)
- Location:
- trunk/src/VBox/Additions/WINNT/Graphics/Video
- Files:
-
- 2 added
- 7 edited
-
common/wddm/VBoxMPIf.h (modified) (1 diff)
-
disp/Makefile.kmk (modified) (1 diff)
-
disp/wddm/VBoxD3DIf.cpp (added)
-
disp/wddm/VBoxD3DIf.h (added)
-
disp/wddm/VBoxDispD3D.cpp (modified) (40 diffs)
-
disp/wddm/VBoxDispD3D.h (modified) (1 diff)
-
disp/wddm/VBoxDispD3DCmn.h (modified) (1 diff)
-
disp/wddm/VBoxDispDbg.cpp (modified) (7 diffs)
-
disp/wddm/VBoxDispDbg.h (modified) (5 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h
r41058 r43236 574 574 return 8; 575 575 case D3DDDIFMT_INDEX32: 576 #ifdef DEBUG_misha577 Assert(0); /* <- test correctness */578 #endif579 576 return 8; 580 577 default: -
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk
r42501 r43236 118 118 wddm/VBoxDispKmt.cpp \ 119 119 wddm/VBoxDispDbg.cpp \ 120 wddm/VBoxD3DIf.cpp \ 120 121 wddm/VBoxDispD3D.rc \ 121 122 wddm/VBoxDispD3D.def -
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp
r42971 r43236 449 449 } 450 450 451 static void vboxResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs)451 void vboxWddmResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs) 452 452 { 453 453 memset(pRc, 0, RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs])); … … 466 466 if (pRc) 467 467 { 468 vbox ResourceInit(pRc, cAllocs);468 vboxWddmResourceInit(pRc, cAllocs); 469 469 return pRc; 470 470 } 471 471 return NULL; 472 }473 474 static void vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo)475 {476 Assert(pAlloc->SurfDesc.pitch);477 Assert(pAlloc->pvMem);478 479 if (!pRect)480 {481 if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch)482 {483 Assert(pAlloc->SurfDesc.cbSize);484 if (bToLockInfo)485 memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.cbSize);486 else487 memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.cbSize);488 }489 else490 {491 uint8_t *pvSrc, *pvDst;492 uint32_t srcPitch, dstPitch;493 if (bToLockInfo)494 {495 pvSrc = (uint8_t *)pAlloc->pvMem;496 pvDst = (uint8_t *)pLockInfo->pBits;497 srcPitch = pAlloc->SurfDesc.pitch;498 dstPitch = pLockInfo->Pitch;499 }500 else501 {502 pvDst = (uint8_t *)pAlloc->pvMem;503 pvSrc = (uint8_t *)pLockInfo->pBits;504 dstPitch = pAlloc->SurfDesc.pitch;505 srcPitch = (uint32_t)pLockInfo->Pitch;506 }507 508 uint32_t cRows = vboxWddmCalcNumRows(0, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format);509 uint32_t pitch = RT_MIN(srcPitch, dstPitch);510 Assert(pitch);511 for (UINT j = 0; j < cRows; ++j)512 {513 memcpy(pvDst, pvSrc, pitch);514 pvSrc += srcPitch;515 pvDst += dstPitch;516 }517 }518 }519 else520 {521 uint8_t *pvSrc, *pvDst;522 uint32_t srcPitch, dstPitch;523 uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem;524 uint32_t offAllocMemStart = vboxWddmCalcOffXYrd(pRect->left, pRect->top, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format);525 pvAllocMemStart += offAllocMemStart;526 527 if (bToLockInfo)528 {529 pvSrc = (uint8_t *)pvAllocMemStart;530 pvDst = (uint8_t *)pLockInfo->pBits;531 srcPitch = pAlloc->SurfDesc.pitch;532 dstPitch = pLockInfo->Pitch;533 }534 else535 {536 pvDst = (uint8_t *)pvAllocMemStart;537 pvSrc = (uint8_t *)pLockInfo->pBits;538 dstPitch = pAlloc->SurfDesc.pitch;539 srcPitch = (uint32_t)pLockInfo->Pitch;540 }541 542 if (pRect->right - pRect->left == pAlloc->SurfDesc.width && srcPitch == dstPitch)543 {544 uint32_t cbSize = vboxWddmCalcSize(pAlloc->SurfDesc.pitch, pRect->bottom - pRect->top, pAlloc->SurfDesc.format);545 memcpy(pvDst, pvSrc, cbSize);546 }547 else548 {549 uint32_t pitch = RT_MIN(srcPitch, dstPitch);550 uint32_t cbCopyLine = vboxWddmCalcRowSize(pRect->left, pRect->right, pAlloc->SurfDesc.format);551 Assert(pitch);552 uint32_t cRows = vboxWddmCalcNumRows(pRect->top, pRect->bottom, pAlloc->SurfDesc.format);553 for (UINT j = 0; j < cRows; ++j)554 {555 memcpy(pvDst, pvSrc, cbCopyLine);556 pvSrc += srcPitch;557 pvDst += dstPitch;558 }559 }560 }561 }562 563 HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,564 D3DLOCKED_RECT * pLockedRect,565 CONST RECT *pRect,566 DWORD fLockFlags)567 {568 HRESULT hr = E_FAIL;569 Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks);570 Assert(pRc->cAllocations > iAlloc);571 switch (pRc->aAllocations[0].enmD3DIfType)572 {573 case VBOXDISP_D3DIFTYPE_SURFACE:574 {575 IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;576 Assert(pD3DIfSurf);577 hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);578 Assert(hr == S_OK);579 break;580 }581 case VBOXDISP_D3DIFTYPE_TEXTURE:582 {583 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;584 Assert(pD3DIfTex);585 hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);586 Assert(hr == S_OK);587 break;588 }589 case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:590 {591 IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;592 Assert(pD3DIfCubeTex);593 hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),594 VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), pLockedRect, pRect, fLockFlags);595 Assert(hr == S_OK);596 break;597 }598 case VBOXDISP_D3DIFTYPE_VERTEXBUFFER:599 {600 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;601 Assert(pD3D9VBuf);602 hr = pD3D9VBuf->Lock(pRect ? pRect->left : 0/* offset */,603 pRect ? pRect->right : 0 /* size 2 lock - 0 means all */,604 &pLockedRect->pBits, fLockFlags);605 Assert(hr == S_OK);606 pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch;607 break;608 }609 case VBOXDISP_D3DIFTYPE_INDEXBUFFER:610 {611 IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;612 Assert(pD3D9IBuf);613 hr = pD3D9IBuf->Lock(pRect ? pRect->left : 0/* offset */,614 pRect ? pRect->right : 0 /* size 2 lock - 0 means all */,615 &pLockedRect->pBits, fLockFlags);616 Assert(hr == S_OK);617 pLockedRect->Pitch = pRc->aAllocations[iAlloc].SurfDesc.pitch;618 break;619 }620 default:621 Assert(0);622 break;623 }624 return hr;625 }626 627 HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)628 {629 HRESULT hr = S_OK;630 Assert(pRc->cAllocations > iAlloc);631 switch (pRc->aAllocations[0].enmD3DIfType)632 {633 case VBOXDISP_D3DIFTYPE_SURFACE:634 {635 IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;636 Assert(pD3DIfSurf);637 hr = pD3DIfSurf->UnlockRect();638 Assert(hr == S_OK);639 break;640 }641 case VBOXDISP_D3DIFTYPE_TEXTURE:642 {643 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;644 Assert(pD3DIfTex);645 hr = pD3DIfTex->UnlockRect(iAlloc);646 Assert(hr == S_OK);647 break;648 }649 case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:650 {651 IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;652 Assert(pD3DIfCubeTex);653 hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc),654 VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc));655 Assert(hr == S_OK);656 break;657 }658 case VBOXDISP_D3DIFTYPE_VERTEXBUFFER:659 {660 IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;661 Assert(pD3D9VBuf);662 hr = pD3D9VBuf->Unlock();663 Assert(hr == S_OK);664 break;665 }666 case VBOXDISP_D3DIFTYPE_INDEXBUFFER:667 {668 IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pRc->aAllocations[iAlloc].pD3DIf;669 Assert(pD3D9IBuf);670 hr = pD3D9IBuf->Unlock();671 Assert(hr == S_OK);672 break;673 }674 default:675 Assert(0);676 hr = E_FAIL;677 break;678 }679 return hr;680 }681 682 static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc)683 {684 if (pRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM)685 {686 return S_OK;687 }688 689 for (UINT i = 0; i < pRc->cAllocations; ++i)690 {691 D3DLOCKED_RECT Rect;692 HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_DISCARD);693 if (FAILED(hr))694 {695 WARN(("vboxWddmLockRect failed, hr(0x%x)", hr));696 return hr;697 }698 699 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];700 Assert(pAlloc->pvMem);701 702 vboxWddmLockUnlockMemSynch(pAlloc, &Rect, NULL, true /*bool bToLockInfo*/);703 704 hr = vboxWddmUnlockRect(pRc, i);705 Assert(SUCCEEDED(hr));706 }707 return S_OK;708 472 } 709 473 … … 764 528 { 765 529 D3DLOCKED_RECT Rect; 766 HRESULT hr = vboxWddmLockRect(pRc, i, &Rect, NULL, D3DLOCK_READONLY);530 HRESULT hr = VBoxD3DIfLockRect(pRc, i, &Rect, NULL, D3DLOCK_READONLY); 767 531 if (FAILED(hr)) 768 532 { 769 WARN((" vboxWddmLockRect failed, hr(0x%x)", hr));533 WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); 770 534 return; 771 535 } … … 776 540 vboxWddmDbgSynchMemCheck(pAlloc, &Rect); 777 541 778 hr = vboxWddmUnlockRect(pRc, i);542 hr = VBoxD3DIfUnlockRect(pRc, i); 779 543 Assert(SUCCEEDED(hr)); 780 544 } … … 782 546 #endif 783 547 784 785 static D3DFORMAT vboxDDI2D3DFormat(D3DDDIFORMAT format)786 {787 /* @todo: check they are all equal */788 return (D3DFORMAT)format;789 }790 791 D3DMULTISAMPLE_TYPE vboxDDI2D3DMultiSampleType(D3DDDIMULTISAMPLE_TYPE enmType)792 {793 /* @todo: check they are all equal */794 return (D3DMULTISAMPLE_TYPE)enmType;795 }796 797 D3DPOOL vboxDDI2D3DPool(D3DDDI_POOL enmPool)798 {799 /* @todo: check they are all equal */800 switch (enmPool)801 {802 case D3DDDIPOOL_SYSTEMMEM:803 return D3DPOOL_SYSTEMMEM;804 case D3DDDIPOOL_VIDEOMEMORY:805 case D3DDDIPOOL_LOCALVIDMEM:806 case D3DDDIPOOL_NONLOCALVIDMEM:807 /* @todo: what would be proper here? */808 return D3DPOOL_DEFAULT;809 default:810 Assert(0);811 }812 return D3DPOOL_DEFAULT;813 }814 815 D3DRENDERSTATETYPE vboxDDI2D3DRenderStateType(D3DDDIRENDERSTATETYPE enmType)816 {817 /* @todo: @fixme: not entirely correct, need to check */818 return (D3DRENDERSTATETYPE)enmType;819 }820 821 VBOXWDDMDISP_TSS_LOOKUP vboxDDI2D3DTestureStageStateType(D3DDDITEXTURESTAGESTATETYPE enmType)822 {823 static const VBOXWDDMDISP_TSS_LOOKUP lookup[] =824 {825 {FALSE, D3DTSS_FORCE_DWORD}, /* 0, D3DDDITSS_TEXTUREMAP */826 {FALSE, D3DTSS_COLOROP}, /* 1, D3DDDITSS_COLOROP */827 {FALSE, D3DTSS_COLORARG1}, /* 2, D3DDDITSS_COLORARG1 */828 {FALSE, D3DTSS_COLORARG2}, /* 3, D3DDDITSS_COLORARG2 */829 {FALSE, D3DTSS_ALPHAOP}, /* 4, D3DDDITSS_ALPHAOP */830 {FALSE, D3DTSS_ALPHAARG1}, /* 5, D3DDDITSS_ALPHAARG1 */831 {FALSE, D3DTSS_ALPHAARG2}, /* 6, D3DDDITSS_ALPHAARG2 */832 {FALSE, D3DTSS_BUMPENVMAT00}, /* 7, D3DDDITSS_BUMPENVMAT00 */833 {FALSE, D3DTSS_BUMPENVMAT01}, /* 8, D3DDDITSS_BUMPENVMAT01 */834 {FALSE, D3DTSS_BUMPENVMAT10}, /* 9, D3DDDITSS_BUMPENVMAT10 */835 {FALSE, D3DTSS_BUMPENVMAT11}, /* 10, D3DDDITSS_BUMPENVMAT11 */836 {FALSE, D3DTSS_TEXCOORDINDEX}, /* 11, D3DDDITSS_TEXCOORDINDEX */837 {FALSE, D3DTSS_FORCE_DWORD}, /* 12, unused */838 {TRUE, D3DSAMP_ADDRESSU}, /* 13, D3DDDITSS_ADDRESSU */839 {TRUE, D3DSAMP_ADDRESSV}, /* 14, D3DDDITSS_ADDRESSV */840 {TRUE, D3DSAMP_BORDERCOLOR}, /* 15, D3DDDITSS_BORDERCOLOR */841 {TRUE, D3DSAMP_MAGFILTER}, /* 16, D3DDDITSS_MAGFILTER */842 {TRUE, D3DSAMP_MINFILTER}, /* 17, D3DDDITSS_MINFILTER */843 {TRUE, D3DSAMP_MIPFILTER}, /* 18, D3DDDITSS_MIPFILTER */844 {TRUE, D3DSAMP_MIPMAPLODBIAS}, /* 19, D3DDDITSS_MIPMAPLODBIAS */845 {TRUE, D3DSAMP_MAXMIPLEVEL}, /* 20, D3DDDITSS_MAXMIPLEVEL */846 {TRUE, D3DSAMP_MAXANISOTROPY}, /* 21, D3DDDITSS_MAXANISOTROPY */847 {FALSE, D3DTSS_BUMPENVLSCALE}, /* 22, D3DDDITSS_BUMPENVLSCALE */848 {FALSE, D3DTSS_BUMPENVLOFFSET}, /* 23, D3DDDITSS_BUMPENVLOFFSET */849 {FALSE, D3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DDDITSS_TEXTURETRANSFORMFLAGS */850 {TRUE, D3DSAMP_ADDRESSW}, /* 25, D3DDDITSS_ADDRESSW */851 {FALSE, D3DTSS_COLORARG0}, /* 26, D3DDDITSS_COLORARG0 */852 {FALSE, D3DTSS_ALPHAARG0}, /* 27, D3DDDITSS_ALPHAARG0 */853 {FALSE, D3DTSS_RESULTARG}, /* 28, D3DDDITSS_RESULTARG */854 {TRUE, D3DSAMP_SRGBTEXTURE}, /* 29, D3DDDITSS_SRGBTEXTURE */855 {TRUE, D3DSAMP_ELEMENTINDEX}, /* 30, D3DDDITSS_ELEMENTINDEX */856 {TRUE, D3DSAMP_DMAPOFFSET}, /* 31, D3DDDITSS_DMAPOFFSET */857 {FALSE, D3DTSS_CONSTANT}, /* 32, D3DDDITSS_CONSTANT */858 {FALSE, D3DTSS_FORCE_DWORD}, /* 33, D3DDDITSS_DISABLETEXTURECOLORKEY */859 {FALSE, D3DTSS_FORCE_DWORD}, /* 34, D3DDDITSS_TEXTURECOLORKEYVAL */860 };861 862 Assert(enmType > 0);863 Assert(enmType < RT_ELEMENTS(lookup));864 Assert(lookup[enmType].dType != D3DTSS_FORCE_DWORD);865 866 return lookup[enmType];867 }868 869 DWORD vboxDDI2D3DUsage(D3DDDI_RESOURCEFLAGS fFlags)870 {871 DWORD fUsage = 0;872 if (fFlags.Dynamic)873 fUsage |= D3DUSAGE_DYNAMIC;874 if (fFlags.AutogenMipmap)875 fUsage |= D3DUSAGE_AUTOGENMIPMAP;876 if (fFlags.DMap)877 fUsage |= D3DUSAGE_DMAP;878 if (fFlags.WriteOnly)879 fUsage |= D3DUSAGE_WRITEONLY;880 if (fFlags.NPatches)881 fUsage |= D3DUSAGE_NPATCHES;882 if (fFlags.Points)883 fUsage |= D3DUSAGE_POINTS;884 if (fFlags.RenderTarget)885 fUsage |= D3DUSAGE_RENDERTARGET;886 if (fFlags.RtPatches)887 fUsage |= D3DUSAGE_RTPATCHES;888 if (fFlags.TextApi)889 fUsage |= D3DUSAGE_TEXTAPI;890 if (fFlags.WriteOnly)891 fUsage |= D3DUSAGE_WRITEONLY;892 //below are wddm 1.1-specific893 // if (fFlags.RestrictedContent)894 // fUsage |= D3DUSAGE_RESTRICTED_CONTENT;895 // if (fFlags.RestrictSharedAccess)896 // fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE;897 return fUsage;898 }899 900 DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags)901 {902 DWORD fFlags = 0;903 if (fLockFlags.Discard)904 fFlags |= D3DLOCK_DISCARD;905 if (fLockFlags.NoOverwrite)906 fFlags |= D3DLOCK_NOOVERWRITE;907 if (fLockFlags.ReadOnly)908 fFlags |= D3DLOCK_READONLY;909 if (fLockFlags.DoNotWait)910 fFlags |= D3DLOCK_DONOTWAIT;911 return fFlags;912 }913 914 D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags)915 {916 if (fFlags.Point)917 {918 /* no flags other than [Begin|Continue|End]PresentToDwm are set */919 Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 1);920 return D3DTEXF_POINT;921 }922 if (fFlags.Linear)923 {924 /* no flags other than [Begin|Continue|End]PresentToDwm are set */925 Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 2);926 return D3DTEXF_LINEAR;927 }928 /* no flags other than [Begin|Continue|End]PresentToDwm are set */929 Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 0);930 return D3DTEXF_NONE;931 }932 933 static D3DQUERYTYPE vboxDDI2D3DQueryType(D3DDDIQUERYTYPE enmType)934 {935 return (D3DQUERYTYPE)enmType;936 }937 938 static DWORD vboxDDI2D3DIssueQueryFlags(D3DDDI_ISSUEQUERYFLAGS Flags)939 {940 DWORD fFlags = 0;941 if (Flags.Begin)942 fFlags |= D3DISSUE_BEGIN;943 if (Flags.End)944 fFlags |= D3DISSUE_END;945 return fFlags;946 }947 548 948 549 /******/ … … 1056 657 } 1057 658 1058 staticVOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)659 VOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain) 1059 660 { 1060 661 vboxWddmSwapchainClear(pDevice, pSwapchain); … … 1202 803 } 1203 804 1204 staticPVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent)805 PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent) 1205 806 { 1206 807 PVBOXWDDMDISP_SWAPCHAIN pSwapchain = pBbAlloc->pSwapchain; … … 1243 844 * thus the aRTs[0] is a backbuffer */ 1244 845 { 1245 PVBOXWDDMDISP_RESOURCE pBbRc = pBbAlloc->pRc;1246 PVBOXWDDMDISP_RESOURCE pRtRc = pRt->pAlloc->pRc;1247 846 if (pBbAlloc->SurfDesc.width == pRt->pAlloc->SurfDesc.width 1248 847 && pBbAlloc->SurfDesc.height == pRt->pAlloc->SurfDesc.height 1249 && pBbAlloc->SurfDesc.format == pRt->pAlloc->SurfDesc.format848 && vboxWddmFmtNoAlphaFormat(pBbAlloc->SurfDesc.format) == vboxWddmFmtNoAlphaFormat(pRt->pAlloc->SurfDesc.format) 1250 849 && pBbAlloc->SurfDesc.VidPnSourceId == pRt->pAlloc->SurfDesc.VidPnSourceId 1251 850 ) … … 1329 928 if (pAlloc->pD3DIf) 1330 929 { 1331 /* since this can be texture, need to do the vboxWddmSurfGet magic */1332 hr = vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9OldSurf);930 /* since this can be texture, need to do the VBoxD3DIfSurfGet magic */ 931 hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9OldSurf); 1333 932 if (FAILED(hr)) 1334 933 { 1335 WARN((" vboxWddmSurfGet failed, hr (0x%x)",hr));934 WARN(("VBoxD3DIfSurfGet failed, hr (0x%x)",hr)); 1336 935 pD3D9Surf->Release(); 1337 936 return hr; … … 1457 1056 } 1458 1057 1459 static VOID vboxWddmFillPresentParams(D3DPRESENT_PARAMETERS *pParams, PVBOXWDDMDISP_RESOURCE pRc, UINT cRTs)1460 {1461 Assert(cRTs);1462 memset(pParams, 0, sizeof (D3DPRESENT_PARAMETERS));1463 pParams->BackBufferWidth = pRc->aAllocations[0].SurfDesc.width;1464 pParams->BackBufferHeight = pRc->aAllocations[0].SurfDesc.height;1465 pParams->BackBufferFormat = vboxDDI2D3DFormat(pRc->aAllocations[0].SurfDesc.format);1466 pParams->BackBufferCount = cRTs - 1;1467 pParams->MultiSampleType = vboxDDI2D3DMultiSampleType(pRc->RcDesc.enmMultisampleType);1468 pParams->MultiSampleQuality = pRc->RcDesc.MultisampleQuality;1469 #if 0 //def VBOXDISP_WITH_WINE_BB_WORKAROUND /* this does not work so far any way :( */1470 if (cRTs == 1)1471 pParams->SwapEffect = D3DSWAPEFFECT_COPY;1472 else1473 #endif1474 if (pRc->RcDesc.fFlags.DiscardRenderTarget)1475 pParams->SwapEffect = D3DSWAPEFFECT_DISCARD;1476 pParams->Windowed = TRUE;1477 }1478 1479 1058 static VOID vboxWddmSwapchainFillPresentParams(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, D3DPRESENT_PARAMETERS *pParams) 1480 1059 { … … 1486 1065 PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainGetBb(pSwapchain); 1487 1066 PVBOXWDDMDISP_RESOURCE pRc = pRt->pAlloc->pRc; 1488 vboxWddmFillPresentParams(pParams, pRc, pSwapchain->cRTs);1067 VBoxD3DIfFillPresentParams(pParams, pRc, pSwapchain->cRTs); 1489 1068 } 1490 1069 … … 1525 1104 { 1526 1105 VOID *pvSwapchain = NULL; 1527 /* since this can be texture, need to do the vboxWddmSurfGet magic */1528 hr = vboxWddmSurfGet(pRT->pAlloc->pRc, pRT->pAlloc->iAlloc, &pD3D9OldSurf);1106 /* since this can be texture, need to do the VBoxD3DIfSurfGet magic */ 1107 hr = VBoxD3DIfSurfGet(pRT->pAlloc->pRc, pRT->pAlloc->iAlloc, &pD3D9OldSurf); 1529 1108 Assert(hr == S_OK); 1530 1109 hr = pD3D9OldSurf->GetContainer(IID_IDirect3DSwapChain9, &pvSwapchain); … … 1643 1222 } 1644 1223 1645 staticHRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)1224 HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain) 1646 1225 { 1647 1226 if (!pSwapchain->fFlags.bChanged && pSwapchain->pSwapChainIf) … … 1664 1243 for (UINT i = 0; i < pSwapchain->cRTs; ++i) 1665 1244 { 1666 if (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_SURFACE) 1245 if (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_SURFACE 1246 && (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_UNDEFINED 1247 || pSwapchain->aRTs[i].pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE 1248 )) 1667 1249 { 1668 1250 fNeedRtPresentSwitch = TRUE; … … 1945 1527 1946 1528 /* if this is not a front-buffer - just return the surface associated with the allocation */ 1947 return vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, ppSurf);1529 return VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, ppSurf); 1948 1530 } 1949 1531 … … 2132 1714 #endif 2133 1715 2134 static HRESULT vboxWddmD3DDeviceCreateDummy(PVBOXWDDMDISP_DEVICE pDevice)2135 {2136 VBOXWDDMDISP_RESOURCE Rc;2137 vboxResourceInit(&Rc, 1);2138 2139 Rc.RcDesc.enmFormat = D3DDDIFMT_A8R8G8B8;2140 Rc.RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;2141 Rc.RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;2142 Rc.RcDesc.MultisampleQuality = 0;2143 PVBOXWDDMDISP_ALLOCATION pAlloc = &Rc.aAllocations[0];2144 pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;2145 pAlloc->SurfDesc.width = 0x4;2146 pAlloc->SurfDesc.height = 0x4;2147 pAlloc->SurfDesc.format = D3DDDIFMT_A8R8G8B8;2148 Assert(!pDevice->pDevice9If);2149 VBOXWINEEX_D3DPRESENT_PARAMETERS Params;2150 vboxWddmFillPresentParams(&Params.Base, &Rc, 2);2151 Params.pHgsmi = &pDevice->Uhgsmi.BasePrivate.Base;2152 DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;2153 PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;2154 IDirect3DDevice9 * pDevice9If = NULL;2155 2156 HRESULT hr = pAdapter->D3D.pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, fFlags, &Params.Base, &pDevice9If);2157 if (!SUCCEEDED(hr))2158 {2159 WARN(("CreateDevice failed hr 0x%x", hr));2160 return hr;2161 }2162 2163 pDevice->pDevice9If = pDevice9If;2164 return S_OK;2165 }2166 2167 DECLINLINE(IDirect3DDevice9*) vboxWddmD3DDeviceGet(PVBOXWDDMDISP_DEVICE pDevice)2168 {2169 if (pDevice->pDevice9If)2170 return pDevice->pDevice9If;2171 2172 #ifdef VBOXWDDMDISP_DEBUG2173 g_VBoxVDbgInternalDevice = pDevice;2174 #endif2175 2176 HRESULT hr = vboxWddmD3DDeviceCreateDummy(pDevice);2177 Assert(hr == S_OK);2178 Assert(pDevice->pDevice9If);2179 return pDevice->pDevice9If;2180 }2181 2182 1716 /******/ 2183 1717 … … 2199 1733 else 2200 1734 { 2201 hr = vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf);1735 hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf); 2202 1736 if (FAILED(hr)) 2203 1737 { 2204 WARN((" vboxWddmSurfGet failed, hr(0x%x)",hr));1738 WARN(("VBoxD3DIfSurfGet failed, hr(0x%x)",hr)); 2205 1739 return hr; 2206 1740 } … … 3021 2555 r.right = pLock->Range.Offset + pLock->Range.Size; 3022 2556 3023 vboxWddmLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/);2557 VBoxD3DIfLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/); 3024 2558 3025 2559 pD3D9VBuf->Unlock(); … … 3172 2706 IDirect3DSurface9 *pSrcSurfIf = NULL; 3173 2707 IDirect3DSurface9 *pDstSurfIf = NULL; 3174 hr = vboxWddmSurfGet(pDstRc, 0, &pDstSurfIf);2708 hr = VBoxD3DIfSurfGet(pDstRc, 0, &pDstSurfIf); 3175 2709 Assert(hr == S_OK); 3176 2710 if (hr == S_OK) 3177 2711 { 3178 hr = vboxWddmSurfGet(pSrcRc, 0, &pSrcSurfIf);2712 hr = VBoxD3DIfSurfGet(pSrcRc, 0, &pSrcSurfIf); 3179 2713 Assert(hr == S_OK); 3180 2714 if (hr == S_OK) … … 3702 3236 else 3703 3237 pr = NULL; 3704 vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/);3238 VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/); 3705 3239 } 3706 3240 } … … 3796 3330 else 3797 3331 pr = NULL; 3798 vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/);3332 VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/); 3799 3333 } 3800 3334 } … … 3983 3517 else 3984 3518 pr = NULL; 3985 vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,3519 VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, 3986 3520 pr, 3987 3521 true /*bool bToLockInfo*/); … … 4024 3558 else 4025 3559 pr = NULL; 4026 vboxWddmLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,3560 VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, 4027 3561 pr, 4028 3562 true /*bool bToLockInfo*/); … … 4077 3611 LRect.Pitch = ((pAlloc->SurfDesc.bpp * pAlloc->SurfDesc.width) + 7) >> 3; 4078 3612 Assert(pAlloc->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_VALID); 4079 vboxWddmLockUnlockMemSynch(pAlloc, &LRect, &pAlloc->DirtyRegion.Rect, TRUE /* bool bToLockInfo*/);3613 VBoxD3DIfLockUnlockMemSynch(pAlloc, &LRect, &pAlloc->DirtyRegion.Rect, TRUE /* bool bToLockInfo*/); 4080 3614 vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion); 4081 3615 fDoUnlock = TRUE; … … 4213 3747 } 4214 3748 bool bIssueCreateResource = false; 4215 bool bCreateSwapchain = false;4216 3749 bool bCreateKMResource = false; 4217 3750 … … 4264 3797 if (VBOXDISPMODE_IS_3D(pAdapter)) 4265 3798 { 4266 if (pR esource->Flags.SharedResource)3799 if (pRc->RcDesc.fFlags.SharedResource) 4267 3800 { 4268 3801 bIssueCreateResource = true; … … 4270 3803 } 4271 3804 4272 if (pResource->Flags.ZBuffer) 4273 { 4274 IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); 4275 for (UINT i = 0; i < pResource->SurfCount; ++i) 4276 { 4277 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 4278 IDirect3DSurface9 *pD3D9Surf; 4279 hr = pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width, 4280 pAllocation->SurfDesc.height, 4281 vboxDDI2D3DFormat(pResource->Format), 4282 vboxDDI2D3DMultiSampleType(pResource->MultisampleType), 4283 pResource->MultisampleQuality, 4284 TRUE /* @todo: BOOL Discard */, 4285 &pD3D9Surf, 4286 NULL /*HANDLE* pSharedHandle*/); 4287 Assert(hr == S_OK); 4288 if (hr == S_OK) 4289 { 4290 Assert(pD3D9Surf); 4291 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; 4292 pAllocation->pD3DIf = pD3D9Surf; 4293 } 4294 else 4295 { 4296 for (UINT j = 0; j < i; ++j) 4297 { 4298 pRc->aAllocations[j].pD3DIf->Release(); 4299 } 4300 break; 4301 } 4302 } 4303 4304 if (SUCCEEDED(hr)) 4305 { 4306 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4307 { 4308 vboxWddmSurfSynchMem(pRc); 4309 } 4310 } 4311 } 4312 else if (pResource->Flags.VertexBuffer) 4313 { 4314 IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); 4315 4316 for (UINT i = 0; i < pResource->SurfCount; ++i) 4317 { 4318 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 4319 IDirect3DVertexBuffer9 *pD3D9VBuf; 4320 hr = pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width, 4321 vboxDDI2D3DUsage(pResource->Flags), 4322 pResource->Fvf, 4323 vboxDDI2D3DPool(pResource->Pool), 4324 &pD3D9VBuf, 4325 NULL /*HANDLE* pSharedHandle*/); 4326 Assert(hr == S_OK); 4327 if (hr == S_OK) 4328 { 4329 Assert(pD3D9VBuf); 4330 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_VERTEXBUFFER; 4331 pAllocation->pD3DIf = pD3D9VBuf; 4332 } 4333 else 4334 { 4335 for (UINT j = 0; j < i; ++j) 4336 { 4337 pRc->aAllocations[j].pD3DIf->Release(); 4338 } 4339 break; 4340 } 4341 } 4342 4343 if (SUCCEEDED(hr)) 4344 { 4345 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4346 { 4347 vboxWddmSurfSynchMem(pRc); 4348 } 4349 } 4350 } 4351 else if (pResource->Flags.IndexBuffer) 4352 { 4353 IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); 4354 4355 for (UINT i = 0; i < pResource->SurfCount; ++i) 4356 { 4357 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 4358 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i]; 4359 IDirect3DIndexBuffer9 *pD3D9IBuf; 4360 hr = pDevice9If->CreateIndexBuffer(pSurf->Width, 4361 vboxDDI2D3DUsage(pResource->Flags), 4362 vboxDDI2D3DFormat(pResource->Format), 4363 vboxDDI2D3DPool(pResource->Pool), 4364 &pD3D9IBuf, 4365 NULL /*HANDLE* pSharedHandle*/ 4366 ); 4367 Assert(hr == S_OK); 4368 if (hr == S_OK) 4369 { 4370 Assert(pD3D9IBuf); 4371 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_INDEXBUFFER; 4372 pAllocation->pD3DIf = pD3D9IBuf; 4373 } 4374 else 4375 { 4376 for (UINT j = 0; j < i; ++j) 4377 { 4378 pRc->aAllocations[j].pD3DIf->Release(); 4379 } 4380 break; 4381 } 4382 } 4383 4384 if (SUCCEEDED(hr)) 4385 { 4386 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4387 { 4388 vboxWddmSurfSynchMem(pRc); 4389 } 4390 } 4391 } 4392 else if (VBOXWDDMDISP_IS_TEXTURE(pResource->Flags)) 4393 { 4394 IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); 4395 4396 if (pResource->Flags.RenderTarget && !pResource->Flags.Texture) 4397 { 4398 bIssueCreateResource = true; 4399 } 4400 4401 if (!pResource->Flags.CubeMap) 4402 { 4403 #ifdef DEBUG 4404 { 4405 uint32_t tstW = pResource->pSurfList[0].Width; 4406 uint32_t tstH = pResource->pSurfList[0].Height; 4407 for (UINT i = 1; i < pResource->SurfCount; ++i) 4408 { 4409 tstW /= 2; 4410 tstH /= 2; 4411 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i]; 4412 Assert((pSurf->Width == tstW) || (!tstW && (pSurf->Width==1))); 4413 Assert((pSurf->Height == tstH) || (!tstH && (pSurf->Height==1))); 4414 } 4415 } 4416 #endif 4417 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; 4418 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0]; 4419 IDirect3DTexture9 *pD3DIfTex; 4420 HANDLE hSharedHandle = NULL; 4421 void **pavClientMem = NULL; 4422 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4423 { 4424 Assert(pSurf->pSysMem); 4425 Assert(pSurf->SysMemPitch); 4426 UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format); 4427 Assert(minPitch); 4428 if (minPitch) 4429 { 4430 if (pSurf->SysMemPitch != minPitch) 4431 pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pSurf->SysMemPitch, pAllocation->SurfDesc.format); 4432 Assert(pAllocation->D3DWidth >= pSurf->Width); 4433 } 4434 else 4435 { 4436 Assert(pAllocation->D3DWidth == pSurf->Width); 4437 } 4438 } 4439 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4440 { 4441 pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pResource->SurfCount); 4442 Assert(pavClientMem); 4443 if (pavClientMem) 4444 { 4445 for (UINT i = 0; i < pResource->SurfCount; ++i) 4446 { 4447 pavClientMem[i] = pRc->aAllocations[i].pvMem; 4448 } 4449 } 4450 else 4451 hr = E_FAIL; 4452 } 4453 if (hr == S_OK) 4454 { 4455 hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If, 4456 pAllocation->D3DWidth, 4457 pSurf->Height, 4458 pResource->SurfCount, 4459 vboxDDI2D3DUsage(pResource->Flags), 4460 vboxDDI2D3DFormat(pResource->Format), 4461 vboxDDI2D3DPool(pResource->Pool), 4462 &pD3DIfTex, 4463 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED 4464 NULL, 4465 #else 4466 pResource->Flags.SharedResource ? &hSharedHandle : NULL, 4467 #endif 4468 pavClientMem); 4469 Assert(hr == S_OK); 4470 if (hr == S_OK) 4471 { 4472 Assert(pD3DIfTex); 4473 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE; 4474 pAllocation->pD3DIf = pD3DIfTex; 4475 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 4476 Assert(!!(pResource->Flags.SharedResource) == !!(hSharedHandle)); 4477 #endif 4478 pAllocation->hSharedHandle = hSharedHandle; 4479 4480 if (!pavClientMem) 4481 { 4482 /* zero-init texture memory */ 4483 4484 } 4485 } 4486 4487 if (pavClientMem) 4488 RTMemFree(pavClientMem); 4489 } 4490 } 4491 else /*pResource->Flags.CubeMap*/ 4492 { 4493 IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); 4494 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; 4495 CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0]; 4496 IDirect3DCubeTexture9 *pD3DIfCubeTex; 4497 HANDLE hSharedHandle = NULL; 4498 void **pavClientMem = NULL; 4499 4500 if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height) 4501 || (pResource->SurfCount%6!=0)) 4502 { 4503 Assert(0); 4504 hr = E_INVALIDARG; 4505 } 4506 else 4507 { 4508 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4509 { 4510 pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pResource->SurfCount); 4511 Assert(pavClientMem); 4512 if (pavClientMem) 4513 { 4514 for (UINT i = 0; i < pResource->SurfCount; ++i) 4515 { 4516 pavClientMem[i] = pRc->aAllocations[i].pvMem; 4517 } 4518 } 4519 else 4520 hr = E_FAIL; 4521 } 4522 4523 if (hr == S_OK) 4524 { 4525 hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If, 4526 pAllocation->SurfDesc.width, 4527 VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc), 4528 vboxDDI2D3DUsage(pResource->Flags), 4529 vboxDDI2D3DFormat(pResource->Format), 4530 vboxDDI2D3DPool(pResource->Pool), 4531 &pD3DIfCubeTex, 4532 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED 4533 NULL, 4534 #else 4535 pResource->Flags.SharedResource ? &hSharedHandle : NULL, 4536 #endif 4537 pavClientMem); 4538 Assert(hr == S_OK); 4539 if (hr == S_OK) 4540 { 4541 Assert(pD3DIfCubeTex); 4542 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE; 4543 pAllocation->pD3DIf = pD3DIfCubeTex; 4544 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 4545 Assert(!!(pResource->Flags.SharedResource) == !!(hSharedHandle)); 4546 #endif 4547 pAllocation->hSharedHandle = hSharedHandle; 4548 } 4549 4550 if (pavClientMem) 4551 RTMemFree(pavClientMem); 4552 } 4553 } 4554 } 4555 } 4556 else if (pResource->Flags.RenderTarget) 4557 { 4558 HWND hWnd = NULL; 3805 if (pRc->RcDesc.fFlags.RenderTarget) 3806 { 4559 3807 bIssueCreateResource = true; 4560 Assert(pResource->SurfCount); 4561 4562 #ifdef VBOXWDDMDISP_DEBUG 4563 if (g_VBoxVDbgCfgForceDummyDevCreate) 4564 { 4565 VBOXDISP_D3DEV(pDevice); 4566 Assert(!RTListIsEmpty(&pDevice->SwapchainList)); 4567 g_VBoxVDbgInternalRc = pRc; 4568 } 4569 #endif 4570 4571 #if 0 /* <- always create an offscreen render target here since wined3dwddm makes host 4572 * to postpone any host window sizing until it becomes visible (which is done to prevent flikering on *nix hosts) 4573 * and thus back/front-buffer data is invalid until then 4574 * and in case the 3d app is running under Aero enabled, the window will never become visible and thus never resized 4575 * to the requested values */ 4576 if (!pResource->Flags.SharedResource /* <- the Shared must NOT be a swapchain (on-screen) render target 4577 * since it will be non-upside-down, 4578 * while the app opening the resource would use it as an off-screen, 4579 * i.e. upside-down */ 4580 && RTListIsEmpty(&pDevice->SwapchainList)) 4581 { 4582 bCreateSwapchain = true; 4583 Assert(bIssueCreateResource); 4584 for (UINT i = 0; i < pRc->cAllocations; ++i) 4585 { 4586 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 4587 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; 4588 } 4589 } 4590 else 4591 #endif 4592 { 4593 /* make sure the device is created */ 4594 IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice); 4595 for (UINT i = 0; i < pResource->SurfCount; ++i) 4596 { 4597 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 4598 HANDLE hSharedHandle = NULL; 4599 4600 IDirect3DSurface9* pD3D9Surf; 4601 hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width, 4602 pAllocation->SurfDesc.height, 4603 vboxDDI2D3DFormat(pResource->Format), 4604 vboxDDI2D3DMultiSampleType(pResource->MultisampleType), 4605 pResource->MultisampleQuality, 4606 !pResource->Flags.NotLockable /* BOOL Lockable */, 4607 &pD3D9Surf, 4608 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED 4609 NULL 4610 #else 4611 pResource->Flags.SharedResource ? &hSharedHandle : NULL 4612 #endif 4613 ); 4614 Assert(hr == S_OK); 4615 if (hr == S_OK) 4616 { 4617 Assert(pD3D9Surf); 4618 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; 4619 pAllocation->pD3DIf = pD3D9Surf; 4620 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 4621 Assert(!!(pResource->Flags.SharedResource) == !!(hSharedHandle)); 4622 #endif 4623 pAllocation->hSharedHandle = hSharedHandle; 4624 continue; 4625 4626 /* fail branch */ 4627 pD3D9Surf->Release(); 4628 } 4629 4630 for (UINT j = 0; j < i; ++j) 4631 { 4632 pRc->aAllocations[j].pD3DIf->Release(); 4633 } 4634 break; 4635 } 4636 4637 if (SUCCEEDED(hr)) 4638 { 4639 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM) 4640 { 4641 Assert(0); 4642 vboxWddmSurfSynchMem(pRc); 4643 } 4644 } 4645 } 4646 } 4647 else 4648 { 4649 hr = E_FAIL; 4650 Assert(0); 3808 } 3809 3810 hr = VBoxD3DIfCreateForRc(pRc); 3811 if (!SUCCEEDED(hr)) 3812 { 3813 WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr)); 4651 3814 } 4652 3815 } … … 4657 3820 } 4658 3821 4659 4660 if (hr == S_OK && bIssueCreateResource) 3822 if (SUCCEEDED(hr) && bIssueCreateResource) 4661 3823 { 4662 3824 pRc->fFlags.KmResource = bCreateKMResource; … … 4728 3890 Assert(hr == S_OK); 4729 3891 Assert(!pDdiAllocate->hKMResource); 4730 if ( hr == S_OK)3892 if (SUCCEEDED(hr)) 4731 3893 { 4732 3894 Assert(pDdiAllocate->pAllocationInfo->hAllocation); … … 4751 3913 } 4752 3914 4753 if ( hr == S_OK)3915 if (SUCCEEDED(hr)) 4754 3916 { 4755 3917 pRc->hKMResource = pDdiAllocate->hKMResource; … … 4780 3942 } 4781 3943 4782 if(bCreateSwapchain) 4783 { 4784 PVBOXWDDMDISP_SWAPCHAIN pSwapchain; 4785 hr = vboxWddmSwapchainCreateIfForRc(pDevice, pRc, &pSwapchain); 4786 Assert(hr == S_OK); 4787 } 4788 else 4789 { 4790 VBOXVDBG_CREATE_CHECK_SWAPCHAIN(); 4791 } 3944 VBOXVDBG_CREATE_CHECK_SWAPCHAIN(); 4792 3945 } 4793 3946 … … 4802 3955 VBOXVDBG_BREAK_SHARED(pRc); 4803 3956 4804 if (hr == S_OK) 3957 if (SUCCEEDED(hr)) 3958 { 4805 3959 pResource->hResource = pRc; 3960 hr = S_OK; 3961 } 4806 3962 else 4807 3963 vboxResourceFree(pRc); … … 5310 4466 VBOXVDBG_BREAK_SHARED(pDstRc); 5311 4467 5312 hr = vboxWddmSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf);4468 hr = VBoxD3DIfSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf); 5313 4469 Assert(hr == S_OK); 5314 4470 if (hr == S_OK) … … 5324 4480 else 5325 4481 { 5326 hr = vboxWddmSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf);4482 hr = VBoxD3DIfSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf); 5327 4483 Assert(hr == S_OK); 5328 4484 } … … 5372 4528 Assert(pRc); 5373 4529 IDirect3DSurface9 *pSurfIf = NULL; 5374 HRESULT hr = vboxWddmSurfGet(pRc, pData->SubResourceIndex, &pSurfIf);4530 HRESULT hr = VBoxD3DIfSurfGet(pRc, pData->SubResourceIndex, &pSurfIf); 5375 4531 Assert(hr == S_OK); 5376 4532 if (hr == S_OK) … … 6062 5218 } 6063 5219 6064 static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)6065 {6066 HRESULT hr = S_OK;6067 pAlloc->hAllocation = pInfo->hAllocation;6068 Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));6069 Assert(pInfo->pPrivateDriverData);6070 if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))6071 {6072 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;6073 pAlloc->enmType = pAllocInfo->enmType;6074 Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE6075 || VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE6076 || VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE);6077 pAlloc->pvMem = NULL;6078 pAlloc->SurfDesc = pAllocInfo->SurfDesc;6079 }6080 else6081 {6082 vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));6083 hr = E_INVALIDARG;6084 }6085 return hr;6086 }6087 6088 5220 static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData) 6089 5221 { … … 6108 5240 pRc->RcDesc.enmRotation = pData->Rotation; 6109 5241 pRc->fFlags.Value = 0; 6110 pRc->fFlags.Generic = 1;6111 5242 pRc->fFlags.Opened = 1; 6112 5243 pRc->fFlags.KmResource = 1; 5244 5245 for (UINT i = 0; i < pData->NumAllocations; ++i) 5246 { 5247 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 5248 D3DDDI_OPENALLOCATIONINFO* pOAI = pData->pOpenAllocationInfo; 5249 Assert(pOAI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO)); 5250 if (pOAI->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO)) 5251 { 5252 hr = E_INVALIDARG; 5253 break; 5254 } 5255 Assert(pOAI->pPrivateDriverData); 5256 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData; 5257 pAllocation->hAllocation = pOAI->hAllocation; 5258 pAllocation->enmType = pAllocInfo->enmType; 5259 pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle; 5260 pAllocation->SurfDesc = pAllocInfo->SurfDesc; 5261 pAllocation->pvMem = NULL; 5262 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 5263 Assert(!pAllocation->hSharedHandle == (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)); 5264 #endif 5265 #ifdef VBOXWDDMDISP_DEBUG_PRINT_SHARED_CREATE 5266 vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared OPENNED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), " 5267 "Handle(0x%x), (0n%d) \n***********\n\n", 5268 GetCurrentProcessId(), GetCurrentProcessId(), 5269 pAllocation, pRc->hKMResource, pAllocation->hAllocation, 5270 pAllocation->hSharedHandle, pAllocation->hSharedHandle 5271 )); 5272 #endif 5273 } 6113 5274 if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize) 6114 5275 { … … 6122 5283 pRc->RcDesc.MipLevels = 0; 6123 5284 pRc->RcDesc.Fvf; 6124 pRc->RcDesc.fFlags.Value = 0; 6125 6126 Assert(pData->NumAllocations); 5285 5286 if (pData->NumAllocations != 1) 5287 { 5288 WARN(("NumAllocations is expected to be 1, but was %d", pData->NumAllocations)); 5289 } 5290 5291 for (UINT i = 0; i < pData->NumAllocations; ++i) 5292 { 5293 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i]; 5294 pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE; 5295 pAlloc->pD3DIf = NULL; 5296 } 5297 6127 5298 D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0]; 6128 5299 Assert(pDdiAllocInfo->pPrivateDriverData); … … 6159 5330 Assert(!pRcInfo->fFlags.Opened); 6160 5331 Assert(pRcInfo->cAllocInfos == pData->NumAllocations); 6161 pRc->fFlags = pRcInfo->fFlags;6162 pRc->fFlags. Opened= 1;5332 pRc->fFlags.Value |= pRcInfo->fFlags.Value; 5333 pRc->fFlags.Generic = 1; 6163 5334 pRc->RcDesc = pRcInfo->RcDesc; 6164 5335 pRc->cAllocations = pData->NumAllocations; 6165 6166 for (UINT i = 0; i < pData->NumAllocations; ++i) 5336 Assert(pRc->RcDesc.fFlags.SharedResource); 5337 5338 hr = VBoxD3DIfCreateForRc(pRc); 5339 if (!SUCCEEDED(hr)) 6167 5340 { 6168 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i]; 6169 D3DDDI_OPENALLOCATIONINFO* pOAI = pData->pOpenAllocationInfo; 6170 Assert(pOAI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO)); 6171 if (pOAI->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO)) 6172 { 6173 hr = E_INVALIDARG; 6174 break; 6175 } 6176 Assert(pOAI->pPrivateDriverData); 6177 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData; 6178 pAllocation->hAllocation = pOAI->hAllocation; 6179 pAllocation->enmType = pAllocInfo->enmType; 6180 pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle; 6181 pAllocation->SurfDesc = pAllocInfo->SurfDesc; 6182 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 6183 Assert(pAllocation->hSharedHandle); 6184 #endif 6185 #ifdef VBOXWDDMDISP_DEBUG_PRINT_SHARED_CREATE 6186 vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared OPENNED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), " 6187 "Handle(0x%x), (0n%d) \n***********\n\n", 6188 GetCurrentProcessId(), GetCurrentProcessId(), 6189 pAllocation, pRc->hKMResource, pAllocation->hAllocation, 6190 pAllocation->hSharedHandle, pAllocation->hSharedHandle 6191 )); 6192 #endif 6193 } 6194 6195 Assert(pRc->RcDesc.fFlags.SharedResource); 6196 if (VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags)) 6197 { 6198 IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice); 6199 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0]; 6200 HANDLE hSharedHandle = pAllocation->hSharedHandle; 6201 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 6202 Assert(pAllocation->hSharedHandle); 6203 #endif 6204 6205 if (!pRc->RcDesc.fFlags.CubeMap) 6206 { 6207 IDirect3DTexture9 *pD3DIfTex; 6208 hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If, 6209 pAllocation->SurfDesc.width, 6210 pAllocation->SurfDesc.height, 6211 pRc->cAllocations, 6212 vboxDDI2D3DUsage(pRc->RcDesc.fFlags), 6213 vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), 6214 vboxDDI2D3DPool(pRc->RcDesc.enmPool), 6215 &pD3DIfTex, 6216 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED 6217 NULL, 6218 #else 6219 &hSharedHandle, 6220 #endif 6221 NULL); 6222 Assert(hr == S_OK); 6223 if (hr == S_OK) 6224 { 6225 Assert(pD3DIfTex); 6226 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE; 6227 pAllocation->pD3DIf = pD3DIfTex; 6228 Assert(pAllocation->hSharedHandle == hSharedHandle); 6229 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 6230 Assert(pAllocation->hSharedHandle); 6231 #endif 6232 } 6233 } 6234 else 6235 { 6236 IDirect3DCubeTexture9 *pD3DIfCubeTex; 6237 6238 if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height) 6239 || (pRc->cAllocations%6!=0)) 6240 { 6241 Assert(0); 6242 hr = E_INVALIDARG; 6243 } 6244 hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If, 6245 pAllocation->SurfDesc.width, 6246 VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc), 6247 vboxDDI2D3DUsage(pRc->RcDesc.fFlags), 6248 vboxDDI2D3DFormat(pRc->RcDesc.enmFormat), 6249 vboxDDI2D3DPool(pRc->RcDesc.enmPool), 6250 &pD3DIfCubeTex, 6251 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED 6252 NULL, 6253 #else 6254 &hSharedHandle, 6255 #endif 6256 NULL); 6257 Assert(hr == S_OK); 6258 if (hr == S_OK) 6259 { 6260 Assert(pD3DIfCubeTex); 6261 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE; 6262 pAllocation->pD3DIf = pD3DIfCubeTex; 6263 Assert(pAllocation->hSharedHandle == hSharedHandle); 6264 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED 6265 Assert(pAllocation->hSharedHandle); 6266 #endif 6267 } 6268 6269 } 6270 } 6271 else 6272 { 6273 /* impl */ 6274 Assert(0); 5341 WARN(("VBoxD3DIfCreateForRc failed, hr %d", hr)); 6275 5342 } 6276 5343 } 6277 5344 else 6278 5345 hr = E_INVALIDARG; 6279 }6280 6281 if (hr == S_OK)6282 {6283 for (UINT i = 0; i < pData->NumAllocations; ++i)6284 {6285 hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]);6286 Assert(hr == S_OK);6287 if (hr != S_OK)6288 break;6289 }6290 5346 } 6291 5347 … … 6623 5679 } 6624 5680 6625 6626 5681 HRESULT APIENTRY OpenAdapter(__inout D3DDDIARG_OPENADAPTER* pOpenData) 6627 5682 { -
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h
r42557 r43236 337 337 } 338 338 339 /* on success increments the surface ref counter, 340 * i.e. one must call pSurf->Release() once the surface is not needed*/ 341 DECLINLINE(HRESULT) vboxWddmSurfGet(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, IDirect3DSurface9 **ppSurf) 342 { 343 HRESULT hr = S_OK; 344 Assert(pRc->cAllocations > iAlloc); 345 switch (pRc->aAllocations[0].enmD3DIfType) 346 { 347 case VBOXDISP_D3DIFTYPE_SURFACE: 348 { 349 IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf; 350 Assert(pD3DIfSurf); 351 pD3DIfSurf->AddRef(); 352 *ppSurf = pD3DIfSurf; 353 break; 354 } 355 case VBOXDISP_D3DIFTYPE_TEXTURE: 356 { 357 Assert(pRc->cAllocations == 1); /* <- vboxWddmSurfGet is typically used in Blt & ColorFill functions 358 * in this case, if texture is used as a destination, 359 * we should update sub-layers as well which is not done currently 360 * so for now check vboxWddmSurfGet is used for one-level textures */ 361 IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf; 362 IDirect3DSurface9 *pSurfaceLevel; 363 Assert(pD3DIfTex); 364 hr = pD3DIfTex->GetSurfaceLevel(iAlloc, &pSurfaceLevel); 365 Assert(hr == S_OK); 366 if (hr == S_OK) 367 { 368 *ppSurf = pSurfaceLevel; 369 } 370 break; 371 } 372 case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE: 373 { 374 Assert(0); 375 IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf; 376 IDirect3DSurface9 *pSurfaceLevel; 377 Assert(pD3DIfCubeTex); 378 hr = pD3DIfCubeTex->GetCubeMapSurface(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, iAlloc), 379 VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, iAlloc), &pSurfaceLevel); 380 Assert(hr == S_OK); 381 if (hr == S_OK) 382 { 383 *ppSurf = pSurfaceLevel; 384 } 385 break; 386 } 387 default: 388 Assert(0); 389 hr = E_FAIL; 390 break; 391 } 392 return hr; 393 } 394 395 HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, 396 D3DLOCKED_RECT * pLockedRect, 397 CONST RECT *pRect, 398 DWORD fLockFlags); 399 HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc); 400 401 #define VBOXDISPMODE_IS_3D(_p) (!!((_p)->D3D.pD3D9If)) 402 #ifdef VBOXDISP_EARLYCREATEDEVICE 403 #define VBOXDISP_D3DEV(_p) (_p)->pDevice9If 404 #else 405 #define VBOXDISP_D3DEV(_p) vboxWddmD3DDeviceGet(_p) 339 void vboxWddmResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs); 340 341 #ifndef IN_VBOXCRHGSMI 342 PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent); 343 HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain); 344 VOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain); 345 406 346 #endif 407 347 -
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DCmn.h
r42154 r43236 64 64 #endif 65 65 #include "VBoxDispD3D.h" 66 66 #ifndef IN_VBOXCRHGSMI 67 #include "VBoxD3DIf.h" 68 #endif 67 69 68 70 # ifdef VBOXWDDMDISP -
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.cpp
r42683 r43236 88 88 89 89 #ifdef VBOXWDDMDISP_DEBUG 90 91 DWORD g_VBoxVDbgFLogRel = 1; 92 DWORD g_VBoxVDbgFLog = 1; 93 DWORD g_VBoxVDbgFLogFlow = 0; 94 95 # ifndef IN_VBOXCRHGSMI 90 96 #define VBOXWDDMDISP_DEBUG_DUMP_DEFAULT 0 91 97 DWORD g_VBoxVDbgFDumpSetTexture = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT; … … 112 118 DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate = 1; 113 119 114 DWORD g_VBoxVDbgFLogRel = 1;115 DWORD g_VBoxVDbgFLog = 1;116 DWORD g_VBoxVDbgFLogFlow = 0;117 118 120 DWORD g_VBoxVDbgCfgMaxDirectRts = 3; 119 121 DWORD g_VBoxVDbgCfgForceDummyDevCreate = 0; … … 277 279 const RECT *pRect = pInfo->pRect; 278 280 IDirect3DSurface9 *pSurf; 279 HRESULT hr = vboxWddmSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pSurf);281 HRESULT hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pSurf); 280 282 if (hr != S_OK) 281 283 { 282 WARN((" vboxWddmSurfGet failed, hr 0x%x", hr));284 WARN(("VBoxD3DIfSurfGet failed, hr 0x%x", hr)); 283 285 return; 284 286 } … … 527 529 } 528 530 529 #ifndef IN_VBOXCRHGSMI530 531 BOOL vboxVDbgDoCheckRectsMatch(const PVBOXWDDMDISP_RESOURCE pDstRc, uint32_t iDstAlloc, 531 532 const PVBOXWDDMDISP_RESOURCE pSrcRc, uint32_t iSrcAlloc, … … 592 593 593 594 D3DLOCKED_RECT SrcLRect, DstLRect; 594 HRESULT hr = vboxWddmLockRect(pDstRc, iDstAlloc, &DstLRect, pDstRect, D3DLOCK_READONLY);595 HRESULT hr = VBoxD3DIfLockRect(pDstRc, iDstAlloc, &DstLRect, pDstRect, D3DLOCK_READONLY); 595 596 if (FAILED(hr)) 596 597 { 597 WARN((" vboxWddmLockRect failed, hr(0x%x)", hr));598 return FALSE; 599 } 600 601 hr = vboxWddmLockRect(pSrcRc, iSrcAlloc, &SrcLRect, pSrcRect, D3DLOCK_READONLY);598 WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); 599 return FALSE; 600 } 601 602 hr = VBoxD3DIfLockRect(pSrcRc, iSrcAlloc, &SrcLRect, pSrcRect, D3DLOCK_READONLY); 602 603 if (FAILED(hr)) 603 604 { 604 WARN((" vboxWddmLockRect failed, hr(0x%x)", hr));605 hr = vboxWddmUnlockRect(pDstRc, iDstAlloc);605 WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr)); 606 hr = VBoxD3DIfUnlockRect(pDstRc, iDstAlloc); 606 607 return FALSE; 607 608 } … … 609 610 fMatch = vboxVDbgDoCheckLRects(&DstLRect, pDstRect, &SrcLRect, pSrcRect, bpp, fBreakOnMismatch); 610 611 611 hr = vboxWddmUnlockRect(pDstRc, iDstAlloc);612 hr = VBoxD3DIfUnlockRect(pDstRc, iDstAlloc); 612 613 Assert(hr == S_OK); 613 614 614 hr = vboxWddmUnlockRect(pSrcRc, iSrcAlloc);615 hr = VBoxD3DIfUnlockRect(pSrcRc, iSrcAlloc); 615 616 Assert(hr == S_OK); 616 617 617 618 return fMatch; 618 619 } 619 #endif620 620 621 621 void vboxVDbgDoPrintAlloc(const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char * pSuffix) … … 643 643 vboxVDbgPrint(("%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix)); 644 644 } 645 646 # endif 645 647 646 648 static VOID CALLBACK vboxVDbgTimerCb(__in PVOID lpParameter, __in BOOLEAN TimerOrWaitFired) -
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.h
r42027 r43236 50 50 # endif 51 51 52 /* log enable flags */ 53 extern DWORD g_VBoxVDbgFLogRel; 54 extern DWORD g_VBoxVDbgFLog; 55 extern DWORD g_VBoxVDbgFLogFlow; 56 57 # ifndef IN_VBOXCRHGSMI 52 58 /* debug config vars */ 53 59 extern DWORD g_VBoxVDbgFDumpSetTexture; … … 74 80 extern DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate; 75 81 76 /* log enable flags */77 extern DWORD g_VBoxVDbgFLogRel;78 extern DWORD g_VBoxVDbgFLog;79 extern DWORD g_VBoxVDbgFLogFlow;80 81 82 extern DWORD g_VBoxVDbgCfgMaxDirectRts; 82 83 extern DWORD g_VBoxVDbgCfgForceDummyDevCreate; … … 87 88 extern DWORD g_VBoxVDbgCfgCreateSwapchainOnDdiOnce; 88 89 89 #endif 90 91 #if 0 92 # ifdef Assert 93 # undef Assert 94 # define Assert(_a) do{}while(0) 95 # endif 96 # ifdef AssertBreakpoint 97 # undef AssertBreakpoint 98 # define AssertBreakpoint() do{}while(0) 99 # endif 100 # ifdef AssertFailed 101 # undef AssertFailed 102 # define AssertFailed() do{}while(0) 103 # endif 90 # endif /* #ifndef IN_VBOXCRHGSMI */ 104 91 #endif 105 92 … … 212 199 void vboxDispLogDbgPrintF(char * szString, ...); 213 200 201 # ifndef IN_VBOXCRHGSMI 214 202 typedef struct VBOXWDDMDISP_ALLOCATION *PVBOXWDDMDISP_ALLOCATION; 215 203 typedef struct VBOXWDDMDISP_RESOURCE *PVBOXWDDMDISP_RESOURCE; … … 640 628 } while (0) 641 629 630 # endif /* # ifndef IN_VBOXCRHGSMI */ 642 631 #else 643 632 #define VBOXVDBG_DUMP_DRAWPRIM_ENTER(_pDevice) do { } while (0)
Note:
See TracChangeset
for help on using the changeset viewer.
