VirtualBox

Ignore:
Timestamp:
Feb 20, 2009 11:25:55 AM (16 years ago)
Author:
vboxsync
Message:

crOpenGL: don't allocate memory for textures on host side (#3461)

Location:
trunk/src/VBox/GuestHost/OpenGL/state_tracker
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_snapshot.c

    r16551 r16969  
    2323#include "state.h"
    2424#include "state/cr_statetypes.h"
     25#include "state/cr_texture.h"
    2526#include "cr_mem.h"
    2627
    … …  
    8485                AssertRCReturn(rc, rc);
    8586            }
     87#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     88            /* Note, this is not a bug.
     89             * Even with CR_STATE_NO_TEXTURE_IMAGE_STORE defined, it's possible that ptl->img!=NULL.
     90             * For ex. we're saving snapshot right after it was loaded
     91             * and some context hasn't been used by the guest application yet
     92             * (pContext->texture.bResyncNeeded==GL_TRUE).
     93             */
     94            else if (ptl->bytes)
     95            {
     96                char *pImg;
     97
     98                pImg = crAlloc(ptl->bytes);
     99                if (!pImg) return VERR_NO_MEMORY;
     100
     101                diff_api.BindTexture(pTexture->target, pTexture->name);
     102                diff_api.GetTexImage(pTexture->target, i, ptl->format, ptl->type, pImg);
     103
     104                rc = SSMR3PutMem(pSSM, pImg, ptl->bytes);
     105                crFree(pImg);
     106                AssertRCReturn(rc, rc);
     107            }
     108#endif
    86109        }
    87110    }
    … …  
    115138                AssertRCReturn(rc, rc);
    116139            }
     140#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     141            /* Same story as in crStateSaveTextureObjData */
     142            else if (ptl->bytes)
     143            {
     144                ptl->img = crAlloc(ptl->bytes);
     145                if (!ptl->img) return VERR_NO_MEMORY;
     146
     147                rc = SSMR3GetMem(pSSM, ptl->img, ptl->bytes);
     148                AssertRCReturn(rc, rc);
     149            }
     150#endif
    117151            crStateTextureInitTextureFormat(ptl, ptl->internalFormat);
    118152
    … …  
    557591    crHashtableWalk(pContext->shared->textureTable, crStateSaveSharedTextureCB, pSSM);
    558592
     593#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     594        /* Restore previous texture bindings via diff_api */
     595        if (ui32)
     596    {
     597        CRTextureUnit *pTexUnit;
     598
     599        pTexUnit = &pContext->texture.unit[pContext->texture.curTextureUnit];
     600
     601            diff_api.BindTexture(GL_TEXTURE_1D, pTexUnit->currentTexture1D->name);
     602            diff_api.BindTexture(GL_TEXTURE_2D, pTexUnit->currentTexture2D->name);
     603            diff_api.BindTexture(GL_TEXTURE_3D, pTexUnit->currentTexture3D->name);
     604#ifdef CR_ARB_texture_cube_map
     605        diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, pTexUnit->currentTextureCubeMap->name);
     606#endif
     607#ifdef CR_NV_texture_rectangle
     608        diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, pTexUnit->currentTextureRect->name);
     609#endif
     610    }
     611#endif
     612
    559613    /* Save current texture pointers */
    560614    for (i=0; i<CR_MAX_TEXTURE_UNITS; ++i)

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_texdiff.c

    r15532 r16969  
    594594void
    595595crStateTextureObjectDiff(CRContext *fromCtx,
    596                                                  const CRbitvalue *bitID, const CRbitvalue *nbitID,
    597                                                  CRTextureObj *tobj, GLboolean alwaysDirty)
     596                         const CRbitvalue *bitID, const CRbitvalue *nbitID,
     597                         CRTextureObj *tobj, GLboolean alwaysDirty)
    598598{
    599599    CRTextureState *from = &(fromCtx->texture);
    … …  
    684684                        if (tl->compressed) {
    685685                            diff_api.CompressedTexImage1DARB(GL_TEXTURE_1D, lvl,
    686                                                                                              tl->internalFormat, tl->width,
    687                                                                                              tl->border, tl->bytes, tl->img);
     686                                                             tl->internalFormat, tl->width,
     687                                                             tl->border, tl->bytes, tl->img);
    688688                        }
    689689                        else {
    … …  
    697697                            }
    698698                            diff_api.TexImage1D(GL_TEXTURE_1D, lvl,
    699                                                                     tl->internalFormat,
    700                                                                     tl->width, tl->border,
    701                                                                     tl->format, tl->type, tl->img);
     699                                                tl->internalFormat,
     700                                                tl->width, tl->border,
     701                                                tl->format, tl->type, tl->img);
    702702                        }
    703703                        if (!alwaysDirty)
     704                        {
    704705                            CLEARDIRTY(tl->dirty, nbitID);
     706                        }
     707#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     708                        else
     709                        {
     710                            crFree(tl->img);
     711                            tl->img = NULL;
     712                        }
     713#endif
    705714                    }
    706715                }
    … …  
    715724                            diff_api.TexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, 1);
    716725                        }
     726
    717727                        if (tl->compressed) {
    718728                            diff_api.CompressedTexImage2DARB(GL_TEXTURE_2D, lvl,
    719                                                                                              tl->internalFormat, tl->width,
    720                                                                                              tl->height, tl->border,
    721                                                                                              tl->bytes, tl->img);
     729                                     tl->internalFormat, tl->width,
     730                                     tl->height, tl->border,
     731                                     tl->bytes, tl->img);
    722732                        }
    723733                        else {
    … …  
    728738                            diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
    729739                            diff_api.TexImage2D(GL_TEXTURE_2D, lvl,
    730                                                                     tl->internalFormat,
    731                                                                     tl->width, tl->height, tl->border,
    732                                                                     tl->format, tl->type, tl->img);
    733                         }
     740                                                tl->internalFormat,
     741                                                tl->width, tl->height, tl->border,
     742                                                tl->format, tl->type, tl->img);
     743                        }
     744
    734745                        if (!alwaysDirty)
     746                        {
    735747                            CLEARDIRTY(tl->dirty, nbitID);
     748                        }
     749#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     750                        else
     751                        {
     752                            crFree(tl->img);
     753                            tl->img = NULL;
     754                        }
     755#endif
    736756                    }
    737757                }
    … …  
    749769                        if (tl->compressed) {
    750770                            diff_api.CompressedTexImage3DARB(GL_TEXTURE_3D, lvl,
    751                                                                                              tl->internalFormat, tl->width,
    752                                                                                              tl->height, tl->depth,
    753                                                                                              tl->border, tl->bytes, tl->img);
     771                                                             tl->internalFormat, tl->width,
     772                                                             tl->height, tl->depth,
     773                                                             tl->border, tl->bytes, tl->img);
    754774                        }
    755775                        else {
    … …  
    760780                            diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
    761781                            diff_api.TexImage3D(GL_TEXTURE_3D, lvl,
    762                                                                     tl->internalFormat,
    763                                                                     tl->width, tl->height, tl->depth,
    764                                                                     tl->border, tl->format,
    765                                                                     tl->type, tl->img);
     782                                                tl->internalFormat,
     783                                                tl->width, tl->height, tl->depth,
     784                                                tl->border, tl->format,
     785                                                tl->type, tl->img);
    766786                        }
    767787                        if (!alwaysDirty)
     788                        {
    768789                            CLEARDIRTY(tl->dirty, nbitID);
     790                        }
     791#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     792                        else
     793                        {
     794                            crFree(tl->img);
     795                            tl->img = NULL;
     796                        }
     797#endif
    769798                    }
    770799                }
    … …  
    781810                        if (tl->compressed) {
    782811                            diff_api.CompressedTexImage2DARB(GL_TEXTURE_RECTANGLE_NV, lvl,
    783                                                                                              tl->internalFormat, tl->width,
    784                                                                                              tl->height, tl->border,
    785                                                                                              tl->bytes, tl->img);
     812                                                             tl->internalFormat, tl->width,
     813                                                             tl->height, tl->border,
     814                                                             tl->bytes, tl->img);
    786815                        }
    787816                        else {
    … …  
    792821                            diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
    793822                            diff_api.TexImage2D(GL_TEXTURE_RECTANGLE_NV, lvl,
    794                                                                     tl->internalFormat,
    795                                                                     tl->width, tl->height, tl->border,
    796                                                                     tl->format, tl->type, tl->img);
     823                                                tl->internalFormat,
     824                                                tl->width, tl->height, tl->border,
     825                                                tl->format, tl->type, tl->img);
    797826                        }
    798827                        if (!alwaysDirty)
     828                        {
    799829                            CLEARDIRTY(tl->dirty, nbitID);
     830                        }
     831#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     832                        else
     833                        {
     834                            crFree(tl->img);
     835                            tl->img = NULL;
     836                        }
     837#endif
    800838                    }
    801839                }
    … …  
    814852                            if (tl->generateMipmap) {
    815853                                diff_api.TexParameteri(GL_TEXTURE_CUBE_MAP_ARB,
    816                                                                              GL_GENERATE_MIPMAP_SGIS, 1);
     854                                                       GL_GENERATE_MIPMAP_SGIS, 1);
    817855                            }
    818856                            if (tl->compressed) {
    819857                                diff_api.CompressedTexImage2DARB(target,
    820                                                                                                  lvl, tl->internalFormat,
    821                                                                                                  tl->width, tl->height,
    822                                                                                                  tl->border, tl->bytes, tl->img);
     858                                                                 lvl, tl->internalFormat,
     859                                                                 tl->width, tl->height,
     860                                                                 tl->border, tl->bytes, tl->img);
    823861                            }
    824862                            else {
    … …  
    829867                                diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
    830868                                diff_api.TexImage2D(target, lvl,
    831                                                                         tl->internalFormat,
    832                                                                         tl->width, tl->height, tl->border,
    833                                                                         tl->format, tl->type, tl->img);
     869                                                    tl->internalFormat,
     870                                                    tl->width, tl->height, tl->border,
     871                                                    tl->format, tl->type, tl->img);
    834872                            }
    835873                            if (!alwaysDirty)
     874                            {
    836875                                CLEARDIRTY(tl->dirty, nbitID);
     876                            }
     877#ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     878                            else
     879                            {
     880                                crFree(tl->img);
     881                                tl->img = NULL;
     882                            }
     883#endif
    837884                        }
    838885                    } /* for lvl */

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_teximage.c

    r16939 r16969  
    544544        tl->bytes = crImageSize(format, type, width, 1);
    545545
     546#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    546547    if (tl->bytes)
    547548    {
    … …  
    553554        {
    554555            crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY,
    555                                      "glTexImage1D out of memory");
     556                         "glTexImage1D out of memory");
    556557            return;
    557558        }
    558559        if (pixels)
    559560            crPixelCopy1D((GLvoid *) tl->img, format, type,
    560                                         pixels, format, type, width, &(c->unpack));
    561     }
     561                          pixels, format, type, width, &(c->unpack));
     562    }
     563#endif
    562564
    563565    tl->width = width;
    … …  
    594596void STATE_APIENTRY
    595597crStateTexImage2D(GLenum target, GLint level, GLint internalFormat,
    596                                     GLsizei width, GLsizei height, GLint border,
    597                                     GLenum format, GLenum type, const GLvoid * pixels)
     598                  GLsizei width, GLsizei height, GLint border,
     599                  GLenum format, GLenum type, const GLvoid * pixels)
    598600{
    599601    CRContext *g = GetCurrentContext();
    … …  
    639641    }
    640642
     643#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    641644    /* allocate the image buffer and fill it */
    642645    if (tl->bytes)
    … …  
    649652        {
    650653            crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY,
    651                                      "glTexImage2D out of memory");
     654                         "glTexImage2D out of memory");
    652655            return;
    653656        }
    … …  
    661664            {
    662665                crPixelCopy2D(width, height,
    663                                             (GLvoid *) tl->img, format, type, NULL, /* dst */
    664                                             pixels, format, type, &(c->unpack));    /* src */
     666                              (GLvoid *) tl->img, format, type, NULL, /* dst */
     667                              pixels, format, type, &(c->unpack));    /* src */
    665668            }
    666669        }
    667670    }
     671#endif
    668672
    669673    tl->width = width;
    … …  
    741745        tl->bytes = crTextureSize(format, type, width, height, depth);
    742746
     747#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    743748    if (tl->bytes)
    744749    {
    … …  
    750755        {
    751756            crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY,
    752                                      "glTexImage3D out of memory");
     757                         "glTexImage3D out of memory");
    753758            return;
    754759        }
    755760        if (pixels)
    756761            crPixelCopy3D(width, height, depth, (GLvoid *) (tl->img), format, type,
    757                                         NULL, pixels, format, type, &(c->unpack));
    758     }
     762                          NULL, pixels, format, type, &(c->unpack));
     763    }
     764#endif
    759765
    760766    tl->internalFormat = internalFormat;
    … …  
    820826    }
    821827
     828#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    822829    xoffset += tl->border;
    823830
    824831    crPixelCopy1D((void *) (tl->img + xoffset * tl->bytesPerPixel),
    825                                 tl->format, tl->type,
    826                                 pixels, format, type, width, &(c->unpack));
     832                  tl->format, tl->type,
     833                  pixels, format, type, width, &(c->unpack));
     834#endif
    827835
    828836#ifdef CR_SGIS_generate_mipmap
    … …  
    844852void STATE_APIENTRY
    845853crStateTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
    846                                          GLsizei width, GLsizei height,
    847                                          GLenum format, GLenum type, const GLvoid * pixels)
     854                     GLsizei width, GLsizei height,
     855                     GLenum format, GLenum type, const GLvoid * pixels)
    848856{
    849857    CRContext *g = GetCurrentContext();
    … …  
    855863    GLubyte *subimg = NULL;
    856864    GLubyte *img = NULL;
     865#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    857866    GLubyte *src;
    858867    int i;
     868#endif
    859869
    860870    FLUSH();
    … …  
    869879    CRASSERT(tl);
    870880
     881#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    871882    xoffset += tl->border;
    872883    yoffset += tl->border;
    873884
    874     subimg =
    875         (GLubyte *) crAlloc(crImageSize(tl->format, tl->type, width, height));
     885    subimg = (GLubyte *) crAlloc(crImageSize(tl->format, tl->type, width, height));
    876886
    877887    crPixelCopy2D(width, height, subimg, tl->format, tl->type, NULL,    /* dst */
    878                                 pixels, format, type, &(c->unpack));    /* src */
     888                  pixels, format, type, &(c->unpack));                  /* src */
    879889
    880890    img = tl->img +
    … …  
    892902
    893903    crFree(subimg);
     904#endif
    894905
    895906#ifdef CR_SGIS_generate_mipmap
    … …  
    925936    GLubyte *subimg = NULL;
    926937    GLubyte *img = NULL;
     938#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    927939    GLubyte *src;
    928940    int i;
     941#endif
    929942
    930943    FLUSH();
    … …  
    935948    }
    936949
     950#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    937951    xoffset += tl->border;
    938952    yoffset += tl->border;
    … …  
    944958
    945959    crPixelCopy3D(width, height, depth, subimg, tl->format, tl->type, NULL,
    946                                 pixels, format, type, &(c->unpack));
     960                  pixels, format, type, &(c->unpack));
    947961
    948962    img = tl->img + xoffset * tl->bytesPerPixel +
    … …  
    961975
    962976    crFree(subimg);
     977#endif
    963978
    964979#ifdef CR_SGIS_generate_mipmap
    … …  
    10141029        tl->bytes = imageSize;
    10151030
     1031#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    10161032    if (tl->bytes)
    10171033    {
    … …  
    10231039        {
    10241040            crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY,
    1025                                      "glTexImage1D out of memory");
     1041                         "glTexImage1D out of memory");
    10261042            return;
    10271043        }
    … …  
    10291045            crMemcpy(tl->img, data, imageSize);
    10301046    }
     1047#endif
    10311048
    10321049    tl->width = width;
    … …  
    10591076void STATE_APIENTRY
    10601077crStateCompressedTexImage2DARB(GLenum target, GLint level,
    1061                                                              GLenum internalFormat, GLsizei width,
    1062                                                              GLsizei height, GLint border,
    1063                                                              GLsizei imageSize, const GLvoid * data)
     1078                               GLenum internalFormat, GLsizei width,
     1079                               GLsizei height, GLint border,
     1080                               GLsizei imageSize, const GLvoid * data)
    10641081{
    10651082    CRContext *g = GetCurrentContext();
    … …  
    10921109        tl->bytes = imageSize;
    10931110
     1111#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    10941112    if (tl->bytes)
    10951113    {
    … …  
    11011119        {
    11021120            crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY,
    1103                                      "glTexImage2D out of memory");
     1121                         "glTexImage2D out of memory");
    11041122            return;
    11051123        }
    … …  
    11071125            crMemcpy(tl->img, data, imageSize);
    11081126    }
     1127#endif
    11091128
    11101129    tl->width = width;
    … …  
    11711190        tl->bytes = imageSize;
    11721191
     1192#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    11731193    if (tl->bytes)
    11741194    {
    … …  
    11801200        {
    11811201            crStateError(__LINE__, __FILE__, GL_OUT_OF_MEMORY,
    1182                                      "glCompressedTexImage3D out of memory");
     1202                         "glCompressedTexImage3D out of memory");
    11831203            return;
    11841204        }
    … …  
    11861206            crMemcpy(tl->img, data, imageSize);
    11871207    }
     1208#endif
    11881209
    11891210    tl->width = width;
    … …  
    12341255    }
    12351256
     1257#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    12361258    xoffset += tl->border;
    12371259
    … …  
    12421264    else {
    12431265        /* XXX this depends on the exact compression method */
    1244     }
     1266        crWarning("Not implemented part crStateCompressedTexSubImage1DARB");
     1267    }
     1268#endif
    12451269
    12461270#ifdef CR_SGIS_generate_mipmap
    … …  
    12811305    }
    12821306
     1307#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    12831308    xoffset += tl->border;
    12841309    yoffset += tl->border;
    12851310
    1286     if (xoffset == 0 && width == tl->width &&
    1287             yoffset == 0 && height == tl->height) {
     1311    if (xoffset == 0 && width == tl->width
     1312        && yoffset == 0 && height == tl->height)
     1313    {
    12881314        /* just memcpy */
    12891315        crMemcpy(tl->img, data, imageSize);
    … …  
    12911317    else {
    12921318        /* XXX this depends on the exact compression method */
    1293     }
     1319        crWarning("Not implemented part crStateCompressedTexSubImage2DARB");
     1320    }
     1321#endif
    12941322
    12951323#ifdef CR_SGIS_generate_mipmap
    … …  
    13311359    }
    13321360
     1361#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    13331362    xoffset += tl->border;
    13341363    yoffset += tl->border;
    … …  
    13361365
    13371366    if (xoffset == 0 && width == tl->width &&
    1338             yoffset == 0 && height == tl->height &&
    1339             zoffset == 0 && depth == tl->depth) {
     1367        yoffset == 0 && height == tl->height &&
     1368        zoffset == 0 && depth == tl->depth) {
    13401369        /* just memcpy */
    13411370        crMemcpy(tl->img, data, imageSize);
    … …  
    13431372    else {
    13441373        /* XXX this depends on the exact compression method */
    1345     }
     1374        crWarning("Not implemented part crStateCompressedTexSubImage3DARB");
     1375    }
     1376#endif
    13461377
    13471378#ifdef CR_SGIS_generate_mipmap
    … …  
    13881419    }
    13891420
     1421#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    13901422    crMemcpy(img, tl->img, tl->bytes);
     1423#else
     1424    diff_api.GetCompressedTexImageARB(target, level, img);
     1425#endif
    13911426}
    13921427
    … …  
    13941429void STATE_APIENTRY
    13951430crStateGetTexImage(GLenum target, GLint level, GLenum format,
    1396                                      GLenum type, GLvoid * pixels)
     1431                   GLenum type, GLvoid * pixels)
    13971432{
    13981433    CRContext *g = GetCurrentContext();
    … …  
    14531488    }
    14541489
     1490#ifndef CR_STATE_NO_TEXTURE_IMAGE_STORE
    14551491#ifdef CR_OPENGL_VERSION_1_2
    14561492    if (target == GL_TEXTURE_3D)
    14571493    {
    14581494        crPixelCopy3D(tl->width, tl->height, tl->depth, (GLvoid *) pixels, format,
    1459                                     type, NULL, (tl->img), format, type, &(c->pack));
     1495                      type, NULL, (tl->img), format, type, &(c->pack));
    14601496    }
    14611497    else
    14621498#endif
    1463     if ((target == GL_TEXTURE_2D) || (target == GL_TEXTURE_1D))
     1499    if ((target == GL_TEXTURE_1D) || (target == GL_TEXTURE_2D))
    14641500    {
    14651501        crPixelCopy2D(tl->width, tl->height, (GLvoid *) pixels, format, type, NULL, /* dst */
    1466                                     (tl->img), format, type, &(c->pack));   /* src */
    1467     }
    1468 }
     1502                      tl->img, format, type, &(c->pack));                           /* src */
     1503    }
     1504#else
     1505    diff_api.GetTexImage(target, level, format, type, pixels);
     1506#endif
     1507}
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