VirtualBox

Changeset 32420 in vbox


Ignore:
Timestamp:
Sep 10, 2010 4:25:10 PM (14 years ago)
Author:
vboxsync
Message:

crOpenGL: some mutter/meego related fixes

Location:
trunk/src/VBox
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r32149 r32420  
    150150}
    151151
     152#ifdef GLX
     153static XErrorHandler oldErrorHandler;
     154static unsigned char lastXError = Success;
     155
     156static int
     157errorHandler (Display *dpy, XErrorEvent *e)
     158{
     159    lastXError = e->error_code;
     160    return 0;
     161}
     162#endif
    152163
    153164GLboolean
    … …  
    166177        XGetWindowAttributes(dpy, win->drawable, &attr);
    167178        XUNLOCK(dpy);
    168         return (attr.map_state != IsUnmapped);
     179
     180        if (attr.map_state == IsUnmapped)
     181        {
     182            return GL_FALSE;
     183        }
     184# if 1
     185        return GL_TRUE;
     186# else
     187        if (attr.override_redirect)
     188        {
     189            return GL_TRUE;
     190        }
     191
     192        if (!stub.bXExtensionsChecked)
     193        {
     194            stubCheckXExtensions(win);
     195        }
     196
     197        if (!stub.bHaveXComposite)
     198        {
     199            return GL_TRUE;
     200        }
     201        else
     202        {
     203            Pixmap p;
     204
     205            crLockMutex(&stub.mutex);
     206
     207            XLOCK(dpy);
     208            XSync(dpy, false);
     209            oldErrorHandler = XSetErrorHandler(errorHandler);
     210            /*@todo this will create new pixmap for window every call*/
     211            p = XCompositeNameWindowPixmap(dpy, win->drawable);
     212            XSync(dpy, false);
     213            XSetErrorHandler(oldErrorHandler);
     214            XUNLOCK(dpy);
     215
     216            switch (lastXError)
     217            {
     218                case Success:
     219                    XFreePixmap(dpy, p);
     220                    crUnlockMutex(&stub.mutex);
     221                    return GL_FALSE;
     222                    break;
     223                case BadMatch:
     224                    /*Window isn't redirected*/
     225                    lastXError = Success;
     226                    break;
     227                default:
     228                    crWarning("Unexpected XError %i", (int)lastXError);
     229                    lastXError = Success;
     230            }
     231
     232            crUnlockMutex(&stub.mutex);
     233
     234            return GL_TRUE;
     235        }
     236# endif
    169237    }
    170238    else {
    … …  
    882950                window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
    883951#endif
    884 
    885952            }
    886953        }
    … …  
    9381005                /*crDebug("(2)stubMakeCurrent ctx=%p(%i) window=%p(%i)", context, context->spuContext, window, window->spuWindow);*/
    9391006                window->spuWindow = stub.spu->dispatch_table.WindowCreate( window->dpyName, context->visBits );
     1007#ifdef CR_NEWWINTRACK
     1008                window->u32ClientID = stub.spu->dispatch_table.VBoxPackGetInjectID();
     1009#endif
    9401010                if (context->currentDrawable && context->currentDrawable->type==CHROMIUM
    9411011                    && context->currentDrawable->pOwner==context)

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

    r32041 r32420  
    10321032}
    10331033
     1034static XErrorHandler oldErrorHandler;
     1035static unsigned char lastXError = Success;
     1036
     1037static int
     1038errorHandler (Display *dpy, XErrorEvent *e)
     1039{
     1040    lastXError = e->error_code;
     1041    return 0;
     1042}
     1043
    10341044DECLEXPORT(void) VBOXGLXTAG(glXSwapBuffers)( Display *dpy, GLXDrawable drawable )
    10351045{
    10361046    WindowInfo *window = stubGetWindowInfo(dpy, drawable);
    10371047    stubSwapBuffers( window, 0 );
     1048
     1049#ifdef VBOX_TEST_MEGOO
     1050    if (!stub.bXExtensionsChecked)
     1051    {
     1052        stubCheckXExtensions(window);
     1053    }
     1054
     1055    if (!stub.bHaveXComposite)
     1056    {
     1057        return;
     1058    }
     1059
     1060    {
     1061        Pixmap p;
     1062        XWindowAttributes attr;
     1063
     1064        XLOCK(dpy);
     1065        XGetWindowAttributes(dpy, window->drawable, &attr);
     1066        if (attr.override_redirect)
     1067        {
     1068            XUNLOCK(dpy);
     1069            return;
     1070        }
     1071
     1072        crLockMutex(&stub.mutex);
     1073
     1074        XSync(dpy, false);
     1075        oldErrorHandler = XSetErrorHandler(errorHandler);
     1076        /*@todo this creates new pixmap for window every call*/
     1077        /*p = XCompositeNameWindowPixmap(dpy, window->drawable);*/
     1078        XSync(dpy, false);
     1079        XSetErrorHandler(oldErrorHandler);
     1080        XUNLOCK(dpy);
     1081
     1082        if (lastXError==Success)
     1083        {
     1084            char *data, *imgdata;
     1085            GC gc;
     1086            XImage *image;
     1087            XVisualInfo searchvis, *pret;
     1088            int nvisuals;
     1089            XGCValues gcValues;
     1090            int i, rowsize;
     1091
     1092            XLOCK(dpy);
     1093
     1094            searchvis.visualid = attr.visual->visualid;
     1095            pret = XGetVisualInfo(dpy, VisualIDMask, &searchvis, &nvisuals);
     1096            if (nvisuals!=1) crWarning("XGetVisualInfo returned %i visuals for %x", nvisuals, (unsigned int) searchvis.visualid);
     1097            CRASSERT(pret);
     1098
     1099            gc = XCreateGC(dpy, window->drawable, 0, &gcValues);
     1100            if (!gc) crWarning("Failed to create gc!");               
     1101           
     1102            data = crCalloc(window->width * window->height * 4);
     1103            imgdata = crCalloc(window->width * window->height * 4);
     1104            CRASSERT(data && imgdata);
     1105            stub.spu->dispatch_table.ReadPixels(0, 0, window->width, window->height, GL_RGBA, GL_UNSIGNED_BYTE, data);
     1106            /*y-invert image*/
     1107            rowsize = 4*window->width;
     1108            for (i=0; i<window->height; ++i)
     1109            {
     1110                crMemcpy(imgdata+rowsize*i, data+rowsize*(window->height-i-1), rowsize);
     1111            }
     1112            crFree(data);
     1113
     1114            XSync(dpy, false);
     1115            image = XCreateImage(dpy, attr.visual, pret->depth, ZPixmap, 0, imgdata, window->width, window->height, 32, 0);
     1116            XPutImage(dpy, window->drawable, gc, image, 0, 0, 0, 0, window->width, window->height);
     1117
     1118            XFree(pret);
     1119            /*XFreePixmap(dpy, p);*/
     1120            XFreeGC(dpy, gc);
     1121            XDestroyImage(image);
     1122            XUNLOCK(dpy);
     1123        }
     1124        lastXError=Success;
     1125        crUnlockMutex(&stub.mutex);
     1126    }
     1127#endif
    10381128}
    10391129
    … …  
    13421432    (void) dpy;
    13431433    (void) config;
     1434
     1435#if 0
     1436    {
     1437        int x, y;
     1438        unsigned int w, h;
     1439        unsigned int border;
     1440        unsigned int depth;
     1441        Window root;
     1442
     1443        crDebug("glXCreatePixmap called for %lu", pixmap);
     1444
     1445        XLOCK(dpy);
     1446        if (!XGetGeometry(dpy, pixmap, &root, &x, &y, &w, &h, &border, &depth))
     1447        {
     1448            XSync(dpy, False);
     1449            if (!XGetGeometry(dpy, pixmap, &root, &x, &y, &w, &h, &border, &depth))
     1450            {
     1451                crDebug("fail");
     1452            }
     1453        }
     1454        crDebug("root: %lu, [%i,%i %u,%u]", root, x, y, w, h);
     1455        XUNLOCK(dpy);
     1456    }
     1457#endif
    13441458
    13451459    pGlxPixmap = crCalloc(sizeof(GLX_Pixmap_t));

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

    r32241 r32420  
    391391    }
    392392#else
    393     ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
    394     {
    395         /*RTThreadWait might return too early, which cause our code being unloaded while RT thread wrapper is still running*/
    396         int rc = pthread_join(RTThreadGetNative(stub.hSyncThread), NULL);
    397         if (!rc)
    398         {
    399             crDebug("pthread_join failed %i", rc);
     393    if (stub.hSyncThread!=NIL_RTTHREAD)
     394    {
     395        ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
     396        {
     397            /*RTThreadWait might return too early, which cause our code being unloaded while RT thread wrapper is still running*/
     398            int rc = pthread_join(RTThreadGetNative(stub.hSyncThread), NULL);
     399            if (!rc)
     400            {
     401                crDebug("pthread_join failed %i", rc);
     402            }
    400403        }
    401404    }
    … …  
    11241127    stub.bShmInitFailed = GL_FALSE;
    11251128    stub.pGLXPixmapsHash = crAllocHashtable();
     1129
     1130    stub.bXExtensionsChecked = GL_FALSE;
     1131    stub.bHaveXComposite = GL_FALSE;
     1132    stub.bHaveXFixes = GL_FALSE;
    11261133#endif
    11271134

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

    r30486 r32420  
    1010#include "stub.h"
    1111#include <iprt/thread.h>
    12 
    13 #ifdef GLX
    14 #include <X11/extensions/Xcomposite.h>
    15 #include <X11/extensions/Xfixes.h>
    16 #endif
    1712
    1813static void crForcedFlush()
    … …  
    3328{
    3429#if defined(CR_NEWWINTRACK)
    35     if (RTThreadNativeSelf()==RTThreadGetNative(stub.hSyncThread))
     30    if ((NIL_RTTHREAD!=stub.hSyncThread) && (RTThreadNativeSelf()==RTThreadGetNative(stub.hSyncThread)))
    3631    {
    3732        if (pWindow && pWindow->dpy && !pWindow->syncDpy)
    … …  
    443438
    444439#elif defined(GLX) //#ifdef WINDOWS
    445 static GLboolean stubCheckXExtensions(WindowInfo *pWindow)
     440void stubCheckXExtensions(WindowInfo *pWindow)
    446441{
    447442    int evb, erb, vmi=0, vma=0;
    448443    Display *dpy = stubGetWindowDisplay(pWindow);
     444
     445    stub.bXExtensionsChecked = GL_TRUE;
     446    stub.trackWindowVisibleRgn = 0;
    449447
    450448    XLOCK(dpy);
    … …  
    453451        && (vma>0 || vmi>=4))
    454452    {
     453        stub.bHaveXComposite = GL_TRUE;
    455454        crDebug("XComposite %i.%i", vma, vmi);
    456455        vma=0;
    … …  
    461460        {
    462461            crDebug("XFixes %i.%i", vma, vmi);
     462            stub.bHaveXFixes = GL_TRUE;
     463            stub.trackWindowVisibleRgn = 1;
    463464            XUNLOCK(dpy);
    464             return GL_TRUE;
     465            return;
    465466        }
    466467        else
    … …  
    474475    }
    475476    XUNLOCK(dpy);
    476     return GL_FALSE;
     477    return;
    477478}
    478479
    … …  
    483484GLboolean stubUpdateWindowVisibileRegions(WindowInfo *pWindow)
    484485{
    485     static GLboolean bExtensionsChecked = GL_FALSE;
    486 
    487486    XserverRegion xreg;
    488487    int cRects, i;
    … …  
    490489    GLint* pGLRects;
    491490    Display *dpy;
    492 
    493     if (bExtensionsChecked || stubCheckXExtensions(pWindow))
    494     {
    495         bExtensionsChecked = GL_TRUE;
    496     }
    497     else
    498     {
    499         stub.trackWindowVisibleRgn = 0;
    500         return GL_FALSE;
     491    bool bNoUpdate = false;
     492
     493    if (!stub.bXExtensionsChecked)
     494    {
     495        stubCheckXExtensions(pWindow);
     496        if (!stub.trackWindowVisibleRgn)
     497        {
     498            return GL_FALSE;
     499        }
    501500    }
    502501
    … …  
    512511    XUNLOCK(dpy);
    513512
    514     /* @todo For some odd reason *first* run of compiz on freshly booted VM gives us 0 cRects all the time.
    515      * In (!pWindow->pVisibleRegions && cRects) "&& cRects" is a workaround for that case, especially as this
    516      * information is useless for full screen composing managers anyway.
    517      * If this is changed, make sure to change crVBoxServerLoadState accordingly.
    518      */
    519     if ((!pWindow->pVisibleRegions && cRects)
    520         || pWindow->cVisibleRegions!=cRects
    521         || (pWindow->pVisibleRegions && crMemcmp(pWindow->pVisibleRegions, pXRects, cRects * sizeof(XRectangle))))
    522     {
     513    /* Check for compiz main window */
     514    if (!pWindow->pVisibleRegions && !cRects)
     515    {
     516#ifdef VBOX_TEST_MEGOO
     517        XWindowAttributes attr;
     518        XLOCK(dpy);
     519        XSync(dpy, false);
     520        XGetWindowAttributes(dpy, pWindow->drawable, &attr);
     521        XUNLOCK(dpy);
     522
     523        bNoUpdate = attr.override_redirect;
     524#else
     525        bNoUpdate = true;
     526#endif
     527    }
     528
     529    if (!bNoUpdate
     530        && (!pWindow->pVisibleRegions
     531            || pWindow->cVisibleRegions!=cRects
     532            || (pWindow->pVisibleRegions && crMemcmp(pWindow->pVisibleRegions, pXRects, cRects * sizeof(XRectangle)))))
     533    {
     534        if (pWindow->pVisibleRegions)
     535        {
     536            XFree(pWindow->pVisibleRegions);
     537        }
     538
    523539        pWindow->pVisibleRegions = pXRects;
    524540        pWindow->cVisibleRegions = cRects;

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

    r30598 r32420  
    4444#include <sys/shm.h>
    4545#include <X11/extensions/Xdamage.h>
     46#include <X11/extensions/Xcomposite.h>
     47#include <X11/extensions/Xfixes.h>
    4648#endif
    4749
    … …  
    5355# error CHROMIUM_THREADSAFE have to be defined
    5456#endif
     57
     58/*#define VBOX_TEST_MEGOO*/
    5559
    5660#if 0 && defined(CR_NEWWINTRACK) && !defined(WINDOWS)
    … …  
    232236
    233237    CRHashTable     *pGLXPixmapsHash;
     238
     239    GLboolean       bXExtensionsChecked;
     240    GLboolean       bHaveXComposite;
     241    GLboolean       bHaveXFixes;
    234242#endif
    235243
    … …  
    284292extern Display* stubGetWindowDisplay(WindowInfo *pWindow);
    285293
     294extern void stubCheckXExtensions(WindowInfo *pWindow);
    286295#endif
    287296

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

    r30973 r32420  
    285285    {
    286286        const char *fname = crGetenv( "CR_DEBUG_FILE" );
     287        char str[1024];
     288
     289#if defined(Linux) && defined(IN_GUEST) && defined(DEBUG_leo)
     290        if (!fname)
     291        {
     292            char pname[1024];
     293            crGetProcName(pname, 1024);
     294            sprintf(str, "/home/leo/crlog_%s.txt", pname);
     295            fname = &str[0];
     296        }
     297#endif
     298
    287299        first_time = 0;
    288300        if (fname)

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

    r31808 r32420  
    304304                if (!RT_SUCCESS(rc))
    305305                {
    306                     Assert(VERR_NOT_SUPPORTED==rc);
    307                     svcClientVersionUnsupported(0, 0);
    308                 }
    309 
     306                    if (VERR_NOT_SUPPORTED==rc)
     307                    {
     308                        svcClientVersionUnsupported(0, 0);
     309                    }
     310                    else
     311                    {
     312                        crWarning("SHCRGL_GUEST_FN_INJECT failed to inject for %i from %i", u32InjectClientID, u32ClientID);
     313                    }
     314                }
    310315            }
    311316            break;

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

    r31808 r32420  
    378378int32_t crVBoxServerClientWrite(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t cbBuffer)
    379379{
    380     CRClient *pClient;
     380    CRClient *pClient = NULL;
    381381    int32_t i;
    382382
    … …  
    388388            && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
    389389        {
     390            pClient = cr_server.clients[i];
    390391            break;
    391392        }
    392393    }
    393     pClient = cr_server.clients[i];
    394     CRASSERT(pClient);
     394    if (!pClient) return VERR_INVALID_PARAMETER;
    395395
    396396    if (!pClient->conn->vMajor) return VERR_NOT_SUPPORTED;
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