VirtualBox

Changeset 50184 in vbox


Ignore:
Timestamp:
Jan 23, 2014 4:10:13 PM (11 years ago)
Author:
vboxsync
Message:

crOpenGL: misc bugfixes, Vrdp+3D working with the new framework

Location:
trunk/src/VBox
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r50095 r50184  
    244244                if (!RT_SUCCESS(rc))
    245245                {
    246                         crWarning("CrBltEnter failed rc %d", rc);
     246                        WARN(("CrBltEnter failed rc %d", rc));
    247247                        return rc;
    248248                }
    … …  
    262262        if (!pTex->Flags.Entered)
    263263        {
    264                 crWarning("invalid Blt Leave");
     264                WARN(("invalid Blt Leave"));
    265265                return;
    266266        }
    … …  
    281281VBOXBLITTERDECL(int) CrTdBltDataAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, const CR_BLITTER_IMG**ppImg);
    282282/* release the texture data, the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup */
    283 VBOXBLITTERDECL(void) CrTdBltDataRelease(PCR_TEXDATA pTex);
     283VBOXBLITTERDECL(int) CrTdBltDataRelease(PCR_TEXDATA pTex);
    284284/* discard the texture data cached with previous CrTdBltDataAcquire.
    285285 * Must be called wit data released (CrTdBltDataRelease) */
    286 VBOXBLITTERDECL(void) CrTdBltDataDiscard(PCR_TEXDATA pTex);
     286VBOXBLITTERDECL(int) CrTdBltDataDiscard(PCR_TEXDATA pTex);
    287287/* does same as CrTdBltDataDiscard, and in addition cleans up.
    288288 * this is kind of a texture destructor, which clients should call on texture object destruction, e.g. from the PFNCRTEXDATA_RELEASED callback */
    289 VBOXBLITTERDECL(void) CrTdBltDataCleanup(PCR_TEXDATA pTex);
     289VBOXBLITTERDECL(int) CrTdBltDataCleanup(PCR_TEXDATA pTex);
     290
     291VBOXBLITTERDECL(int) CrTdBltDataCleanupNe(PCR_TEXDATA pTex);
    290292
    291293DECLINLINE(uint32_t) CrTdAddRef(PCR_TEXDATA pTex)
    … …  
    302304            pTex->pfnTextureReleased(pTex);
    303305        else
    304             CrTdBltDataCleanup(pTex);
     306            CrTdBltDataCleanupNe(pTex);
    305307        }
    306308

  • trunk/src/VBox/GuestHost/OpenGL/util/blitter.cpp

    r50095 r50184  
    550550    if (!CrBltIsEntered(pBlitter))
    551551    {
    552         crWarning("CrBltLeave: blitter not entered");
     552        WARN(("CrBltLeave: blitter not entered"));
    553553        return;
    554554    }
    … …  
    573573    if (!pBlitter->CurrentMural.Base.id && pBlitter->CtxInfo.Base.id)
    574574    {
    575         crWarning("current mural not initialized!");
     575        WARN(("current mural not initialized!"));
    576576        return VERR_INVALID_STATE;
    577577    }
    … …  
    579579    if (CrBltIsEntered(pBlitter))
    580580    {
    581         crWarning("blitter is entered already!");
     581        WARN(("blitter is entered already!"));
    582582        return VERR_INVALID_STATE;
    583583    }
    … …  
    600600    }
    601601
    602     crWarning("crBltInitOnMakeCurent failed, rc %d", rc);
     602    WARN(("crBltInitOnMakeCurent failed, rc %d", rc));
    603603    CrBltLeave(pBlitter);
    604604    return rc;
    … …  
    12031203    if (pTex->idPBO)
    12041204    {
     1205        Assert(CrBltIsEntered(pBlitter));
    12051206        pBlitter->pDispatch->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pTex->idPBO);
    12061207        pBlitter->pDispatch->UnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
    … …  
    12631264
    12641265/* release the texture data, the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup */
    1265 VBOXBLITTERDECL(void) CrTdBltDataRelease(PCR_TEXDATA pTex)
    1266 {
     1266VBOXBLITTERDECL(int) CrTdBltDataRelease(PCR_TEXDATA pTex)
     1267{
     1268    if (!pTex->Flags.Entered)
     1269    {
     1270        WARN(("tex not entered"));
     1271        return VERR_INVALID_STATE;
     1272    }
    12671273    Assert(pTex->Img.pvData);
     1274    return VINF_SUCCESS;
    12681275}
    12691276
    12701277/* discard the texture data cached with previous CrTdBltDataAcquire.
    12711278 * Must be called wit data released (CrTdBltDataRelease) */
    1272 VBOXBLITTERDECL(void) CrTdBltDataDiscard(PCR_TEXDATA pTex)
    1273 {
     1279VBOXBLITTERDECL(int) CrTdBltDataDiscard(PCR_TEXDATA pTex)
     1280{
     1281    if (!pTex->Flags.Entered)
     1282    {
     1283        WARN(("tex not entered"));
     1284        return VERR_INVALID_STATE;
     1285    }
     1286
    12741287    crTdBltImgFree(pTex);
    1275 }
    1276 /* does same as CrTdBltDataDiscard, and in addition cleans up */
    1277 VBOXBLITTERDECL(void) CrTdBltDataCleanup(PCR_TEXDATA pTex)
     1288
     1289    return VINF_SUCCESS;
     1290}
     1291
     1292static void crTdBltDataCleanup(PCR_TEXDATA pTex)
    12781293{
    12791294    crTdBltImgFree(pTex);
    … …  
    12831298    if (pTex->idPBO)
    12841299    {
     1300        Assert(CrBltIsEntered(pBlitter));
    12851301        pBlitter->pDispatch->DeleteBuffersARB(1, &pTex->idPBO);
    12861302        pTex->idPBO = 0;
    … …  
    12891305    if (pTex->idInvertTex)
    12901306    {
     1307        Assert(CrBltIsEntered(pBlitter));
    12911308        pBlitter->pDispatch->DeleteTextures(1, &pTex->idInvertTex);
    12921309        pTex->idInvertTex = 0;
    12931310    }
     1311}
     1312
     1313/* does same as CrTdBltDataDiscard, and in addition cleans up */
     1314VBOXBLITTERDECL(int) CrTdBltDataCleanup(PCR_TEXDATA pTex)
     1315{
     1316    if (!pTex->Flags.Entered)
     1317    {
     1318        WARN(("tex not entered"));
     1319        return VERR_INVALID_STATE;
     1320    }
     1321
     1322    crTdBltDataCleanup(pTex);
     1323
     1324    return VINF_SUCCESS;
     1325}
     1326
     1327VBOXBLITTERDECL(int) CrTdBltDataCleanupNe(PCR_TEXDATA pTex)
     1328{
     1329    bool fEntered = false;
     1330    if (pTex->idPBO || pTex->idInvertTex)
     1331    {
     1332        int rc = CrTdBltEnter(pTex);
     1333        if (!RT_SUCCESS(rc))
     1334        {
     1335            WARN(("err"));
     1336            return rc;
     1337        }
     1338
     1339        fEntered = true;
     1340    }
     1341
     1342    crTdBltDataCleanup(pTex);
     1343
     1344    if (fEntered)
     1345        CrTdBltLeave(pTex);
     1346
     1347    return VINF_SUCCESS;
    12941348}
    12951349
    … …  
    12991353VBOXBLITTERDECL(int) CrTdBltDataAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, const CR_BLITTER_IMG**ppImg)
    13001354{
     1355    if (!pTex->Flags.Entered)
     1356    {
     1357        WARN(("tex not entered"));
     1358        return VERR_INVALID_STATE;
     1359    }
     1360
    13011361    if (pTex->Img.pvData && pTex->Img.enmFormat == enmFormat && !pTex->Flags.DataInverted == !fInverted)
    13021362    {
    … …  
    13161376        if (!RT_SUCCESS(rc))
    13171377        {
    1318             crWarning("crTdBltCheckInvertTex failed rc %d", rc);
     1378            WARN(("crTdBltCheckInvertTex failed rc %d", rc));
    13191379            return rc;
    13201380        }
    … …  
    13421402    if (!RT_SUCCESS(rc))
    13431403    {
    1344         crWarning("crTdBltImgAcquire failed rc %d", rc);
     1404        WARN(("crTdBltImgAcquire failed rc %d", rc));
    13451405        return rc;
    13461406    }

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

    r50095 r50184  
    238238        }
    239239        cr_server.projectionOverride = GL_TRUE;
     240        break;
     241
     242    case GL_HH_SET_TMPCTX_MAKE_CURRENT:
     243        /*we should not receive it from the guest! */
    240244        break;
    241245
    … …  
    673677        Ctx.Base.id = cr_server.MainContextInfo.SpuContext;
    674678        Ctx.Base.visualBits = cr_server.MainContextInfo.CreateInfo.visualBits;
    675         rc = CrBltInit(&cr_server.Blitter, &Ctx, true, true, NULL, &cr_server.head_spu->dispatch_table);
     679        rc = CrBltInit(&cr_server.Blitter, &Ctx, true, true, NULL, &cr_server.TmpCtxDispatch);
    676680        if (RT_SUCCESS(rc))
    677681        {
    … …  
    685689        }
    686690    }
     691
     692    if (!CrBltMuralGetCurrentInfo(&cr_server.Blitter)->Base.id)
     693    {
     694        CRMuralInfo *dummy = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.visualBits);
     695        CR_BLITTER_WINDOW DummyInfo;
     696        CRASSERT(dummy);
     697        crServerVBoxBlitterWinInit(&DummyInfo, dummy);
     698        CrBltMuralSetCurrentInfo(&cr_server.Blitter, &DummyInfo);
     699    }
     700
    687701    return &cr_server.Blitter;
    688702}
    … …  
    13471361    if (pCtx)
    13481362    {
    1349         GLint curSrvSpuCtx = cr_server.currentCtxInfo && cr_server.currentCtxInfo->SpuContext > 0 ? cr_server.currentCtxInfo->SpuContext : cr_server.MainContextInfo.SpuContext;
    1350         bool fSwitchToTmpCtx = (curSrvSpuCtx != context);
    13511363        CRMuralInfo *pCurrentMural = cr_server.currentMural;
    1352         CRContextInfo *pCurCtxInfo = cr_server.currentCtxInfo;
    1353         pCurCtx = pCurCtxInfo ? pCurCtxInfo->pContext : NULL;
    1354 
    1355         CRASSERT(pCurCtx == pCtx);
     1364
     1365        pCurCtx = cr_server.currentCtxInfo ? cr_server.currentCtxInfo->pContext : cr_server.MainContextInfo.pContext;
     1366        Assert(pCurCtx == pCtx);
     1367
     1368        if (!context)
     1369        {
     1370            if (pCurrentMural)
     1371            {
     1372                Assert(cr_server.currentCtxInfo);
     1373                context = cr_server.currentCtxInfo->SpuContext > 0 ? cr_server.currentCtxInfo->SpuContext : cr_server.MainContextInfo.SpuContext;
     1374                window = pCurrentMural->spuWindow;
     1375            }
     1376            else
     1377            {
     1378                CRMuralInfo * pDummy;
     1379                Assert(!cr_server.currentCtxInfo);
     1380                pDummy = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.visualBits);
     1381                context = cr_server.MainContextInfo.SpuContext;
     1382                window = pDummy->spuWindow;
     1383            }
     1384
     1385
     1386            fDoPrePostProcess = -1;
     1387        }
     1388        else
     1389        {
     1390            fDoPrePostProcess = 1;
     1391        }
    13561392
    13571393        if (pCurrentMural)
    … …  
    13651401            idReadFBO = 0;
    13661402        }
    1367 
    1368         fDoPrePostProcess = fSwitchToTmpCtx ? 1 : -1;
    13691403    }
    13701404    else
    … …  
    13841418void crServerInitTmpCtxDispatch()
    13851419{
     1420    MakeCurrentFunc_t pfnMakeCurrent;
     1421
    13861422    crSPUInitDispatchTable(&cr_server.TmpCtxDispatch);
    13871423    crSPUCopyDispatchTable(&cr_server.TmpCtxDispatch, &cr_server.head_spu->dispatch_table);
    13881424    cr_server.TmpCtxDispatch.MakeCurrent = crServerMakeTmpCtxCurrent;
     1425
     1426    pfnMakeCurrent = crServerMakeTmpCtxCurrent;
     1427    cr_server.head_spu->dispatch_table.ChromiumParametervCR(GL_HH_SET_TMPCTX_MAKE_CURRENT, GL_BYTE, sizeof (void*), &pfnMakeCurrent);
     1428
    13891429}
    13901430

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp

    r50178 r50184  
    330330    CRTextureObj *pTobj = pFbTex->pTobj;
    331331
    332     CrTdBltDataCleanup(pTex);
     332    CrTdBltDataCleanupNe(pTex);
    333333
    334334    if (pTobj)
    … …  
    24332433        }
    24342434
    2435         return vrdpFrame(hNewEntry);
     2435        const VBOXVR_SCR_COMPOSITOR_ENTRY* pReplacedEntry = CrFbEntryGetCompositorEntry(hReplacedEntry);
     2436        CR_TEXDATA *pReplacedTex = CrVrScrCompositorEntryTexGet(pReplacedEntry);
     2437        const VBOXVR_SCR_COMPOSITOR_ENTRY* pNewEntry = CrFbEntryGetCompositorEntry(hNewEntry);
     2438        CR_TEXDATA *pNewTex = CrVrScrCompositorEntryTexGet(pNewEntry);
     2439
     2440        rc = CrTdBltEnter(pReplacedTex);
     2441        if (RT_SUCCESS(rc))
     2442        {
     2443            if (pNewTex != pReplacedTex)
     2444            {
     2445                CrTdBltDataDiscard(pReplacedTex);
     2446                rc = CrTdBltEnter(pNewTex);
     2447                if (RT_SUCCESS(rc))
     2448                {
     2449                    rc = vrdpFrame(hNewEntry);
     2450                    CrTdBltLeave(pNewTex);
     2451                }
     2452                else
     2453                    WARN(("CrTdBltEnter failed %d", rc));
     2454            }
     2455            else
     2456                rc = vrdpFrame(hNewEntry);
     2457
     2458            CrTdBltLeave(pReplacedTex);
     2459        }
     2460        else
     2461            WARN(("CrTdBltEnter failed %d", rc));
     2462
     2463        return rc;
    24362464    }
    24372465
    … …  
    24452473        }
    24462474
    2447         return vrdpFrame(hEntry);
     2475        const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
     2476        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
     2477
     2478        rc = CrTdBltEnter(pTex);
     2479        if (RT_SUCCESS(rc))
     2480        {
     2481            rc = vrdpFrame(hEntry);
     2482            CrTdBltLeave(pTex);
     2483        }
     2484        else
     2485            WARN(("CrTdBltEnter failed %d", rc));
     2486
     2487        return rc;
    24482488    }
    24492489
    … …  
    25972637        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
    25982638        const CR_BLITTER_IMG *pImg;
     2639        CrTdBltDataDiscard(pTex);
    25992640        int rc = CrTdBltDataAcquire(pTex, GL_BGRA, !!(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS), &pImg);
    26002641        if (!RT_SUCCESS(rc))

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

    r50123 r50184  
    196196                CR_BLITTER_WINDOW DummyInfo;
    197197                CRASSERT(dummy);
     198                crServerVBoxBlitterWinInit(&DummyInfo, dummy);
    198199                CrBltMuralSetCurrentInfo(pBlitter, &DummyInfo);
    199200        }

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.c

    r50095 r50184  
    15451545                memcpy(&render_spu.blitterDispatch.MakeCurrent, values, count);
    15461546        else
    1547                 crWarning("unexpected type(%#x) - count(%d) pair", type, count);
     1547                WARN(("unexpected type(%#x) - count(%d) pair", type, count));
    15481548        break;
    15491549
    15501550    default:
    15511551#if 0
    1552         crWarning("Unhandled target in renderspuChromiumParametervCR(0x%x)", (int) target);
     1552        WARN(("Unhandled target in renderspuChromiumParametervCR(0x%x)", (int) target));
    15531553#endif
    15541554        break;
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