VirtualBox

Changeset 50848 in vbox


Ignore:
Timestamp:
Mar 24, 2014 10:15:41 AM (11 years ago)
Author:
vboxsync
Message:

crOpenGL: new command submission continued

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxVideoHost3D.h

    r50831 r50848  
    2828#include <iprt/cdefs.h>
    2929#include <VBox/VBoxVideo.h>
     30#include <VBox/hgcmsvc.h>
    3031
    3132/* screen update instance */
    … …  
    112113        void(*pfnInternal)();
    113114        void* pvInternal;
    114     };
     115    } u;
    115116} VBOXCRCMDCTL;
     117
     118typedef struct VBOXCRCMDCTL_HGCM
     119{
     120    VBOXCRCMDCTL Hdr;
     121    VBOXHGCMSVCPARM aParms[1];
     122} VBOXCRCMDCTL_HGCM;
    116123
    117124typedef struct VBOXVDMAHOST * HVBOXCRCMDCTL_REMAINING_HOST_COMMAND;

  • trunk/include/VBox/vmm/pdmifs.h

    r50763 r50848  
    30763076                                                                   PFNCRCTLCOMPLETION pfnCompletion,
    30773077                                                                   void *pvCompletion));
     3078
     3079    DECLR3CALLBACKMEMBER(int, pfnCrCtlSubmitSync, (PPDMIDISPLAYVBVACALLBACKS pInterface,
     3080                                                                   struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd));
    30783081} PDMIDISPLAYVBVACALLBACKS;
    30793082/** PDMIDISPLAYVBVACALLBACKS  */
    3080 #define PDMIDISPLAYVBVACALLBACKS_IID            "b78b81d2-c821-4e66-96ff-dbafa76343a5"
     3083#define PDMIDISPLAYVBVACALLBACKS_IID            "193b2975-215f-480a-abef-42f029ae890f"
    30813084
    30823085/** Pointer to a PCI raw connector interface. */

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

    r50804 r50848  
    59555955#endif
    59565956    pThis->IVBVACallbacks.pfnCrCtlSubmit = vboxCmdVBVACmdHostCtl;
     5957    pThis->IVBVACallbacks.pfnCrCtlSubmitSync = vboxCmdVBVACmdHostCtlSync;
    59575958
    59585959    /*

  • trunk/src/VBox/Devices/Graphics/DevVGA.h

    r50760 r50848  
    630630                                                               PFNCRCTLCOMPLETION pfnCompletion,
    631631                                                               void *pvCompletion);
     632int vboxCmdVBVACmdHostCtlSync(PPDMIDISPLAYVBVACALLBACKS pInterface,
     633                                                               struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
    632634
    633635int vboxVBVASaveStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM);

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

    r50831 r50848  
    605605    if ((enmSource == VBVAEXHOSTCTL_SOURCE_HOST_ENABLED) && !VBoxVBVAExHSIsEnabled(pCmdVbva))
    606606    {
    607         WARN(("cmd vbva not enabled\n"));
     607        Log(("cmd vbva not enabled\n"));
    608608        return VERR_INVALID_STATE;
    609609    }
    … …  
    619619            if ((enmSource == VBVAEXHOSTCTL_SOURCE_HOST_ENABLED) && !VBoxVBVAExHSIsEnabled(pCmdVbva))
    620620            {
    621                 WARN(("cmd vbva not enabled\n"));
     621                Log(("cmd vbva not enabled\n"));
    622622                RTCritSectLeave(&pCmdVbva->CltCritSect);
    623623                return VERR_INVALID_STATE;
    … …  
    669669    VBOXCRCMD_SVRINFO CrSrvInfo;
    670670    VBVAEXHOSTCTL* pCurRemainingHostCtl;
     671    RTSEMEVENTMULTI HostCrCtlCompleteEvent;
     672    int32_t volatile i32cHostCrCtlCompleted;
    671673#ifdef VBOX_VDMA_WITH_WATCHDOG
    672674    PTMTIMERR3 WatchDogTimer;
    … …  
    21572159        pVdma->pVGAState = pVGAState;
    21582160
     2161        rc = RTSemEventMultiCreate(&pVdma->HostCrCtlCompleteEvent);
     2162        if (RT_SUCCESS(rc))
     2163        {
    21592164#ifdef VBOX_VDMA_WITH_WATCHDOG
    2160         rc = PDMDevHlpTMTimerCreate(pVGAState->pDevInsR3, TMCLOCK_REAL, vboxVDMAWatchDogTimer,
    2161                                     pVdma, TMTIMER_FLAGS_NO_CRIT_SECT,
    2162                                     "VDMA WatchDog Timer", &pVdma->WatchDogTimer);
    2163         AssertRC(rc);
     2165            rc = PDMDevHlpTMTimerCreate(pVGAState->pDevInsR3, TMCLOCK_REAL, vboxVDMAWatchDogTimer,
     2166                                        pVdma, TMTIMER_FLAGS_NO_CRIT_SECT,
     2167                                        "VDMA WatchDog Timer", &pVdma->WatchDogTimer);
     2168            AssertRC(rc);
    21642169#endif
    2165         rc = VBoxVBVAExHSInit(&pVdma->CmdVbva);
    2166         if (RT_SUCCESS(rc))
    2167         {
    2168             rc = VBoxVDMAThreadCreate(&pVdma->Thread, vboxVDMAWorkerThread, pVdma);
     2170            rc = VBoxVBVAExHSInit(&pVdma->CmdVbva);
    21692171            if (RT_SUCCESS(rc))
    21702172            {
    2171                 pVGAState->pVdma = pVdma;
     2173                rc = VBoxVDMAThreadCreate(&pVdma->Thread, vboxVDMAWorkerThread, pVdma);
     2174                if (RT_SUCCESS(rc))
     2175                {
     2176                    pVGAState->pVdma = pVdma;
    21722177#ifdef VBOX_WITH_CRHGSMI
    2173                 int rcIgnored = vboxVDMACrCtlHgsmiSetup(pVdma); NOREF(rcIgnored); /** @todo is this ignoring intentional? */
     2178                    int rcIgnored = vboxVDMACrCtlHgsmiSetup(pVdma); NOREF(rcIgnored); /** @todo is this ignoring intentional? */
    21742179#endif
    2175                 return VINF_SUCCESS;
     2180                    return VINF_SUCCESS;
     2181                }
     2182                else
     2183                    WARN(("VBoxVDMAThreadCreate faile %d\n", rc));
     2184
     2185                VBoxVBVAExHSTerm(&pVdma->CmdVbva);
    21762186            }
    21772187            else
    2178                 WARN(("VBoxVDMAThreadCreate faile %d\n", rc));
    2179 
    2180             VBoxVBVAExHSTerm(&pVdma->CmdVbva);
     2188                WARN(("VBoxVBVAExHSInit failed %d\n", rc));
     2189
     2190            RTSemEventMultiDestroy(pVdma->HostCrCtlCompleteEvent);
    21812191        }
    21822192        else
    2183             WARN(("VBoxVBVAExHSInit faile %d\n", rc));
     2193            WARN(("RTSemEventMultiCreate failed %d\n", rc));
     2194
    21842195
    21852196        RTMemFree(pVdma);
    … …  
    22162227    VBoxVDMAThreadTerm(&pVdma->Thread);
    22172228    VBoxVBVAExHSTerm(&pVdma->CmdVbva);
     2229    RTSemEventMultiDestroy(pVdma->HostCrCtlCompleteEvent);
    22182230    RTMemFree(pVdma);
    22192231    return VINF_SUCCESS;
    … …  
    23932405    }
    23942406    else
    2395         WARN(("VBoxVBVAExHCtlSubmit failed %d\n", rc));
     2407        Log(("VBoxVBVAExHCtlSubmit failed %d\n", rc));
    23962408
    23972409    return rc;
    … …  
    24262438    if (!RT_SUCCESS(rc))
    24272439    {
    2428         WARN(("vdmaVBVACtlSubmit failed rc %d\n", rc));
     2440        Log(("vdmaVBVACtlSubmit failed rc %d\n", rc));
    24292441        return rc;;
    24302442    }
    … …  
    24502462{
    24512463    VBOXCRCMDCTL* pVboxCtl = (VBOXCRCMDCTL*)pCtl->u.cmd.pu8Cmd;
    2452     if (pVboxCtl->pfnInternal)
    2453         ((PFNCRCTLCOMPLETION)pVboxCtl->pfnInternal)(pVboxCtl, pCtl->u.cmd.cbCmd, rc, pvCompletion);
     2464    if (pVboxCtl->u.pfnInternal)
     2465        ((PFNCRCTLCOMPLETION)pVboxCtl->u.pfnInternal)(pVboxCtl, pCtl->u.cmd.cbCmd, rc, pvCompletion);
    24542466    VBoxVBVAExHCtlFree(pVbva, pCtl);
    24552467}
    … …  
    24592471        void *pvCompletion)
    24602472{
    2461     pCmd->pfnInternal = (void(*)())pfnCompletion;
     2473    pCmd->u.pfnInternal = (void(*)())pfnCompletion;
    24622474    int rc = vdmaVBVACtlOpaqueSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_HOST_ENABLED, (uint8_t*)pCmd, cbCmd, vboxCmdVBVACmdCtlHostCompletion, pvCompletion);
    24632475    if (!RT_SUCCESS(rc))
    … …  
    24652477        if (rc == VERR_INVALID_STATE)
    24662478        {
    2467             pCmd->pfnInternal = NULL;
     2479            pCmd->u.pfnInternal = NULL;
    24682480            PVGASTATE pVGAState = pVdma->pVGAState;
    24692481            rc = pVGAState->pDrv->pfnCrHgcmCtlSubmit(pVGAState->pDrv, pCmd, cbCmd, pfnCompletion, pvCompletion);
    … …  
    25972609}
    25982610
     2611typedef struct VBOXCMDVBVA_CMDHOSTCTL_SYNC
     2612{
     2613    struct VBOXVDMAHOST *pVdma;
     2614    uint32_t fProcessing;
     2615    int rc;
     2616} VBOXCMDVBVA_CMDHOSTCTL_SYNC;
     2617
     2618static DECLCALLBACK(void) vboxCmdVBVACmdHostCtlSyncCb(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion)
     2619{
     2620    VBOXCMDVBVA_CMDHOSTCTL_SYNC *pData = (VBOXCMDVBVA_CMDHOSTCTL_SYNC*)pvCompletion;
     2621
     2622    pData->rc = rc;
     2623    pData->fProcessing = 0;
     2624
     2625    struct VBOXVDMAHOST *pVdma = pData->pVdma;
     2626
     2627    ASMAtomicIncS32(&pVdma->i32cHostCrCtlCompleted);
     2628
     2629    RTSemEventMultiSignal(pVdma->HostCrCtlCompleteEvent);
     2630}
     2631
     2632int vboxCmdVBVACmdHostCtlSync(PPDMIDISPLAYVBVACALLBACKS pInterface,
     2633                                                               struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
     2634{
     2635    PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
     2636    struct VBOXVDMAHOST *pVdma = pVGAState->pVdma;
     2637    VBOXCMDVBVA_CMDHOSTCTL_SYNC Data;
     2638    Data.pVdma = pVdma;
     2639    Data.fProcessing = 1;
     2640    Data.rc = VERR_INTERNAL_ERROR;
     2641    int rc = vdmaVBVACtlOpaqueHostSubmit(pVdma, pCmd, cbCmd, vboxCmdVBVACmdHostCtlSyncCb, &Data);
     2642    if (!RT_SUCCESS(rc))
     2643    {
     2644        WARN(("vdmaVBVACtlOpaqueHostSubmit failed %d", rc));
     2645        return rc;
     2646    }
     2647
     2648    while (Data.fProcessing)
     2649    {
     2650        /* Poll infrequently to make sure no completed message has been missed. */
     2651        RTSemEventMultiWait(pVdma->HostCrCtlCompleteEvent, 500);
     2652
     2653        if (Data.fProcessing)
     2654            RTThreadYield();
     2655    }
     2656
     2657    /* 'Our' message has been processed, so should reset the semaphore.
     2658     * There is still possible that another message has been processed
     2659     * and the semaphore has been signalled again.
     2660     * Reset only if there are no other messages completed.
     2661     */
     2662    int32_t c = ASMAtomicDecS32(&pVdma->i32cHostCrCtlCompleted);
     2663    Assert(c >= 0);
     2664    if (!c)
     2665        RTSemEventMultiReset(pVdma->HostCrCtlCompleteEvent);
     2666
     2667    rc = Data.rc;
     2668    if (!RT_SUCCESS(rc))
     2669        WARN(("host call failed %d", rc));
     2670
     2671    return rc;
     2672}
     2673
    25992674int vboxCmdVBVACmdCtl(PVGASTATE pVGAState, VBOXCMDVBVA_CTL *pCtl, uint32_t cbCtl)
    26002675{

  • trunk/src/VBox/Main/include/DisplayImpl.h

    r50828 r50848  
    2626#include <VBox/VMMDev.h>
    2727#include <VBox/VBoxVideo.h>
     28#include <VBox/vmm/pdmifs.h>
    2829
    2930#ifdef VBOX_WITH_CROGL
    … …  
    168169#endif
    169170#ifdef VBOX_WITH_CRHGSMI
     171    void handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
     172    void handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
    170173    void handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
    171174    void handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
    172 
    173     void handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
    174     void handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
    175175#endif
    176176    int  handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
    … …  
    178178                                        void *pvCompletion);
    179179#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
    180     void  handleCrAsyncCmdCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
    181180    void  handleCrVRecScreenshotPerform(uint32_t uScreen,
    182181                                        uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
    … …  
    298297
    299298    static DECLCALLBACK(void)  displayVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
    300     static DECLCALLBACK(void)  displayCrAsyncCmdCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
    301 #endif
     299#endif
     300    static DECLCALLBACK(void) displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
    302301
    303302    static DECLCALLBACK(void)  displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser);
    … …  
    350349    volatile uint32_t mfCrOglVideoRecState;
    351350    CRVBOXHGCMTAKESCREENSHOT mCrOglScreenshotData;
     351    VBOXCRCMDCTL_HGCM mCrOglScreenshotCtl;
    352352#endif
    353353
    … …  
    374374#endif
    375375
     376    int crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
     377    int crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
     378
    376379private:
    377380    static void InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);

  • trunk/src/VBox/Main/src-client/ConsoleVRDPServer.cpp

    r50686 r50848  
    21312131    }
    21322132
    2133     VBOXHGCMSVCPARM parm;
    2134 
    2135     parm.type = VBOX_HGCM_SVC_PARM_PTR;
    2136     parm.u.pointer.addr = &outputRedirect;
    2137     parm.u.pointer.size = sizeof(outputRedirect);
    2138 
    2139     VMMDev *pVMMDev = mConsole->getVMMDev();
    2140 
    2141     if (!pVMMDev)
    2142     {
    2143         AssertMsgFailed(("remote3DRedirect no vmmdev\n"));
    2144         return;
    2145     }
    2146 
    2147     int rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL",
    2148                                    SHCRGL_HOST_FN_SET_OUTPUT_REDIRECT,
    2149                                    SHCRGL_CPARMS_SET_OUTPUT_REDIRECT,
    2150                                    &parm);
    2151 
     2133    VBOXCRCMDCTL_HGCM data;
     2134    data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     2135    data.Hdr.u32Function = SHCRGL_HOST_FN_SET_OUTPUT_REDIRECT;
     2136
     2137    data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     2138    data.aParms[0].u.pointer.addr = &outputRedirect;
     2139    data.aParms[0].u.pointer.size = sizeof(outputRedirect);
     2140
     2141    int rc = mConsole->getDisplay()->crCtlSubmitSync(&data.Hdr, sizeof (data));
    21522142    if (!RT_SUCCESS(rc))
    21532143    {
    … …  
    21572147
    21582148    LogRel(("VRDE: %s 3D redirect.\n", fEnable? "Enabled": "Disabled"));
     2149#ifdef DEBUG_misha
     2150    AssertFailed();
     2151#endif
    21592152
    21602153    return;

  • trunk/src/VBox/Main/src-client/DisplayImpl.cpp

    r50828 r50848  
    338338                    pScreenshot->Base.pfnScreenshotEnd = NULL;
    339339
    340                     VBOXHGCMSVCPARM parm;
    341 
    342                     parm.type = VBOX_HGCM_SVC_PARM_PTR;
    343                     parm.u.pointer.addr = &pScreenshot->Base;
    344                     parm.u.pointer.size = sizeof (pScreenshot->Base);
    345 
    346                     int rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_TAKE_SCREENSHOT, 1, &parm);
     340                    VBOXCRCMDCTL_HGCM data;
     341                    data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     342                    data.Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
     343
     344                    data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     345                    data.aParms[0].u.pointer.addr = &pScreenshot->Base;
     346                    data.aParms[0].u.pointer.size = sizeof (pScreenshot->Base);
     347
     348                    int rc = that->crCtlSubmitSync(&data.Hdr, sizeof (data));
    347349                    if (RT_SUCCESS(rc))
    348350                    {
    … …  
    723725}
    724726
     727DECLCALLBACK(void) Display::displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion)
     728{
     729    Assert(pvCompletion);
     730    RTMemFree(pvCompletion);
     731}
     732
    725733#ifdef VBOX_WITH_CROGL
    726734int Display::crOglWindowsShow(bool fShow)
    … …  
    747755    }
    748756
    749     VBOXHGCMSVCPARM parm;
    750 
    751     parm.type = VBOX_HGCM_SVC_PARM_32BIT;
    752     parm.u.uint32 = (uint32_t)fShow;
    753 
    754     int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_WINDOWS_SHOW, &parm, NULL, NULL);
     757    VBOXCRCMDCTL_HGCM *pData = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (VBOXCRCMDCTL_HGCM));
     758    if (!pData)
     759    {
     760        AssertMsgFailed(("RTMemAlloc failed\n"));
     761        return VERR_NO_MEMORY;
     762    }
     763
     764    pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     765    pData->Hdr.u32Function = SHCRGL_HOST_FN_WINDOWS_SHOW;
     766
     767    pData->aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
     768    pData->aParms[0].u.uint32 = (uint32_t)fShow;
     769
     770    int rc = crCtlSubmit(&pData->Hdr, sizeof (*pData), displayCrCmdFree, pData);
    755771    if (RT_SUCCESS(rc))
    756772        mfCrOglDataHidden = !fShow;
    757773    else
    758         AssertMsgFailed(("hgcmHostFastCallAsync failed rc %n", rc));
     774    {
     775        AssertMsgFailed(("crCtlSubmit failed rc %n", rc));
     776        RTMemFree(pData);
     777    }
    759778
    760779    return rc;
    … …  
    850869            if (pVMMDev)
    851870            {
    852                 CRVBOXHGCMDEVRESIZE *pData = (CRVBOXHGCMDEVRESIZE*)RTMemAlloc(sizeof (*pData));
    853                 if (pData)
     871                VBOXCRCMDCTL_HGCM *pCtl = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (CRVBOXHGCMDEVRESIZE) + sizeof (VBOXCRCMDCTL_HGCM));
     872                if (pCtl)
    854873                {
     874                    CRVBOXHGCMDEVRESIZE *pData = (CRVBOXHGCMDEVRESIZE*)(pCtl+1);
    855875                    pData->Screen = *pScreen;
    856876                    pData->pvVRAM = pvVRAM;
    857877
    858                     VBOXHGCMSVCPARM parm;
    859 
    860                     parm.type = VBOX_HGCM_SVC_PARM_PTR;
    861                     parm.u.pointer.addr = pData;
    862                     parm.u.pointer.size = sizeof (*pData);
    863 
    864                     rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_DEV_RESIZE, &parm, displayCrAsyncCmdCompletion, this);
    865                     AssertRC(rc);
     878                    pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     879                    pCtl->Hdr.u32Function = SHCRGL_HOST_FN_DEV_RESIZE;
     880                    pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     881                    pCtl->aParms[0].u.pointer.addr = pData;
     882                    pCtl->aParms[0].u.pointer.size = sizeof (*pData);
     883
     884                    rc = crCtlSubmit(&pCtl->Hdr, sizeof (*pCtl), displayCrCmdFree, pCtl);
     885                    if (!RT_SUCCESS(rc))
     886                    {
     887                        AssertMsgFailed(("crCtlSubmit failed rc %n", rc));
     888                        RTMemFree(pCtl);
     889                    }
    866890                }
    867891                else
    … …  
    11131137            if (is3denabled)
    11141138            {
    1115                 VBOXHGCMSVCPARM parm;
    1116 
    1117                 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
    1118                 parm.u.uint32 = uScreenId;
    1119 
    1120                 VMMDev *pVMMDev = mParent->getVMMDev();
    1121                 if (pVMMDev)
    1122                 {
    1123 #if 0
    1124                     if (mhCrOglSvc)
    1125                         pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_SCREEN_CHANGED, &parm, NULL, NULL);
    1126                     else
    1127                         AssertMsgFailed(("mhCrOglSvc is NULL\n"));
    1128 #else
    1129                     pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
    1130 #endif
    1131                 }
     1139                VBOXCRCMDCTL_HGCM data;
     1140                data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     1141                data.Hdr.u32Function = SHCRGL_HOST_FN_SCREEN_CHANGED;
     1142
     1143                data.aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
     1144                data.aParms[0].u.uint32 = uScreenId;
     1145
     1146                crCtlSubmitSync(&data.Hdr, sizeof (data));
    11321147            }
    11331148        }
    … …  
    14471462        if (mhCrOglSvc)
    14481463        {
    1449             RTRECT *pRectsCopy = (RTRECT *)RTMemAlloc(  RT_MAX(cRect, 1)
    1450                                                              * sizeof (RTRECT));
    1451             if (pRectsCopy)
     1464            VBOXCRCMDCTL_HGCM *pCtl = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(RT_MAX(cRect, 1) * sizeof (RTRECT)
     1465                    + sizeof (VBOXCRCMDCTL_HGCM));
     1466            if (pCtl)
    14521467            {
     1468                RTRECT *pRectsCopy = (RTRECT*)(pCtl+1);
    14531469                memcpy(pRectsCopy, pRect, cRect * sizeof (RTRECT));
    14541470
    1455                 VBOXHGCMSVCPARM parm;
    1456 
    1457                 parm.type = VBOX_HGCM_SVC_PARM_PTR;
    1458                 parm.u.pointer.addr = pRectsCopy;
    1459                 parm.u.pointer.size = cRect * sizeof (RTRECT);
    1460 
    1461                 vmmDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_SET_VISIBLE_REGION, &parm, displayCrAsyncCmdCompletion, this);
     1471                pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     1472                pCtl->Hdr.u32Function = SHCRGL_HOST_FN_SET_VISIBLE_REGION;
     1473
     1474                pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     1475                pCtl->aParms[0].u.pointer.addr = pRectsCopy;
     1476                pCtl->aParms[0].u.pointer.size = cRect * sizeof (RTRECT);
     1477
     1478                int rc = crCtlSubmit(&pCtl->Hdr, sizeof (*pCtl), displayCrCmdFree, pCtl);
     1479                if (!RT_SUCCESS(rc))
     1480                {
     1481                    AssertMsgFailed(("crCtlSubmit failed rc %n", rc));
     1482                    RTMemFree(pCtl);
     1483                }
    14621484            }
    14631485            else
    … …  
    24102432            if (is3denabled)
    24112433            {
    2412                 VBOXHGCMSVCPARM parm;
    2413 
    2414                 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
    2415                 parm.u.uint32 = aScreenId;
    2416 
    2417                 VMMDev *pVMMDev = mParent->getVMMDev();
     2434                VBOXCRCMDCTL_HGCM data;
     2435                data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     2436                data.Hdr.u32Function = SHCRGL_HOST_FN_SCREEN_CHANGED;
     2437
     2438                data.aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
     2439                data.aParms[0].u.uint32 = aScreenId;
    24182440
    24192441                alock.release();
    24202442
    2421                 if (pVMMDev)
    2422                 {
    2423 #if 0
    2424                     if (mhCrOglSvc)
    2425                         pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_SCREEN_CHANGED, &parm, NULL, NULL);
    2426                     else
    2427                         AssertMsgFailed(("mhCrOglSvc is NULL\n"));
    2428 #else
    2429                     pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
    2430 #endif
    2431                 }
    2432                 /*ComAssertRCRet (vrc, E_FAIL);*/
     2443                crCtlSubmitSync(&data.Hdr, sizeof (data));
    24332444
    24342445                alock.acquire();
    … …  
    25602571        if (is3denabled && vmmDev)
    25612572        {
    2562             VBOXHGCMSVCPARM parm;
    2563 
    2564             parm.type = VBOX_HGCM_SVC_PARM_PTR;
    2565             /* NULL means disable */
    2566             parm.u.pointer.addr = NULL;
    2567             parm.u.pointer.size = 0;  /* <- means null rects, NULL pRects address and 0 rects means "disable" */
    2568 
    2569             if (mhCrOglSvc)
    2570                 vmmDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_SET_VISIBLE_REGION, &parm, NULL, NULL);
    2571             else
    2572                 AssertMsgFailed(("mhCrOglSvc is NULL\n"));
    2573 
     2573            VBOXCRCMDCTL_HGCM *pData = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (VBOXCRCMDCTL_HGCM));
     2574            if (!pData)
     2575            {
     2576                AssertMsgFailed(("RTMemAlloc failed\n"));
     2577                return VERR_NO_MEMORY;
     2578            }
     2579
     2580            pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     2581            pData->Hdr.u32Function = SHCRGL_HOST_FN_SET_VISIBLE_REGION;
     2582
     2583            pData->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     2584            pData->aParms[0].u.pointer.addr = NULL;
     2585            pData->aParms[0].u.pointer.size = 0; /* <- means null rects, NULL pRects address and 0 rects means "disable" */
     2586
     2587            int rc = crCtlSubmit(&pData->Hdr, sizeof (*pData), displayCrCmdFree, pData);
     2588            if (!RT_SUCCESS(rc))
     2589            {
     2590                AssertMsgFailed(("crCtlSubmit failed rc %n", rc));
     2591                RTMemFree(pData);
     2592            }
    25742593        }
    25752594    }
    … …  
    26022621                pScreenshot->pfnScreenshotEnd = NULL;
    26032622
    2604                 VBOXHGCMSVCPARM parm;
    2605 
    2606                 parm.type = VBOX_HGCM_SVC_PARM_PTR;
    2607                 parm.u.pointer.addr = pScreenshot;
    2608                 parm.u.pointer.size = sizeof (*pScreenshot);
    2609 
    2610                 int rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_TAKE_SCREENSHOT, 1, &parm);
     2623                VBOXCRCMDCTL_HGCM data;
     2624                data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     2625                data.Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
     2626
     2627                data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     2628                data.aParms[0].u.pointer.addr = pScreenshot;
     2629                data.aParms[0].u.pointer.size = sizeof (*pScreenshot);
     2630
     2631                int rc = pDisplay->crCtlSubmitSync(&data.Hdr, sizeof (data));
    26112632
    26122633                RTMemFree(pScreenshot);
    … …  
    35903611void Display::crViewportNotify(VMMDev *pVMMDev, ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
    35913612{
    3592 #if 0
    3593     VBOXHGCMSVCPARM parm;
    3594 
    3595     CRVBOXHGCMVIEWPORT *pViewportInfo = (CRVBOXHGCMVIEWPORT*)RTMemAlloc(sizeof (*pViewportInfo));
    3596     if(!pViewportInfo)
    3597     {
    3598         AssertMsgFailed(("RTMemAlloc failed!\n"));
    3599         return;
    3600     }
    3601 
    3602     pViewportInfo->u32Screen = aScreenId;
    3603     pViewportInfo->x = x;
    3604     pViewportInfo->y = y;
    3605     pViewportInfo->width = width;
    3606     pViewportInfo->height = height;
    3607 
    3608     parm.type = VBOX_HGCM_SVC_PARM_PTR;
    3609     parm.u.pointer.addr = pViewportInfo;
    3610     parm.u.pointer.size = sizeof (*pViewportInfo);
    3611 
    3612     pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_VIEWPORT_CHANGED2, &parm, displayCrAsyncCmdCompletion, this);
    3613 #else
    3614     VBOXHGCMSVCPARM aParms[5];
    3615 
    3616     aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
    3617     aParms[0].u.uint32 = aScreenId;
    3618 
    3619     aParms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
    3620     aParms[1].u.uint32 = x;
    3621 
    3622     aParms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
    3623     aParms[2].u.uint32 = y;
    3624 
    3625 
    3626     aParms[3].type = VBOX_HGCM_SVC_PARM_32BIT;
    3627     aParms[3].u.uint32 = width;
    3628 
    3629     aParms[4].type = VBOX_HGCM_SVC_PARM_32BIT;
    3630     aParms[4].u.uint32 = height;
    3631 
    3632     pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_VIEWPORT_CHANGED, SHCRGL_CPARMS_VIEWPORT_CHANGED, aParms);
    3633 #endif
     3613    struct {
     3614        VBOXCRCMDCTL_HGCM data;
     3615        VBOXHGCMSVCPARM aParms[4];
     3616    } s;
     3617
     3618    s.data.Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     3619    s.data.Hdr.u32Function = SHCRGL_HOST_FN_VIEWPORT_CHANGED;
     3620
     3621    s.data.aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
     3622    s.data.aParms[0].u.uint32 = aScreenId;
     3623
     3624    s.data.aParms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
     3625    s.data.aParms[1].u.uint32 = x;
     3626
     3627    s.data.aParms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
     3628    s.data.aParms[2].u.uint32 = y;
     3629
     3630    s.data.aParms[3].type = VBOX_HGCM_SVC_PARM_32BIT;
     3631    s.data.aParms[3].u.uint32 = width;
     3632
     3633    s.data.aParms[4].type = VBOX_HGCM_SVC_PARM_32BIT;
     3634    s.data.aParms[4].u.uint32 = height;
     3635
     3636    crCtlSubmitSync(&s.data.Hdr, RT_OFFSETOF(VBOXCRCMDCTL_HGCM, aParms[5]));
    36343637}
    36353638#endif
    … …  
    36623665        if (RT_SUCCESS(rc))
    36633666        {
    3664             ULONG ul;
    3665 
    3666             for (ul = 0; ul < mcMonitors; ul++)
    3667             {
    3668                 DISPLAYFBINFO *pFb = &maFramebuffers[ul];
    3669                 if (!pFb->pendingViewportInfo.fPending)
    3670                     continue;
    3671 
    3672                 crViewportNotify(pVMMDev, ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y, pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
    3673                 pFb->pendingViewportInfo.fPending = false;
    3674             }
    3675 
    36763667            mCrOglCallbacks = Completion.MainInterface;
    36773668
    … …  
    39133904                    {
    39143905                        /* submit */
    3915 
    3916                         VBOXHGCMSVCPARM parm;
    3917 
    3918                         parm.type = VBOX_HGCM_SVC_PARM_PTR;
    3919                         parm.u.pointer.addr = &pDisplay->mCrOglScreenshotData;
    3920                         parm.u.pointer.size = sizeof (pDisplay->mCrOglScreenshotData);
    3921 
    3922                         VMMDev *pVMMDev = pDisplay->mParent->getVMMDev();
    3923                         if (pVMMDev)
    3924                         {
    3925                             int rc = pVMMDev->hgcmHostFastCallAsync(pDisplay->mhCrOglSvc, SHCRGL_HOST_FN_TAKE_SCREENSHOT, &parm, displayVRecCompletion, pDisplay);
    3926                             if (RT_SUCCESS(rc))
    3927                                 break;
    3928                             else
    3929                                 AssertMsgFailed(("hgcmHostFastCallAsync failed %f\n", rc));
    3930                         }
    3931                         else
    3932                             AssertMsgFailed(("no VMMDev\n"));
     3906                        VBOXCRCMDCTL_HGCM *pData = &pDisplay->mCrOglScreenshotCtl;
     3907
     3908                        pData->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
     3909                        pData->Hdr.u32Function = SHCRGL_HOST_FN_TAKE_SCREENSHOT;
     3910
     3911                        pData->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
     3912                        pData->aParms[0].u.pointer.addr = &pDisplay->mCrOglScreenshotData;
     3913                        pData->aParms[0].u.pointer.size = sizeof (pDisplay->mCrOglScreenshotData);
     3914                        int rc = pDisplay->crCtlSubmit(&pData->Hdr, sizeof (*pData), displayCrCmdFree, pData);
     3915                        if (!RT_SUCCESS(rc))
     3916                            AssertMsgFailed(("crCtlSubmit failed rc %n", rc));
    39333917                    }
    39343918
    … …  
    43054289void Display::handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
    43064290{
    4307     mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr, result);
     4291    PVBOXVDMACMD_CHROMIUM_CTL pCtl = (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr;
     4292    mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, pCtl, result);
    43084293}
    43094294
    … …  
    43494334        if (pVMMDev)
    43504335        {
     4336            bool fCheckPendingViewport = (pCtl->enmType == VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP);
    43514337            rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm, Display::displayCrHgsmiControlCompletion, this);
    43524338            AssertRC(rc);
    43534339            if (RT_SUCCESS(rc))
     4340            {
     4341                if (fCheckPendingViewport)
     4342                {
     4343                    ULONG ul;
     4344                    for (ul = 0; ul < mcMonitors; ul++)
     4345                    {
     4346                        DISPLAYFBINFO *pFb = &maFramebuffers[ul];
     4347                        if (!pFb->pendingViewportInfo.fPending)
     4348                            continue;
     4349
     4350                        crViewportNotify(pVMMDev, ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y, pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
     4351                        pFb->pendingViewportInfo.fPending = false;
     4352                    }
     4353                }
    43544354                return;
     4355            }
    43554356        }
    43564357        else
    … …  
    43874388    Display *pDisplay = (Display *)pvContext;
    43884389    pDisplay->handleCrHgsmiControlCompletion(result, u32Function, pParam);
     4390
    43894391}
    43904392#endif
    … …  
    43934395{
    43944396    VBOXCRCMDCTL *pCmd = (VBOXCRCMDCTL*)pParam->u.pointer.addr;
    4395     if (pCmd->pfnInternal)
    4396         ((PFNCRCTLCOMPLETION)pCmd->pfnInternal)(pCmd, pParam->u.pointer.size, result, pvContext);
     4397    if (pCmd->u.pfnInternal)
     4398        ((PFNCRCTLCOMPLETION)pCmd->u.pfnInternal)(pCmd, pParam->u.pointer.size, result, pvContext);
    43974399}
    43984400
    … …  
    44144416    parm.u.pointer.size = cbCmd;
    44154417
    4416     pCmd->pfnInternal = (void(*)())pfnCompletion;
     4418    pCmd->u.pfnInternal = (void(*)())pfnCompletion;
    44174419    int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, displayCrHgcmCtlSubmitCompletion, pvCompletion);
    44184420    if (!RT_SUCCESS(rc))
    … …  
    44324434}
    44334435
     4436int Display::crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion)
     4437{
     4438    return mpDrv->pVBVACallbacks->pfnCrCtlSubmit(mpDrv->pVBVACallbacks, pCmd, cbCmd, pfnCompletion, pvCompletion);
     4439}
     4440
     4441int Display::crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
     4442{
     4443    return mpDrv->pVBVACallbacks->pfnCrCtlSubmitSync(mpDrv->pVBVACallbacks, pCmd, cbCmd);
     4444}
     4445
    44344446#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
    4435 DECLCALLBACK(void)  Display::displayCrAsyncCmdCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
    4436 {
    4437     Display *pDisplay = (Display *)pvContext;
    4438     pDisplay->handleCrAsyncCmdCompletion(result, u32Function, pParam);
    4439 }
    4440 
    4441 
    4442 void  Display::handleCrAsyncCmdCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
    4443 {
    4444     if (pParam->type == VBOX_HGCM_SVC_PARM_PTR && pParam->u.pointer.addr)
    4445         RTMemFree(pParam->u.pointer.addr);
    4446 }
    4447 
    44484447bool  Display::handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp)
    44494448{
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