VirtualBox

Changeset 82101 in vbox for trunk


Ignore:
Timestamp:
Nov 22, 2019 1:19:41 PM (5 years ago)
Author:
vboxsync
Message:

Devices/Graphics: OpenGL backend: use glTexSubImage for uploading data to textures

Location:
trunk/src/VBox/Devices/Graphics
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

    r82095 r82101  
    11561156# define VMSVGA3D_PARANOID_TEXTURE_PACKING
    11571157
     1158/** @name VMSVGAPACKPARAMS_* - which packing parameters were set.
     1159 * @{ */
     1160# define VMSVGAPACKPARAMS_ALIGNMENT    RT_BIT_32(0)
     1161# define VMSVGAPACKPARAMS_ROW_LENGTH   RT_BIT_32(1)
     1162# define VMSVGAPACKPARAMS_IMAGE_HEIGHT RT_BIT_32(2)
     1163# define VMSVGAPACKPARAMS_SWAP_BYTES   RT_BIT_32(3)
     1164# define VMSVGAPACKPARAMS_LSB_FIRST    RT_BIT_32(4)
     1165# define VMSVGAPACKPARAMS_SKIP_ROWS    RT_BIT_32(5)
     1166# define VMSVGAPACKPARAMS_SKIP_PIXELS  RT_BIT_32(6)
     1167# define VMSVGAPACKPARAMS_SKIP_IMAGES  RT_BIT_32(7)
     1168/** @} */
     1169
    11581170/**
    11591171 * Saved texture packing parameters (shared by both pack and unpack).
     
    11611173typedef struct VMSVGAPACKPARAMS
    11621174{
     1175    uint32_t    fChanged;
    11631176    GLint       iAlignment;
    11641177    GLint       cxRow;
     1178    GLint       cyImage;
    11651179# ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
    1166     GLint       cyImage;
    11671180    GLboolean   fSwapBytes;
    11681181    GLboolean   fLsbFirst;
     
    11811194void vmsvga3dOglRestorePackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
    11821195                               PCVMSVGAPACKPARAMS pSave);
    1183 void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
     1196void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, GLint cxRow, GLint cyImage,
    11841197                                PVMSVGAPACKPARAMS pSave);
    1185 void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
     1198void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext,
    11861199                                    PCVMSVGAPACKPARAMS pSave);
    11871200
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp

    r82095 r82101  
    20292029int vmsvga3dSurfaceCopy(PVGASTATE pThis, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
    20302030{
     2031    int rc;
     2032
     2033    LogFunc(("Copy %d boxes from sid=%u face=%u mipmap=%u to sid=%u face=%u mipmap=%u\n",
     2034             cCopyBoxes, src.sid, src.face, src.mipmap, dest.sid, dest.face, dest.mipmap));
     2035
     2036    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
     2037    AssertReturn(pState, VERR_INVALID_STATE);
     2038
     2039    PVMSVGA3DSURFACE pSurfaceSrc;
     2040    rc = vmsvga3dSurfaceFromSid(pState, src.sid, &pSurfaceSrc);
     2041    AssertRCReturn(rc, rc);
     2042
     2043    PVMSVGA3DSURFACE pSurfaceDst;
     2044    rc = vmsvga3dSurfaceFromSid(pState, dest.sid, &pSurfaceDst);
     2045    AssertRCReturn(rc, rc);
     2046
     2047    if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceSrc))
     2048    {
     2049        /* The source surface is still in memory. */
     2050        PVMSVGA3DMIPMAPLEVEL pMipmapLevelSrc;
     2051        rc = vmsvga3dMipmapLevel(pSurfaceSrc, src.face, src.mipmap, &pMipmapLevelSrc);
     2052        AssertRCReturn(rc, rc);
     2053
     2054        PVMSVGA3DMIPMAPLEVEL pMipmapLevelDst;
     2055        rc = vmsvga3dMipmapLevel(pSurfaceDst, dest.face, dest.mipmap, &pMipmapLevelDst);
     2056        AssertRCReturn(rc, rc);
     2057
     2058        /* The copy operation is performed on the shared context. */
     2059        PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
     2060        VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
     2061
     2062        /* Use glTexSubImage to upload the data to the destination texture.
     2063         * The latter must be an OpenGL texture.
     2064         */
     2065        if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceDst))
     2066        {
     2067            LogFunc(("dest sid=%u type=0x%x format=%d -> create texture\n", dest.sid, pSurfaceDst->surfaceFlags, pSurfaceDst->format));
     2068            rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSurfaceDst);
     2069            AssertRCReturn(rc, rc);
     2070        }
     2071
     2072        GLenum target;
     2073        if (pSurfaceDst->targetGL == GL_TEXTURE_CUBE_MAP)
     2074            target = vmsvga3dCubemapFaceFromIndex(dest.face);
     2075        else
     2076        {
     2077            AssertMsg(pSurfaceDst->targetGL == GL_TEXTURE_2D, ("Test %#x\n", pSurfaceDst->targetGL));
     2078            target = pSurfaceDst->targetGL;
     2079        }
     2080
     2081        /* Save the unpacking parameters and set what we need here. */
     2082        VMSVGAPACKPARAMS SavedParams;
     2083        vmsvga3dOglSetUnpackParams(pState, pContext,
     2084                                   pMipmapLevelSrc->mipmapSize.width,
     2085                                   target == GL_TEXTURE_3D ? pMipmapLevelSrc->mipmapSize.height : 0,
     2086                                   &SavedParams);
     2087
     2088        glBindTexture(pSurfaceDst->targetGL, pSurfaceDst->oglId.texture);
     2089        VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
     2090
     2091        for (uint32_t i = 0; i < cCopyBoxes; ++i)
     2092        {
     2093            SVGA3dCopyBox clipBox = pBox[i];
     2094            vmsvgaR3ClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDst->mipmapSize, &clipBox);
     2095            if (   !clipBox.w
     2096                || !clipBox.h
     2097                || !clipBox.d)
     2098            {
     2099                LogFunc(("Skipped empty box.\n"));
     2100                continue;
     2101            }
     2102
     2103            LogFunc(("copy box %d,%d,%d %dx%d to %d,%d,%d\n",
     2104                     clipBox.srcx, clipBox.srcy, clipBox.srcz, clipBox.w, clipBox.h, clipBox.x, clipBox.y, clipBox.z));
     2105
     2106            uint32_t const u32BlockX = clipBox.srcx / pSurfaceSrc->cxBlock;
     2107            uint32_t const u32BlockY = clipBox.srcy / pSurfaceSrc->cyBlock;
     2108            uint32_t const u32BlockZ = clipBox.srcz;
     2109            Assert(u32BlockX * pSurfaceSrc->cxBlock == clipBox.srcx);
     2110            Assert(u32BlockY * pSurfaceSrc->cyBlock == clipBox.srcy);
     2111
     2112            uint8_t const *pSrcBits = (uint8_t *)pMipmapLevelSrc->pSurfaceData
     2113                + pMipmapLevelSrc->cbSurfacePlane * u32BlockZ
     2114                + pMipmapLevelSrc->cbSurfacePitch * u32BlockY
     2115                + pSurfaceSrc->cbBlock * u32BlockX;
     2116
     2117            if (target == GL_TEXTURE_3D)
     2118            {
     2119                if (   pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
     2120                    || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
     2121                    || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
     2122                {
     2123                    pState->ext.glCompressedTexSubImage3D(target, dest.mipmap,
     2124                                                          clipBox.x, clipBox.y, clipBox.z,
     2125                                                          clipBox.w, clipBox.h, clipBox.d,
     2126                                                          pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
     2127                    VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
     2128                }
     2129                else
     2130                {
     2131                    pState->ext.glTexSubImage3D(target, dest.mipmap,
     2132                                                clipBox.x, clipBox.y, clipBox.z,
     2133                                                clipBox.w, clipBox.h, clipBox.d,
     2134                                                pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
     2135                    VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
     2136                }
     2137            }
     2138            else
     2139            {
     2140                if (   pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
     2141                    || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
     2142                    || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
     2143                {
     2144                    pState->ext.glCompressedTexSubImage2D(target, dest.mipmap,
     2145                                                          clipBox.x, clipBox.y, clipBox.w, clipBox.h,
     2146                                                          pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
     2147                    VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
     2148                }
     2149                else
     2150                {
     2151                    glTexSubImage2D(target, dest.mipmap,
     2152                                    clipBox.x, clipBox.y, clipBox.w, clipBox.h,
     2153                                    pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
     2154                    VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
     2155                }
     2156            }
     2157        }
     2158
     2159        glBindTexture(pSurfaceDst->targetGL, 0);
     2160        VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
     2161
     2162        vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
     2163
     2164        return VINF_SUCCESS;
     2165    }
     2166
    20312167    for (uint32_t i = 0; i < cCopyBoxes; i++)
    20322168    {
     
    20482184
    20492185        /* No stretching is required, therefore use SVGA3D_STRETCH_BLT_POINT which translated to GL_NEAREST. */
    2050         int rc = vmsvga3dSurfaceStretchBlt(pThis, &dest, &destBox, &src, &srcBox, SVGA3D_STRETCH_BLT_POINT);
     2186        rc = vmsvga3dSurfaceStretchBlt(pThis, &dest, &destBox, &src, &srcBox, SVGA3D_STRETCH_BLT_POINT);
    20512187        AssertRCReturn(rc, rc);
    20522188    }
     
    20562192
    20572193/**
    2058  * Save texture unpacking parameters and loads those appropriate for the given
    2059  * surface.
     2194 * Saves texture unpacking parameters and loads the specified ones.
    20602195 *
    20612196 * @param   pState              The VMSVGA3D state structure.
    20622197 * @param   pContext            The active context.
    2063  * @param   pSurface            The surface.
     2198 * @param   cxRow               The number of pixels in a row. 0 for the entire width.
     2199 * @param   cyImage             The height of the image in pixels. 0 for the entire height.
    20642200 * @param   pSave               Where to save stuff.
    20652201 */
    2066 void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
     2202void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, GLint cxRow, GLint cyImage,
    20672203                                PVMSVGAPACKPARAMS pSave)
    20682204{
     
    20762212    pSave->cxRow = 0;
    20772213    VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_ROW_LENGTH, &pSave->cxRow), pState, pContext);
     2214    pSave->cyImage = 0;
     2215    VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &pSave->cyImage), pState, pContext);
    20782216
    20792217#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
    2080     pSave->cyImage = 0;
    2081     glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &pSave->cyImage);
    2082     Assert(pSave->cyImage == 0);
    2083 
    20842218    pSave->fSwapBytes = GL_FALSE;
    20852219    glGetBooleanv(GL_UNPACK_SWAP_BYTES, &pSave->fSwapBytes);
     
    21112245     *       aligning of line pitches anywhere.
    21122246     */
    2113     NOREF(pSurface);
     2247    pSave->fChanged = 0;
    21142248    if (pSave->iAlignment != 1)
     2249    {
    21152250        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1), pState, pContext);
    2116     if (pSave->cxRow != 0)
    2117         VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, 0), pState, pContext);
     2251        pSave->fChanged |= VMSVGAPACKPARAMS_ALIGNMENT;
     2252    }
     2253    if (pSave->cxRow != cxRow)
     2254    {
     2255        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, cxRow), pState, pContext);
     2256        pSave->fChanged |= VMSVGAPACKPARAMS_ROW_LENGTH;
     2257    }
     2258    if (pSave->cyImage != cyImage)
     2259    {
     2260        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, cyImage), pState, pContext);
     2261        pSave->fChanged |= VMSVGAPACKPARAMS_IMAGE_HEIGHT;
     2262    }
    21182263#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
    2119     if (pSave->cyImage != 0)
    2120         VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0), pState, pContext);
    21212264    if (pSave->fSwapBytes != 0)
     2265    {
    21222266        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE), pState, pContext);
     2267        pSave->fChanged |= VMSVGAPACKPARAMS_SWAP_BYTES;
     2268    }
    21232269    if (pSave->fLsbFirst != 0)
     2270    {
    21242271        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE), pState, pContext);
     2272        pSave->fChanged |= VMSVGAPACKPARAMS_LSB_FIRST;
     2273    }
    21252274    if (pSave->cSkipRows != 0)
     2275    {
    21262276        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS, 0), pState, pContext);
     2277        pSave->fChanged |= VMSVGAPACKPARAMS_SKIP_ROWS;
     2278    }
    21272279    if (pSave->cSkipPixels != 0)
     2280    {
    21282281        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0), pState, pContext);
     2282        pSave->fChanged |= VMSVGAPACKPARAMS_SKIP_PIXELS;
     2283    }
    21292284    if (pSave->cSkipImages != 0)
     2285    {
    21302286        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0), pState, pContext);
     2287        pSave->fChanged |= VMSVGAPACKPARAMS_SKIP_IMAGES;
     2288    }
    21312289#endif
    21322290}
     
    21382296 * @param   pState              The VMSVGA3D state structure.
    21392297 * @param   pContext            The active context.
    2140  * @param   pSurface            The surface.
    21412298 * @param   pSave               Where stuff was saved.
    21422299 */
    2143 void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
     2300void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext,
    21442301                                    PCVMSVGAPACKPARAMS pSave)
    21452302{
    2146     RT_NOREF(pState, pSurface);
    2147 
    2148     if (pSave->iAlignment != 1)
     2303    RT_NOREF(pState);
     2304
     2305    if (pSave->fChanged & VMSVGAPACKPARAMS_ALIGNMENT)
    21492306        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, pSave->iAlignment), pState, pContext);
    2150     if (pSave->cxRow != 0)
     2307    if (pSave->fChanged & VMSVGAPACKPARAMS_ROW_LENGTH)
    21512308        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, pSave->cxRow), pState, pContext);
     2309    if (pSave->fChanged & VMSVGAPACKPARAMS_IMAGE_HEIGHT)
     2310        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, pSave->cyImage), pState, pContext);
    21522311#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
    2153     if (pSave->cyImage != 0)
    2154         VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, pSave->cyImage), pState, pContext);
    2155     if (pSave->fSwapBytes != 0)
     2312    if (pSave->fChanged & VMSVGAPACKPARAMS_SWAP_BYTES)
    21562313        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SWAP_BYTES, pSave->fSwapBytes), pState, pContext);
    2157     if (pSave->fLsbFirst != 0)
     2314    if (pSave->fChanged & VMSVGAPACKPARAMS_LSB_FIRST)
    21582315        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_LSB_FIRST, pSave->fLsbFirst), pState, pContext);
    2159     if (pSave->cSkipRows != 0)
     2316    if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_ROWS)
    21602317        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS, pSave->cSkipRows), pState, pContext);
    2161     if (pSave->cSkipPixels != 0)
     2318    if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_PIXELS)
    21622319        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS, pSave->cSkipPixels), pState, pContext);
    2163     if (pSave->cSkipImages != 0)
     2320    if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_IMAGES)
    21642321        VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_IMAGES, pSave->cSkipImages), pState, pContext);
    21652322#endif
     
    22352392    /* Set the unpacking parameters. */
    22362393    VMSVGAPACKPARAMS SavedParams;
    2237     vmsvga3dOglSetUnpackParams(pState, pContext, pSurface, &SavedParams);
     2394    vmsvga3dOglSetUnpackParams(pState, pContext, 0, 0, &SavedParams);
    22382395
    22392396    /** @todo Set the mip map generation filter settings. */
     
    24342591
    24352592    /* Restore unpacking parameters. */
    2436     vmsvga3dOglRestoreUnpackParams(pState, pContext, pSurface, &SavedParams);
     2593    vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
    24372594
    24382595    /* Restore the old active texture. */
     
    27932950
    27942951            /* Set row length and alignment of the input data. */
     2952            /* We do not need to set ROW_LENGTH to w here, because the image in pDoubleBuffer is tightly packed. */
    27952953            VMSVGAPACKPARAMS SavedParams;
    2796             vmsvga3dOglSetUnpackParams(pState, pContext, pSurface, &SavedParams); /** @todo do we need to set ROW_LENGTH to w here? */
     2954            vmsvga3dOglSetUnpackParams(pState, pContext, 0, 0, &SavedParams);
    27972955
    27982956            if (texImageTarget == GL_TEXTURE_3D)
     
    28683026
    28693027            /* Restore old values. */
    2870             vmsvga3dOglRestoreUnpackParams(pState, pContext, pSurface, &SavedParams);
     3028            vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
    28713029
    28723030            /* Restore the old active texture. */
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