VirtualBox

Changeset 42499 in vbox


Ignore:
Timestamp:
Aug 1, 2012 10:26:43 AM (12 years ago)
Author:
vboxsync
Message:

crOgl/wddm: per-context connections

Location:
trunk/src/VBox
Files:
1 added
56 edited

Legend:

Unmodified
Added
Removed

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

    r41374 r42499  
    2424static VBOXDISPKMT_CALLBACKS g_VBoxCrHgsmiKmtCallbacks;
    2525static int g_bVBoxKmtCallbacksInited = 0;
    26 static uint32_t g_VBoxCrVersionMajor;
    27 static uint32_t g_VBoxCrVersionMinor;
    2826
    29 #ifdef VBOX_CRHGSMI_WITH_D3DDEV
    30 static VBOXCRHGSMI_CALLBACKS g_VBoxCrHgsmiCallbacks;
    31 static HMODULE g_hVBoxCrHgsmiProvider = NULL;
    32 static uint32_t g_cVBoxCrHgsmiProvider = 0;
    33 
    34 
    35 typedef VBOXWDDMDISP_DECL(int) FNVBOXDISPCRHGSMI_INIT(PVBOXCRHGSMI_CALLBACKS pCallbacks);
    36 typedef FNVBOXDISPCRHGSMI_INIT *PFNVBOXDISPCRHGSMI_INIT;
    37 
    38 typedef VBOXWDDMDISP_DECL(int) FNVBOXDISPCRHGSMI_TERM();
    39 typedef FNVBOXDISPCRHGSMI_TERM *PFNVBOXDISPCRHGSMI_TERM;
    40 
    41 typedef VBOXWDDMDISP_DECL(HVBOXCRHGSMI_CLIENT) FNVBOXDISPCRHGSMI_QUERY_CLIENT();
    42 typedef FNVBOXDISPCRHGSMI_QUERY_CLIENT *PFNVBOXDISPCRHGSMI_QUERY_CLIENT;
    43 
    44 static PFNVBOXDISPCRHGSMI_INIT g_pfnVBoxDispCrHgsmiInit = NULL;
    45 static PFNVBOXDISPCRHGSMI_TERM g_pfnVBoxDispCrHgsmiTerm = NULL;
    46 static PFNVBOXDISPCRHGSMI_QUERY_CLIENT g_pfnVBoxDispCrHgsmiQueryClient = NULL;
    47 
    48 VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks)
    49 {
    50     if (!g_bVBoxKmtCallbacksInited)
    51     {
    52         HRESULT hr = vboxDispKmtCallbacksInit(&g_VBoxCrHgsmiKmtCallbacks);
    53         Assert(hr == S_OK);
    54         if (hr == S_OK)
    55             g_bVBoxKmtCallbacksInited = 1;
    56         else
    57             g_bVBoxKmtCallbacksInited = -1;
    58     }
    59 
    60     Assert(g_bVBoxKmtCallbacksInited);
    61     if (g_bVBoxKmtCallbacksInited < 0)
    62     {
    63         Assert(0);
    64         return VERR_NOT_SUPPORTED;
    65     }
    66 
    67     g_VBoxCrHgsmiCallbacks = *pCallbacks;
    68     if (!g_hVBoxCrHgsmiProvider)
    69     {
    70         g_hVBoxCrHgsmiProvider = GetModuleHandle(L"VBoxDispD3D");
    71         if (g_hVBoxCrHgsmiProvider)
    72         {
    73             g_hVBoxCrHgsmiProvider = LoadLibrary(L"VBoxDispD3D");
    74         }
    75 
    76         if (g_hVBoxCrHgsmiProvider)
    77         {
    78             g_pfnVBoxDispCrHgsmiInit = (PFNVBOXDISPCRHGSMI_INIT)GetProcAddress(g_hVBoxCrHgsmiProvider, "VBoxDispCrHgsmiInit");
    79             Assert(g_pfnVBoxDispCrHgsmiInit);
    80             if (g_pfnVBoxDispCrHgsmiInit)
    81             {
    82                 g_pfnVBoxDispCrHgsmiInit(pCallbacks);
    83             }
    84 
    85             g_pfnVBoxDispCrHgsmiTerm = (PFNVBOXDISPCRHGSMI_TERM)GetProcAddress(g_hVBoxCrHgsmiProvider, "VBoxDispCrHgsmiTerm");
    86             Assert(g_pfnVBoxDispCrHgsmiTerm);
    87 
    88             g_pfnVBoxDispCrHgsmiQueryClient = (PFNVBOXDISPCRHGSMI_QUERY_CLIENT)GetProcAddress(g_hVBoxCrHgsmiProvider, "VBoxDispCrHgsmiQueryClient");
    89             Assert(g_pfnVBoxDispCrHgsmiQueryClient);
    90         }
    91 #ifdef DEBUG_misha
    92         else
    93         {
    94             DWORD winEr = GetLastError();
    95             Assert(0);
    96         }
    97 #endif
    98     }
    99 
    100     if (g_hVBoxCrHgsmiProvider)
    101     {
    102         if (g_pfnVBoxDispCrHgsmiInit)
    103         {
    104             g_pfnVBoxDispCrHgsmiInit(pCallbacks);
    105         }
    106         ++g_cVBoxCrHgsmiProvider;
    107         return VINF_SUCCESS;
    108     }
    109 
    110     /* we're called from ogl ICD driver*/
    111     Assert(0);
    112 
    113     return VINF_SUCCESS;
    114 }
    115 
    116 static __declspec(thread) PVBOXUHGSMI_PRIVATE_KMT gt_pHgsmiGL = NULL;
    117 
    118 VBOXCRHGSMI_DECL(HVBOXCRHGSMI_CLIENT) VBoxCrHgsmiQueryClient()
    119 {
    120 
    121     HVBOXCRHGSMI_CLIENT hClient;
    122     if (g_pfnVBoxDispCrHgsmiQueryClient)
    123     {
    124         hClient = g_pfnVBoxDispCrHgsmiQueryClient();
    125 //#ifdef DEBUG_misha
    126 //        Assert(hClient);
    127 //#endif
    128         if (hClient)
    129             return hClient;
    130     }
    131     PVBOXUHGSMI_PRIVATE_KMT pHgsmiGL = gt_pHgsmiGL;
    132     if (pHgsmiGL)
    133     {
    134         Assert(pHgsmiGL->BasePrivate.hClient);
    135         return pHgsmiGL->BasePrivate.hClient;
    136     }
    137     pHgsmiGL = (PVBOXUHGSMI_PRIVATE_KMT)RTMemAllocZ(sizeof (*pHgsmiGL));
    138     if (pHgsmiGL)
    139     {
    140 #if 0
    141         HRESULT hr = vboxUhgsmiKmtCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
    142 #else
    143         HRESULT hr = vboxUhgsmiKmtEscCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
    144 #endif
    145         Assert(hr == S_OK);
    146         if (hr == S_OK)
    147         {
    148             hClient = g_VBoxCrHgsmiCallbacks.pfnClientCreate(&pHgsmiGL->BasePrivate.Base);
    149             Assert(hClient);
    150             if (hClient)
    151             {
    152                 pHgsmiGL->BasePrivate.hClient = hClient;
    153                 gt_pHgsmiGL = pHgsmiGL;
    154                 return hClient;
    155             }
    156             vboxUhgsmiKmtDestroy(pHgsmiGL);
    157         }
    158         RTMemFree(pHgsmiGL);
    159     }
    160 
    161     return NULL;
    162 }
    163 #else
    16427static int vboxCrHgsmiInitPerform(VBOXDISPKMT_CALLBACKS *pCallbacks)
    16528{
    … …  
    18346}
    18447
    185 VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit(uint32_t crVersionMajor, uint32_t crVersionMinor)
     48VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit()
    18649{
    18750    if (!g_bVBoxKmtCallbacksInited)
    … …  
    18952        g_bVBoxKmtCallbacksInited = vboxCrHgsmiInitPerform(&g_VBoxCrHgsmiKmtCallbacks);
    19053        Assert(g_bVBoxKmtCallbacksInited);
    191         if (g_bVBoxKmtCallbacksInited)
    192         {
    193             g_VBoxCrVersionMajor = crVersionMajor;
    194             g_VBoxCrVersionMinor = crVersionMinor;
    195         }
    19654    }
    19755
    … …  
    20563    {
    20664#if 0
    207         HRESULT hr = vboxUhgsmiKmtCreate(pHgsmiGL, g_VBoxCrVersionMajor, g_VBoxCrVersionMinor, TRUE /* bD3D tmp for injection thread*/);
     65        HRESULT hr = vboxUhgsmiKmtCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
    20866#else
    209         HRESULT hr = vboxUhgsmiKmtEscCreate(pHgsmiGL, g_VBoxCrVersionMajor, g_VBoxCrVersionMinor, TRUE /* bD3D tmp for injection thread*/);
     67        HRESULT hr = vboxUhgsmiKmtEscCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
    21068#endif
    211         Log(("CrHgsmi: faled to create KmtEsc UHGSMI instance, hr (0x%x)\n", hr));
     69        Log(("CrHgsmi: faled to create KmtEsc VBOXUHGSMI instance, hr (0x%x)\n", hr));
    21270        if (hr == S_OK)
    21371        {
    … …  
    23088    }
    23189}
    232 #endif
    23390
    23491VBOXCRHGSMI_DECL(int) VBoxCrHgsmiTerm()
    … …  
    256113{
    257114    PVBOXUHGSMI_PRIVATE_BASE pHgsmiPrivate = (PVBOXUHGSMI_PRIVATE_BASE)pHgsmi;
    258     int rc = VBoxCrHgsmiPrivateCtlConGetClientID(pHgsmiPrivate, pu32ClientID);
     115    int rc = vboxCrHgsmiPrivateCtlConGetClientID(pHgsmiPrivate, pu32ClientID);
    259116    if (!RT_SUCCESS(rc))
    260117    {
    … …  
    267124{
    268125    PVBOXUHGSMI_PRIVATE_BASE pHgsmiPrivate = (PVBOXUHGSMI_PRIVATE_BASE)pHgsmi;
    269     int rc = VBoxCrHgsmiPrivateCtlConCall(pHgsmiPrivate, pCallInfo, cbCallInfo);
     126    int rc = vboxCrHgsmiPrivateCtlConCall(pHgsmiPrivate, pCallInfo, cbCallInfo);
    270127    if (!RT_SUCCESS(rc))
    271128    {

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

    r40483 r42499  
    2323#include <iprt/list.h>
    2424
     25#include <cr_protocol.h>
    2526
    2627typedef struct VBOXDISPCM_SESSION
    … …  
    114115HRESULT vboxDispCmCtxCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_CONTEXT pContext)
    115116{
     117    BOOL fIsCrContext;
    116118    VBOXWDDM_CREATECONTEXT_INFO Info = {0};
    117119    Info.u32IfVersion = pDevice->u32IfVersion;
    118     Info.enmType = VBOXDISPMODE_IS_3D(pDevice->pAdapter) ? VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D : VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D;
     120    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
     121    {
     122        Info.enmType = VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D;
     123        Info.crVersionMajor = CR_PROTOCOL_VERSION_MAJOR;
     124        Info.crVersionMinor = CR_PROTOCOL_VERSION_MINOR;
     125        fIsCrContext = TRUE;
     126    }
     127    else
     128    {
     129        Info.enmType = VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D;
     130        fIsCrContext = FALSE;
     131    }
    119132    Info.hUmEvent = (uint64_t)g_pVBoxCmMgr.Session.hEvent;
    120133    Info.u64UmInfo = (uint64_t)pContext;
    … …  
    151164        vboxDispCmSessionCtxAdd(&g_pVBoxCmMgr.Session, pContext);
    152165        pContext->pDevice = pDevice;
     166        if (fIsCrContext)
     167            vboxUhgsmiD3DEscInit(&pDevice->Uhgsmi, pDevice);
    153168    }
    154169    else

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

    r36867 r42499  
    1818        OpenAdapter
    1919        VBoxDispMpGetCallbacks
    20     VBoxDispCrHgsmiInit
    21     VBoxDispCrHgsmiTerm
    22     VBoxDispCrHgsmiQueryClient

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

    r41858 r42499  
    207207    D3DVIEWPORT9 ViewPort;
    208208    VBOXWDDMDISP_CONTEXT DefaultContext;
    209 #ifdef VBOX_WITH_CRHGSMI
    210209    VBOXUHGSMI_PRIVATE_D3D Uhgsmi;
    211 #endif
    212210
    213211    /* no lock is needed for this since we're guaranteed the per-device calls are not reentrant */
    … …  
    312310#define VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, idx) ((D3DCUBEMAP_FACES)(D3DCUBEMAP_FACE_POSITIVE_X+(idx)%VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc)))
    313311#define VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, idx) ((idx)%VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc))
    314 
    315 #ifdef VBOX_WITH_CRHGSMI
    316 HRESULT vboxUhgsmiGlobalSetCurrent();
    317 HRESULT vboxUhgsmiGlobalClearCurrent();
    318 #endif
    319312
    320313DECLINLINE(PVBOXWDDMDISP_SWAPCHAIN) vboxWddmSwapchainForAlloc(PVBOXWDDMDISP_ALLOCATION pAlloc)

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

    r41374 r42499  
    7474    g_VBoxDispMp.cbEscapeCmd = 0;
    7575    vboxVideoCmIterInit(&g_VBoxDispMp.Iterator, NULL, 0);
    76 #ifdef VBOX_WITH_CRHGSMI
    77     vboxUhgsmiGlobalSetCurrent();
    78 #endif
    7976    LeaveCriticalSection(&g_VBoxDispMp.CritSect);
    8077    return S_OK;
    … …  
    9087        g_VBoxDispMp.pEscapeCmd = NULL;
    9188    }
    92 #ifdef VBOX_WITH_CRHGSMI
    93     vboxUhgsmiGlobalClearCurrent();
    94 #endif
    9589    LeaveCriticalSection(&g_VBoxDispMp.CritSect);
    9690    return S_OK;

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

    r41058 r42499  
    3333#endif
    3434
     35#if 0
    3536typedef DECLCALLBACK(int) FNVBOXCRHGSMI_CTLCON_CALL(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo);
    3637typedef FNVBOXCRHGSMI_CTLCON_CALL *PFNVBOXCRHGSMI_CTLCON_CALL;
    3738
    38 #define VBoxCrHgsmiPrivateCtlConCall(_pHgsmi, _pCallInfo, _cbCallInfo) (_pHgsmi->pfnCtlConCall((_pHgsmi), (_pCallInfo), (_cbCallInfo)))
     39#define vboxCrHgsmiPrivateCtlConCall(_pHgsmi, _pCallInfo, _cbCallInfo) (_pHgsmi->pfnCtlConCall((_pHgsmi), (_pCallInfo), (_cbCallInfo)))
    3940
    4041
    … …  
    4243typedef FNVBOXCRHGSMI_CTLCON_GETCLIENTID *PFNVBOXCRHGSMI_CTLCON_GETCLIENTID;
    4344
    44 #define VBoxCrHgsmiPrivateCtlConGetClientID(_pHgsmi, _pu32ClientID) (_pHgsmi->pfnCtlConGetClientID((_pHgsmi), (_pu32ClientID)))
    45 
     45#define vboxCrHgsmiPrivateCtlConGetClientID(_pHgsmi, _pu32ClientID) (_pHgsmi->pfnCtlConGetClientID((_pHgsmi), (_pu32ClientID)))
     46#else
     47int vboxCrHgsmiPrivateCtlConCall(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo);
     48int vboxCrHgsmiPrivateCtlConGetClientID(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, uint32_t *pu32ClientID);
     49#endif
     50
     51typedef DECLCALLBACK(int) FNVBOXCRHGSMI_ESCAPE(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, void *pvData, uint32_t cbData, BOOL fHwAccess);
     52typedef FNVBOXCRHGSMI_ESCAPE *PFNVBOXCRHGSMI_ESCAPE;
     53
     54#define vboxCrHgsmiPrivateEscape(_pHgsmi, _pvData, _cbData, _fHwAccess) (_pHgsmi->pfnEscape((_pHgsmi), (_pvData), (_cbData), (_fHwAccess)))
    4655
    4756typedef struct VBOXUHGSMI_PRIVATE_BASE
    4857{
    4958    VBOXUHGSMI Base;
    50     PFNVBOXCRHGSMI_CTLCON_CALL pfnCtlConCall;
    51     PFNVBOXCRHGSMI_CTLCON_GETCLIENTID pfnCtlConGetClientID;
    52 #ifdef VBOX_CRHGSMI_WITH_D3DDEV
    53     HVBOXCRHGSMI_CLIENT hClient;
    54 #endif
     59    PFNVBOXCRHGSMI_ESCAPE pfnEscape;
    5560} VBOXUHGSMI_PRIVATE_BASE, *PVBOXUHGSMI_PRIVATE_BASE;
    5661
    … …  
    5863{
    5964    VBOXUHGSMI_BUFFER Base;
     65    PVBOXUHGSMI_PRIVATE_BASE pHgsmi;
     66} VBOXUHGSMI_BUFFER_PRIVATE_BASE, *PVBOXUHGSMI_BUFFER_PRIVATE_BASE;
     67
     68typedef struct VBOXUHGSMI_BUFFER_PRIVATE_ESC_BASE
     69{
     70    VBOXUHGSMI_BUFFER_PRIVATE_BASE PrivateBase;
     71    VBOXVIDEOCM_UM_ALLOC Alloc;
    6072    HANDLE hSynch;
     73} VBOXUHGSMI_BUFFER_PRIVATE_ESC_BASE, *PVBOXUHGSMI_BUFFER_PRIVATE_ESC_BASE;
     74
     75typedef struct VBOXUHGSMI_BUFFER_PRIVATE_DX_ALLOC_BASE
     76{
     77    VBOXUHGSMI_BUFFER_PRIVATE_BASE PrivateBase;
    6178    D3DKMT_HANDLE hAllocation;
    62 } VBOXUHGSMI_BUFFER_PRIVATE_BASE, *PVBOXUHGSMI_BUFFER_PRIVATE_BASE;
     79    UINT aLockPageIndices[1];
     80} VBOXUHGSMI_BUFFER_PRIVATE_DX_ALLOC_BASE, *PVBOXUHGSMI_BUFFER_PRIVATE_DX_ALLOC_BASE;
    6381
    6482#define VBOXUHGSMIBASE_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, Base)))
    … …  
    6684#define VBOXUHGSMIBASE_GET_BUFFER(_p) VBOXUHGSMIBASE_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_BASE)
    6785
     86#define VBOXUHGSMIPRIVATEBASE_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, PrivateBase.Base)))
     87#define VBOXUHGSMIESCBASE_GET_BUFFER(_p) VBOXUHGSMIPRIVATEBASE_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_ESC_BASE)
     88#define VBOXUHGSMDXALLOCBASE_GET_BUFFER(_p) VBOXUHGSMIPRIVATEBASE_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_DX_ALLOC_BASE)
    6889
    6990DECLINLINE(int) vboxUhgsmiBaseLockData(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags,
    … …  
    120141}
    121142
    122 DECLINLINE(int) vboxUhgsmiBaseEventChkCreate(VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType, HANDLE *phSynch)
    123 {
    124     *phSynch = NULL;
    125 
    126     if (fUhgsmiType.fCommand)
    127     {
    128         *phSynch = CreateEvent(
    129                   NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes */
    130                   FALSE, /* BOOL bManualReset */
    131                   FALSE, /* BOOL bInitialState */
    132                   NULL /* LPCTSTR lpName */
    133             );
    134         Assert(*phSynch);
    135         if (!*phSynch)
    136         {
    137             DWORD winEr = GetLastError();
    138             /* todo: translate winer */
    139             return VERR_GENERAL_FAILURE;
    140         }
    141     }
    142     return VINF_SUCCESS;
    143 }
    144 
     143#if 0
    145144DECLINLINE(int) vboxUhgsmiBaseDmaFill(PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers,
    146145        VOID* pCommandBuffer, UINT *pCommandBufferSize,
    … …  
    196195    return VINF_SUCCESS;
    197196}
     197#endif
     198
     199DECLCALLBACK(int) vboxUhgsmiBaseEscBufferLock(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock);
     200DECLCALLBACK(int) vboxUhgsmiBaseEscBufferUnlock(PVBOXUHGSMI_BUFFER pBuf);
     201int vboxUhgsmiBaseBufferTerm(PVBOXUHGSMI_BUFFER_PRIVATE_ESC_BASE pBuffer);
     202static int vboxUhgsmiBaseEventChkCreate(VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType, HANDLE *phSynch);
     203int vboxUhgsmiKmtEscBufferInit(PVBOXUHGSMI_PRIVATE_BASE pPrivate, PVBOXUHGSMI_BUFFER_PRIVATE_ESC_BASE pBuffer, uint32_t cbBuf, VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType, PFNVBOXUHGSMI_BUFFER_DESTROY pfnDestroy);
     204DECLCALLBACK(int) vboxUhgsmiBaseEscBufferSubmit(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers);
     205DECLCALLBACK(int) vboxUhgsmiBaseEscBufferDestroy(PVBOXUHGSMI_BUFFER pBuf);
     206DECLCALLBACK(int) vboxUhgsmiBaseEscBufferCreate(PVBOXUHGSMI pHgsmi, uint32_t cbBuf, VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType, PVBOXUHGSMI_BUFFER* ppBuf);
     207DECLINLINE(void) vboxUhgsmiBaseInit(PVBOXUHGSMI_PRIVATE_BASE pHgsmi, PFNVBOXCRHGSMI_ESCAPE pfnEscape)
     208{
     209    pHgsmi->Base.pfnBufferCreate = vboxUhgsmiBaseEscBufferCreate;
     210    pHgsmi->Base.pfnBufferSubmit = vboxUhgsmiBaseEscBufferSubmit;
     211    pHgsmi->pfnEscape = pfnEscape;
     212}
    198213
    199214#endif /* #ifndef ___VBoxUhgsmiBase_h__ */

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

    r41058 r42499  
    1919#include "VBoxDispD3DCmn.h"
    2020
     21#define VBOXUHGSMID3D_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, BasePrivate.Base)))
     22#define VBOXUHGSMID3D_GET(_p) VBOXUHGSMID3D_GET_PRIVATE(_p, VBOXUHGSMI_PRIVATE_D3D)
     23
     24#if 0
     25#define VBOXUHGSMID3D_GET_BUFFER(_p) VBOXUHGSMID3D_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_D3D)
     26
    2127#include <iprt/mem.h>
    2228#include <iprt/err.h>
    … …  
    2935} VBOXUHGSMI_BUFFER_PRIVATE_D3D, *PVBOXUHGSMI_BUFFER_PRIVATE_D3D;
    3036
    31 #define VBOXUHGSMID3D_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, BasePrivate.Base)))
    32 #define VBOXUHGSMID3D_GET(_p) VBOXUHGSMID3D_GET_PRIVATE(_p, VBOXUHGSMI_PRIVATE_D3D)
    33 #define VBOXUHGSMID3D_GET_BUFFER(_p) VBOXUHGSMID3D_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_D3D)
     37
    3438
    3539DECLCALLBACK(int) vboxUhgsmiD3DBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
    … …  
    210214    pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiD3DBufferCreate;
    211215    pHgsmi->BasePrivate.Base.pfnBufferSubmit = vboxUhgsmiD3DBufferSubmit;
    212     pHgsmi->BasePrivate.hClient = NULL;
    213216    pHgsmi->pDevice = pDevice;
    214217    return S_OK;
    215218}
    216 
     219#endif
     220
     221static DECLCALLBACK(int) vboxCrHhgsmiDispEscape(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, void *pvData, uint32_t cbData, BOOL fHwAccess)
     222{
     223    PVBOXUHGSMI_PRIVATE_D3D pPrivate = VBOXUHGSMID3D_GET(pHgsmi);
     224    PVBOXWDDMDISP_DEVICE pDevice = pPrivate->pDevice;
     225    D3DDDICB_ESCAPE DdiEscape = {0};
     226    DdiEscape.hContext = pDevice->DefaultContext.ContextInfo.hContext;
     227    DdiEscape.hDevice = pDevice->hDevice;
     228    DdiEscape.Flags.HardwareAccess = !!fHwAccess;
     229    DdiEscape.pPrivateDriverData = pvData;
     230    DdiEscape.PrivateDriverDataSize = cbData;
     231    HRESULT hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
     232    if (SUCCEEDED(hr))
     233    {
     234        return VINF_SUCCESS;
     235    }
     236
     237    WARN(("pfnEscapeCb failed, hr 0x%x", hr));
     238    return VERR_GENERAL_FAILURE;
     239}
     240
     241
     242void vboxUhgsmiD3DEscInit(PVBOXUHGSMI_PRIVATE_D3D pHgsmi, struct VBOXWDDMDISP_DEVICE *pDevice)
     243{
     244    vboxUhgsmiBaseInit(&pHgsmi->BasePrivate, vboxCrHhgsmiDispEscape);
     245    pHgsmi->pDevice = pDevice;
     246}

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

    r41058 r42499  
    2222#include <iprt/err.h>
    2323
     24#include <cr_protocol.h>
     25
    2426#ifndef NT_SUCCESS
    2527# define NT_SUCCESS(_Status) (((NTSTATUS)(_Status)) >= 0)
    2628#endif
    2729
     30#if 0
    2831typedef struct VBOXUHGSMI_BUFFER_PRIVATE_KMT
    2932{
    3033    VBOXUHGSMI_BUFFER_PRIVATE_BASE BasePrivate;
    31     PVBOXUHGSMI_PRIVATE_KMT pHgsmi;
    3234    CRITICAL_SECTION CritSect;
    33     UINT aLockPageIndices[1];
    3435} VBOXUHGSMI_BUFFER_PRIVATE_KMT, *PVBOXUHGSMI_BUFFER_PRIVATE_KMT;
    3536
    36 typedef struct VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC
    37 {
    38     VBOXUHGSMI_BUFFER Base;
    39     PVBOXUHGSMI_PRIVATE_KMT pHgsmi;
    40     VBOXVIDEOCM_UM_ALLOC Alloc;
    41     HANDLE hSynch;
    42 } VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC, *PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC;
    4337
    4438#define VBOXUHGSMIKMT_GET_BUFFER(_p) VBOXUHGSMIKMT_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_KMT)
    45 #define VBOXUHGSMIKMTESC_GET_PRIVATE(_p, _t) ((_t*)(((uint8_t*)_p) - RT_OFFSETOF(_t, Base)))
    46 #define VBOXUHGSMIKMTESC_GET_BUFFER(_p) VBOXUHGSMIKMTESC_GET_PRIVATE(_p, VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC)
    4739
    4840DECLCALLBACK(int) vboxUhgsmiKmtBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
    … …  
    236228    return VERR_GENERAL_FAILURE;
    237229}
    238 
    239 
    240 DECLCALLBACK(int) vboxUhgsmiKmtEscBufferLock(PVBOXUHGSMI_BUFFER pBuf, uint32_t offLock, uint32_t cbLock, VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags, void**pvLock)
    241 {
    242     PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuffer = VBOXUHGSMIKMTESC_GET_BUFFER(pBuf);
    243     *pvLock = (void*)(pBuffer->Alloc.pvData + offLock);
    244     return VINF_SUCCESS;
    245 }
    246 
    247 DECLCALLBACK(int) vboxUhgsmiKmtEscBufferUnlock(PVBOXUHGSMI_BUFFER pBuf)
    248 {
    249     return VINF_SUCCESS;
    250 }
    251 
    252 DECLCALLBACK(int) vboxUhgsmiKmtEscBufferDestroy(PVBOXUHGSMI_BUFFER pBuf)
    253 {
    254     PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuffer = VBOXUHGSMIKMTESC_GET_BUFFER(pBuf);
    255     PVBOXUHGSMI_PRIVATE_KMT pPrivate = pBuffer->pHgsmi;
    256     D3DKMT_ESCAPE DdiEscape = {0};
    257     VBOXDISPIFESCAPE_UHGSMI_DEALLOCATE DeallocInfo = {0};
    258     DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
    259     DdiEscape.hDevice = pPrivate->Device.hDevice;
    260     DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
    261     //Buf.DdiEscape.Flags.HardwareAccess = 1;
    262     DdiEscape.pPrivateDriverData = &DeallocInfo;
    263     DdiEscape.PrivateDriverDataSize = sizeof (DeallocInfo);
    264     DdiEscape.hContext = pPrivate->Context.hContext;
    265 
    266     DeallocInfo.EscapeHdr.escapeCode = VBOXESC_UHGSMI_DEALLOCATE;
    267     DeallocInfo.hAlloc = pBuffer->Alloc.hAlloc;
    268 
    269     NTSTATUS Status = pPrivate->Callbacks.pfnD3DKMTEscape(&DdiEscape);
    270     if (NT_SUCCESS(Status))
    271     {
    272         if (pBuffer->hSynch)
    273             CloseHandle(pBuffer->hSynch);
    274         RTMemFree(pBuffer);
    275         return VINF_SUCCESS;
    276     }
    277     else
    278     {
    279         WARN(("pfnD3DKMTEscape failed, Status (0x%x)", Status));
    280     }
    281 
    282     return VERR_GENERAL_FAILURE;
    283 }
    284 
    285 DECLCALLBACK(int) vboxUhgsmiKmtEscBufferCreate(PVBOXUHGSMI pHgsmi, uint32_t cbBuf, VBOXUHGSMI_BUFFER_TYPE_FLAGS fUhgsmiType, PVBOXUHGSMI_BUFFER* ppBuf)
    286 {
    287     HANDLE hSynch = NULL;
    288     if (!cbBuf)
    289         return VERR_INVALID_PARAMETER;
    290 
    291     int rc = vboxUhgsmiBaseEventChkCreate(fUhgsmiType, &hSynch);
    292     AssertRC(rc);
    293     if (RT_FAILURE(rc))
    294         return rc;
    295 
    296     cbBuf = VBOXWDDM_ROUNDBOUND(cbBuf, 0x1000);
    297     Assert(cbBuf);
    298     uint32_t cPages = cbBuf >> 12;
    299     Assert(cPages);
    300 
    301     PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
    302     PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuf = (PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC)RTMemAllocZ(sizeof (VBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC));
    303     Assert(pBuf);
    304     if (pBuf)
    305     {
    306         struct
    307         {
    308             D3DKMT_ESCAPE DdiEscape;
    309             VBOXDISPIFESCAPE_UHGSMI_ALLOCATE AllocInfo;
    310         } Buf;
    311         memset(&Buf, 0, sizeof (Buf));
    312         Buf.DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
    313         Buf.DdiEscape.hDevice = pPrivate->Device.hDevice;
    314         Buf.DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
    315         //Buf.DdiEscape.Flags.HardwareAccess = 1;
    316         Buf.DdiEscape.pPrivateDriverData = &Buf.AllocInfo;
    317         Buf.DdiEscape.PrivateDriverDataSize = sizeof (Buf.AllocInfo);
    318         Buf.DdiEscape.hContext = pPrivate->Context.hContext;
    319 
    320         Buf.AllocInfo.EscapeHdr.escapeCode = VBOXESC_UHGSMI_ALLOCATE;
    321         Buf.AllocInfo.Alloc.cbData = cbBuf;
    322         Buf.AllocInfo.Alloc.hSynch = (uint64_t)hSynch;
    323         Buf.AllocInfo.Alloc.fUhgsmiType = fUhgsmiType;
    324 
    325         NTSTATUS Status = pPrivate->Callbacks.pfnD3DKMTEscape(&Buf.DdiEscape);
    326         if (NT_SUCCESS(Status))
    327         {
    328             pBuf->Alloc = Buf.AllocInfo.Alloc;
    329             Assert(pBuf->Alloc.pvData);
    330             pBuf->pHgsmi = pPrivate;
    331             pBuf->Base.pfnLock = vboxUhgsmiKmtEscBufferLock;
    332             pBuf->Base.pfnUnlock = vboxUhgsmiKmtEscBufferUnlock;
    333             pBuf->Base.pfnDestroy = vboxUhgsmiKmtEscBufferDestroy;
    334 
    335             pBuf->Base.fType = fUhgsmiType;
    336             pBuf->Base.cbBuffer = Buf.AllocInfo.Alloc.cbData;
    337 
    338             pBuf->hSynch = hSynch;
    339 
    340             *ppBuf = &pBuf->Base;
    341 
    342             return VINF_SUCCESS;
    343         }
    344         else
    345         {
    346             WARN(("pfnD3DKMTEscape failed, Status (0x%x)", Status));
    347             rc = VERR_OUT_OF_RESOURCES;
    348         }
    349 
    350         RTMemFree(pBuf);
    351     }
    352     else
    353         rc = VERR_NO_MEMORY;
    354 
    355     if (hSynch)
    356         CloseHandle(hSynch);
    357 
    358     return rc;
    359 }
    360 
    361 DECLCALLBACK(int) vboxUhgsmiKmtEscBufferSubmit(PVBOXUHGSMI pHgsmi, PVBOXUHGSMI_BUFFER_SUBMIT aBuffers, uint32_t cBuffers)
    362 {
    363     /* we no chromium will not submit more than three buffers actually,
    364      * for simplicity allocate it statically on the stack  */
    365     struct
    366     {
    367         VBOXDISPIFESCAPE_UHGSMI_SUBMIT SubmitInfo;
    368         VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE aBufInfos[3];
    369     } Buf;
    370 
    371     if (!cBuffers || cBuffers > RT_ELEMENTS(Buf.aBufInfos) + 1)
    372     {
    373         WARN(("invalid cBuffers!"));
    374         return VERR_INVALID_PARAMETER;
    375     }
    376 
    377     HANDLE hSynch = VBOXUHGSMIKMTESC_GET_BUFFER(aBuffers[0].pBuf)->hSynch;
    378     if (!hSynch)
    379     {
    380         WARN(("the fist buffer is not command!"));
    381         return VERR_INVALID_PARAMETER;
    382     }
    383     PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
    384     D3DKMT_ESCAPE DdiEscape = {0};
    385 
    386     DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
    387     DdiEscape.hDevice = pPrivate->Device.hDevice;
    388     DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
    389     //Buf.DdiEscape.Flags.HardwareAccess = 1;
    390     DdiEscape.pPrivateDriverData = &Buf.SubmitInfo;
    391     DdiEscape.PrivateDriverDataSize = RT_OFFSETOF(VBOXDISPIFESCAPE_UHGSMI_SUBMIT, aBuffers[cBuffers]);
    392     DdiEscape.hContext = pPrivate->Context.hContext;
    393 
    394     Buf.SubmitInfo.EscapeHdr.escapeCode = VBOXESC_UHGSMI_SUBMIT;
    395     Buf.SubmitInfo.EscapeHdr.u32CmdSpecific = cBuffers;
    396     for (UINT i = 0; i < cBuffers; ++i)
    397     {
    398         VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE *pSubmInfo = &Buf.SubmitInfo.aBuffers[i];
    399         PVBOXUHGSMI_BUFFER_SUBMIT pBufInfo = &aBuffers[i];
    400         PVBOXUHGSMI_BUFFER_PRIVATE_KMT_ESC pBuf = VBOXUHGSMIKMTESC_GET_BUFFER(pBufInfo->pBuf);
    401         pSubmInfo->hAlloc = pBuf->Alloc.hAlloc;
    402         pSubmInfo->Info.bDoNotSignalCompletion = 0;
    403         if (pBufInfo->fFlags.bEntireBuffer)
    404         {
    405             pSubmInfo->Info.offData = 0;
    406             pSubmInfo->Info.cbData = pBuf->Base.cbBuffer;
    407         }
    408         else
    409         {
    410             pSubmInfo->Info.offData = pBufInfo->offData;
    411             pSubmInfo->Info.cbData = pBufInfo->cbData;
    412         }
    413     }
    414 
    415     NTSTATUS Status = pPrivate->Callbacks.pfnD3DKMTEscape(&DdiEscape);
    416     if (NT_SUCCESS(Status))
    417     {
    418         DWORD dwResult = WaitForSingleObject(hSynch, INFINITE);
    419         if (dwResult == WAIT_OBJECT_0)
    420             return VINF_SUCCESS;
    421         WARN(("wait failed, (0x%x)", dwResult));
    422         return VERR_GENERAL_FAILURE;
    423     }
    424     else
    425     {
    426         WARN(("pfnD3DKMTEscape failed, Status (0x%x)", Status));
    427     }
    428 
    429     return VERR_GENERAL_FAILURE;
    430 }
    431 
    432 static HRESULT vboxUhgsmiKmtEngineCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi,
    433         uint32_t crVersionMajor, uint32_t crVersionMinor, BOOL bD3D)
     230#endif
     231
     232static HRESULT vboxUhgsmiKmtEngineCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
    434233{
    435234    HRESULT hr = vboxDispKmtCallbacksInit(&pHgsmi->Callbacks);
    … …  
    444243                hr = vboxDispKmtCreateContext(&pHgsmi->Device, &pHgsmi->Context,
    445244                        bD3D ? VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_3D : VBOXWDDM_CONTEXT_TYPE_CUSTOM_UHGSMI_GL,
    446                                 crVersionMajor, crVersionMinor,
     245                                CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR,
    447246                                NULL, 0);
    448247                if (hr == S_OK)
    … …  
    476275}
    477276
    478 /* Cr calls have <= 3args, we try to allocate it on stack first */
    479 typedef struct VBOXCRHGSMI_CALLDATA
    480 {
    481     VBOXDISPIFESCAPE_CRHGSMICTLCON_CALL CallHdr;
    482     HGCMFunctionParameter aArgs[3];
    483 } VBOXCRHGSMI_CALLDATA, *PVBOXCRHGSMI_CALLDATA;
    484 
    485 static DECLCALLBACK(int) vboxCrHhgsmiKmtEscCtlConCall(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo)
    486 {
    487     VBOXCRHGSMI_CALLDATA Buf;
    488     PVBOXCRHGSMI_CALLDATA pBuf;
    489     int cbBuffer = cbCallInfo + RT_OFFSETOF(VBOXCRHGSMI_CALLDATA, CallHdr.CallInfo);
    490 
    491     if (cbBuffer <= sizeof (Buf))
    492         pBuf = &Buf;
    493     else
    494     {
    495         pBuf = (PVBOXCRHGSMI_CALLDATA)RTMemAlloc(cbBuffer);
    496         if (!pBuf)
    497         {
    498             WARN(("RTMemAlloc failed!"));
    499             return VERR_NO_MEMORY;
    500         }
    501     }
    502 
     277static DECLCALLBACK(int) vboxCrHhgsmiKmtEscape(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, void *pvData, uint32_t cbData, BOOL fHwAccess)
     278{
    503279    PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
    504280    D3DKMT_ESCAPE DdiEscape = {0};
    505 
    506281    DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
    507282    DdiEscape.hDevice = pPrivate->Device.hDevice;
    508283    DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
    509     //Buf.DdiEscape.Flags.HardwareAccess = 1;
    510     DdiEscape.pPrivateDriverData = pBuf;
    511     DdiEscape.PrivateDriverDataSize = cbBuffer;
     284    DdiEscape.Flags.HardwareAccess = !!fHwAccess;
     285    DdiEscape.pPrivateDriverData = pvData;
     286    DdiEscape.PrivateDriverDataSize = cbData;
    512287    DdiEscape.hContext = pPrivate->Context.hContext;
    513288
    514     pBuf->CallHdr.EscapeHdr.escapeCode = VBOXESC_CRHGSMICTLCON_CALL;
    515     pBuf->CallHdr.EscapeHdr.u32CmdSpecific = 0;
    516     memcpy(&pBuf->CallHdr.CallInfo, pCallInfo, cbCallInfo);
    517 
    518     int rc;
    519289    NTSTATUS Status = pPrivate->Callbacks.pfnD3DKMTEscape(&DdiEscape);
    520290    if (NT_SUCCESS(Status))
    521291    {
    522         memcpy(pCallInfo, &pBuf->CallHdr.CallInfo, cbCallInfo);
    523         rc = VINF_SUCCESS;
    524     }
    525     else
    526     {
    527         WARN(("pfnD3DKMTEscape failed, Status (0x%x)", Status));
    528         rc = VERR_GENERAL_FAILURE;
    529     }
    530     /* cleanup */
    531     if (pBuf != &Buf)
    532         RTMemFree(pBuf);
    533 
    534     return rc;
    535 }
    536 
    537 static DECLCALLBACK(int) vboxCrHhgsmiKmtEscCtlConGetClientID(struct VBOXUHGSMI_PRIVATE_BASE *pHgsmi, uint32_t *pu32ClientID)
    538 {
    539     VBOXDISPIFESCAPE GetId = {0};
    540     PVBOXUHGSMI_PRIVATE_KMT pPrivate = VBOXUHGSMIKMT_GET(pHgsmi);
    541     D3DKMT_ESCAPE DdiEscape = {0};
    542 
    543     DdiEscape.hAdapter = pPrivate->Adapter.hAdapter;
    544     DdiEscape.hDevice = pPrivate->Device.hDevice;
    545     DdiEscape.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
    546     //Buf.DdiEscape.Flags.HardwareAccess = 1;
    547     DdiEscape.pPrivateDriverData = &GetId;
    548     DdiEscape.PrivateDriverDataSize = sizeof (GetId);
    549     DdiEscape.hContext = pPrivate->Context.hContext;
    550 
    551     GetId.escapeCode = VBOXESC_CRHGSMICTLCON_GETCLIENTID;
    552 
    553     NTSTATUS Status = pPrivate->Callbacks.pfnD3DKMTEscape(&DdiEscape);
    554     if (NT_SUCCESS(Status))
    555     {
    556         Assert(GetId.u32CmdSpecific);
    557         *pu32ClientID = GetId.u32CmdSpecific;
    558         return VINF_SUCCESS;
    559     }
    560     else
    561     {
    562         *pu32ClientID = 0;
    563         WARN(("pfnD3DKMTEscape failed, Status (0x%x)", Status));
    564     }
    565     return VERR_GENERAL_FAILURE;
    566 }
    567 
    568 HRESULT vboxUhgsmiKmtCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, uint32_t crVersionMajor, uint32_t crVersionMinor, BOOL bD3D)
    569 {
    570     pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtBufferCreate;
    571     pHgsmi->BasePrivate.Base.pfnBufferSubmit = vboxUhgsmiKmtBufferSubmit;
    572     pHgsmi->BasePrivate.pfnCtlConCall = vboxCrHhgsmiKmtEscCtlConCall;
    573     pHgsmi->BasePrivate.pfnCtlConGetClientID = vboxCrHhgsmiKmtEscCtlConGetClientID;
    574 #ifdef VBOX_CRHGSMI_WITH_D3DDEV
    575     pHgsmi->BasePrivate.hClient = NULL;
     292        return VINF_SUCCESS;
     293    }
     294
     295    WARN(("pfnD3DKMTEscape failed, Status (0x%x)", Status));
     296    return VERR_GENERAL_FAILURE;
     297}
     298
     299#if 0
     300HRESULT vboxUhgsmiKmtCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
     301{
     302    vboxUhgsmiBaseInit(&pHgsmi->BasePrivate, vboxCrHhgsmiKmtEscape);
     303#error "port me!"
     304    return vboxUhgsmiKmtEngineCreate(pHgsmi, bD3D);
     305}
    576306#endif
    577     return vboxUhgsmiKmtEngineCreate(pHgsmi, crVersionMajor, crVersionMinor, bD3D);
    578 }
    579 
    580 HRESULT vboxUhgsmiKmtEscCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, uint32_t crVersionMajor, uint32_t crVersionMinor, BOOL bD3D)
    581 {
    582     pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtEscBufferCreate;
    583     pHgsmi->BasePrivate.Base.pfnBufferSubmit = vboxUhgsmiKmtEscBufferSubmit;
    584     pHgsmi->BasePrivate.pfnCtlConCall = vboxCrHhgsmiKmtEscCtlConCall;
    585     pHgsmi->BasePrivate.pfnCtlConGetClientID = vboxCrHhgsmiKmtEscCtlConGetClientID;
    586 #ifdef VBOX_CRHGSMI_WITH_D3DDEV
    587     pHgsmi->BasePrivate.hClient = NULL;
    588 #endif
    589     return vboxUhgsmiKmtEngineCreate(pHgsmi, crVersionMajor, crVersionMinor, bD3D);
     307
     308HRESULT vboxUhgsmiKmtEscCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D)
     309{
     310    vboxUhgsmiBaseInit(&pHgsmi->BasePrivate, vboxCrHhgsmiKmtEscape);
     311    return vboxUhgsmiKmtEngineCreate(pHgsmi, bD3D);
    590312}
    591313

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

    r40483 r42499  
    3636#define VBOXUHGSMIKMT_GET(_p) VBOXUHGSMIKMT_GET_PRIVATE(_p, VBOXUHGSMI_PRIVATE_KMT)
    3737
    38 HRESULT vboxUhgsmiKmtCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, uint32_t crVersionMajor, uint32_t crVersionMinor, BOOL bD3D);
     38#if 0
     39HRESULT vboxUhgsmiKmtCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D);
     40#endif
    3941HRESULT vboxUhgsmiKmtDestroy(PVBOXUHGSMI_PRIVATE_KMT pHgsmi);
    4042
    41 HRESULT vboxUhgsmiKmtEscCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, uint32_t crVersionMajor, uint32_t crVersionMinor, BOOL bD3D);
     43HRESULT vboxUhgsmiKmtEscCreate(PVBOXUHGSMI_PRIVATE_KMT pHgsmi, BOOL bD3D);
    4244
    4345

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9_private.h

    r40388 r42499  
    192192
    193193HRESULT device_init(IDirect3DDevice9Impl *device, IWineD3D *wined3d, UINT adapter, D3DDEVTYPE device_type,
    194         HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters) DECLSPEC_HIDDEN;
     194        HWND focus_window, DWORD flags
     195#ifdef VBOX_WITH_WDDM
     196        , VBOXWINEEX_D3DPRESENT_PARAMETERS *parameters
     197#else
     198        , D3DPRESENT_PARAMETERS *parameters
     199#endif
     200        ) DECLSPEC_HIDDEN;
    195201
    196202/* IDirect3DDevice9: */

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c

    r40388 r42499  
    31533153};
    31543154
     3155#ifdef VBOX_WITH_WDDM
     3156# define PP_BASE(_p) (&(_p)->Base)
     3157#else
     3158# define PP_BASE(_p) (_p)
     3159#endif
    31553160HRESULT device_init(IDirect3DDevice9Impl *device, IWineD3D *wined3d, UINT adapter, D3DDEVTYPE device_type,
    3156         HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters)
     3161        HWND focus_window, DWORD flags
     3162#ifdef VBOX_WITH_WDDM
     3163        , VBOXWINEEX_D3DPRESENT_PARAMETERS *parameters
     3164#else
     3165        , D3DPRESENT_PARAMETERS *parameters
     3166#endif
     3167        )
    31573168{
    31583169    WINED3DPRESENT_PARAMETERS *wined3d_parameters;
    … …  
    32093220    for (i = 0; i < count; ++i)
    32103221    {
    3211         wined3d_parameters[i].BackBufferWidth = parameters[i].BackBufferWidth;
    3212         wined3d_parameters[i].BackBufferHeight = parameters[i].BackBufferHeight;
    3213         wined3d_parameters[i].BackBufferFormat = wined3dformat_from_d3dformat(parameters[i].BackBufferFormat);
    3214         wined3d_parameters[i].BackBufferCount = parameters[i].BackBufferCount;
    3215         wined3d_parameters[i].MultiSampleType = parameters[i].MultiSampleType;
    3216         wined3d_parameters[i].MultiSampleQuality = parameters[i].MultiSampleQuality;
    3217         wined3d_parameters[i].SwapEffect = parameters[i].SwapEffect;
    3218         wined3d_parameters[i].hDeviceWindow = parameters[i].hDeviceWindow;
    3219         wined3d_parameters[i].Windowed = parameters[i].Windowed;
    3220         wined3d_parameters[i].EnableAutoDepthStencil = parameters[i].EnableAutoDepthStencil;
     3222        wined3d_parameters[i].BackBufferWidth = PP_BASE(&parameters[i])->BackBufferWidth;
     3223        wined3d_parameters[i].BackBufferHeight =PP_BASE(&parameters[i])->BackBufferHeight;
     3224        wined3d_parameters[i].BackBufferFormat = wined3dformat_from_d3dformat(PP_BASE(&parameters[i])->BackBufferFormat);
     3225        wined3d_parameters[i].BackBufferCount = PP_BASE(&parameters[i])->BackBufferCount;
     3226        wined3d_parameters[i].MultiSampleType =PP_BASE(&parameters[i])->MultiSampleType;
     3227        wined3d_parameters[i].MultiSampleQuality =PP_BASE(&parameters[i])->MultiSampleQuality;
     3228        wined3d_parameters[i].SwapEffect =PP_BASE(&parameters[i])->SwapEffect;
     3229        wined3d_parameters[i].hDeviceWindow =PP_BASE(&parameters[i])->hDeviceWindow;
     3230        wined3d_parameters[i].Windowed =PP_BASE(&parameters[i])->Windowed;
     3231        wined3d_parameters[i].EnableAutoDepthStencil =PP_BASE(&parameters[i])->EnableAutoDepthStencil;
    32213232        wined3d_parameters[i].AutoDepthStencilFormat =
    3222                 wined3dformat_from_d3dformat(parameters[i].AutoDepthStencilFormat);
    3223         wined3d_parameters[i].Flags = parameters[i].Flags;
    3224         wined3d_parameters[i].FullScreen_RefreshRateInHz = parameters[i].FullScreen_RefreshRateInHz;
    3225         wined3d_parameters[i].PresentationInterval = parameters[i].PresentationInterval;
     3233                wined3dformat_from_d3dformat(PP_BASE(&parameters[i])->AutoDepthStencilFormat);
     3234        wined3d_parameters[i].Flags =PP_BASE(&parameters[i])->Flags;
     3235        wined3d_parameters[i].FullScreen_RefreshRateInHz =PP_BASE(&parameters[i])->FullScreen_RefreshRateInHz;
     3236        wined3d_parameters[i].PresentationInterval =PP_BASE(&parameters[i])->PresentationInterval;
    32263237        wined3d_parameters[i].AutoRestoreDisplayMode = TRUE;
     3238#ifdef VBOX_WITH_WDDM
     3239        wined3d_parameters[i].pHgsmi = parameters[i].pHgsmi;
     3240#endif
    32273241    }
    32283242
    … …  
    32443258    for (i = 0; i < count; ++i)
    32453259    {
    3246         parameters[i].BackBufferWidth = wined3d_parameters[i].BackBufferWidth;
    3247         parameters[i].BackBufferHeight = wined3d_parameters[i].BackBufferHeight;
    3248         parameters[i].BackBufferFormat = d3dformat_from_wined3dformat(wined3d_parameters[i].BackBufferFormat);
    3249         parameters[i].BackBufferCount = wined3d_parameters[i].BackBufferCount;
    3250         parameters[i].MultiSampleType = wined3d_parameters[i].MultiSampleType;
    3251         parameters[i].MultiSampleQuality = wined3d_parameters[i].MultiSampleQuality;
    3252         parameters[i].SwapEffect = wined3d_parameters[i].SwapEffect;
    3253         parameters[i].hDeviceWindow = wined3d_parameters[i].hDeviceWindow;
    3254         parameters[i].Windowed = wined3d_parameters[i].Windowed;
    3255         parameters[i].EnableAutoDepthStencil = wined3d_parameters[i].EnableAutoDepthStencil;
    3256         parameters[i].AutoDepthStencilFormat =
     3260        PP_BASE(&parameters[i])->BackBufferWidth = wined3d_parameters[i].BackBufferWidth;
     3261        PP_BASE(&parameters[i])->BackBufferHeight = wined3d_parameters[i].BackBufferHeight;
     3262        PP_BASE(&parameters[i])->BackBufferFormat = d3dformat_from_wined3dformat(wined3d_parameters[i].BackBufferFormat);
     3263        PP_BASE(&parameters[i])->BackBufferCount = wined3d_parameters[i].BackBufferCount;
     3264        PP_BASE(&parameters[i])->MultiSampleType = wined3d_parameters[i].MultiSampleType;
     3265        PP_BASE(&parameters[i])->MultiSampleQuality = wined3d_parameters[i].MultiSampleQuality;
     3266        PP_BASE(&parameters[i])->SwapEffect = wined3d_parameters[i].SwapEffect;
     3267        PP_BASE(&parameters[i])->hDeviceWindow = wined3d_parameters[i].hDeviceWindow;
     3268        PP_BASE(&parameters[i])->Windowed = wined3d_parameters[i].Windowed;
     3269        PP_BASE(&parameters[i])->EnableAutoDepthStencil = wined3d_parameters[i].EnableAutoDepthStencil;
     3270        PP_BASE(&parameters[i])->AutoDepthStencilFormat =
    32573271                d3dformat_from_wined3dformat(wined3d_parameters[i].AutoDepthStencilFormat);
    3258         parameters[i].Flags = wined3d_parameters[i].Flags;
    3259         parameters[i].FullScreen_RefreshRateInHz = wined3d_parameters[i].FullScreen_RefreshRateInHz;
    3260         parameters[i].PresentationInterval = wined3d_parameters[i].PresentationInterval;
     3272        PP_BASE(&parameters[i])->Flags = wined3d_parameters[i].Flags;
     3273        PP_BASE(&parameters[i])->FullScreen_RefreshRateInHz = wined3d_parameters[i].FullScreen_RefreshRateInHz;
     3274        PP_BASE(&parameters[i])->PresentationInterval = wined3d_parameters[i].PresentationInterval;
    32613275    }
    32623276    HeapFree(GetProcessHeap(), 0, wined3d_parameters);

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/directx.c

    r40389 r42499  
    523523    }
    524524
    525     hr = device_init(object, This->WineD3D, adapter, device_type, focus_window, flags, parameters);
     525    hr = device_init(object, This->WineD3D, adapter, device_type, focus_window, flags,
     526#ifdef VBOX_WITH_WDDM
     527        (VBOXWINEEX_D3DPRESENT_PARAMETERS *)
     528#endif
     529                    parameters);
    526530    if (FAILED(hr))
    527531    {

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/VBoxWineEx.h

    r40388 r42499  
    8484VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSwapchain9Present(IDirect3DSwapChain9 *iface,
    8585                                IDirect3DSurface9 *surf); /* use the given surface as a frontbuffer content source */
     86
     87typedef struct VBOXWINEEX_D3DPRESENT_PARAMETERS
     88{
     89    D3DPRESENT_PARAMETERS Base;
     90    struct VBOXUHGSMI *pHgsmi;
     91} VBOXWINEEX_D3DPRESENT_PARAMETERS, *PVBOXWINEEX_D3DPRESENT_PARAMETERS;
    8692#ifdef __cplusplus
    8793}

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/wined3d.h

    r42285 r42499  
    22622262    UINT PresentationInterval;
    22632263    BOOL AutoRestoreDisplayMode;
     2264#ifdef VBOX_WITH_WDDM
     2265    struct VBOXUHGSMI *pHgsmi;
     2266#endif
    22642267} WINED3DPRESENT_PARAMETERS;
    22652268typedef struct _WINED3DSURFACE_DESC {

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/context.c

    r42285 r42499  
    15321532 *****************************************************************************/
    15331533struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
    1534         const struct wined3d_format_desc *ds_format_desc)
     1534        const struct wined3d_format_desc *ds_format_desc
     1535#ifdef VBOX_WITH_WDDM
     1536        , struct VBOXUHGSMI *pHgsmi
     1537#endif
     1538        )
    15351539{
    15361540    IWineD3DDeviceImpl *device = swapchain->device;
    … …  
    15491553    TRACE("swapchain %p, target %p, window %p.\n", swapchain, target, swapchain->win_handle);
    15501554
     1555#ifdef VBOX_WITH_WDDM
     1556    if (!pHgsmi)
     1557    {
     1558        ERR("HGSMI should be specified!");
     1559        return NULL;
     1560    }
     1561#endif
     1562
    15511563    ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
    15521564    if (!ret)
    … …  
    16441656    }
    16451657
    1646     ctx = pwglCreateContext(hdc);
     1658    ctx = pVBoxCreateContext(hdc
     1659#ifdef VBOX_WITH_WDDM
     1660            , pHgsmi
     1661#else
     1662            , NULL
     1663#endif
     1664            );
    16471665    if (device->numContexts)
    16481666    {
    … …  
    19551973    {
    19561974        Assert(!device->NumberOfSwapChains);
    1957         context = context_create(swapchain, target, ds_format_desc);
     1975        context = context_create(swapchain, target, ds_format_desc
     1976#ifdef VBOX_WITH_WDDM
     1977                , device->pHgsmi
     1978#endif
     1979                );
    19581980    }
    19591981    else

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c

    r42408 r42499  
    16051605    if(!This->adapter->opengl) return WINED3DERR_INVALIDCALL;
    16061606
     1607#ifdef VBOX_WITH_WDDM
     1608    if (!pPresentationParameters->pHgsmi)
     1609    {
     1610        ERR("hgsmi not specified!");
     1611        return WINED3DERR_INVALIDCALL;
     1612    }
     1613    This->pHgsmi = pPresentationParameters->pHgsmi;
     1614#endif
    16071615    TRACE("(%p) : Creating stateblock\n", This);
    16081616    /* Creating the startup stateBlock - Note Special Case: 0 => Don't fill in yet! */
    … …  
    64566464    IWineD3DSurfaceImpl *target;
    64576465
     6466#ifdef VBOX_WITH_WDDM
     6467    ERR("Should not be here!");
     6468#endif
     6469
    64586470#ifndef VBOX_WITH_WDDM
    64596471    /* Recreate the primary swapchain's context */
    … …  
    64676479
    64686480    target = (IWineD3DSurfaceImpl *)(swapchain->backBuffer ? swapchain->backBuffer[0] : swapchain->frontBuffer);
    6469     if (!(context = context_create(swapchain, target, swapchain->ds_format)))
     6481    if (!(context = context_create(swapchain, target, swapchain->ds_format
     6482#ifdef VBOX_WITH_WDDM
     6483                , This->pHgsmi
     6484#endif
     6485            )))
    64706486    {
    64716487        WARN("Failed to create context.\n");

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/directx.c

    r42285 r42499  
    3636#include <stdio.h>
    3737#include "wined3d_private.h"
     38
     39#ifdef VBOX_WITH_WDDM
     40# include <VBox/VBoxCrHgsmi.h>
     41#endif
    3842
    3943WINE_DEFAULT_DEBUG_CHANNEL(d3d);
    … …  
    254258}
    255259
    256 static BOOL WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx *ctx)
     260static BOOL WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx *ctx, struct VBOXUHGSMI *pHgsmi)
    257261{
    258262    PIXELFORMATDESCRIPTOR pfd;
    … …  
    300304
    301305    /* Create a GL context. */
    302     ctx->gl_ctx = pwglCreateContext(ctx->dc);
     306    ctx->gl_ctx = pVBoxCreateContext(ctx->dc, pHgsmi);
    303307    if (!ctx->gl_ctx)
    304308    {
    … …  
    53095313    BOOL ret;
    53105314    int ps_selected_mode, vs_selected_mode;
     5315    struct VBOXUHGSMI *pHgsmi = NULL;
    53115316
    53125317    /* No need to hold any lock. The calling library makes sure only one thread calls
    … …  
    53555360#define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
    53565361    WGL_FUNCS_GEN;
     5362    VBOX_FUNCS_GEN;
    53575363#undef USE_WGL_FUNC
    53585364
    … …  
    53805386    glDisableWINE = glDisable;
    53815387
     5388#ifdef VBOX_WITH_WDDM
     5389    pHgsmi = VBoxCrHgsmiCreate();
     5390    if (!pHgsmi)
     5391    {
     5392        ERR("VBoxCrHgsmiCreate failed");
     5393        goto nogl_adapter;
     5394    }
     5395#endif
     5396
    53825397    /* For now only one default adapter */
    53835398    {
    … …  
    54065421                adapter->luid.HighPart, adapter->luid.LowPart);
    54075422
    5408         if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx))
     5423        if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx, pHgsmi))
    54095424        {
    54105425            ERR("Failed to get a gl context for default adapter\n");
    … …  
    55955610    TRACE("%u adapters successfully initialized\n", This->adapter_count);
    55965611
     5612#ifdef VBOX_WITH_WDDM
     5613    VBoxCrHgsmiDestroy(pHgsmi);
     5614    pHgsmi = NULL;
     5615#endif
     5616
    55975617    return TRUE;
    55985618
    … …  
    56155635#endif
    56165636    initPixelFormatsNoGL(&This->adapters[0].gl_info);
     5637
     5638#ifdef VBOX_WITH_WDDM
     5639    if (pHgsmi)
     5640    {
     5641        VBoxCrHgsmiDestroy(pHgsmi);
     5642        pHgsmi = NULL;
     5643    }
     5644#endif
    56175645
    56185646    This->adapter_count = 1;

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/swapchain.c

    r39869 r42499  
    12331233    TRACE("Creating a new context for swapchain %p, thread %d\n", This, GetCurrentThreadId());
    12341234
    1235     if (!(ctx = context_create(This, (IWineD3DSurfaceImpl *)This->frontBuffer, This->ds_format)))
     1235#ifdef VBOX_WITH_WDDM
     1236     ERR("Should not be here");
     1237#endif
     1238
     1239    if (!(ctx = context_create(This, (IWineD3DSurfaceImpl *)This->frontBuffer, This->ds_format
     1240#ifdef VBOX_WITH_WDDM
     1241                , This->device->pHgsmi
     1242#endif
     1243            )))
    12361244    {
    12371245        ERR("Failed to create a new context for the swapchain\n");

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/vboxext.c

    r42408 r42499  
    1818#include "wined3d_private.h"
    1919#include "vboxext.h"
     20#ifdef VBOX_WITH_WDDM
     21#include <VBox/VBoxCrHgsmi.h>
     22#include <iprt/err.h>
     23#endif
    2024
    2125WINE_DEFAULT_DEBUG_CHANNEL(d3d_vbox);
    … …  
    282286{
    283287    HRESULT hr = S_OK;
     288#ifdef VBOX_WITH_WDDM
     289    int rc = VBoxCrHgsmiInit();
     290    if (!RT_SUCCESS(rc))
     291    {
     292        ERR("VBoxCrHgsmiInit failed rc %d", rc);
     293        return E_FAIL;
     294    }
     295#endif
    284296    memset(&g_VBoxExtGlobal, 0, sizeof (g_VBoxExtGlobal));
    285297    hr = VBoxExtWorkerCreate(&g_VBoxExtGlobal.Worker);
     298    if (SUCCEEDED(hr))
     299        return S_OK;
     300
     301    /* failure branch */
     302#ifdef VBOX_WITH_WDDM
     303    VBoxCrHgsmiTerm();
     304#endif
    286305    return hr;
    287306}
    … …  
    305324        return hr;
    306325    }
     326
     327#ifdef VBOX_WITH_WDDM
     328    VBoxCrHgsmiTerm();
     329#endif
     330
    307331    return S_OK;
    308332}

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_gl.h

    r41929 r42499  
    13741374
    13751375/* WGL functions */
    1376 HGLRC (WINAPI *pwglCreateContext)(HDC) DECLSPEC_HIDDEN;
    13771376BOOL (WINAPI *pwglDeleteContext)(HGLRC) DECLSPEC_HIDDEN;
    13781377HGLRC (WINAPI *pwglGetCurrentContext)(void) DECLSPEC_HIDDEN;
    … …  
    13821381BOOL (WINAPI *pwglSwapLayerBuffers)(HDC, UINT) DECLSPEC_HIDDEN;
    13831382BOOL (WINAPI *pwglShareLists)(HGLRC, HGLRC) DECLSPEC_HIDDEN;
     1383
     1384HGLRC (WINAPI *pVBoxCreateContext)(HDC, struct VBOXUHGSMI*) DECLSPEC_HIDDEN;
    13841385
    13851386#define GL_FUNCS_GEN \
    … …  
    17211722
    17221723#define WGL_FUNCS_GEN \
    1723     USE_WGL_FUNC(wglCreateContext) \
    17241724    USE_WGL_FUNC(wglDeleteContext) \
    17251725    USE_WGL_FUNC(wglGetCurrentContext) \
    … …  
    17291729    USE_WGL_FUNC(wglShareLists) \
    17301730    USE_WGL_FUNC(wglSwapLayerBuffers)
     1731
     1732#define VBOX_FUNCS_GEN \
     1733    USE_WGL_FUNC(VBoxCreateContext)
    17311734
    17321735/* OpenGL extensions. */

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_private.h

    r42408 r42499  
    12831283        GLenum fbo_target, DWORD idx, IWineD3DSurfaceImpl *surface) DECLSPEC_HIDDEN;
    12841284struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
    1285         const struct wined3d_format_desc *ds_format_desc) DECLSPEC_HIDDEN;
     1285        const struct wined3d_format_desc *ds_format_desc
     1286#ifdef VBOX_WITH_WDDM
     1287                , struct VBOXUHGSMI *pHgsmi
     1288#endif
     1289        ) DECLSPEC_HIDDEN;
    12861290struct IWineD3DDeviceImpl *context_get_device(const struct wined3d_context *context); DECLSPEC_HIDDEN;
    12871291#ifdef VBOX_WITH_WDDM
    … …  
    18001804    struct wined3d_context **contexts;
    18011805    UINT                    numContexts;
     1806
     1807#ifdef VBOX_WITH_WDDM
     1808    struct VBOXUHGSMI *pHgsmi;
     1809#endif
    18021810
    18031811#ifdef VBOX_WINE_WITH_SHADER_CACHE

  • trunk/src/VBox/Additions/common/crOpenGL/Makefile.kmk

    r42220 r42499  
    212212 endif
    213213endif
     214ifdef VBOX_WITH_CRHGSMI
     215VBoxOGL_DEFS.win   += VBOX_WITH_CRHGSMI
     216endif
     217ifdef VBOX_WITH_WDDM
     218VBoxOGL_DEFS.win   += VBOX_WITH_WDDM
     219endif
    214220
    215221ifdef VBOX_WITH_WDDM
    … …  
    402408        $(PATH_STAGE_LIB)/additions/VBoxOGLspuload$(VBOX_SUFF_LIB) \
    403409        $(PATH_STAGE_LIB)/additions/VBoxOGLcrstate$(VBOX_SUFF_LIB)
     410ifdef VBOX_WITH_CRHGSMI
     411VBoxOGLarrayspu_DEFS.win   += VBOX_WITH_CRHGSMI
     412endif
     413ifdef VBOX_WITH_WDDM
     414VBoxOGLarrayspu_DEFS.win   += VBOX_WITH_WDDM
     415endif
    404416
    405417ifdef VBOX_WITH_WDDM
    … …  
    440452VBoxOGLpassthroughspu_LIBS        = \
    441453        $(VBOX_LIB_OGL_CRUTIL)
     454ifdef VBOX_WITH_CRHGSMI
     455VBoxOGLpassthroughspu_DEFS.win   += VBOX_WITH_CRHGSMI
     456endif
     457ifdef VBOX_WITH_WDDM
     458VBoxOGLpassthroughspu_DEFS.win   += VBOX_WITH_WDDM
     459endif
    442460
    443461ifdef VBOX_WITH_WDDM
    … …  
    510528        $(PATH_STAGE_LIB)/additions/VBoxOGLcrstate$(VBOX_SUFF_LIB) \
    511529        $(PATH_STAGE_LIB)/additions/VBoxOGLcrpacker$(VBOX_SUFF_LIB)
     530ifdef VBOX_WITH_CRHGSMI
     531VBoxOGLpackspu_DEFS.win   += VBOX_WITH_CRHGSMI
     532endif
     533ifdef VBOX_WITH_WDDM
     534VBoxOGLpackspu_DEFS.win   += VBOX_WITH_WDDM
     535endif
    512536
    513537ifdef VBOX_WITH_WDDM
    … …  
    581605        $(PATH_STAGE_LIB)/additions/VBoxOGLspuload$(VBOX_SUFF_LIB) \
    582606        $(PATH_STAGE_LIB)/additions/VBoxOGLcrstate$(VBOX_SUFF_LIB)
     607ifdef VBOX_WITH_CRHGSMI
     608VBoxOGLfeedbackspu_DEFS.win   += VBOX_WITH_CRHGSMI
     609endif
     610ifdef VBOX_WITH_WDDM
     611VBoxOGLfeedbackspu_DEFS.win   += VBOX_WITH_WDDM
     612endif
    583613
    584614ifdef VBOX_WITH_WDDM

  • trunk/src/VBox/Additions/common/crOpenGL/context.c

    r41963 r42499  
    123123#ifdef VBOX_WITH_WDDM
    124124    if (stub.bRunningUnderWDDM)
     125    {
     126        crError("Should not be here: WindowCreate/Destroy & VBoxPackGetInjectID recuire connection id!");
    125127        winInfo->mapped = 0;
     128    }
    126129    else
    127130#endif
    … …  
    148151#endif
    149152#ifdef CR_NEWWINTRACK
    150     winInfo->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
     153    winInfo->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID(0);
    151154#endif
    152155    winInfo->spuWindow = spuWin;
    … …  
    347350        stub.spu->dispatch_table.DestroyContext( context->spuContext );
    348351        crHashtableWalk(stub.windowTable, stubWindowCheckOwnerCB, context);
     352#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     353        if (context->spuConnection)
     354        {
     355            stub.spu->dispatch_table.VBoxConDestroy(context->spuConnection);
     356            context->spuConnection = 0;
     357        }
     358#endif
    349359    }
    350360
    … …  
    379389    ContextInfo *
    380390stubNewContext( const char *dpyName, GLint visBits, ContextType type,
    381     unsigned long shareCtx )
    382 {
    383     GLint spuContext = -1, spuShareCtx = 0;
     391    unsigned long shareCtx
     392#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     393        , struct VBOXUHGSMI *pHgsmi
     394#endif
     395    )
     396{
     397    GLint spuContext = -1, spuShareCtx = 0, spuConnection = 0;
    384398    ContextInfo *context;
    385399
    … …  
    393407
    394408    if (type == CHROMIUM) {
     409#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     410        if (pHgsmi)
     411        {
     412            spuConnection = stub.spu->dispatch_table.VBoxConCreate(pHgsmi);
     413            if (!spuConnection)
     414            {
     415                crWarning("VBoxConCreate failed");
     416                return NULL;
     417            }
     418        }
     419#endif
    395420        spuContext
    396             = stub.spu->dispatch_table.CreateContext(dpyName, visBits, spuShareCtx);
     421            = stub.spu->dispatch_table.VBoxCreateContext(spuConnection, dpyName, visBits, spuShareCtx);
    397422        if (spuContext < 0)
     423        {
     424            crWarning("VBoxCreateContext failed");
     425#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     426            if (spuConnection)
     427                stub.spu->dispatch_table.VBoxConDestroy(spuConnection);
     428#endif
    398429            return NULL;
     430        }
    399431    }
    400432
    … …  
    402434    if (!context) {
    403435        stub.spu->dispatch_table.DestroyContext(spuContext);
     436#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     437        if (spuConnection)
     438            stub.spu->dispatch_table.VBoxConDestroy(spuConnection);
     439#endif
    404440        return NULL;
    405441    }
    … …  
    415451    crStrncpy(context->dpyName, dpyName, MAX_DPY_NAME);
    416452    context->dpyName[MAX_DPY_NAME-1] = 0;
     453
     454#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     455    context->spuConnection = spuConnection;
     456    context->pHgsmi = pHgsmi;
     457#endif
    417458
    418459#ifdef CHROMIUM_THREADSAFE
    … …  
    10191060            GLint spuShareCtx = 0;
    10201061#endif
    1021 
     1062            GLint spuConnection = 0;
    10221063            CRASSERT(stub.spu);
    10231064            CRASSERT(stub.spu->dispatch_table.CreateContext);
    10241065            context->type = CHROMIUM;
    10251066
     1067#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1068            if (context->pHgsmi)
     1069            {
     1070                spuConnection = stub.spu->dispatch_table.VBoxConCreate(context->pHgsmi);
     1071                if (!spuConnection)
     1072                {
     1073                    crWarning("VBoxConCreate failed");
     1074                    return GL_FALSE;
     1075                }
     1076                context->spuConnection = spuConnection;
     1077            }
     1078#endif
     1079
    10261080            context->spuContext
    1027                 = stub.spu->dispatch_table.CreateContext( context->dpyName,
    1028                                                           context->visBits,
    1029                                                           spuShareCtx );
     1081                = stub.spu->dispatch_table.VBoxCreateContext(spuConnection, context->dpyName,
     1082                                                    context->visBits,
     1083                                                    spuShareCtx);
    10301084            if (window->spuWindow == -1)
    10311085            {
    10321086                /*crDebug("(1)stubMakeCurrent ctx=%p(%i) window=%p(%i)", context, context->spuContext, window, window->spuWindow);*/
    1033                 window->spuWindow = stub.spu->dispatch_table.WindowCreate( window->dpyName, context->visBits );
     1087                window->spuWindow = stub.spu->dispatch_table.VBoxWindowCreate(
     1088                        spuConnection,
     1089                        window->dpyName, context->visBits );
    10341090#ifdef CR_NEWWINTRACK
    1035                 window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
     1091                window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID(spuConnection);
    10361092#endif
    10371093            }
    … …  
    10891145            {
    10901146                /*crDebug("(2)stubMakeCurrent ctx=%p(%i) window=%p(%i)", context, context->spuContext, window, window->spuWindow);*/
    1091                 window->spuWindow = stub.spu->dispatch_table.WindowCreate( window->dpyName, context->visBits );
     1147                window->spuWindow = stub.spu->dispatch_table.VBoxWindowCreate(
     1148#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1149                        context->spuConnection,
     1150#else
     1151                        0,
     1152#endif
     1153                        window->dpyName, context->visBits );
    10921154#ifdef CR_NEWWINTRACK
    1093                 window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
     1155                window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID(
     1156# if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1157                        context->spuConnection
     1158# else
     1159                        0
     1160# endif
     1161                        );
    10941162#endif
    10951163                if (context->currentDrawable && context->currentDrawable->type==CHROMIUM
    … …  
    11281196    window->type = context->type;
    11291197    window->pOwner = context;
     1198#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1199    window->spuConnection = context->spuConnection;
     1200#endif
    11301201    context->currentDrawable = window;
    11311202    stubSetCurrentContext(context);

  • trunk/src/VBox/Additions/common/crOpenGL/defs.py

    r20635 r42499  
    495495crMakeCurrent
    496496crSwapBuffers
    497 crGetProcAddress"""
     497crGetProcAddress
     498VBoxCreateContext"""
    498499#print "DllMain"

  • trunk/src/VBox/Additions/common/crOpenGL/defs64.py

    r29790 r42499  
    476476crMakeCurrent
    477477crSwapBuffers
    478 crGetProcAddress"""
     478crGetProcAddress
     479VBoxCreateContext"""
    479480#print "DllMain"

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedback_context.c

    r28800 r42499  
    2424
    2525GLint FEEDBACKSPU_APIENTRY
    26 feedbackspu_CreateContext( const char *dpyName, GLint visual, GLint shareCtx )
     26feedbackspu_VBoxCreateContext( GLint con, const char *dpyName, GLint visual, GLint shareCtx )
    2727{
    2828    GLint ctx, slot;
    … …  
    3232#endif
    3333
    34     ctx = feedback_spu.child.CreateContext(dpyName, visual, shareCtx);
     34    ctx = feedback_spu.child.VBoxCreateContext(con, dpyName, visual, shareCtx);
    3535
    3636    /* find an empty context slot */
    … …  
    5353
    5454    return ctx;
     55}
     56
     57GLint FEEDBACKSPU_APIENTRY
     58feedbackspu_CreateContext( const char *dpyName, GLint visual, GLint shareCtx )
     59{
     60    return feedbackspu_VBoxCreateContext( 0, dpyName, visual, shareCtx );
    5561}
    5662

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedback_state.py

    r19099 r42499  
    1616#include "feedbackspu_proto.h"
    1717"""
    18 custom = ["CreateContext", "MakeCurrent", "DestroyContext"]
     18custom = ["CreateContext", "VBoxCreateContext", "MakeCurrent", "DestroyContext"]
    1919
    2020keys = apiutil.GetDispatchedFunctions(sys.argv[1]+"/APIspec.txt")

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedback_state_special

    r40431 r42499  
    6464VBoxAttachThread
    6565VBoxDetachThread
     66VBoxCreateContext

  • trunk/src/VBox/Additions/common/crOpenGL/icd_drv.c

    r41971 r42499  
    164164#endif
    165165
    166     context = stubNewContext(dpyName, desiredVisual, UNDECIDED, 0);
     166    context = stubNewContext(dpyName, desiredVisual, UNDECIDED, 0
     167#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     168        , NULL
     169#endif
     170            );
    167171    if (!context)
    168172        return 0;

  • trunk/src/VBox/Additions/common/crOpenGL/load.c

    r41963 r42499  
    10151015    VBOXCR_UPDATEWNDCB RegionsData;
    10161016    HRESULT hr;
     1017    GLint spuConnection = 0;
    10171018# endif
    10181019#endif
    … …  
    10611062        }
    10621063    }
    1063 # endif
    1064 #endif
     1064# endif /* VBOX_WITH_WDDM */
     1065#endif /* WINDOWS */
    10651066
    10661067    crLockMutex(&stub.mutex);
    1067     stub.spu->dispatch_table.VBoxPackSetInjectThread();
     1068#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
     1069    spuConnection =
     1070#endif
     1071            stub.spu->dispatch_table.VBoxPackSetInjectThread(NULL);
     1072#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
     1073    if (!spuConnection)
     1074    {
     1075        crError("VBoxPackSetInjectThread failed!");
     1076    }
     1077#endif
    10681078    crUnlockMutex(&stub.mutex);
    10691079
    … …  
    11421152        VBoxDispMpTstCallbacks.pfnDisableEvents();
    11431153    }
     1154    if (spuConnection)
     1155    {
     1156        stub.spu->dispatch_table.VBoxConDestroy(spuConnection);
     1157    }
    11441158    if (hVBoxD3D)
    11451159    {
    … …  
    12031217        ns.name = "vboxhgcm://host:0";
    12041218        ns.buffer_size = 1024;
    1205         crNetServerConnect(&ns);
     1219        crNetServerConnect(&ns
     1220#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1221                , NULL
     1222#endif
     1223                );
    12061224        if (!ns.conn)
    12071225        {
    … …  
    14141432        ns.name = "vboxhgcm://host:0";
    14151433        ns.buffer_size = 1024;
    1416         crNetServerConnect(&ns);
     1434        crNetServerConnect(&ns
     1435#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1436                , NULL
     1437#endif
     1438);
    14171439        if (!ns.conn)
    14181440        {

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu.h

    r38143 r42499  
    6767    int idxThreadInUse; /*index of any used thread*/
    6868
     69#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
     70    bool bRunningUnderWDDM;
     71#endif
     72
    6973    int numContexts;
    7074    ContextInfo context[CR_MAX_CONTEXTS];
    … …  
    7377extern PackSPU pack_spu;
    7478
     79#define THREAD_OFFSET_MAGIC 2000
     80
    7581#ifdef CHROMIUM_THREADSAFE
    7682extern CRmutex _PackMutex;
    7783extern CRtsd _PackTSD;
    78 #define GET_THREAD(T)  ThreadInfo *T = crGetTSD(&_PackTSD)
     84#define GET_THREAD_VAL()  (crGetTSD(&_PackTSD))
     85#define GET_THREAD_VAL_ID(_id) (&(pack_spu.thread[(_id) - THREAD_OFFSET_MAGIC]))
    7986#else
    80 #define GET_THREAD(T)  ThreadInfo *T = &(pack_spu.thread[0])
     87#define GET_THREAD_VAL()  (&(pack_spu.thread[0]))
    8188#endif
     89#define GET_THREAD(T)  ThreadInfo *T = GET_THREAD_VAL()
     90#define GET_THREAD_ID(T, _id) ThreadInfo *T = GET_THREAD_VAL_ID(_id)
     91
     92
    8293
    8394#define GET_CONTEXT(C)                      \
    … …  
    8596  ContextInfo *C = thread->currentContext
    8697
     98#define CRPACKSPU_WRITEBACK_WAIT(_thread, _writeback)  CR_WRITEBACK_WAIT((_thread)->netServer.conn, _writeback)
     99#if defined(WINDOWS) && defined(VBOX_WITH_WDDM) && defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     100# define CRPACKSPU_IS_WDDM_CRHGSMI() (pack_spu.bRunningUnderWDDM)
     101#else
     102# define CRPACKSPU_IS_WDDM_CRHGSMI() (GL_FALSE)
     103#endif
     104
    87105extern void packspuCreateFunctions( void );
    88106extern void packspuSetVBoxConfiguration( const SPU *child_spu );
    89 extern void packspuConnectToServer( CRNetServer *server );
     107extern void packspuConnectToServer( CRNetServer *server
     108#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     109                , struct VBOXUHGSMI *pHgsmi
     110#endif
     111        );
    90112extern void packspuFlush( void *arg );
    91113extern void packspuHuge( CROpcode opcode, void *buf );
    … …  
    93115extern GLboolean packspuSyncOnFlushes();
    94116
    95 extern ThreadInfo *packspuNewThread( unsigned long id );
     117extern ThreadInfo *packspuNewThread(
     118#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     119                struct VBOXUHGSMI *pHgsmi
     120#endif
     121        );
    96122
     123extern ThreadInfo *packspuNewCtxThread( struct VBOXUHGSMI *pHgsmi );
    97124
    98125#endif /* CR_PACKSPU_H */

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_bufferobject.c

    r27091 r42499  
    2020    packspuFlush((void *) thread);
    2121
    22     while (writeback)
    23         crNetRecv();
     22    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    2423}
    2524

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_client.c

    r35912 r42499  
    560560        crPackIsEnabled(cap, &return_val, &writeback);
    561561            packspuFlush( (void *) thread );
    562             while (writeback)
    563                   crNetRecv();
     562            CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    564563        CRASSERT(return_val==res);
    565564    }

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_context.c

    r39288 r42499  
    1212
    1313#define MAGIC_OFFSET 3000
    14 
    1514
    1615/*
    … …  
    2120 * using threads.
    2221 */
    23 ThreadInfo *packspuNewThread( unsigned long id )
     22ThreadInfo *packspuNewThread(
     23#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     24                struct VBOXUHGSMI *pHgsmi
     25#endif
     26)
    2427{
    2528    ThreadInfo *thread=NULL;
    … …  
    3235#endif
    3336
     37#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     38    CRASSERT(!CRPACKSPU_IS_WDDM_CRHGSMI() == !pHgsmi);
     39#endif
     40
    3441    CRASSERT(pack_spu.numThreads < MAX_THREADS);
    3542    for (i=0; i<MAX_THREADS; ++i)
    … …  
    4451
    4552    thread->inUse = GL_TRUE;
    46     thread->id = id;
     53    if (!CRPACKSPU_IS_WDDM_CRHGSMI())
     54        thread->id = crThreadID();
     55    else
     56        thread->id = THREAD_OFFSET_MAGIC + i;
    4757    thread->currentContext = NULL;
    4858    thread->bInjectThread = GL_FALSE;
    … …  
    5262    thread->netServer.buffer_size = pack_spu.buffer_size;
    5363    if (pack_spu.numThreads == 0) {
    54         packspuConnectToServer( &(thread->netServer) );
     64        packspuConnectToServer( &(thread->netServer)
     65#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     66                , pHgsmi
     67#endif
     68                );
    5569        if (!thread->netServer.conn) {
    5670            return NULL;
    … …  
    6074    else {
    6175        /* a new pthread */
    62         crNetNewClient(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn, &(thread->netServer));
     76        crNetNewClient(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn, &(thread->netServer)
     77#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     78                , pHgsmi
     79#endif
     80        );
    6381        CRASSERT(thread->netServer.conn);
    6482    }
    … …  
    7593    crPackFlushArg( thread->packer, (void *) thread );
    7694    crPackSendHugeFunc( thread->packer, packspuHuge );
    77     crPackSetContext( thread->packer );
    78 
    79 #ifdef CHROMIUM_THREADSAFE
    80     crSetTSD(&_PackTSD, thread);
     95
     96    if (!CRPACKSPU_IS_WDDM_CRHGSMI())
     97    {
     98        crPackSetContext( thread->packer );
     99    }
     100
     101
     102#ifdef CHROMIUM_THREADSAFE
     103    if (!CRPACKSPU_IS_WDDM_CRHGSMI())
     104    {
     105        crSetTSD(&_PackTSD, thread);
     106    }
    81107#endif
    82108
    … …  
    89115}
    90116
    91 
    92117GLint PACKSPU_APIENTRY
    93 packspu_CreateContext( const char *dpyName, GLint visual, GLint shareCtx )
     118packspu_VBoxConCreate(struct VBOXUHGSMI *pHgsmi)
     119{
     120#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     121    ThreadInfo * thread;
     122    CRASSERT(CRPACKSPU_IS_WDDM_CRHGSMI());
     123    CRASSERT(pHgsmi);
     124
     125    thread = packspuNewThread(pHgsmi);
     126
     127    if (thread)
     128    {
     129        CRASSERT(thread->id);
     130        CRASSERT(thread->id - THREAD_OFFSET_MAGIC < RT_ELEMENTS(pack_spu.thread)
     131                && GET_THREAD_VAL_ID(thread->id) == thread);
     132        return thread->id;
     133    }
     134    crError("packspuNewThread failed");
     135#endif
     136    return 0;
     137}
     138
     139void PACKSPU_APIENTRY
     140packspu_VBoxConFlush(GLint con)
     141{
     142#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     143    GET_THREAD_ID(thread, con);
     144    CRASSERT(con);
     145    CRASSERT(CRPACKSPU_IS_WDDM_CRHGSMI());
     146    CRASSERT(thread->packer);
     147    packspuFlush((void *) thread);
     148#endif
     149}
     150
     151void PACKSPU_APIENTRY
     152packspu_VBoxConDestroy(GLint con)
     153{
     154#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     155    GET_THREAD_ID(thread, con);
     156    CRASSERT(con);
     157    CRASSERT(CRPACKSPU_IS_WDDM_CRHGSMI());
     158    CRASSERT(pack_spu.numThreads>0);
     159    CRASSERT(thread->packer);
     160    packspuFlush((void *) thread);
     161
     162    crLockMutex(&_PackMutex);
     163
     164    crPackDeleteContext(thread->packer);
     165
     166    crNetFreeConnection(thread->netServer.conn);
     167
     168    pack_spu.numThreads--;
     169    /*note can't shift the array here, because other threads have TLS references to array elements*/
     170    crMemZero(thread, sizeof(ThreadInfo));
     171
     172#if 0
     173    if (&pack_spu.thread[pack_spu.idxThreadInUse]==thread)
     174    {
     175        int i;
     176        crError("Should not be here since idxThreadInUse should be always 0 for the dummy connection created in packSPUInit!");
     177        for (i=0; i<MAX_THREADS; ++i)
     178        {
     179            if (pack_spu.thread[i].inUse)
     180            {
     181                pack_spu.idxThreadInUse=i;
     182                break;
     183            }
     184        }
     185    }
     186#endif
     187    crUnlockMutex(&_PackMutex);
     188#endif
     189}
     190
     191
     192GLint PACKSPU_APIENTRY
     193packspu_VBoxCreateContext( GLint con, const char *dpyName, GLint visual, GLint shareCtx )
    94194{
    95195    GET_THREAD(thread);
     196    CRPackContext * curPacker = crPackGetContext();
     197    ThreadInfo *curThread = thread;
    96198    int writeback = 1;
    97199    GLint serverCtx = (GLint) -1;
    98200    int slot;
    99201
     202    CRASSERT(!curThread == !curPacker);
     203    CRASSERT(!curThread || !curPacker || curThread->packer == curPacker);
    100204#ifdef CHROMIUM_THREADSAFE
    101205    crLockMutex(&_PackMutex);
    102206#endif
    103207
    104     if (!thread) {
    105         thread = packspuNewThread(crThreadID());
     208#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     209    CRASSERT(!con == !CRPACKSPU_IS_WDDM_CRHGSMI());
     210#endif
     211
     212    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     213    {
     214        if (!con)
     215        {
     216            crError("connection should be specified!");
     217            return -1;
     218        }
     219        thread = GET_THREAD_VAL_ID(con);
     220    }
     221    else
     222    {
     223        CRASSERT(!con);
     224        if (!thread)
     225        {
     226            thread = packspuNewThread(
     227#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     228                NULL
     229#endif
     230                );
     231        }
    106232    }
    107233    CRASSERT(thread);
    … …  
    145271    }
    146272    else {
    147         while (writeback)
    148             crNetRecv();
     273        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    149274
    150275        if (pack_spu.swap) {
    … …  
    156281#endif
    157282            crWarning("Failure in packspu_CreateContext");
     283
     284            if (CRPACKSPU_IS_WDDM_CRHGSMI())
     285            {
     286                /* restore the packer context to the tls */
     287                crPackSetContext(curPacker);
     288            }
    158289            return -1;  /* failed */
    159290        }
    … …  
    171302    }
    172303
     304    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     305    {
     306        thread->currentContext = &pack_spu.context[slot];
     307        pack_spu.context[slot].currentThread = thread;
     308    }
     309
    173310    /* Fill in the new context info */
    174311    /* XXX fix-up sharedCtx param here */
    … …  
    181318#endif
    182319
     320    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     321    {
     322        /* restore the packer context to the tls */
     323        crPackSetContext(curPacker);
     324    }
     325
    183326    return MAGIC_OFFSET + slot;
    184327}
    185328
     329GLint PACKSPU_APIENTRY
     330packspu_CreateContext( const char *dpyName, GLint visual, GLint shareCtx )
     331{
     332    return packspu_VBoxCreateContext( 0, dpyName, visual, shareCtx );
     333}
     334
    186335
    187336void PACKSPU_APIENTRY packspu_DestroyContext( GLint ctx )
    188337{
     338    GET_THREAD(thread);
     339    ThreadInfo *curThread = thread;
    189340    const int slot = ctx - MAGIC_OFFSET;
    190     ContextInfo *context;
    191     GET_THREAD(thread);
     341    ContextInfo *context, *curContext;
     342    CRPackContext * curPacker = crPackGetContext();
    192343
    193344    CRASSERT(slot >= 0);
    194345    CRASSERT(slot < pack_spu.numContexts);
     346
     347    context = &(pack_spu.context[slot]);
     348
     349    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     350    {
     351        thread = context->currentThread;
     352        crPackSetContext(thread->packer);
     353        CRASSERT(!(thread->packer == curPacker) == !(thread == curThread));
     354    }
    195355    CRASSERT(thread);
    196 
    197     context = &(pack_spu.context[slot]);
     356    curContext = curThread ? curThread->currentContext : NULL;
    198357
    199358    if (pack_spu.swap)
    … …  
    206365    context->clientState = NULL;
    207366    context->serverCtx = 0;
    208 
    209     if (thread->currentContext == context) {
    210         thread->currentContext = NULL;
     367    context->currentThread = NULL;
     368
     369    if (curContext == context)
     370    {
     371        if (!CRPACKSPU_IS_WDDM_CRHGSMI())
     372        {
     373            curThread->currentContext = NULL;
     374        }
     375        else
     376        {
     377            CRASSERT(thread == curThread);
     378            crSetTSD(&_PackTSD, NULL);
     379            crPackSetContext(NULL);
     380        }
    211381        crStateMakeCurrent( NULL );
    212382    }
     383    else
     384    {
     385        if (CRPACKSPU_IS_WDDM_CRHGSMI())
     386        {
     387            crPackSetContext(curPacker);
     388        }
     389    }
    213390}
    214391
    215392void PACKSPU_APIENTRY packspu_MakeCurrent( GLint window, GLint nativeWindow, GLint ctx )
    216393{
    217     GET_THREAD(thread);
     394    ThreadInfo *thread;
    218395    GLint serverCtx;
    219396    ContextInfo *newCtx;
    220397
    221     if (!thread) {
    222         thread = packspuNewThread( crThreadID() );
    223     }
    224     CRASSERT(thread);
    225     CRASSERT(thread->packer);
     398    if (!CRPACKSPU_IS_WDDM_CRHGSMI())
     399    {
     400        thread = GET_THREAD_VAL();
     401        if (!thread) {
     402            thread = packspuNewThread(
     403#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     404                    NULL
     405#endif
     406                    );
     407        }
     408        CRASSERT(thread);
     409        CRASSERT(thread->packer);
     410    }
    226411
    227412    if (ctx) {
    … …  
    234419        CRASSERT(newCtx->clientState);  /* verify valid */
    235420
    236         if (newCtx->fAutoFlush)
    237         {
    238             if (newCtx->currentThread && newCtx->currentThread != thread)
     421        if (CRPACKSPU_IS_WDDM_CRHGSMI())
     422        {
     423            thread = newCtx->currentThread;
     424            CRASSERT(thread);
     425            crSetTSD(&_PackTSD, thread);
     426            crPackSetContext( thread->packer );
     427        }
     428        else
     429        {
     430            if (!newCtx->fAutoFlush)
    239431            {
    240                 crLockMutex(&_PackMutex);
    241                 /* do a flush for the previously assigned thread
    242                  * to ensure all commands issued there are submitted */
    243                 if (newCtx->currentThread
    244                     && newCtx->currentThread->inUse
    245                     && newCtx->currentThread->netServer.conn
    246                     && newCtx->currentThread->packer && newCtx->currentThread->packer->currentBuffer)
     432                if (newCtx->currentThread && newCtx->currentThread != thread)
    247433                {
    248                     packspuFlush((void *) newCtx->currentThread);
     434                    crLockMutex(&_PackMutex);
     435                    /* do a flush for the previously assigned thread
     436                     * to ensure all commands issued there are submitted */
     437                    if (newCtx->currentThread
     438                        && newCtx->currentThread->inUse
     439                        && newCtx->currentThread->netServer.conn
     440                        && newCtx->currentThread->packer && newCtx->currentThread->packer->currentBuffer)
     441                    {
     442                        packspuFlush((void *) newCtx->currentThread);
     443                    }
     444                    crUnlockMutex(&_PackMutex);
    249445                }
    250                 crUnlockMutex(&_PackMutex);
     446                newCtx->currentThread = thread;
    251447            }
    252             newCtx->currentThread = thread;
    253         }
    254 
    255         thread->currentContext = newCtx;
    256 
    257         crPackSetContext( thread->packer );
     448
     449            thread->currentContext = newCtx;
     450            crPackSetContext( thread->packer );
     451        }
     452
    258453        crStateMakeCurrent( newCtx->clientState );
    259454        //crStateSetCurrentPointers(newCtx->clientState, &thread->packer->current);
    … …  
    261456    }
    262457    else {
    263         thread->currentContext = NULL;
    264458        crStateMakeCurrent( NULL );
     459        if (CRPACKSPU_IS_WDDM_CRHGSMI())
     460        {
     461            thread = GET_THREAD_VAL();
     462            if (!thread)
     463            {
     464                CRASSERT(crPackGetContext() == NULL);
     465                return;
     466            }
     467            CRASSERT(thread->currentContext);
     468            CRASSERT(thread->packer == crPackGetContext());
     469        }
     470        else
     471        {
     472            thread->currentContext = NULL;
     473        }
    265474        newCtx = NULL;
    266475        serverCtx = 0;

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_framebuffer.c

    r28800 r42499  
    9393
    9494        packspuFlush((void *) thread);
    95         while (writeback)
    96                 crNetRecv();
     95    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    9796
    9897    crStateSetFramebufferStatus(target, status);

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_get.py

    r37216 r42499  
    132132                crPack%s(%s, &writeback);
    133133                packspuFlush( (void *) thread );
    134                 while (writeback)
    135                     crNetRecv();
     134                CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    136135                for (i=0; i<__numValues(pname); ++i)
    137136                {
    … …  
    164163        print '\t}'
    165164        print '\tpackspuFlush( (void *) thread );'
    166         print '\twhile (writeback)'
    167         print '\t\tcrNetRecv();'
     165        print '\tCRPACKSPU_WRITEBACK_WAIT(thread, writeback);'
    168166
    169167

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_getshaders.c

    r40479 r42499  
    4646
    4747    packspuFlush((void *) thread);
    48     while (writeback)
    49         crNetRecv();
     48    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    5049
    5150    if (length) *length = pLocal->length;
    … …  
    7069
    7170    packspuFlush((void *) thread);
    72     while (writeback)
    73         crNetRecv();
     71    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    7472
    7573    if (length) *length = pLocal->length;
    … …  
    9492
    9593    packspuFlush((void *) thread);
    96     while (writeback)
    97         crNetRecv();
     94    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    9895
    9996    if (count) *count=*pLocal;
    … …  
    116113
    117114    packspuFlush((void *) thread);
    118     while (writeback)
    119         crNetRecv();
     115    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    120116
    121117    if (count) *count=*pLocal;
    … …  
    140136
    141137    packspuFlush((void *) thread);
    142     while (writeback)
    143         crNetRecv();
     138    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    144139
    145140    CRASSERT((pLocal[0]) <= maxLength);
    … …  
    164159
    165160    packspuFlush((void *) thread);
    166     while (writeback)
    167         crNetRecv();
     161    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    168162
    169163    if (length) *length=*pLocal;
    … …  
    186180
    187181    packspuFlush((void *) thread);
    188     while (writeback)
    189         crNetRecv();
     182    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    190183
    191184    if (length) *length=*pLocal;
    … …  
    208201
    209202    packspuFlush((void *) thread);
    210     while (writeback)
    211         crNetRecv();
     203    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    212204
    213205    if (length) *length=*pLocal;

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_getstring.c

    r37830 r42499  
    2929    packspuFlush( (void *) thread );
    3030
    31     while (writeback)
    32         crNetRecv();
     31    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    3332}
    3433
    … …  
    6665    packspuFlush( (void *) thread );
    6766
    68     while (writeback)
    69         crNetRecv();
     67    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    7068
    7169    CRASSERT(crStrlen((char *)return_value) < 10*1000);

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_glsl.c

    r39012 r42499  
    4242    }
    4343    packspuFlush((void *) thread);
    44     while (writeback)
    45         crNetRecv();
     44    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    4645    if (pack_spu.swap)
    4746    {
    … …  
    7271    }
    7372    packspuFlush((void *) thread);
    74     while (writeback)
    75         crNetRecv();
     73    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    7674    if (pack_spu.swap)
    7775    {
    … …  
    104102
    105103        packspuFlush((void *) thread);
    106         while (writeback)
    107             crNetRecv();
     104        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    108105
    109106        crStateGLSLProgramCacheUniforms(program, pData[0], &pData[1]);
    … …  
    137134    GLuint hwid = crStateGetProgramHWID(obj);
    138135
     136    CRASSERT(obj);
     137
    139138    if (hwid)
    140139    {

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_init.c

    r39061 r42499  
    4747    packspuSetVBoxConfiguration( child );
    4848
     49#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
     50    pack_spu.bRunningUnderWDDM = !!GetModuleHandle("VBoxDispD3D");
     51#endif
     52
    4953    /* This connects to the server, sets up the packer, etc. */
    50     thread = packspuNewThread( crThreadID() );
     54    thread = packspuNewThread(
     55#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     56            NULL
     57#endif
     58             );
    5159
    5260    if (!thread) {

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

    r41109 r42499  
    9898            packspuFlush( (void *) thread );
    9999
    100             while (writeback)
    101                 crNetRecv();
     100            CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    102101        }
    103102    }
    … …  
    117116            crPackWriteback(&writeback);
    118117            packspuFlush( (void *) thread );
    119             while (writeback)
    120                 crNetRecv();
     118            CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    121119        }
    122120    }
    … …  
    158156}
    159157
    160 GLint PACKSPU_APIENTRY packspu_WindowCreate( const char *dpyName, GLint visBits )
     158void PACKSPU_APIENTRY packspu_VBoxWindowDestroy( GLint con, GLint window )
     159{
     160    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     161    {
     162        ThreadInfo *thread;
     163        CRPackContext * curPacker = crPackGetContext();
     164        if (!con)
     165        {
     166            crError("connection expected!!");
     167            return;
     168        }
     169        thread = GET_THREAD_VAL_ID(con);
     170        crPackSetContext(thread->packer);
     171        crPackWindowDestroy(window);
     172        if (curPacker != thread->packer)
     173            crPackSetContext(curPacker);
     174        return;
     175    }
     176    crPackWindowDestroy(window);
     177}
     178
     179GLint PACKSPU_APIENTRY packspu_VBoxWindowCreate( GLint con, const char *dpyName, GLint visBits )
    161180{
    162181    GET_THREAD(thread);
    … …  
    164183    int writeback = pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network;
    165184    GLint return_val = (GLint) 0;
    166 
    167     if (!thread) {
    168         thread = packspuNewThread( crThreadID() );
     185    ThreadInfo *curThread = thread;
     186    GLint retVal;
     187
     188    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     189    {
     190        if (!con)
     191        {
     192            crError("connection expected!");
     193            return 0;
     194        }
     195        thread = GET_THREAD_VAL_ID(con);
     196    }
     197    else
     198    {
     199        CRASSERT(!con);
     200        if (!thread) {
     201            thread = packspuNewThread(
     202#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     203                NULL
     204#endif
     205                );
     206        }
    169207    }
    170208    CRASSERT(thread);
    171209    CRASSERT(thread->packer);
     210    CRASSERT(crPackGetContext() == (curThread ? curThread->packer : NULL));
    172211
    173212    crPackSetContext(thread->packer);
    … …  
    184223    if (!(thread->netServer.conn->actual_network))
    185224    {
    186         return num_calls++;
    187     }
    188     else
    189     {
    190         while (writeback)
    191             crNetRecv();
     225        retVal = num_calls++;
     226    }
     227    else
     228    {
     229        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    192230        if (pack_spu.swap)
    193231        {
    194232            return_val = (GLint) SWAP32(return_val);
    195233        }
    196         return return_val;
    197     }
    198 }
    199 
    200 
     234        retVal = return_val;
     235    }
     236
     237    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     238    {
     239        if (thread != curThread)
     240        {
     241            if (curThread)
     242                crPackSetContext(curThread->packer);
     243            else
     244                crPackSetContext(NULL);
     245        }
     246    }
     247
     248    return retVal;
     249}
     250
     251GLint PACKSPU_APIENTRY packspu_WindowCreate( const char *dpyName, GLint visBits )
     252{
     253    return packspu_VBoxWindowCreate( 0, dpyName, visBits );
     254}
    201255
    202256GLboolean PACKSPU_APIENTRY
    … …  
    224278    packspuFlush( (void *) thread );
    225279
    226     while (writeback)
    227         crNetRecv();
     280    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    228281
    229282    /* Since the Chromium packer/unpacker can't return both 'residences'
    … …  
    264317    packspuFlush( (void *) thread );
    265318
    266     while (writeback)
    267         crNetRecv();
     319    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    268320
    269321    /* Since the Chromium packer/unpacker can't return both 'residences'
    … …  
    299351    {
    300352        packspuFlush( (void *) thread );
    301         while (writeback)
    302             crNetRecv();
     353        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    303354    }
    304355}
    … …  
    323374    {
    324375        packspuFlush( (void *) thread );
    325         while (writeback)
    326             crNetRecv();
     376        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    327377    }
    328378}
    … …  
    347397    {
    348398        packspuFlush( (void *) thread );
    349         while (writeback)
    350             crNetRecv();
     399        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    351400    }
    352401}
    … …  
    371420    {
    372421        packspuFlush( (void *) thread );
    373         while (writeback)
    374             crNetRecv();
     422        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    375423    }
    376424}
    … …  
    410458
    411459#ifdef CHROMIUM_THREADSAFE
    412 void PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(void)
    413 {
     460GLint PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(struct VBOXUHGSMI *pHgsmi)
     461{
     462    GLint con = 0;
     463    int i;
     464    GET_THREAD(thread);
     465    CRASSERT(!thread);
    414466    crLockMutex(&_PackMutex);
    415467    {
    416         int i;
    417         GET_THREAD(thread);
    418         CRASSERT(!thread);
    419468        CRASSERT((pack_spu.numThreads>0) && (pack_spu.numThreads<MAX_THREADS));
    420469
    … …  
    430479
    431480        thread->inUse = GL_TRUE;
    432         thread->id = crThreadID();
     481        if (!CRPACKSPU_IS_WDDM_CRHGSMI())
     482            thread->id = crThreadID();
     483        else
     484            thread->id = THREAD_OFFSET_MAGIC + i;
    433485        thread->currentContext = NULL;
    434486        thread->bInjectThread = GL_TRUE;
    … …  
    437489        thread->netServer.buffer_size = 64 * 1024;
    438490
    439         crNetNewClient(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn, &(thread->netServer));
     491        crNetNewClient(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn, &(thread->netServer)
     492#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     493                , pHgsmi
     494#endif
     495        );
    440496        CRASSERT(thread->netServer.conn);
    441497
    … …  
    458514    }
    459515    crUnlockMutex(&_PackMutex);
    460 }
    461 
    462 GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(void)
     516
     517    if (CRPACKSPU_IS_WDDM_CRHGSMI())
     518    {
     519        CRASSERT(thread->id - THREAD_OFFSET_MAGIC < RT_ELEMENTS(pack_spu.thread)
     520                && GET_THREAD_VAL_ID(thread->id) == thread);
     521        con = thread->id;
     522    }
     523    return con;
     524}
     525
     526GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(GLint con)
    463527{
    464528    GLuint ret;
    … …  
    466530    crLockMutex(&_PackMutex);
    467531    {
    468         GET_THREAD(thread);
     532        ThreadInfo *thread = NULL;
     533        if (CRPACKSPU_IS_WDDM_CRHGSMI())
     534        {
     535            if (!con)
     536            {
     537                crError("connection expected!");
     538                return 0;
     539            }
     540            thread = GET_THREAD_VAL_ID(con);
     541        }
     542        else
     543        {
     544            CRASSERT(!con);
     545            thread = GET_THREAD_VAL();
     546        }
    469547        CRASSERT(thread && thread->netServer.conn && thread->netServer.conn->type==CR_VBOXHGCM);
    470548        ret = thread->netServer.conn->u32ClientID;
    … …  
    514592    if (thread)
    515593    {
    516         crLockMutex(&_PackMutex);
    517 
    518         for (i=0; i<MAX_THREADS; ++i)
    519         {
    520             if (pack_spu.thread[i].inUse && thread==&pack_spu.thread[i]
    521                 && thread->id==crThreadID() && thread->netServer.conn)
     594        if (CRPACKSPU_IS_WDDM_CRHGSMI())
     595        {
     596            crPackSetContext(NULL);
     597            crSetTSD(&_PackTSD, NULL);
     598        }
     599        else
     600        {
     601            crLockMutex(&_PackMutex);
     602
     603            for (i=0; i<MAX_THREADS; ++i)
    522604            {
    523                 CRASSERT(pack_spu.numThreads>0);
    524 
    525                 packspuFlush((void *) thread);
    526 
    527                 if (pack_spu.thread[i].packer)
     605                if (pack_spu.thread[i].inUse && thread==&pack_spu.thread[i]
     606                    && thread->id==crThreadID() && thread->netServer.conn)
    528607                {
    529                     CR_LOCK_PACKER_CONTEXT(thread->packer);
    530                     crPackSetContext(NULL);
    531                     CR_UNLOCK_PACKER_CONTEXT(thread->packer);
    532                     crPackDeleteContext(pack_spu.thread[i].packer);
    533                 }
    534                 crNetFreeConnection(pack_spu.thread[i].netServer.conn);
    535 
    536                 pack_spu.numThreads--;
    537                 /*note can't shift the array here, because other threads have TLS references to array elements*/
    538                 crMemZero(&pack_spu.thread[i], sizeof(ThreadInfo));
    539 
    540                 crSetTSD(&_PackTSD, NULL);
    541 
    542                 if (i==pack_spu.idxThreadInUse)
    543                 {
    544                     for (i=0; i<MAX_THREADS; ++i)
     608                    CRASSERT(pack_spu.numThreads>0);
     609
     610                    packspuFlush((void *) thread);
     611
     612                    if (pack_spu.thread[i].packer)
    545613                    {
    546                         if (pack_spu.thread[i].inUse)
     614                        CR_LOCK_PACKER_CONTEXT(thread->packer);
     615                        crPackSetContext(NULL);
     616                        CR_UNLOCK_PACKER_CONTEXT(thread->packer);
     617                        crPackDeleteContext(pack_spu.thread[i].packer);
     618                    }
     619                    crNetFreeConnection(pack_spu.thread[i].netServer.conn);
     620
     621                    pack_spu.numThreads--;
     622                    /*note can't shift the array here, because other threads have TLS references to array elements*/
     623                    crMemZero(&pack_spu.thread[i], sizeof(ThreadInfo));
     624
     625                    crSetTSD(&_PackTSD, NULL);
     626
     627                    if (i==pack_spu.idxThreadInUse)
     628                    {
     629                        for (i=0; i<MAX_THREADS; ++i)
    547630                        {
    548                             pack_spu.idxThreadInUse=i;
    549                             break;
     631                            if (pack_spu.thread[i].inUse)
     632                            {
     633                                pack_spu.idxThreadInUse=i;
     634                                break;
     635                            }
    550636                        }
    551637                    }
     638
     639                    break;
    552640                }
    553 
    554                 break;
    555641            }
    556         }
    557 
    558         for (i=0; i<CR_MAX_CONTEXTS; ++i)
    559         {
    560             ContextInfo *ctx = &pack_spu.context[i];
    561             if (ctx->currentThread == thread)
     642
     643            for (i=0; i<CR_MAX_CONTEXTS; ++i)
    562644            {
    563                 CRASSERT(ctx->fAutoFlush);
    564                 ctx->currentThread = NULL;
     645                ContextInfo *ctx = &pack_spu.context[i];
     646                if (ctx->currentThread == thread)
     647                {
     648                    CRASSERT(ctx->fAutoFlush);
     649                    ctx->currentThread = NULL;
     650                }
    565651            }
    566         }
    567 
    568         crUnlockMutex(&_PackMutex);
     652
     653            crUnlockMutex(&_PackMutex);
     654        }
    569655    }
    570656
    … …  
    605691
    606692#else  /*ifdef CHROMIUM_THREADSAFE*/
    607 void PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(void)
    608 {
    609 }
    610 
    611 GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(void)
     693GLint PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(struct VBOXUHGSMI *pHgsmi)
     694{
     695}
     696
     697GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(GLint con)
    612698{
    613699    return 0;

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_net.c

    r35845 r42499  
    230230}
    231231
    232 void packspuConnectToServer( CRNetServer *server )
     232void packspuConnectToServer( CRNetServer *server
     233#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     234                , struct VBOXUHGSMI *pHgsmi
     235#endif
     236        )
    233237{
    234238    crNetInit( packspuReceiveData, NULL );
    235     crNetServerConnect( server );
    236 }
     239    crNetServerConnect( server
     240#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     241                , pHgsmi
     242#endif
     243            );
     244}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_pixel.c

    r38772 r42499  
    322322
    323323        packspuFlush((void *) thread);
    324         while (pack_spu.ReadPixels)
    325             crNetRecv();
     324        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    326325    }
    327326}
    … …  
    588587    {
    589588        packspuFlush( (void *) thread );
    590         while (writeback)
    591             crNetRecv();
     589        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    592590    }
    593591}
    … …  
    622620    {
    623621        packspuFlush( (void *) thread );
    624         while (writeback)
    625             crNetRecv();
     622        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    626623    }
    627624}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_special

    r40431 r42499  
    107107VBoxAttachThread
    108108VBoxDetachThread
     109VBoxCreateContext
     110VBoxWindowCreate
     111VBoxWindowDestroy
     112VBoxConCreate
     113VBoxConDestroy
     114VBoxConFlush
    109115ChromiumParameteriCR
    110116CompressedTexImage1DARB

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_swapbuf.c

    r33540 r42499  
    8585            /* Make sure writeback from previous frame has been received.
    8686             */
    87             while (thread->writeback)
    88             {
    89                 crNetRecv();
    90             }
     87            CRPACKSPU_WRITEBACK_WAIT(thread, thread->writeback);
    9188            break;
    9289        }

  • trunk/src/VBox/Additions/common/crOpenGL/stub.c

    r41963 r42499  
    1111#include <iprt/thread.h>
    1212
    13 static void crForcedFlush()
     13static void crForcedFlush(
     14#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     15        GLint con
     16#endif
     17        )
    1418{
    1519#if 0
    … …  
    2024    stub.spu->dispatch_table.DrawBuffer(buffer);
    2125#else
    22     stub.spu->dispatch_table.Flush();
     26#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     27    if (con)
     28    {
     29        stub.spu->dispatch_table.VBoxConFlush(con);
     30    }
     31    else
     32#endif
     33    {
     34        stub.spu->dispatch_table.Flush();
     35    }
    2336#endif
    2437}
    … …  
    6376     * That didn't seem right so it was changed to CHROMIUM. (Brian)
    6477     */
    65     context = stubNewContext(dpyName, visBits, CHROMIUM, 0);
     78    context = stubNewContext(dpyName, visBits, CHROMIUM, 0
     79#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     80        , NULL
     81#endif
     82            );
    6683    return context ? (int) context->id : -1;
    6784}
    … …  
    143160        crHashtableLock(stub.windowTable);
    144161
    145         stub.spu->dispatch_table.WindowDestroy( winInfo->spuWindow );
     162        stub.spu->dispatch_table.VBoxWindowDestroy(
     163#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     164                winInfo->spuConnection,
     165#else
     166                0
     167#endif
     168                winInfo->spuWindow );
    146169
    147170#ifdef WINDOWS
    … …  
    162185# endif
    163186#endif
    164         crForcedFlush();
    165 
     187        crForcedFlush(
     188#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     189                winInfo->spuConnection
     190#endif
     191                );
     192
     193#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     194        winInfo->spuConnection = 0;
     195#endif
    166196        crHashtableWalk(stub.contextTable, stubWindowCleanupForContextsCB, winInfo);
    167197

  • trunk/src/VBox/Additions/common/crOpenGL/stub.h

    r39602 r42499  
    115115    WindowInfo *currentDrawable;
    116116
     117#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     118    GLint spuConnection;
     119    struct VBOXUHGSMI *pHgsmi;
     120#endif
     121
    117122#ifdef CHROMIUM_THREADSAFE
    118123    VBOXTLSREFDATA
    … …  
    165170    ContextInfo *pOwner;     /* ctx which created this window */
    166171    GLboolean mapped;
     172#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     173    GLint spuConnection;
     174#endif
    167175#ifdef WINDOWS
    168176    HDC      drawable;
    … …  
    329337
    330338
    331 extern ContextInfo *stubNewContext( const char *dpyName, GLint visBits, ContextType type, unsigned long shareCtx );
     339extern ContextInfo *stubNewContext( const char *dpyName, GLint visBits, ContextType type, unsigned long shareCtx
     340#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     341        , struct VBOXUHGSMI *pHgsmi
     342#endif
     343        );
    332344extern void stubDestroyContext( unsigned long contextId );
    333345extern GLboolean stubMakeCurrent( WindowInfo *window, ContextInfo *context );

  • trunk/src/VBox/Additions/common/crOpenGL/wgl.c

    r41971 r42499  
    295295
    296296
    297 HGLRC WINAPI wglCreateContext_prox( HDC hdc )
     297HGLRC WINAPI VBoxCreateContext( HDC hdc, struct VBOXUHGSMI *pHgsmi )
    298298{
    299299    char dpyName[MAX_DPY_NAME];
    … …  
    312312#endif
    313313
    314     context = stubNewContext(dpyName, desiredVisual, UNDECIDED, 0);
     314    context = stubNewContext(dpyName, desiredVisual, UNDECIDED, 0
     315#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     316        , pHgsmi
     317#else
     318        , NULL
     319#endif
     320            );
    315321    if (!context)
    316322        return 0;
    317323
    318324    return (HGLRC) context->id;
     325}
     326
     327HGLRC WINAPI wglCreateContext_prox( HDC hdc )
     328{
     329    return VBoxCreateContext(hdc, NULL);
    319330}
    320331

  • trunk/src/VBox/GuestHost/OpenGL/Makefile.kmk

    r42311 r42499  
    9393endif
    9494ifdef VBOX_WITH_WDDM
     95VBoxOGLcrutil_DEFS.win   += VBOX_WITH_WDDM
    9596VBoxOGLcrutil_DEFS.win    += CR_DEBUG_BACKDOOR_ENABLE
    9697VBoxOGLcrutil_INCS.win    += $(PATH_ROOT)/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm
    … …  
    252253        $(VBOX_PATH_CROGL_GENFILES)/cr_opcodes.h \
    253254        $(VBOX_PATH_CROGL_GENFILES)/state/cr_currentpointers.h
     255ifdef VBOX_WITH_CRHGSMI
     256VBoxOGLcrpacker_DEFS.win    += VBOX_WITH_CRHGSMI
     257endif
     258ifdef VBOX_WITH_WDDM
     259VBoxOGLcrpacker_DEFS.win   += VBOX_WITH_WDDM
     260endif
    254261
    255262if defined(VBOX_WITH_WDDM) && defined(VBOX_WITH_ADDITIONS)
    … …  
    330337        $(VBOX_PATH_CROGL_GENFILES)/glloader.c \
    331338        $(VBOX_PATH_CROGL_GENFILES)/spu_dispatch_table.h
    332 
     339ifdef VBOX_WITH_CRHGSMI
     340VBoxOGLspuload_DEFS.win    += VBOX_WITH_CRHGSMI
     341endif
     342ifdef VBOX_WITH_WDDM
     343VBoxOGLspuload_DEFS.win   += VBOX_WITH_WDDM
     344endif
    333345
    334346if defined(VBOX_WITH_WDDM) && defined(VBOX_WITH_ADDITIONS)
    … …  
    459471VBoxOGLcrstate_CFLAGS +=
    460472endif
    461 
     473ifdef VBOX_WITH_CRHGSMI
     474VBoxOGLcrstate_DEFS.win    += VBOX_WITH_CRHGSMI
     475endif
     476ifdef VBOX_WITH_WDDM
     477VBoxOGLcrstate_DEFS.win   += VBOX_WITH_WDDM
     478endif
    462479
    463480if defined(VBOX_WITH_WDDM) && defined(VBOX_WITH_ADDITIONS)
    … …  
    582599VBoxOGLerrorspu_LIBS = \
    583600        $(VBOX_LIB_OGL_CRUTIL)
     601ifdef VBOX_WITH_CRHGSMI
     602VBoxOGLerrorspu_DEFS.win    += VBOX_WITH_CRHGSMI
     603endif
     604ifdef VBOX_WITH_WDDM
     605VBoxOGLerrorspu_DEFS.win   += VBOX_WITH_WDDM
     606endif
     607
    584608
    585609if defined(VBOX_WITH_WDDM) && defined(VBOX_WITH_ADDITIONS)

  • trunk/src/VBox/GuestHost/OpenGL/glapi_parser/APIspec.txt

    r40431 r42499  
    85018501
    85028502name        VBoxPackSetInjectThread
    8503 return      void
     8503return      GLint
     8504param       pHgsmi      struct VBOXUHGSMI *
    85048505category    VBox
    85058506chromium    nopack
    … …  
    85078508name        VBoxPackGetInjectID
    85088509return      GLuint
     8510param       con         GLint
    85098511category    VBox
    85108512chromium    nopack
    … …  
    85238525name        VBoxDetachThread
    85248526return      void
     8527category    VBox
     8528chromium    nopack
     8529
     8530name        VBoxCreateContext
     8531return      GLint
     8532param       con         GLint
     8533param       dpyName     const char *
     8534param       visual      GLint
     8535param       shareCtx    GLint
     8536category    VBox
     8537chromium    nopack
     8538
     8539name        VBoxWindowCreate
     8540return      GLint
     8541param       con         GLint
     8542param       dpyName     const char *
     8543param       visBits     GLint
     8544category    VBox
     8545chromium    nopack
     8546
     8547name        VBoxWindowDestroy
     8548return      void
     8549param       con         GLint
     8550param       window      GLint
     8551category    VBox
     8552chromium    nopack
     8553
     8554name        VBoxConCreate
     8555return      GLint
     8556param       pHgsmi      struct VBOXUHGSMI *
     8557category    VBox
     8558chromium    nopack
     8559
     8560name        VBoxConDestroy
     8561return      void
     8562param       con         GLint
     8563category    VBox
     8564chromium    nopack
     8565
     8566name        VBoxConFlush
     8567return      void
     8568param       con         GLint
    85258569category    VBox
    85268570chromium    nopack

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_net.h

    r39288 r42499  
    3535
    3636#include <iprt/types.h>
     37#include <iprt/thread.h>
    3738   
    3839#ifdef __cplusplus
    … …  
    236237    uint32_t u32InjectClientID;
    237238# ifdef VBOX_WITH_CRHGSMI
    238 #  ifndef VBOX_CRHGSMI_WITH_D3DDEV
    239239    CRVBOXHGSMI_CLIENT HgsmiClient;
    240 #  endif
     240    struct VBOXUHGSMI *pExternalHgsmi;
    241241# endif
    242242#else
    … …  
    283283extern DECLEXPORT(int) crNetNumMessages(CRConnection *conn);
    284284extern DECLEXPORT(void) crNetReadline( CRConnection *conn, void *buf );
    285 extern DECLEXPORT(int) crNetRecv( void );
    286 #define CR_WRITEBACK_WAIT() do { \
    287         while (writeback) { \
    288             crNetRecv();    \
    289         }                   \
     285extern DECLEXPORT(int) crNetRecv(
     286#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     287                CRConnection *conn
     288#endif
     289        );
     290#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     291#define CR_WRITEBACK_WAIT(_conn, _writeback) do { \
     292        while (_writeback) {     \
     293            RTThreadYield();     \
     294            crNetRecv(_conn);    \
     295        }                        \
    290296    } while (0)
     297#else
     298#define CR_WRITEBACK_WAIT(_conn, _writeback) do { \
     299        while (_writeback) { \
     300            RTThreadYield(); \
     301            crNetRecv();     \
     302        }                    \
     303    } while (0)
     304
     305#endif
    291306extern DECLEXPORT(void) crNetDefaultRecv( CRConnection *conn, CRMessage *msg, unsigned int len );
    292307extern DECLEXPORT(void) crNetDispatchMessage( CRNetReceiveFuncList *rfl, CRConnection *conn, CRMessage *msg, unsigned int len );
    293308
    294 extern DECLEXPORT(CRConnection *) crNetConnectToServer( const char *server, unsigned short default_port, int mtu, int broker );
     309extern DECLEXPORT(CRConnection *) crNetConnectToServer( const char *server, unsigned short default_port, int mtu, int broker
     310#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     311                , struct VBOXUHGSMI *pHgsmi
     312#endif
     313);
    295314extern DECLEXPORT(CRConnection *) crNetAcceptClient( const char *protocol, const char *hostname, unsigned short port, unsigned int mtu, int broker );
    296315

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_netserver.h

    r15532 r42499  
    2222} CRNetServer;
    2323
    24 DECLEXPORT(void) crNetServerConnect( CRNetServer *ns );
    25 DECLEXPORT(void) crNetNewClient( CRConnection *conn, CRNetServer *ns );
     24DECLEXPORT(void) crNetServerConnect( CRNetServer *ns
     25#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     26                , struct VBOXUHGSMI *pHgsmi
     27#endif
     28                );
     29DECLEXPORT(void) crNetNewClient( CRConnection *conn, CRNetServer *ns
     30#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     31                , struct VBOXUHGSMI *pHgsmi
     32#endif
     33);
    2634
    2735#ifdef __cplusplus

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_init.c

    r41109 r42499  
    664664{
    665665}
     666
     667GLint crStateVBoxCreateContext( GLint con, const char * dpyName, GLint visual, GLint shareCtx )
     668{
     669    return 0;
     670}
     671
     672GLint crStateVBoxWindowCreate( GLint con, const char *dpyName, GLint visBits  )
     673{
     674    return 0;
     675}
     676
     677void crStateVBoxWindowDestroy( GLint con, GLint window )
     678{
     679}
     680
     681GLint crStateVBoxConCreate(struct VBOXUHGSMI *pHgsmi)
     682{
     683    return 0;
     684}
     685
     686void crStateVBoxConDestroy(GLint con)
     687{
     688}
     689
     690void crStateVBoxConFlush(GLint con)
     691{
     692}

  • trunk/src/VBox/GuestHost/OpenGL/util/net.c

    r40124 r42499  
    7373 */
    7474static void
    75 InitConnection(CRConnection *conn, const char *protocol, unsigned int mtu)
     75InitConnection(CRConnection *conn, const char *protocol, unsigned int mtu
     76#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     77                , struct VBOXUHGSMI *pHgsmi
     78#endif
     79        )
    7680{
    7781    if (!crStrcmp(protocol, "devnull"))
    … …  
    111115        cr_net.use_hgcm++;
    112116        crVBoxHGCMInit(cr_net.recv_list, cr_net.close_list, mtu);
    113         crVBoxHGCMConnection(conn);
     117        crVBoxHGCMConnection(conn
     118#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     119                    , pHgsmi
     120#endif
     121                );
    114122    }
    115123#endif
    … …  
    184192 *                the mothership
    185193 */
    186 CRConnection *
    187 crNetConnectToServer( const char *server, unsigned short default_port,
    188                       int mtu, int broker )
     194CRConnection * crNetConnectToServer( const char *server, unsigned short default_port, int mtu, int broker
     195#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     196                , struct VBOXUHGSMI *pHgsmi
     197#endif
     198)
    189199{
    190200    char hostname[4096], protocol[4096];
    … …  
    270280
    271281    /* now, just dispatch to the appropriate protocol's initialization functions. */
    272     InitConnection(conn, protocol, mtu);
     282    InitConnection(conn, protocol, mtu
     283#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     284                , pHgsmi
     285#endif
     286            );
    273287
    274288    if (!crNetConnect( conn ))
    … …  
    287301}
    288302
    289 
    290303/**
    291304 * Send a message to the receiver that another connection is needed.
    292305 * We send a CR_MESSAGE_NEWCLIENT packet, then call crNetServerConnect.
    293306 */
    294 void crNetNewClient( CRConnection *conn, CRNetServer *ns )
     307void crNetNewClient( CRConnection *conn, CRNetServer *ns
     308#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     309                , struct VBOXUHGSMI *pHgsmi
     310#endif
     311)
    295312{
    296313    /*
    … …  
    308325    */
    309326
    310     crNetServerConnect( ns );
     327    crNetServerConnect( ns
     328#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     329                , pHgsmi
     330#endif
     331);
    311332}
    312333
    … …  
    368389
    369390    /* call the protocol-specific init routines */  // ktd (add)
    370     InitConnection(conn, protocol_only, mtu);       // ktd (add)
     391    InitConnection(conn, protocol_only, mtu
     392#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     393                , NULL
     394#endif
     395            );       // ktd (add)
    371396    }
    372397    else {
    373398    /* call the protocol-specific init routines */
    374       InitConnection(conn, protocol, mtu);
     399      InitConnection(conn, protocol, mtu
     400#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     401                , NULL
     402#endif
     403              );
    375404    }
    376405
    … …  
    834863 * When done, the CrNetServer's conn field will be initialized.
    835864 */
    836 void crNetServerConnect( CRNetServer *ns )
     865void crNetServerConnect( CRNetServer *ns
     866#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     867                , struct VBOXUHGSMI *pHgsmi
     868#endif
     869)
    837870{
    838871    ns->conn = crNetConnectToServer( ns->name, DEFAULT_SERVER_PORT,
    839                                      ns->buffer_size, 0 );
    840 }
    841 
     872                                     ns->buffer_size, 0
     873#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     874                , pHgsmi
     875#endif
     876            );
     877}
    842878
    843879/**
    … …  
    11861222        if (len)
    11871223            return len;
    1188         crNetRecv();
     1224        crNetRecv(
     1225#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1226                conn
     1227#endif
     1228                );
    11891229    }
    11901230
    … …  
    12341274 * is assumed to be placed on queues for processing by the handler.
    12351275 */
    1236 int crNetRecv( void )
     1276int crNetRecv(
     1277#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1278        CRConnection *conn
     1279#endif
     1280        )
    12371281{
    12381282    int found_work = 0;
    … …  
    12421286#ifdef VBOX_WITH_HGCM
    12431287    if ( cr_net.use_hgcm )
    1244         found_work += crVBoxHGCMRecv();
     1288        found_work += crVBoxHGCMRecv(
     1289#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     1290                    conn
     1291#endif
     1292                );
    12451293#endif
    12461294#ifdef SDP_SUPPORT

  • trunk/src/VBox/GuestHost/OpenGL/util/net_internals.h

    r33561 r42499  
    9292#ifdef VBOX_WITH_HGCM
    9393extern void crVBoxHGCMInit( CRNetReceiveFuncList *rfl, CRNetCloseFuncList *cfl, unsigned int mtu );
    94 extern void crVBoxHGCMConnection( CRConnection *conn );
    95 extern int crVBoxHGCMRecv( void );
     94extern void crVBoxHGCMConnection( CRConnection *conn
     95#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     96        , struct VBOXUHGSMI *pHgsmi
     97#endif
     98        );
     99extern int crVBoxHGCMRecv(
     100#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     101        CRConnection *conn
     102#endif
     103        );
    96104extern CRConnection** crVBoxHGCMDump( int *num );
    97105extern void crVBoxHGCMTearDown(void);

  • trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c

    r41912 r42499  
    345345        return &conn->HgsmiClient;
    346346    {
    347         PVBOXUHGSMI pHgsmi = VBoxCrHgsmiCreate();
     347        PVBOXUHGSMI pHgsmi = conn->pExternalHgsmi ? conn->pExternalHgsmi : VBoxCrHgsmiCreate();
    348348        if (pHgsmi)
    349349        {
    … …  
    356356            else
    357357                crWarning("_crVBoxHGSMIClientGet: _crVBoxHGSMIClientInit failed rc %d", rc);
    358             VBoxCrHgsmiDestroy(pHgsmi);
     358            if (!conn->pExternalHgsmi)
     359                VBoxCrHgsmiDestroy(pHgsmi);
    359360        }
    360361        else
    … …  
    23332334        _crVBoxHGSMIClientTerm(&conn->HgsmiClient, &pHgsmi);
    23342335        CRASSERT(pHgsmi);
    2335         VBoxCrHgsmiDestroy(pHgsmi);
     2336        if (!conn->pExternalHgsmi)
     2337            VBoxCrHgsmiDestroy(pHgsmi);
    23362338    }
    23372339#else
    … …  
    24982500}
    24992501
    2500 void crVBoxHGCMConnection(CRConnection *conn)
     2502void crVBoxHGCMConnection(CRConnection *conn
     2503#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     2504        , struct VBOXUHGSMI *pHgsmi
     2505#endif
     2506        )
    25012507{
    25022508    int i, found = 0;
    … …  
    25202526        conn->InstantReclaim = crVBoxHGSMIInstantReclaim;
    25212527        conn->HandleNewMessage = crVBoxHGSMIHandleNewMessage;
     2528        conn->pExternalHgsmi = pHgsmi;
    25222529    }
    25232530    else
    … …  
    25772584}
    25782585
    2579 int crVBoxHGCMRecv(void)
     2586#if defined(IN_GUEST)
     2587void _crVBoxHGCMPerformPollHost(CRConnection *conn)
     2588{
     2589    if (conn->type == CR_NO_CONNECTION )
     2590        return;
     2591
     2592    if (!conn->pBuffer)
     2593    {
     2594#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     2595        PCRVBOXHGSMI_CLIENT pClient;
     2596        if (g_crvboxhgcm.bHgsmiOn && !!(pClient = _crVBoxHGSMIClientGet(conn)))
     2597        {
     2598            _crVBoxHGSMIPollHost(conn, pClient);
     2599        }
     2600        else
     2601#endif
     2602        {
     2603            crVBoxHGCMPollHost(conn);
     2604        }
     2605    }
     2606}
     2607#endif
     2608
     2609void _crVBoxHGCMPerformReceiveMessage(CRConnection *conn)
     2610{
     2611    if ( conn->type == CR_NO_CONNECTION )
     2612        return;
     2613
     2614    if (conn->cbBuffer>0)
     2615    {
     2616        _crVBoxHGCMReceiveMessage(conn);
     2617    }
     2618}
     2619
     2620int crVBoxHGCMRecv(
     2621#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     2622        CRConnection *conn
     2623#endif
     2624        )
    25802625{
    25812626    int32_t i;
    … …  
    25882633
    25892634#ifdef IN_GUEST
     2635# if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     2636    CRASSERT(!g_crvboxhgcm.bHgsmiOn == !conn);
     2637    if (conn && g_crvboxhgcm.bHgsmiOn)
     2638    {
     2639        _crVBoxHGCMPerformPollHost(conn);
     2640        _crVBoxHGCMPerformReceiveMessage(conn);
     2641        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     2642        return 0;
     2643    }
     2644# endif
    25902645    /* we're on guest side, poll host if it got something for us */
    25912646    for (i=0; i<g_crvboxhgcm.num_conns; i++)
    … …  
    25932648        CRConnection *conn = g_crvboxhgcm.conns[i];
    25942649
    2595         if ( !conn || conn->type == CR_NO_CONNECTION )
     2650        if ( !conn )
    25962651            continue;
    25972652
    2598         if (!conn->pBuffer)
    2599         {
    2600 #if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
    2601             PCRVBOXHGSMI_CLIENT pClient;
    2602             if (g_crvboxhgcm.bHgsmiOn && !!(pClient = _crVBoxHGSMIClientGet(conn)))
    2603             {
    2604                 _crVBoxHGSMIPollHost(conn, pClient);
    2605             }
    2606             else
    2607 #endif
    2608             {
    2609                 crVBoxHGCMPollHost(conn);
    2610             }
    2611         }
     2653        _crVBoxHGCMPerformPollHost(conn);
    26122654    }
    26132655#endif
    … …  
    26172659        CRConnection *conn = g_crvboxhgcm.conns[i];
    26182660
    2619         if ( !conn || conn->type == CR_NO_CONNECTION )
     2661        if ( !conn )
    26202662            continue;
    26212663
    2622         if (conn->cbBuffer>0)
    2623         {
    2624             _crVBoxHGCMReceiveMessage(conn);
    2625         }
     2664        _crVBoxHGCMPerformReceiveMessage(conn);
    26262665    }
    26272666
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