VirtualBox

Changeset 50812 in vbox


Ignore:
Timestamp:
Mar 18, 2014 5:14:09 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
92856
Message:

crOpenGL: bugfixes, more on new command submission

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxVideo.h

    r50774 r50812  
    17491749} VBOXCMDVBVA_CTL_ENABLE;
    17501750
     1751#define VBOXCMDVBVA3DCTL_TYPE_CONNECT     1
     1752#define VBOXCMDVBVA3DCTL_TYPE_DISCONNECT  2
     1753#define VBOXCMDVBVA3DCTL_TYPE_CMD         3
     1754
     1755typedef struct VBOXCMDVBVA_3DCTL
     1756{
     1757    uint32_t u32Type;
     1758    uint32_t u32CmdClientId;
     1759} VBOXCMDVBVA_3DCTL;
     1760
     1761typedef struct VBOXCMDVBVA_3DCTL_CONNECT
     1762{
     1763    VBOXCMDVBVA_3DCTL Hdr;
     1764    uint32_t u32MajorVersion;
     1765    uint32_t u32MinorVersion;
     1766    uint64_t u64Pid;
     1767} VBOXCMDVBVA_3DCTL_CONNECT;
     1768
     1769typedef struct VBOXCMDVBVA_3DCTL_CMD
     1770{
     1771    VBOXCMDVBVA_3DCTL Hdr;
     1772    VBOXCMDVBVA_HDR Cmd;
     1773} VBOXCMDVBVA_3DCTL_CMD;
     1774
    17511775#pragma pack()
    17521776

  • trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

    r50799 r50812  
    22132213}
    22142214
    2215 static int vdmaVBVACtlEnableDisableSubmitInternal(PVBOXVDMAHOST pVdma, VBOXCMDVBVA_CTL_ENABLE *pEnable, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
     2215static int vdmaVBVACtlEnableDisableSubmitInternal(PVBOXVDMAHOST pVdma, VBVAENABLE *pEnable, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
    22162216{
    22172217    VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(&pVdma->CmdVbva, VBVAEXHOSTCTL_TYPE_GH_ENABLE_DISABLE);
    … …  
    22222222    }
    22232223
    2224     pHCtl->u.cmd.pu8Cmd = (uint8_t*)&pEnable->Enable;
    2225     pHCtl->u.cmd.cbCmd = sizeof (pEnable->Enable);
     2224    pHCtl->u.cmd.pu8Cmd = (uint8_t*)pEnable;
     2225    pHCtl->u.cmd.cbCmd = sizeof (*pEnable);
    22262226    int rc = vdmaVBVACtlSubmit(pVdma, pHCtl, VBVAEXHOSTCTL_SOURCE_GUEST, pfnComplete, pvComplete);
    22272227    if (!RT_SUCCESS(rc))
    … …  
    22362236{
    22372237    VBoxSHGSMICommandMarkAsynchCompletion(&pEnable->Hdr);
    2238     int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, pEnable, vboxCmdVBVACmdCtlGuestCompletion, pVdma);
     2238    int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, &pEnable->Enable, vboxCmdVBVACmdCtlGuestCompletion, pVdma);
    22392239    if (RT_SUCCESS(rc))
    22402240        return VINF_SUCCESS;

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

    r50799 r50812  
    572572extern DECLEXPORT(int32_t) crVBoxServerHgcmDisable();
    573573
     574extern int crVBoxServerHostCtl(VBOXCRCMDCTL *pCtl, uint32_t cbCtl);
     575
    574576#ifdef __cplusplus
    575577}

  • trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

    r50754 r50812  
    962962 * We differentiate between a function handler for the guest and one for the host.
    963963 */
    964 static int svcHostCallPerform(void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     964static int svcHostCallPerform(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    965965{
    966966    int rc = VINF_SUCCESS;
    … …  
    14731473}
    14741474
    1475 static DECLCALLBACK(int) svcHostCall (void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1475int crVBoxServerHostCtl(VBOXCRCMDCTL *pCtl, uint32_t cbCtl)
     1476{
     1477    if ((cbCtl - sizeof (VBOXCRCMDCTL)) % sizeof(VBOXHGCMSVCPARM))
     1478    {
     1479        WARN(("invalid param size"));
     1480        return VERR_INVALID_PARAMETER;
     1481    }
     1482    uint32_t cParams = (cbCtl - sizeof (VBOXCRCMDCTL)) / sizeof (VBOXHGCMSVCPARM);
     1483    return svcHostCallPerform(pCtl->u32Function, cParams, (VBOXHGCMSVCPARM*)(pCtl + 1));
     1484}
     1485
     1486static DECLCALLBACK(int) svcHostCall(void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    14761487{
    14771488    switch (u32Function)
    … …  
    14971508            }
    14981509
    1499             if ((paParms->u.pointer.size - sizeof (VBOXCRCMDCTL)) % sizeof(VBOXHGCMSVCPARM))
    1500             {
    1501                 WARN(("invalid param size"));
    1502                 return VERR_INVALID_PARAMETER;
    1503             }
    1504 
    15051510            VBOXCRCMDCTL *pCtl = (VBOXCRCMDCTL*)paParms->u.pointer.addr;
    1506             uint32_t cParams = (paParms->u.pointer.size - sizeof (VBOXCRCMDCTL)) / sizeof (VBOXHGCMSVCPARM);
    1507             return svcHostCallPerform(NULL, pCtl->u32Function, cParms, (VBOXHGCMSVCPARM*)(pCtl + 1));
    1508         }
    1509         case VBOXCRCMDCTL_TYPE_DISABLE:
    1510             AssertMsgFailed(("VBOXCRCMDCTL_TYPE_DISABLE\n"));
    1511             return VERR_NOT_IMPLEMENTED;
    1512         case VBOXCRCMDCTL_TYPE_ENABLE:
    1513             AssertMsgFailed(("VBOXCRCMDCTL_TYPE_ENABLE\n"));
    1514             return VERR_NOT_IMPLEMENTED;
     1511            switch (pCtl->enmType)
     1512            {
     1513                case VBOXCRCMDCTL_TYPE_HGCM:
     1514                {
     1515                    return crVBoxServerHostCtl(pCtl, paParms->u.pointer.size);
     1516                }
     1517                case VBOXCRCMDCTL_TYPE_DISABLE:
     1518                {
     1519                    if (paParms->u.pointer.size != sizeof (VBOXCRCMDCTL))
     1520                        WARN(("invalid param size"));
     1521                    return crVBoxServerHgcmDisable();
     1522                }
     1523                case VBOXCRCMDCTL_TYPE_ENABLE:
     1524                {
     1525                    if (paParms->u.pointer.size != sizeof (VBOXCRCMDCTL_ENABLE))
     1526                        WARN(("invalid param size"));
     1527                    VBOXCRCMDCTL_ENABLE *pEnable = (VBOXCRCMDCTL_ENABLE*)pCtl;
     1528                    return crVBoxServerHgcmEnable(pEnable->hRHCmd, pEnable->pfnRHCmd);
     1529                }
     1530                default:
     1531                    WARN(("invalid function"));
     1532                    return VERR_INVALID_PARAMETER;
     1533            }
     1534            WARN(("should not be here!"));
     1535            return VERR_INTERNAL_ERROR;
     1536        }
    15151537        default:
    1516             return svcHostCallPerform(NULL, u32Function, cParms, paParms);
    1517     }
    1518 
     1538            return svcHostCallPerform(u32Function, cParms, paParms);
     1539    }
    15191540}
    15201541

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r50754 r50812  
    116116GLint crServerDispatchCreateContextEx(const char *dpyName, GLint visualBits, GLint shareCtx, GLint preloadCtxID, int32_t internalID);
    117117GLint crServerDispatchWindowCreateEx(const char *dpyName, GLint visBits, GLint preloadWinID);
    118 GLint crServerMuralInit(CRMuralInfo *mural, const char *dpyName, GLint visBits, GLint preloadWinID);
     118GLint crServerMuralInit(CRMuralInfo *mural, GLboolean fGuestWindow, GLint visBits, GLint preloadWinID);
    119119void crServerMuralTerm(CRMuralInfo *mural);
    120120GLboolean crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height);

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

    r50802 r50812  
    6060int tearingdown = 0; /* can't be static */
    6161
     62static DECLCALLBACK(int) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr, PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd);
     63
    6264DECLINLINE(int32_t) crVBoxServerClientGet(uint32_t u32ClientID, CRClient **ppClient)
    6365{
    … …  
    528530
    529531    return GL_TRUE;
     532}
     533
     534static int32_t crVBoxServerAddClientObj(uint32_t u32ClientID, CRClient **ppNewClient)
     535{
     536    CRClient *newClient;
     537
     538    if (cr_server.numClients>=CR_MAX_CLIENTS)
     539    {
     540        if (ppNewClient)
     541            *ppNewClient = NULL;
     542        return VERR_MAX_THRDS_REACHED;
     543    }
     544
     545    newClient = (CRClient *) crCalloc(sizeof(CRClient));
     546    crDebug("crServer: AddClient u32ClientID=%d", u32ClientID);
     547
     548    newClient->spu_id = 0;
     549    newClient->currentCtxInfo = &cr_server.MainContextInfo;
     550    newClient->currentContextNumber = -1;
     551    newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
     552                                        cr_server.tcpip_port,
     553                                        cr_server.mtu, 0);
     554    newClient->conn->u32ClientID = u32ClientID;
     555
     556    cr_server.clients[cr_server.numClients++] = newClient;
     557
     558    crServerAddToRunQueue(newClient);
     559
     560    if (ppNewClient)
     561        *ppNewClient = newClient;
     562
     563    return VINF_SUCCESS;
    530564}
    531565
    … …  
    745779}
    746780
     781static int32_t crVBoxServerClientObjSetVersion(CRClient *pClient, uint32_t vMajor, uint32_t vMinor)
     782{
     783    pClient->conn->vMajor = vMajor;
     784    pClient->conn->vMinor = vMinor;
     785
     786    if (vMajor != CR_PROTOCOL_VERSION_MAJOR
     787        || vMinor != CR_PROTOCOL_VERSION_MINOR)
     788        return VERR_NOT_SUPPORTED;
     789    return VINF_SUCCESS;
     790}
     791
    747792int32_t crVBoxServerClientSetVersion(uint32_t u32ClientID, uint32_t vMajor, uint32_t vMinor)
    748793{
    … …  
    761806    if (!pClient) return VERR_INVALID_PARAMETER;
    762807
    763     pClient->conn->vMajor = vMajor;
    764     pClient->conn->vMinor = vMinor;
    765 
    766     if (vMajor != CR_PROTOCOL_VERSION_MAJOR
    767         || vMinor != CR_PROTOCOL_VERSION_MINOR)
    768     {
    769         return VERR_NOT_SUPPORTED;
    770     }
    771     else return VINF_SUCCESS;
     808    return crVBoxServerClientObjSetVersion(pClient, vMajor, vMinor);
     809}
     810
     811static int32_t crVBoxServerClientObjSetPID(CRClient *pClient, uint64_t pid)
     812{
     813    pClient->pid = pid;
     814
     815    return VINF_SUCCESS;
    772816}
    773817
    … …  
    788832    if (!pClient) return VERR_INVALID_PARAMETER;
    789833
    790     pClient->pid = pid;
    791 
    792     return VINF_SUCCESS;
     834    return crVBoxServerClientObjSetPID(pClient, pid);
    793835}
    794836
    … …  
    10051047            return NULL;
    10061048        }
    1007         id = crServerMuralInit(pMural,
    1008 #ifdef RT_OS_DARWIN
    1009                 /* tested on darwin only so far */
    1010                 NULL
    1011 #else
    1012                 ""
    1013 #endif
    1014                 , visualBits, 0);
     1049        id = crServerMuralInit(pMural, GL_FALSE, visualBits, 0);
    10151050        if (id < 0)
    10161051        {
    … …  
    28912926}
    28922927
     2928static void crVBoxServerDefaultContextSet()
     2929{
     2930    GLint spuWindow, spuCtx;
     2931
     2932    if (cr_server.MainContextInfo.SpuContext)
     2933    {
     2934        CRMuralInfo *pMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
     2935        if (!pMural)
     2936        {
     2937            WARN(("dummy mural is NULL"));
     2938            spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
     2939            spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
     2940        }
     2941        else
     2942        {
     2943            spuCtx = cr_server.MainContextInfo.SpuContext;
     2944            spuWindow = pMural->CreateInfo.realVisualBits;
     2945        }
     2946    }
     2947    else
     2948    {
     2949        spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
     2950        spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
     2951    }
     2952
     2953    cr_server.head_spu->dispatch_table.MakeCurrent(spuWindow, 0, spuCtx);
     2954}
    28932955
    28942956#ifdef VBOX_WITH_CRHGSMI
    28952957
    2896 static int32_t crVBoxServerCmdVbvaCrCmdProcess(struct VBOXCMDVBVA_CRCMD_CMD *pCmd)
     2958static int32_t crVBoxServerCmdVbvaCrCmdProcess(struct VBOXCMDVBVA_CRCMD_CMD *pCmd, uint32_t cbCmd)
    28972959{
    28982960    int32_t rc;
    … …  
    29072969    if (!g_pvVRamBase)
    29082970    {
    2909         crWarning("g_pvVRamBase is not initialized");
     2971        WARN(("g_pvVRamBase is not initialized"));
    29102972        return VERR_INVALID_STATE;
    29112973    }
    … …  
    29132975    if (!cBuffers)
    29142976    {
    2915         crWarning("zero buffers passed in!");
     2977        WARN(("zero buffers passed in!"));
    29162978        return VERR_INVALID_PARAMETER;
    29172979    }
    29182980
    29192981    cParams = cBuffers-1;
     2982
     2983    if (cbCmd != RT_OFFSETOF(VBOXCMDVBVA_CRCMD_CMD, aBuffers[cBuffers]))
     2984    {
     2985        WARN(("invalid buffer size"));
     2986        return VERR_INVALID_PARAMETER;
     2987    }
    29202988
    29212989    cbHdr = pCmd->aBuffers[0].cbBuffer;
    … …  
    29232991    if (!pHdr)
    29242992    {
    2925         crWarning("invalid header buffer!");
     2993        WARN(("invalid header buffer!"));
    29262994        return VERR_INVALID_PARAMETER;
    29272995    }
    … …  
    29292997    if (cbHdr < sizeof (*pHdr))
    29302998    {
    2931         crWarning("invalid header buffer size!");
     2999        WARN(("invalid header buffer size!"));
    29323000        return VERR_INVALID_PARAMETER;
    29333001    }
    … …  
    31963264{
    31973265    cr_server.CrCmdClientInfo = *pInfo;
     3266
     3267    crVBoxServerDefaultContextSet();
     3268
     3269    return VINF_SUCCESS;
     3270}
     3271
     3272static DECLCALLBACK(int) crVBoxCrCmdDisable(HVBOXCRCMDSVR hSvr)
     3273{
     3274    cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
     3275
     3276    memset(&cr_server.CrCmdClientInfo, 0, sizeof (cr_server.CrCmdClientInfo));
     3277
     3278    return VINF_SUCCESS;
     3279}
     3280
     3281static DECLCALLBACK(int) crVBoxCrCmdHostCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
     3282{
     3283    return crVBoxServerHostCtl((VBOXCRCMDCTL*)pCmd, cbCmd);
     3284}
     3285
     3286static DECLCALLBACK(int) crVBoxCrCmdGuestCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
     3287{
     3288    VBOXCMDVBVA_3DCTL *pCtl = (VBOXCMDVBVA_3DCTL*)pCmd;
     3289    if (cbCmd < sizeof (VBOXCMDVBVA_3DCTL))
     3290    {
     3291        WARN(("invalid buffer size"));
     3292        return VERR_INVALID_PARAMETER;
     3293    }
     3294
     3295    switch (pCtl->u32Type)
     3296    {
     3297        case VBOXCMDVBVA3DCTL_TYPE_CONNECT:
     3298        {
     3299            VBOXCMDVBVA_3DCTL_CONNECT *pConnect = (VBOXCMDVBVA_3DCTL_CONNECT*)pCtl;
     3300
     3301            return VERR_NOT_SUPPORTED;
     3302        }
     3303        case VBOXCMDVBVA3DCTL_TYPE_DISCONNECT:
     3304        {
     3305            return VERR_NOT_SUPPORTED;
     3306        }
     3307        case VBOXCMDVBVA3DCTL_TYPE_CMD:
     3308        {
     3309            VBOXCMDVBVA_3DCTL_CMD *p3DCmd;
     3310            if (cbCmd < sizeof (VBOXCMDVBVA_3DCTL_CMD))
     3311            {
     3312                WARN(("invalid size"));
     3313                return VERR_INVALID_PARAMETER;
     3314            }
     3315
     3316            p3DCmd = (VBOXCMDVBVA_3DCTL_CMD*)pCmd;
     3317
     3318            return crVBoxCrCmdCmd(NULL, &p3DCmd->Cmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_3DCTL_CMD, Cmd));
     3319        }
     3320        default:
     3321            WARN(("invalid function"));
     3322            return VERR_INVALID_PARAMETER;
     3323    }
     3324}
     3325
     3326static DECLCALLBACK(int) crVBoxCrCmdSaveState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM)
     3327{
    31983328    AssertFailed();
    31993329    return VERR_NOT_IMPLEMENTED;
    32003330}
    32013331
    3202 static DECLCALLBACK(int) crVBoxCrCmdDisable(HVBOXCRCMDSVR hSvr)
    3203 {
    3204     AssertFailed();
    3205     memset(&cr_server.CrCmdClientInfo, 0, sizeof (cr_server.CrCmdClientInfo));
    3206     return VERR_NOT_IMPLEMENTED;
    3207 }
    3208 
    3209 static DECLCALLBACK(int) crVBoxCrCmdHostCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
     3332static DECLCALLBACK(int) crVBoxCrCmdLoadState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM, uint32_t u32Version)
    32103333{
    32113334    AssertFailed();
    … …  
    32133336}
    32143337
    3215 static DECLCALLBACK(int) crVBoxCrCmdGuestCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
    3216 {
    3217     AssertFailed();
    3218     return VERR_NOT_IMPLEMENTED;
    3219 }
    3220 
    3221 static DECLCALLBACK(int) crVBoxCrCmdSaveState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM)
    3222 {
    3223     AssertFailed();
    3224     return VERR_NOT_IMPLEMENTED;
    3225 }
    3226 
    3227 static DECLCALLBACK(int) crVBoxCrCmdLoadState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM, uint32_t u32Version)
    3228 {
    3229     AssertFailed();
    3230     return VERR_NOT_IMPLEMENTED;
    3231 }
    3232 
    32333338
    32343339static DECLCALLBACK(int) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr, PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd)
    … …  
    32393344        case VBOXCMDVBVA_OPTYPE_CRCMD:
    32403345        {
    3241             VBOXCMDVBVA_CRCMD *pCrCmdDr = (VBOXCMDVBVA_CRCMD*)pCmd;
    3242             VBOXCMDVBVA_CRCMD_CMD *pCrCmd = &pCrCmdDr->Cmd;
    3243             int rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd);
     3346            VBOXCMDVBVA_CRCMD *pCrCmdDr;
     3347            VBOXCMDVBVA_CRCMD_CMD *pCrCmd;
     3348            int rc;
     3349            pCrCmdDr = (VBOXCMDVBVA_CRCMD*)pCmd;
     3350            pCrCmd = &pCrCmdDr->Cmd;
     3351            if (cbCmd < sizeof (VBOXCMDVBVA_CRCMD))
     3352            {
     3353                WARN(("invalid buffer size"));
     3354                pCmd->u.i8Result = -1;
     3355                break;
     3356            }
     3357            rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd));
    32443358            if (RT_SUCCESS(rc))
    32453359            {
    … …  
    32493363            else
    32503364            {
    3251                 crWarning("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc);
     3365                WARN(("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc));
    32523366                pCmd->u.i8Result = -1;
    32533367            }
    … …  
    32953409    if (!g_pvVRamBase)
    32963410    {
    3297         crWarning("g_pvVRamBase is not initialized");
     3411        WARN(("g_pvVRamBase is not initialized"));
    32983412
    32993413        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_STATE);
    … …  
    33033417    if (!cBuffers)
    33043418    {
    3305         crWarning("zero buffers passed in!");
     3419        WARN(("zero buffers passed in!"));
    33063420
    33073421        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
    … …  
    33103424
    33113425    cParams = cBuffers-1;
     3426
     3427#if 0
     3428    if (cbCmd != RT_OFFSETOF(VBOXCMDVBVA_CRCMD_CMD, aBuffers[cBuffers]))
     3429    {
     3430        WARN(("invalid buffer size"));
     3431        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
     3432        return VINF_SUCCESS;
     3433    }
     3434#endif
    33123435
    33133436    cbHdr = pCmd->aBuffers[0].cbBuffer;
    … …  
    33153438    if (!pHdr)
    33163439    {
    3317         crWarning("invalid header buffer!");
     3440        WARN(("invalid header buffer!"));
    33183441
    33193442        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
    … …  
    33233446    if (cbHdr < sizeof (*pHdr))
    33243447    {
    3325         crWarning("invalid header buffer size!");
     3448        WARN(("invalid header buffer size!"));
    33263449
    33273450        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
    … …  
    36583781}
    36593782
    3660 void crVBoxServerDefaultContextSet()
    3661 {
    3662     GLint spuWindow, spuCtx;
    3663 
    3664     if (cr_server.MainContextInfo.SpuContext)
    3665     {
    3666         CRMuralInfo *pMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
    3667         if (!pMural)
    3668         {
    3669             WARN(("dummy mural is NULL"));
    3670             spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
    3671             spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
    3672         }
    3673         else
    3674         {
    3675             spuCtx = cr_server.MainContextInfo.SpuContext;
    3676             spuWindow = pMural->CreateInfo.realVisualBits;
    3677         }
    3678     }
    3679     else
    3680     {
    3681         spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
    3682         spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
    3683     }
    3684 
    3685     cr_server.head_spu->dispatch_table.MakeCurrent(spuWindow, 0, spuCtx);
    3686 }
    3687 
    36883783int32_t crVBoxServerHgcmEnable(HVBOXCRCMDCTL_REMAINING_HOST_COMMAND hRHCmd, PFNVBOXCRCMDCTL_REMAINING_HOST_COMMAND pfnRHCmd)
    36893784{

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.c

    r50802 r50812  
    1919}
    2020
    21 GLint crServerMuralInit(CRMuralInfo *mural, const char *dpyName, GLint visBits, GLint preloadWinID)
     21GLint crServerMuralInit(CRMuralInfo *mural, GLboolean fGuestWindow, GLint visBits, GLint preloadWinID)
    2222{
    2323    CRMuralInfo *defaultMural;
    … …  
    2626    GLint spuWindow = 0;
    2727    GLint realVisBits = visBits;
     28    const char *dpyName = "";
    2829
    2930    crMemset(mural, 0, sizeof (*mural));
    … …  
    3233        realVisBits = cr_server.fVisualBitsDefault;
    3334
    34     if (!dpyName)
     35#ifdef RT_OS_DARWIN
     36    if (fGuestWindow)
     37    {
     38        CRMuralInfo *dummy = crServerGetDummyMural(visBits);
     39        if (!dummy)
     40        {
     41            WARN(("crServerGetDummyMural failed"));
     42            return -1;
     43        }
     44        spuWindow = dummy->spuWindow;
     45    }
     46    else
     47#endif
    3548    {
    3649        /*
    … …  
    4154            return spuWindow;
    4255        }
    43     }
    44     else
    45     {
    46         CRMuralInfo *dummy = crServerGetDummyMural(visBits);
    47         if (!dummy)
    48         {
    49             WARN(("crServerGetDummyMural failed"));
    50             return -1;
    51         }
    52         spuWindow = dummy->spuWindow;
    5356    }
    5457
    … …  
    134137    }
    135138
    136     windowID = crServerMuralInit(mural, dpyName, visBits, preloadWinID);
     139    windowID = crServerMuralInit(mural, GL_TRUE, visBits, preloadWinID);
    137140    if (windowID < 0)
    138141    {
Note: See TracChangeset for help on using the changeset viewer.

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