VirtualBox

Changeset 50848 in vbox for trunk/src/VBox/Main/src-client


Ignore:
Timestamp:
Mar 24, 2014 10:15:41 AM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
92933
Message:

crOpenGL: new command submission continued

Location:
trunk/src/VBox/Main/src-client
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • 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.

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