VirtualBox

Changeset 49244 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Oct 22, 2013 8:08:34 PM (11 years ago)
Author:
vboxsync
Message:

wddm: fix 3D rendering to primary

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

Legend:

Unmodified
Added
Removed

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

    r48070 r49244  
    478478    uint64_t hAlloc;
    479479} VBOXDISPIFESCAPE_SHRC_REF, *PVBOXDISPIFESCAPE_SHRC_REF;
     480
     481typedef struct VBOXDISPIFESCAPE_SETALLOCHOSTID
     482{
     483    VBOXDISPIFESCAPE EscapeHdr;
     484    int32_t rc;
     485    uint32_t hostID;
     486    uint64_t hAlloc;
     487
     488} VBOXDISPIFESCAPE_SETALLOCHOSTID, *PVBOXDISPIFESCAPE_SETALLOCHOSTID;
    480489
    481490typedef struct VBOXDISPIFESCAPE_CRHGSMICTLCON_CALL

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

    r46966 r49244  
    868868}
    869869
     870int vboxD3DIfSetHostId(PVBOXWDDMDISP_ALLOCATION pAlloc, uint32_t hostID, uint32_t *pHostID)
     871{
     872    struct VBOXWDDMDISP_RESOURCE *pRc = pAlloc->pRc;
     873    PVBOXWDDMDISP_DEVICE pDevice = pRc->pDevice;
     874
     875    VBOXDISPIFESCAPE_SETALLOCHOSTID SetHostID = {0};
     876    SetHostID.EscapeHdr.escapeCode = VBOXESC_SETALLOCHOSTID;
     877    SetHostID.hostID = hostID;
     878    SetHostID.hAlloc = pAlloc->hAllocation;
     879
     880    D3DDDICB_ESCAPE DdiEscape = {0};
     881    DdiEscape.hContext = pDevice->DefaultContext.ContextInfo.hContext;
     882    DdiEscape.hDevice = pDevice->hDevice;
     883//    DdiEscape.Flags.Value = 0;
     884    DdiEscape.pPrivateDriverData = &SetHostID;
     885    DdiEscape.PrivateDriverDataSize = sizeof (SetHostID);
     886    HRESULT hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
     887    if (SUCCEEDED(hr))
     888    {
     889        if (pHostID)
     890            *pHostID = SetHostID.EscapeHdr.u32CmdSpecific;
     891
     892        return SetHostID.rc;
     893    }
     894    else
     895        WARN(("pfnEscapeCb VBOXESC_SETALLOCHOSTID failed hr 0x%x", hr));
     896
     897    return VERR_GENERAL_FAILURE;
     898}
     899
     900IUnknown* vboxD3DIfCreateSharedPrimary(PVBOXWDDMDISP_ALLOCATION pAlloc)
     901{
     902    IDirect3DSurface9 *pSurfIf;
     903    struct VBOXWDDMDISP_RESOURCE *pRc = pAlloc->pRc;
     904    PVBOXWDDMDISP_DEVICE pDevice = pRc->pDevice;
     905
     906    HRESULT hr = VBoxD3DIfCreateForRc(pRc);
     907    if (!SUCCEEDED(hr))
     908    {
     909        WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr));
     910        return NULL;
     911    }
     912
     913    Assert(pAlloc->pD3DIf);
     914    Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
     915    Assert(pAlloc->pRc->RcDesc.fFlags.SharedResource);
     916
     917    hr = VBoxD3DIfSurfGet(pRc, pAlloc->iAlloc, &pSurfIf);
     918    if (!SUCCEEDED(hr))
     919    {
     920        WARN(("VBoxD3DIfSurfGet failed hr %#x", hr));
     921        return NULL;
     922    }
     923
     924    uint32_t hostID, usedHostId;
     925    hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DSurf9GetHostId(pSurfIf, &hostID);
     926    if (SUCCEEDED(hr))
     927    {
     928        Assert(hostID);
     929        int rc = vboxD3DIfSetHostId(pAlloc, hostID, &usedHostId);
     930        if (!RT_SUCCESS(rc))
     931        {
     932            if (rc == VERR_NOT_EQUAL)
     933            {
     934                WARN(("another hostId % is in use, using it instead", usedHostId));
     935                Assert(hostID != usedHostId);
     936                Assert(usedHostId);
     937                pSurfIf->Release();
     938                pSurfIf = NULL;
     939                for (UINT i = 0; i < pRc->cAllocations; ++i)
     940                {
     941                    PVBOXWDDMDISP_ALLOCATION pCurAlloc = &pRc->aAllocations[i];
     942                    if (pCurAlloc->pD3DIf)
     943                    {
     944                        pCurAlloc->pD3DIf->Release();
     945                        pCurAlloc->pD3DIf = NULL;
     946                    }
     947                }
     948
     949                pAlloc->hSharedHandle = (HANDLE)usedHostId;
     950
     951                hr = VBoxD3DIfCreateForRc(pRc);
     952                if (!SUCCEEDED(hr))
     953                {
     954                    WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr));
     955                    return NULL;
     956                }
     957
     958                hr = VBoxD3DIfSurfGet(pRc, pAlloc->iAlloc, &pSurfIf);
     959                if (!SUCCEEDED(hr))
     960                {
     961                    WARN(("VBoxD3DIfSurfGet failed hr %#x", hr));
     962                    return NULL;
     963                }
     964            }
     965            else
     966            {
     967                WARN(("vboxD3DIfSetHostId failed %#x, ignoring", hr));
     968                hr = S_OK;
     969                hostID = 0;
     970                usedHostId = 0;
     971            }
     972        }
     973        else
     974        {
     975            Assert(hostID == usedHostId);
     976        }
     977
     978        pSurfIf->Release();
     979        pSurfIf = NULL;
     980    }
     981    else
     982        WARN(("pfnVBoxWineExD3DSurf9GetHostId failed, hr 0x%x", hr));
     983
     984    return pAlloc->pD3DIf;
     985}

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

    r43360 r49244  
    4141void VBoxD3DIfLockUnlockMemSynch(struct VBOXWDDMDISP_ALLOCATION *pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo);
    4242
     43IUnknown* vboxD3DIfCreateSharedPrimary(PVBOXWDDMDISP_ALLOCATION pAlloc);
     44
     45
    4346/* NOTE: does NOT increment a ref counter! NO Release needed!! */
    44 DECLINLINE(IUnknown*) VBoxD3DIfGet(PVBOXWDDMDISP_ALLOCATION pAlloc)
     47DECLINLINE(IUnknown*) vboxD3DIfGet(PVBOXWDDMDISP_ALLOCATION pAlloc)
    4548{
    4649    if (pAlloc->pD3DIf)
    … …  
    5356    }
    5457
    55     HRESULT hr = VBoxD3DIfCreateForRc(pAlloc->pRc);
    56     if (!SUCCEEDED(hr))
    57     {
    58         WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr));
    59         return NULL;
    60     }
    61 
    62     Assert(pAlloc->pD3DIf);
    63     Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
    64 
    65     return pAlloc->pD3DIf;
     58    return vboxD3DIfCreateSharedPrimary(pAlloc);
    6659}
    6760
    … …  
    7366    Assert(pRc->cAllocations > iAlloc);
    7467    *ppSurf = NULL;
    75     IUnknown* pD3DIf = VBoxD3DIfGet(&pRc->aAllocations[iAlloc]);
     68    IUnknown* pD3DIf = vboxD3DIfGet(&pRc->aAllocations[iAlloc]);
    7669
    7770    switch (pRc->aAllocations[0].enmD3DIfType)

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

    r49220 r49244  
    57485748            pRc->RcDesc.MultisampleQuality = 0;
    57495749            pRc->RcDesc.MipLevels = 0;
    5750             pRc->RcDesc.Fvf;
     5750            /*pRc->RcDesc.Fvf;*/
     5751            pRc->RcDesc.fFlags.SharedResource = 1;
    57515752
    57525753            if (pData->NumAllocations != 1)

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.h

    r47070 r49244  
    236236
    237237#define VBOXMP_CRCMD_HEADER_SIZE sizeof (CRMessageOpcodes)
    238 /* last +4 below is 4-aligned comand opcode size (i.e. ((1 + 3) & ~3)) */
     238/* last +4 below is 4-aligned command opcode size (i.e. ((1 + 3) & ~3)) */
    239239#define VBOXMP_CRCMD_SIZE_WINDOWPOSITION (20 + 4)
    240240#define VBOXMP_CRCMD_SIZE_WINDOWVISIBLEREGIONS(_cRects) (16 + (_cRects) * 4 * sizeof (GLint) + 4)
    … …  
    243243#define VBOXMP_CRCMD_SIZE_WINDOWSIZE (20 + 4)
    244244#define VBOXMP_CRCMD_SIZE_GETCHROMIUMPARAMETERVCR (36 + 4)
     245#define VBOXMP_CRCMD_SIZE_CHROMIUMPARAMETERICR (16 + 4)
     246#define VBOXMP_CRCMD_SIZE_WINDOWCREATE (256 + 28 + 4)
     247#define VBOXMP_CRCMD_SIZE_WINDOWDESTROY (12 + 4)
     248#define VBOXMP_CRCMD_SIZE_CREATECONTEXT (256 + 32 + 4)
     249#define VBOXMP_CRCMD_SIZE_DESTROYCONTEXT (12 + 4)
    245250
    246251#endif /* #ifndef ___VBoxMPCr_h__ */

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h

    r48070 r49244  
    108108    VBOXWDDM_ADDR Addr;
    109109    uint32_t hostID;
     110    uint32_t cHostIDRefs;
    110111    struct VBOXWDDM_SWAPCHAIN *pSwapchain;
    111112} VBOXWDDM_ALLOC_DATA, *PVBOXWDDM_ALLOC_DATA;
    … …  
    320321    uint32_t cShRcRefs;
    321322    uint32_t cOpens;
     323    uint32_t cHostIDRefs;
    322324} VBOXWDDM_OPENALLOCATION, *PVBOXWDDM_OPENALLOCATION;
    323325

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

    r47566 r49244  
    897897}
    898898
     899typedef struct VBOXMP_CRHGSMIMGR
     900{
     901    VBOXMP_CRPACKER CrPacker;
     902    void *pvCommandBuffer;
     903} VBOXMP_CRHGSMIMGR;
     904
     905DECLINLINE(CRPackContext*) vboxVdmaCrHmGetPackContext(VBOXMP_CRHGSMIMGR *pMgr)
     906{
     907    return &pMgr->CrPacker.CrPacker;
     908}
     909
     910NTSTATUS vboxVdmaCrHmCreate(PVBOXMP_DEVEXT pDevExt, VBOXMP_CRHGSMIMGR *pMgr, uint32_t cbCommandBuffer, uint32_t cCommands)
     911{
     912    pMgr->pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
     913    if (!pMgr->pvCommandBuffer)
     914    {
     915        WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
     916        return VERR_OUT_OF_RESOURCES;
     917    }
     918
     919    VBoxMpCrPackerInit(&pMgr->CrPacker);
     920
     921    VBoxMpCrPackerTxBufferInit(&pMgr->CrPacker, pMgr->pvCommandBuffer, cbCommandBuffer, cCommands);
     922
     923    return STATUS_SUCCESS;
     924}
     925
     926NTSTATUS vboxVdmaCrHmSubmitWrSync(PVBOXMP_DEVEXT pDevExt, VBOXMP_CRHGSMIMGR *pMgr, uint32_t u32CrConClientID)
     927{
     928    NTSTATUS Status = vboxVdmaCrRxGenericSync(pDevExt, &pMgr->CrPacker, u32CrConClientID);
     929    if (!NT_SUCCESS(Status))
     930    {
     931        WARN(("vboxVdmaCrRxGenericSync failed Status 0x%x", Status));
     932        VBoxMpCrShgsmiTransportBufFree(&pDevExt->CrHgsmiTransport, pMgr->pvCommandBuffer);
     933        return Status;
     934    }
     935
     936    return STATUS_SUCCESS;
     937}
    899938#if 0
    900939NTSTATUS vboxVdmaCrCmdGetChromiumParametervCR(PVBOXMP_DEVEXT pDevExt, uint32_t u32CrConClientID, GLenum target, GLuint index, GLenum type, GLsizei count, GLvoid * values)
    … …  
    902941    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE + VBOXMP_CRCMD_SIZE_GETCHROMIUMPARAMETERVCR;
    903942    uint32_t cCommands = 1;
    904     void *pvCommandBuffer = VBoxMpCrShgsmiTransportBufAlloc(&pDevExt->CrHgsmiTransport, cbCommandBuffer);
    905     if (!pvCommandBuffer)
    906     {
    907         WARN(("VBoxMpCrShgsmiTransportBufAlloc failed!"));
    908         return VERR_OUT_OF_RESOURCES;
    909     }
    910 
    911     VBOXMP_CRPACKER CrPacker;
    912     VBoxMpCrPackerInit(&CrPacker);
    913 
    914     VBoxMpCrPackerTxBufferInit(&CrPacker, pvCommandBuffer, cbCommandBuffer, cCommands);
     943
     944    VBOXMP_CRHGSMIMGR Mgr;
     945    NTSTATUS Status = vboxVdmaCrHmCreate(pDevExt, &Mgr, cbCommandBuffer, cCommands);
     946    if (!NT_SUCCESS(Status))
     947    {
     948        WARN(("vboxVdmaCrHmCreate failed Status 0x%x", Status));
     949        return Status;
     950    }
    915951
    916952    int dummy = 1;
    917953
    918     crPackGetChromiumParametervCR(&CrPacker.CrPacker, target, index, type, count, values, &dummy);
    919 
    920 
    921     NTSTATUS Status = vboxVdmaCrRxGenericSync(pDevExt, &CrPacker, u32CrConClientID);
     954    crPackGetChromiumParametervCR(vboxVdmaCrHmGetPackContext(&Mgr), target, index, type, count, values, &dummy);
     955
     956    Status = vboxVdmaCrHmSubmitWrSync(pDevExt, &Mgr, u32CrConClientID);
    922957    if (!NT_SUCCESS(Status))
    923958    {
    924         WARN(("vboxVdmaCrRxGenericSync failed Status 0x%x", Status));
    925         VBoxMpCrShgsmiTransportBufFree(&pDevExt->CrHgsmiTransport, pvCommandBuffer);
     959        WARN(("vboxVdmaCrHmSubmitWrSync failed Status 0x%x", Status));
    926960        return Status;
    927961    }
    928962
    929 
     963    return STATUS_SUCCESS;
     964}
     965
     966static NTSTATUS vboxVdmaCrCmdCreateContext(PVBOXMP_DEVEXT pDevExt, int32_t visualBits, int32_t *pi32CtxID)
     967{
     968    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE + VBOXMP_CRCMD_SIZE_CREATECONTEXT;
     969    uint32_t cCommands = 1;
     970
     971    VBOXMP_CRHGSMIMGR Mgr;
     972    NTSTATUS Status = vboxVdmaCrHmCreate(pDevExt, &Mgr, cbCommandBuffer, cCommands);
     973    if (!NT_SUCCESS(Status))
     974    {
     975        WARN(("vboxVdmaCrHmCreate failed Status 0x%x", Status));
     976        return Status;
     977    }
     978
     979    int dummy = 1;
     980
     981    crPackCreateContext(&CrPacker.CrPacker, "", visualBits, 0, &pi32CtxID, &dummy);
     982
     983    Status = vboxVdmaCrHmSubmitWrSync(pDevExt, &Mgr, u32CrConClientID);
     984    if (!NT_SUCCESS(Status))
     985    {
     986        WARN(("vboxVdmaCrHmSubmitWrSync failed Status 0x%x", Status));
     987        return Status;
     988    }
     989
     990    return STATUS_SUCCESS;
     991}
     992
     993static NTSTATUS vboxVdmaCrCmdWindowCreate(PVBOXMP_DEVEXT pDevExt, int32_t visualBits, int32_t *pi32WinID)
     994{
     995    uint32_t cbCommandBuffer = VBOXMP_CRCMD_HEADER_SIZE + VBOXMP_CRCMD_SIZE_WINDOWCREATE;
     996    uint32_t cCommands = 1;
     997
     998    VBOXMP_CRHGSMIMGR Mgr;
     999    NTSTATUS Status = vboxVdmaCrHmCreate(pDevExt, &Mgr, cbCommandBuffer, cCommands);
     1000    if (!NT_SUCCESS(Status))
     1001    {
     1002        WARN(("vboxVdmaCrHmCreate failed Status 0x%x", Status));
     1003        return Status;
     1004    }
     1005
     1006    int dummy = 1;
     1007
     1008    crPackWindowCreate(&CrPacker.CrPacker, "", visualBits, 0, &pi32CtxID, &dummy);
     1009
     1010    Status = vboxVdmaCrHmSubmitWrSync(pDevExt, &Mgr, u32CrConClientID);
     1011    if (!NT_SUCCESS(Status))
     1012    {
     1013        WARN(("vboxVdmaCrHmSubmitWrSync failed Status 0x%x", Status));
     1014        return Status;
     1015    }
     1016
     1017    return STATUS_SUCCESS;
     1018}
     1019
     1020static NTSTATUS vboxVdmaCrCtlGetDefaultCtxId(PVBOXMP_DEVEXT pDevExt, int32_t *pi32CtxID)
     1021{
     1022    if (!pDevExt->i32CrConDefaultCtxID)
     1023    {
     1024        if (!pDevExt->f3DEnabled)
     1025        {
     1026            WARN(("3D disabled, should not be here!"));
     1027            return STATUS_UNSUCCESSFUL;
     1028        }
     1029
     1030        uint32_t u32ClienID;
     1031        NTSTATUS Status = vboxVdmaCrCtlGetDefaultClientId(pDevExt, &u32ClienID);
     1032        if (!NT_SUCCESS(Status))
     1033        {
     1034            WARN(("vboxVdmaCrCtlGetDefaultClientId failed, Status %#x", Status));
     1035            return Status;
     1036        }
     1037
     1038        Status = vboxVdmaCrCmdWindowCreate(PVBOXMP_DEVEXT pDevExt, int32_t visualBits, int32_t *pi32WinID)
     1039
     1040        VBOXMP_CRPACKER CrPacker;
     1041        VBoxMpCrPackerInit(&CrPacker);
     1042
     1043        int rc = VBoxMpCrCtlConConnect(&pDevExt->CrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pDevExt->u32CrConDefaultClientID);
     1044        if (!RT_SUCCESS(rc))
     1045        {
     1046            WARN(("VBoxMpCrCtlConConnect failed, rc %d", rc));
     1047            return STATUS_UNSUCCESSFUL;
     1048        }
     1049    }
     1050
     1051    *pi32CtxID = pDevExt->i32CrConDefaultCtxID;
    9301052    return STATUS_SUCCESS;
    9311053}

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r49171 r49244  
    5757}
    5858
     59DECLINLINE(void) VBoxWddmOaHostIDReleaseLocked(PVBOXWDDM_OPENALLOCATION pOa)
     60{
     61    Assert(pOa->cHostIDRefs);
     62    PVBOXWDDM_ALLOCATION pAllocation = pOa->pAllocation;
     63    Assert(pAllocation->AllocData.cHostIDRefs >= pOa->cHostIDRefs);
     64    Assert(pAllocation->AllocData.hostID);
     65    --pOa->cHostIDRefs;
     66    --pAllocation->AllocData.cHostIDRefs;
     67    if (!pAllocation->AllocData.cHostIDRefs)
     68        pAllocation->AllocData.hostID = 0;
     69}
     70
     71DECLINLINE(void) VBoxWddmOaHostIDCheckReleaseLocked(PVBOXWDDM_OPENALLOCATION pOa)
     72{
     73    if (pOa->cHostIDRefs)
     74        VBoxWddmOaHostIDReleaseLocked(pOa);
     75}
     76
    5977DECLINLINE(void) VBoxWddmOaRelease(PVBOXWDDM_OPENALLOCATION pOa)
    6078{
    … …  
    6381    KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
    6482    Assert(pAllocation->cOpens);
     83    VBoxWddmOaHostIDCheckReleaseLocked(pOa);
    6584    --pAllocation->cOpens;
    6685    uint32_t cOpens = --pOa->cOpens;
    … …  
    97116    KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
    98117    return pOa;
     118}
     119
     120DECLINLINE(int) VBoxWddmOaSetHostID(PVBOXWDDM_DEVICE pDevice, PVBOXWDDM_ALLOCATION pAllocation, uint32_t hostID, uint32_t *pHostID)
     121{
     122    PVBOXWDDM_OPENALLOCATION pOa;
     123    KIRQL OldIrql;
     124    int rc = VINF_SUCCESS;
     125    KeAcquireSpinLock(&pAllocation->OpenLock, &OldIrql);
     126    pOa = VBoxWddmOaSearchLocked(pDevice, pAllocation);
     127    if (!pOa)
     128    {
     129        KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);;
     130        WARN(("no open allocation!"));
     131        return VERR_INVALID_STATE;
     132    }
     133
     134    if (hostID)
     135    {
     136        if (pAllocation->AllocData.hostID == 0)
     137        {
     138            pAllocation->AllocData.hostID = hostID;
     139        }
     140        else if (pAllocation->AllocData.hostID != hostID)
     141        {
     142            WARN(("hostID differ: alloc(%d), trying to assign(%d)", pAllocation->AllocData.hostID, hostID));
     143            hostID = pAllocation->AllocData.hostID;
     144            rc = VERR_NOT_EQUAL;
     145        }
     146
     147        ++pAllocation->AllocData.cHostIDRefs;
     148        ++pOa->cHostIDRefs;
     149    }
     150    else
     151        VBoxWddmOaHostIDCheckReleaseLocked(pOa);
     152
     153    KeReleaseSpinLock(&pAllocation->OpenLock, OldIrql);
     154
     155    if (pHostID)
     156        *pHostID = hostID;
     157
     158    return rc;
    99159}
    100160
    … …  
    40414101                break;
    40424102            }
     4103            case VBOXESC_SETALLOCHOSTID:
     4104            {
     4105                PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)pEscape->hDevice;
     4106                if (!pDevice)
     4107                {
     4108                    WARN(("VBOXESC_SETALLOCHOSTID called without no device specified, failing"));
     4109                    Status = STATUS_INVALID_PARAMETER;
     4110                    break;
     4111                }
     4112
     4113                if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_SETALLOCHOSTID))
     4114                {
     4115                    WARN(("invalid buffer size for VBOXDISPIFESCAPE_SHRC_REF, was(%d), but expected (%d)",
     4116                            pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SHRC_REF)));
     4117                    Status = STATUS_INVALID_PARAMETER;
     4118                    break;
     4119                }
     4120
     4121                PVBOXDISPIFESCAPE_SETALLOCHOSTID pSetHostID = (PVBOXDISPIFESCAPE_SETALLOCHOSTID)pEscapeHdr;
     4122                PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pSetHostID->hAlloc);
     4123                if (!pAlloc)
     4124                {
     4125                    WARN(("failed to get allocation from handle"));
     4126                    Status = STATUS_INVALID_PARAMETER;
     4127                    break;
     4128                }
     4129
     4130                if (pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
     4131                {
     4132                    WARN(("setHostID: invalid allocation type: %d", pAlloc->enmType));
     4133                    Status = STATUS_INVALID_PARAMETER;
     4134                    break;
     4135                }
     4136
     4137                pSetHostID->rc = VBoxWddmOaSetHostID(pDevice, pAlloc, pSetHostID->hostID, &pSetHostID->EscapeHdr.u32CmdSpecific);
     4138                Status = STATUS_SUCCESS;
     4139                break;
     4140            }
    40434141            case VBOXESC_SHRC_ADDREF:
    40444142            case VBOXESC_SHRC_RELEASE:
    40454143            {
    40464144                PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)pEscape->hDevice;
     4145                if (!pDevice)
     4146                {
     4147                    WARN(("VBOXESC_SHRC_ADDREF|VBOXESC_SHRC_RELEASE called without no device specified, failing"));
     4148                    Status = STATUS_INVALID_PARAMETER;
     4149                    break;
     4150                }
     4151
    40474152                /* query whether the allocation represanted by the given [wine-generated] shared resource handle still exists */
    40484153                if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_SHRC_REF))
    … …  
    50025107    if (pOpenAllocation->PrivateDriverSize)
    50035108    {
    5004         Assert(pOpenAllocation->PrivateDriverSize == sizeof (VBOXWDDM_RCINFO));
    50055109        Assert(pOpenAllocation->pPrivateDriverData);
    5006         if (pOpenAllocation->PrivateDriverSize >= sizeof (VBOXWDDM_RCINFO))
     5110        if (pOpenAllocation->PrivateDriverSize == sizeof (VBOXWDDM_RCINFO))
    50075111        {
    50085112            pRcInfo = (PVBOXWDDM_RCINFO)pOpenAllocation->pPrivateDriverData;
    … …  
    50105114        }
    50115115        else
     5116        {
     5117            WARN(("Invalid PrivateDriverSize %d", pOpenAllocation->PrivateDriverSize));
    50125118            Status = STATUS_INVALID_PARAMETER;
     5119        }
    50135120    }
    50145121

  • trunk/src/VBox/Additions/WINNT/include/VBoxDisplay.h

    r48070 r49244  
    3939# define VBOXESC_SETCTXHOSTID               0xABCD9012
    4040# define VBOXESC_CONFIGURETARGETS           0xABCD9013
     41# define VBOXESC_SETALLOCHOSTID             0xABCD9014
    4142#endif /* #ifdef VBOX_WITH_WDDM */
    4243
Note: See TracChangeset for help on using the changeset viewer.

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