VirtualBox

Ignore:
Timestamp:
Sep 14, 2012 5:34:33 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
80768
Message:

wddm/3d: volume texture func impl; fixes & cleanup

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoTools.h

    r39992 r43334  
    229229}
    230230
     231typedef struct VBOXPOINT3D
     232{
     233    UINT x;
     234    UINT y;
     235    UINT z;
     236} VBOXPOINT3D, *PVBOXPOINT3D;
     237
     238typedef struct VBOXBOX3D
     239{
     240    UINT Left;
     241    UINT Top;
     242    UINT Right;
     243    UINT Bottom;
     244    UINT Front;
     245    UINT Back;
     246} VBOXBOX3D, *PVBOXBOX3D;
     247
     248DECLINLINE(void) vboxWddmBoxTranslate(VBOXBOX3D * pBox, int x, int y, int z)
     249{
     250    pBox->Left   += x;
     251    pBox->Top    += y;
     252    pBox->Right  += x;
     253    pBox->Bottom += y;
     254    pBox->Front  += z;
     255    pBox->Back   += z;
     256}
     257
     258DECLINLINE(void) vboxWddmBoxMove(VBOXBOX3D * pBox, int x, int y, int z)
     259{
     260    LONG w = pBox->Right - pBox->Left;
     261    LONG h = pBox->Bottom - pBox->Top;
     262    LONG d = pBox->Back - pBox->Front;
     263    pBox->Left   = x;
     264    pBox->Top    = y;
     265    pBox->Right  = w + x;
     266    pBox->Bottom = h + y;
     267    pBox->Front  = z;
     268    pBox->Back   = d + z;
     269}
     270
     271#define VBOXWDDM_BOXDIV_U(_v, _d, _nz) do { \
     272        UINT tmp = (_v) / (_d); \
     273        if (!tmp && (_v) && (_nz)) \
     274            (_v) = 1; \
     275        else \
     276            (_v) = tmp; \
     277    } while (0)
     278
     279DECLINLINE(void) vboxWddmBoxDivide(VBOXBOX3D * pBox, int div, bool fDontReachZero)
     280{
     281    VBOXWDDM_BOXDIV_U(pBox->Left, div, fDontReachZero);
     282    VBOXWDDM_BOXDIV_U(pBox->Top, div, fDontReachZero);
     283    VBOXWDDM_BOXDIV_U(pBox->Right, div, fDontReachZero);
     284    VBOXWDDM_BOXDIV_U(pBox->Bottom, div, fDontReachZero);
     285    VBOXWDDM_BOXDIV_U(pBox->Front, div, fDontReachZero);
     286    VBOXWDDM_BOXDIV_U(pBox->Back, div, fDontReachZero);
     287}
     288
     289DECLINLINE(void) vboxWddmPoint3DDivide(VBOXPOINT3D * pPoint, int div, bool fDontReachZero)
     290{
     291    VBOXWDDM_BOXDIV_U(pPoint->x, div, fDontReachZero);
     292    VBOXWDDM_BOXDIV_U(pPoint->y, div, fDontReachZero);
     293    VBOXWDDM_BOXDIV_U(pPoint->y, div, fDontReachZero);
     294}
     295
     296DECLINLINE(void) vboxWddmBoxTranslated(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int x, int y, int z)
     297{
     298    *pDst = *pBox;
     299    vboxWddmBoxTranslate(pDst, x, y, z);
     300}
     301
     302DECLINLINE(void) vboxWddmBoxMoved(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int x, int y, int z)
     303{
     304    *pDst = *pBox;
     305    vboxWddmBoxMove(pDst, x, y, z);
     306}
     307
     308DECLINLINE(void) vboxWddmBoxDivided(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int div, bool fDontReachZero)
     309{
     310    *pDst = *pBox;
     311    vboxWddmBoxDivide(pDst, div, fDontReachZero);
     312}
     313
     314DECLINLINE(void) vboxWddmPoint3DDivided(VBOXPOINT3D * pDst, const VBOXPOINT3D * pPoint, int div, bool fDontReachZero)
     315{
     316    *pDst = *pPoint;
     317    vboxWddmPoint3DDivide(pDst, div, fDontReachZero);
     318}
     319
    231320/* the dirty rect info is valid */
    232321#define VBOXWDDM_DIRTYREGION_F_VALID      0x00000001

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h

    r43236 r43334  
    537537        case D3DDDIFMT_L8:
    538538            return 8;
     539        case D3DDDIFMT_L16:
    539540        case D3DDDIFMT_A8L8:
    540541            return 16;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp

    r43236 r43334  
    543543    else if (VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags))
    544544    {
     545        PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
     546        IDirect3DBaseTexture9 *pD3DIfTex;
     547        HANDLE hSharedHandle = pAllocation->hSharedHandle;
     548        void **pavClientMem = NULL;
     549        VBOXDISP_D3DIFTYPE enmD3DIfType = VBOXDISP_D3DIFTYPE_UNDEFINED;
     550        hr = S_OK;
     551        if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
     552        {
     553            pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations);
     554            Assert(pavClientMem);
     555            if (pavClientMem)
     556            {
     557                for (UINT i = 0; i < pRc->cAllocations; ++i)
     558                {
     559                    Assert(pRc->aAllocations[i].pvMem);
     560                    pavClientMem[i] = pRc->aAllocations[i].pvMem;
     561                }
     562            }
     563            else
     564                hr = E_FAIL;
     565        }
     566
     567#ifdef DEBUG
    545568        if (!pRc->RcDesc.fFlags.CubeMap)
    546569        {
    547 #ifdef DEBUG
    548             {
    549                 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
    550                 uint32_t tstW = pAlloc->SurfDesc.width;
    551                 uint32_t tstH = pAlloc->SurfDesc.height;
    552                 for (UINT i = 1; i < pRc->cAllocations; ++i)
    553                 {
    554                     tstW /= 2;
    555                     tstH /= 2;
    556                     pAlloc = &pRc->aAllocations[i];
    557                     Assert((pAlloc->SurfDesc.width == tstW) || (!tstW && (pAlloc->SurfDesc.width==1)));
    558                     Assert((pAlloc->SurfDesc.height == tstH) || (!tstH && (pAlloc->SurfDesc.height==1)));
    559                 }
    560             }
     570            PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
     571            uint32_t tstW = pAlloc->SurfDesc.width;
     572            uint32_t tstH = pAlloc->SurfDesc.height;
     573            for (UINT i = 1; i < pRc->cAllocations; ++i)
     574            {
     575                tstW /= 2;
     576                tstH /= 2;
     577                pAlloc = &pRc->aAllocations[i];
     578                Assert((pAlloc->SurfDesc.width == tstW) || (!tstW && (pAlloc->SurfDesc.width==1)));
     579                Assert((pAlloc->SurfDesc.height == tstH) || (!tstH && (pAlloc->SurfDesc.height==1)));
     580            }
     581        }
    561582#endif
    562             PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
    563             IDirect3DTexture9 *pD3DIfTex;
    564             HANDLE hSharedHandle = pAllocation->hSharedHandle;
    565             void **pavClientMem = NULL;
    566             hr = S_OK;
    567             if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
    568             {
    569                 Assert(pAllocation->pvMem);
    570                 Assert(pAllocation->SurfDesc.pitch);
    571                 UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format);
    572                 Assert(minPitch);
    573                 if (minPitch)
    574                 {
    575                     if (pAllocation->SurfDesc.pitch != minPitch)
    576                     {
    577                         Assert(pAllocation->SurfDesc.pitch > minPitch);
    578                         pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format);
    579                     }
    580                     Assert(pAllocation->D3DWidth >= pAllocation->SurfDesc.width);
     583
     584        if (SUCCEEDED(hr))
     585        {
     586            if (pRc->RcDesc.fFlags.CubeMap)
     587            {
     588                if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height)
     589                     || (pRc->cAllocations%6!=0))
     590                {
     591                    WARN(("unexpected cubemap texture config: (%d ; %d), allocs: %d",
     592                            pAllocation->SurfDesc.width, pAllocation->SurfDesc.height, pRc->cAllocations));
     593                    hr = E_INVALIDARG;
    581594                }
    582595                else
    583596                {
    584                     Assert(pAllocation->D3DWidth == pAllocation->SurfDesc.width);
    585                 }
    586             }
    587             if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
    588             {
    589                 pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations);
    590                 Assert(pavClientMem);
    591                 if (pavClientMem)
    592                 {
    593                     for (UINT i = 0; i < pRc->cAllocations; ++i)
    594                     {
    595                         Assert(pRc->aAllocations[i].pvMem);
    596                         pavClientMem[i] = pRc->aAllocations[i].pvMem;
    597                     }
    598                 }
    599                 else
    600                     hr = E_FAIL;
    601             }
    602             if (hr == S_OK)
     597                    hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If,
     598                                                pAllocation->D3DWidth,
     599                                                VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc),
     600                                                vboxDDI2D3DUsage(pRc->RcDesc.fFlags),
     601                                                vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
     602                                                vboxDDI2D3DPool(pRc->RcDesc.enmPool),
     603                                                (IDirect3DCubeTexture9**)&pD3DIfTex,
     604#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
     605                                                NULL,
     606#else
     607                                                pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL,
     608#endif
     609                                                pavClientMem);
     610                        Assert(hr == S_OK);
     611                        Assert(pD3DIfTex);
     612                        enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE;
     613                }
     614            }
     615            else if (pRc->RcDesc.fFlags.Volume)
     616            {
     617                hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateVolumeTexture((IDirect3DDevice9Ex *)pDevice9If,
     618                                            pAllocation->D3DWidth,
     619                                            pAllocation->SurfDesc.height,
     620                                            pAllocation->SurfDesc.depth,
     621                                            pRc->cAllocations,
     622                                            vboxDDI2D3DUsage(pRc->RcDesc.fFlags),
     623                                            vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
     624                                            vboxDDI2D3DPool(pRc->RcDesc.enmPool),
     625                                            (IDirect3DVolumeTexture9**)&pD3DIfTex,
     626#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
     627                                            NULL,
     628#else
     629                                            pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL,
     630#endif
     631                                            pavClientMem);
     632                Assert(hr == S_OK);
     633                Assert(pD3DIfTex);
     634                enmD3DIfType = VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE;
     635            }
     636            else
    603637            {
    604638                hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If,
    … …  
    609643                                            vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
    610644                                            vboxDDI2D3DPool(pRc->RcDesc.enmPool),
    611                                             &pD3DIfTex,
     645                                            (IDirect3DTexture9**)&pD3DIfTex,
    612646#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
    613647                                            NULL,
    … …  
    617651                                            pavClientMem);
    618652                Assert(hr == S_OK);
    619                 if (hr == S_OK)
    620                 {
    621                     Assert(pD3DIfTex);
     653                Assert(pD3DIfTex);
     654                enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE;
     655            }
     656
     657            if (SUCCEEDED(hr))
     658            {
     659                Assert(pD3DIfTex);
     660                Assert(enmD3DIfType != VBOXDISP_D3DIFTYPE_UNDEFINED);
    622661#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
    623                     Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle));
     662                Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle));
    624663#endif
    625                     for (UINT i = 0; i < pRc->cAllocations; ++i)
    626                     {
    627                         PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
    628                         pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE;
    629                         pAlloc->pD3DIf = pD3DIfTex;
    630                         pAlloc->hSharedHandle = hSharedHandle;
    631                         if (i > 0)
    632                             pD3DIfTex->AddRef();
    633                     }
    634                 }
    635 
    636                 if (pavClientMem)
    637                     RTMemFree(pavClientMem);
    638             }
    639         }
    640         else /*pRc->RcDesc.fFlags.CubeMap*/
    641         {
    642             PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
    643             IDirect3DCubeTexture9 *pD3DIfCubeTex;
    644             HANDLE hSharedHandle = pAllocation->hSharedHandle;
    645             void **pavClientMem = NULL;
    646 
    647             if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height)
    648                  || (pRc->cAllocations%6!=0))
    649             {
    650                 Assert(0);
    651                 hr = E_INVALIDARG;
    652             }
    653             else
    654             {
    655                 hr = S_OK;
    656                 if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
    657                 {
    658                     pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations);
    659                     Assert(pavClientMem);
    660                     if (pavClientMem)
    661                     {
    662                         for (UINT i = 0; i < pRc->cAllocations; ++i)
    663                         {
    664                             pavClientMem[i] = pRc->aAllocations[i].pvMem;
    665                         }
    666                     }
    667                     else
    668                         hr = E_FAIL;
    669                 }
    670 
    671                 if (hr == S_OK)
    672                 {
    673                     hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If,
    674                                             pAllocation->SurfDesc.width,
    675                                             VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc),
    676                                             vboxDDI2D3DUsage(pRc->RcDesc.fFlags),
    677                                             vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
    678                                             vboxDDI2D3DPool(pRc->RcDesc.enmPool),
    679                                             &pD3DIfCubeTex,
    680 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED
    681                                             NULL,
    682 #else
    683                                             pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL,
    684 #endif
    685                                             pavClientMem);
    686                     Assert(hr == S_OK);
    687                     if (hr == S_OK)
    688                     {
    689                         Assert(pD3DIfCubeTex);
    690 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED
    691                         Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle));
    692 #endif
    693 
    694                         for (UINT i = 0; i < pRc->cAllocations; ++i)
    695                         {
    696                             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
    697                             pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE;
    698                             pAlloc->pD3DIf = pD3DIfCubeTex;
    699                             pAlloc->hSharedHandle = hSharedHandle;
    700                             if (i > 0)
    701                                 pD3DIfCubeTex->AddRef();
    702                         }
    703                     }
    704 
    705                     if (pavClientMem)
    706                         RTMemFree(pavClientMem);
    707                 }
    708             }
    709         }
     664                for (UINT i = 0; i < pRc->cAllocations; ++i)
     665                {
     666                    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
     667                    pAlloc->enmD3DIfType = enmD3DIfType;
     668                    pAlloc->pD3DIf = pD3DIfTex;
     669                    pAlloc->hSharedHandle = hSharedHandle;
     670                    if (i > 0)
     671                        pD3DIfTex->AddRef();
     672                }
     673            }
     674        }
     675
     676        if (pavClientMem)
     677            RTMemFree(pavClientMem);
    710678    }
    711679    else if (pRc->RcDesc.fFlags.RenderTarget || pRc->RcDesc.fFlags.Primary)

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

    r43314 r43334  
    22092209            VBOXVDBG_DUMP_SETTEXTURE(pRc);
    22102210        }
     2211        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     2212        {
     2213            pD3DIfTex = (IDirect3DVolumeTexture9*)pRc->aAllocations[0].pD3DIf;
     2214
     2215            VBOXVDBG_BREAK_SHARED(pRc);
     2216            VBOXVDBG_DUMP_SETTEXTURE(pRc);
     2217        }
    22112218        else
    22122219        {
    … …  
    27012708}
    27022709
     2710AssertCompile(sizeof (D3DDDIBOX) == sizeof (VBOXBOX3D));
     2711AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(VBOXBOX3D, Left));
     2712AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(VBOXBOX3D, Top));
     2713AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(VBOXBOX3D, Right));
     2714AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom));
     2715AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(VBOXBOX3D, Front));
     2716AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(VBOXBOX3D, Back));
     2717
     2718AssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(VBOXBOX3D, Left));
     2719AssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(VBOXBOX3D, Top));
     2720AssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(VBOXBOX3D, Right));
     2721AssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom));
     2722AssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(VBOXBOX3D, Front));
     2723AssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(VBOXBOX3D, Back));
     2724
    27032725static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
    27042726{
    27052727    VBOXDISP_DDI_PROLOGUE_DEV(hDevice);
     2728    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2729    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2730    Assert(pDevice);
     2731    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
     2732    IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
     2733    PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
     2734    PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
     2735    /* requirements for D3DDevice9::UpdateTexture */
     2736    Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2737    Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2738    IDirect3DVolumeTexture9 * pSrcTex = (IDirect3DVolumeTexture9*)pSrcRc->aAllocations[0].pD3DIf;
     2739    IDirect3DVolumeTexture9 * pDstTex = (IDirect3DVolumeTexture9*)pDstRc->aAllocations[0].pD3DIf;
     2740    VBOXPOINT3D Point;
     2741    Point.x = pData->DstX;
     2742    Point.y = pData->DstY;
     2743    Point.z = pData->DstZ;
     2744
     2745    HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9VolTexBlt((IDirect3DDevice9Ex*)pDevice9If, pSrcTex, pDstTex,
     2746                                        (VBOXBOX3D*)&pData->SrcBox, &Point);
     2747    if (FAILED(hr))
     2748        WARN(("pfnVBoxWineExD3DDev9VolTexBlt failed hr 0x%x", hr));
     2749    else
     2750        hr = S_OK;
    27062751    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2707     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
    2708     Assert(pDevice);
    2709     VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
    2710     Assert(0);
    2711 //    @todo: vboxWddmDalCheckAdd(pDevice);
    2712     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2713     return E_FAIL;
     2752    return hr;;
    27142753}
    27152754
    … …  
    27392778    /* requirements for D3DDevice9::UpdateTexture */
    27402779    Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
    2741             || pDstRc->aAllocations[0].enmD3DIfType==VBOXDISP_D3DIFTYPE_CUBE_TEXTURE);
     2780            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
     2781            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
    27422782    Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
    2743             || pSrcRc->aAllocations[0].enmD3DIfType==VBOXDISP_D3DIFTYPE_CUBE_TEXTURE);
     2783            || pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
     2784            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2785    Assert(pSrcRc->aAllocations[0].enmD3DIfType == pDstRc->aAllocations[0].enmD3DIfType);
    27442786    Assert(pSrcRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
    27452787    Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
    … …  
    27692811    else
    27702812    {
     2813        Assert(pDstRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2814        Assert(pSrcRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2815
    27712816        IDirect3DSurface9 *pSrcSurfIf = NULL;
    27722817        IDirect3DSurface9 *pDstSurfIf = NULL;
    … …  
    30403085}
    30413086
     3087AssertCompile(sizeof (D3DDDIBOX) == sizeof (D3DBOX));
     3088AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(D3DBOX, Left));
     3089AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(D3DBOX, Top));
     3090AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(D3DBOX, Right));
     3091AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(D3DBOX, Bottom));
     3092AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(D3DBOX, Front));
     3093AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(D3DBOX, Back));
     3094
     3095AssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(D3DBOX, Left));
     3096AssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(D3DBOX, Top));
     3097AssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(D3DBOX, Right));
     3098AssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(D3DBOX, Bottom));
     3099AssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(D3DBOX, Front));
     3100AssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(D3DBOX, Back));
     3101
    30423102static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
    30433103{
    … …  
    30703130            Assert(pTexAlloc->pD3DIf);
    30713131            RECT *pRect = NULL;
    3072             bool bNeedResynch = false;
     3132            BOOL fNeedLock = TRUE;
    30733133            Assert(!pData->Flags.RangeValid);
    30743134            Assert(!pData->Flags.BoxValid);
    … …  
    30803140            /* else - we lock the entire texture, pRect == NULL */
    30813141
    3082             if (!pLockAlloc->LockInfo.cLocks)
     3142            if (pLockAlloc->LockInfo.cLocks)
     3143            {
     3144                Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
     3145                if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
     3146                {
     3147                    Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
     3148                    Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
     3149                    Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
     3150                    Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
     3151                }
     3152                Assert(pLockAlloc->LockInfo.LockedRect.pBits);
     3153                Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
     3154
     3155                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
     3156                {
     3157                    switch (pTexAlloc->enmD3DIfType)
     3158                    {
     3159                        case VBOXDISP_D3DIFTYPE_TEXTURE:
     3160                            hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
     3161                            break;
     3162                        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
     3163                            hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
     3164                                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
     3165                            break;
     3166                        case VBOXDISP_D3DIFTYPE_SURFACE:
     3167                            hr = pD3DIfSurface->UnlockRect();
     3168                            break;
     3169                        default:
     3170                            Assert(0);
     3171                            break;
     3172                    }
     3173                    Assert(hr == S_OK);
     3174                }
     3175                else
     3176                {
     3177                    fNeedLock = FALSE;
     3178                }
     3179            }
     3180
     3181            if (fNeedLock && SUCCEEDED(hr))
    30833182            {
    30843183                VBOXVDBG_CHECK_SMSYNC(pRc);
     3184
     3185                pLockAlloc->LockInfo.fFlags = pData->Flags;
     3186                if (pRect)
     3187                {
     3188                    pLockAlloc->LockInfo.Area = *pRect;
     3189                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
     3190                }
     3191                else
     3192                {
     3193                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
     3194                }
     3195
    30853196                switch (pTexAlloc->enmD3DIfType)
    30863197                {
    … …  
    31073218                        break;
    31083219                }
    3109                 Assert(hr == S_OK);
    3110                 if (hr == S_OK)
    3111                 {
    3112                     pLockAlloc->LockInfo.fFlags = pData->Flags;
    3113                     if (pRect)
    3114                     {
    3115                         pLockAlloc->LockInfo.Area = *pRect;
    3116                         Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
    3117                     }
    3118                     else
    3119                     {
    3120                         Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
    3121                     }
    3122 
    3123                     bNeedResynch = !pData->Flags.Discard;
    3124                 }
    3125             }
    3126             else
    3127             {
    3128                 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
    3129                 if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
    3130                 {
    3131                     Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
    3132                     Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
    3133                     Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
    3134                     Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
    3135                 }
    3136                 Assert(pLockAlloc->LockInfo.LockedRect.pBits);
    3137 
    3138                 bNeedResynch = pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard;
    3139 
    3140                 Assert(!bNeedResynch);
    3141 
    3142                 if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
    3143                 {
    3144                     switch (pTexAlloc->enmD3DIfType)
    3145                     {
    3146                         case VBOXDISP_D3DIFTYPE_TEXTURE:
    3147                             hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
    3148                             break;
    3149                         case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
    3150                             hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
    3151                                     VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
    3152                             break;
    3153                         case VBOXDISP_D3DIFTYPE_SURFACE:
    3154                             hr = pD3DIfSurface->UnlockRect();
    3155                             break;
    3156                         default:
    3157                             Assert(0);
    3158                             break;
    3159                     }
    3160                     Assert(hr == S_OK);
    3161                     if (hr == S_OK)
    3162                     {
    3163                         switch (pTexAlloc->enmD3DIfType)
    3164                         {
    3165                             case VBOXDISP_D3DIFTYPE_TEXTURE:
    3166                                 hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
    3167                                         &pLockAlloc->LockInfo.LockedRect,
    3168                                         pRect,
    3169                                         vboxDDI2D3DLockFlags(pData->Flags));
    3170                                 break;
    3171                             case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
    3172                                 hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
    3173                                         VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex),
    3174                                         &pLockAlloc->LockInfo.LockedRect,
    3175                                         pRect,
    3176                                         vboxDDI2D3DLockFlags(pData->Flags));
    3177                                 break;
    3178                             case VBOXDISP_D3DIFTYPE_SURFACE:
    3179                                 hr = pD3DIfSurface->LockRect(&pLockAlloc->LockInfo.LockedRect,
    3180                                         pRect,
    3181                                         vboxDDI2D3DLockFlags(pData->Flags));
    3182                                 break;
    3183                             default:
    3184                                 Assert(0);
    3185                                 break;
    3186                         }
    3187                         Assert(hr == S_OK);
    3188                         pLockAlloc->LockInfo.fFlags.ReadOnly = 0;
    3189                     }
    3190                 }
    3191             }
    3192 
    3193             if (hr == S_OK)
     3220
     3221                if (FAILED(hr))
     3222                {
     3223                    WARN(("LockRect failed, hr", hr));
     3224                }
     3225            }
     3226
     3227            if (SUCCEEDED(hr))
    31943228            {
    31953229                ++pLockAlloc->LockInfo.cLocks;
    … …  
    32103244
    32113245                VBOXVDBG_DUMP_LOCK_ST(pData);
     3246
     3247                hr = S_OK;
     3248            }
     3249        }
     3250        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     3251        {
     3252            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
     3253            Assert(pData->SubResourceIndex < pRc->cAllocations);
     3254            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3255            IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
     3256            Assert(pTexAlloc->pD3DIf);
     3257            D3DDDIBOX *pBox = NULL;
     3258            BOOL fNeedLock = TRUE;
     3259            Assert(!pData->Flags.AreaValid);
     3260            Assert(!pData->Flags.BoxValid);
     3261            if (pData->Flags.BoxValid)
     3262            {
     3263                pBox = &pData->Box;
     3264            }
     3265
     3266            /* else - we lock the entire texture, pBox == NULL */
     3267
     3268            if (pLockAlloc->LockInfo.cLocks)
     3269            {
     3270                Assert(pLockAlloc->LockInfo.fFlags.BoxValid == pData->Flags.BoxValid);
     3271                if (pLockAlloc->LockInfo.fFlags.BoxValid && pData->Flags.BoxValid)
     3272                {
     3273                    Assert(pLockAlloc->LockInfo.Box.Left == pData->Box.Left);
     3274                    Assert(pLockAlloc->LockInfo.Box.Top == pData->Box.Top);
     3275                    Assert(pLockAlloc->LockInfo.Box.Right == pData->Box.Right);
     3276                    Assert(pLockAlloc->LockInfo.Box.Bottom == pData->Box.Bottom);
     3277                    Assert(pLockAlloc->LockInfo.Box.Front == pData->Box.Front);
     3278                    Assert(pLockAlloc->LockInfo.Box.Back == pData->Box.Back);
     3279                }
     3280                Assert(pLockAlloc->LockInfo.LockedBox.pBits);
     3281                Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
     3282
     3283                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
     3284                {
     3285                    hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
     3286                    Assert(hr == S_OK);
     3287                }
     3288                else
     3289                {
     3290                    fNeedLock = FALSE;
     3291                }
     3292            }
     3293
     3294            if (fNeedLock && SUCCEEDED(hr))
     3295            {
     3296                VBOXVDBG_CHECK_SMSYNC(pRc);
     3297
     3298                pLockAlloc->LockInfo.fFlags = pData->Flags;
     3299                if (pBox)
     3300                {
     3301                    pLockAlloc->LockInfo.Box = *pBox;
     3302                    Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 1);
     3303                }
     3304                else
     3305                {
     3306                    Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 0);
     3307                }
     3308
     3309                hr = pD3DIfTex->LockBox(pData->SubResourceIndex,
     3310                                &pLockAlloc->LockInfo.LockedBox,
     3311                                (D3DBOX*)pBox,
     3312                                vboxDDI2D3DLockFlags(pData->Flags));
     3313                if (FAILED(hr))
     3314                {
     3315                    WARN(("LockRect failed, hr", hr));
     3316                }
     3317            }
     3318
     3319            if (SUCCEEDED(hr))
     3320            {
     3321                ++pLockAlloc->LockInfo.cLocks;
     3322
     3323                if (!pData->Flags.NotifyOnly)
     3324                {
     3325                    pData->pSurfData = pLockAlloc->LockInfo.LockedBox.pBits;
     3326                    pData->Pitch = pLockAlloc->LockInfo.LockedBox.RowPitch;
     3327                    pData->SlicePitch = pLockAlloc->LockInfo.LockedBox.SlicePitch;
     3328                    Assert(!pLockAlloc->pvMem);
     3329                }
     3330                else
     3331                {
     3332                    Assert(pLockAlloc->pvMem);
     3333                    Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
     3334                }
     3335
     3336                VBOXVDBG_DUMP_LOCK_ST(pData);
     3337
     3338                hr = S_OK;
    32123339            }
    32133340        }
    … …  
    35463673                        break;
    35473674                }
    3548                 Assert(hr == S_OK);
     3675                if (FAILED(hr))
     3676                    WARN(("UnlockRect failed, hr 0x%x", hr));
    35493677                VBOXVDBG_CHECK_SMSYNC(pRc);
    35503678            }
    3551             else
    3552             {
    3553                 Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
     3679        }
     3680        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     3681        {
     3682            Assert(pData->SubResourceIndex < pRc->cAllocations);
     3683            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3684
     3685            VBOXVDBG_DUMP_UNLOCK_ST(pData);
     3686
     3687            --pLockAlloc->LockInfo.cLocks;
     3688            Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
     3689            if (!pLockAlloc->LockInfo.cLocks)
     3690            {
     3691                PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
     3692                Assert(pTexAlloc->pD3DIf);
     3693                IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
     3694                hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
     3695                if (FAILED(hr))
     3696                    WARN(("UnlockBox failed, hr 0x%x", hr));
     3697                VBOXVDBG_CHECK_SMSYNC(pRc);
    35543698            }
    35553699        }
    … …  
    38584002
    38594003        pAllocation->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
     4004
     4005        if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
     4006        {
     4007            Assert(pAllocation->pvMem);
     4008            Assert(pAllocation->SurfDesc.pitch);
     4009            UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format);
     4010            Assert(minPitch);
     4011            if (minPitch)
     4012            {
     4013                if (pAllocation->SurfDesc.pitch != minPitch)
     4014                {
     4015                    Assert(pAllocation->SurfDesc.pitch > minPitch);
     4016                    pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format);
     4017                    Assert(VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags) && !pRc->RcDesc.fFlags.CubeMap); /* <- tested for textures only! */
     4018                }
     4019                Assert(pAllocation->D3DWidth >= pAllocation->SurfDesc.width);
     4020            }
     4021            else
     4022            {
     4023                Assert(pAllocation->D3DWidth == pAllocation->SurfDesc.width);
     4024            }
     4025        }
     4026
    38604027    }
    38614028

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h

    r43236 r43334  
    234234    };
    235235    D3DDDI_LOCKFLAGS fFlags;
    236     D3DLOCKED_RECT LockedRect;
     236    union {
     237        D3DLOCKED_RECT LockedRect;
     238        D3DLOCKED_BOX LockedBox;
     239    };
    237240#ifdef VBOXWDDMDISP_DEBUG
    238241    PVOID pvData;
    … …  
    246249    VBOXDISP_D3DIFTYPE_TEXTURE,
    247250    VBOXDISP_D3DIFTYPE_CUBE_TEXTURE,
     251    VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE,
    248252    VBOXDISP_D3DIFTYPE_VERTEXBUFFER,
    249253    VBOXDISP_D3DIFTYPE_INDEXBUFFER

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp

    r42557 r43334  
    6666        }
    6767
     68        pD3D->pfnVBoxWineExD3DDev9CreateVolumeTexture = (PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateVolumeTexture");
     69        if (!pD3D->pfnVBoxWineExD3DDev9CreateVolumeTexture)
     70        {
     71            WARN(("no VBoxWineExD3DDev9CreateVolumeTexture"));
     72            break;
     73        }
     74
    6875        pD3D->pfnVBoxWineExD3DDev9Flush = (PFNVBOXWINEEXD3DDEV9_FLUSH)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Flush");
    6976        if (!pD3D->pfnVBoxWineExD3DDev9Flush)
    7077        {
    7178            WARN(("no VBoxWineExD3DDev9Flush"));
     79            break;
     80        }
     81
     82        pD3D->pfnVBoxWineExD3DDev9VolBlt = (PFNVBOXWINEEXD3DDEV9_VOLBLT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9VolBlt");
     83        if (!pD3D->pfnVBoxWineExD3DDev9VolBlt)
     84        {
     85            WARN(("no VBoxWineExD3DDev9VolBlt"));
     86            break;
     87        }
     88
     89        pD3D->pfnVBoxWineExD3DDev9VolTexBlt = (PFNVBOXWINEEXD3DDEV9_VOLTEXBLT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9VolTexBlt");
     90        if (!pD3D->pfnVBoxWineExD3DDev9VolTexBlt)
     91        {
     92            WARN(("no VBoxWineExD3DDev9VolTexBlt"));
    7293            break;
    7394        }

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h

    r42557 r43334  
    5959    PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE pfnVBoxWineExD3DDev9CreateCubeTexture;
    6060
     61    PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE pfnVBoxWineExD3DDev9CreateVolumeTexture;
     62
    6163    PFNVBOXWINEEXD3DDEV9_FLUSH pfnVBoxWineExD3DDev9Flush;
     64
     65    PFNVBOXWINEEXD3DDEV9_VOLBLT pfnVBoxWineExD3DDev9VolBlt;
     66
     67    PFNVBOXWINEEXD3DDEV9_VOLTEXBLT pfnVBoxWineExD3DDev9VolTexBlt;
    6268
    6369    PFNVBOXWINEEXD3DDEV9_UPDATE pfnVBoxWineExD3DDev9Update;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxScreen.cpp

    r38112 r43334  
    1717 */
    1818
     19#include "VBoxDispD3DCmn.h"
    1920#include "VBoxScreen.h"
    2021

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxUhgsmiKmt.h

    r42499 r43334  
    2020#define ___VBoxUhgsmiKmt_h__
    2121
    22 #include "VBoxUhgsmiBase.h"
    2322#include "VBoxDispD3DCmn.h"
    2423
Note: See TracChangeset for help on using the changeset viewer.

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