Creating functions for uploading a mipmapped texture.

src/gpu/GrContext.cpp

-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "GrContextOptions.h"
 #include "GrDrawingManager.h"
 #include "GrDrawContext.h"
 #include "GrLayerCache.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrSurfacePriv.h"
 #include "GrTextBlobCache.h"
 
 #include "SkConfig8888.h"
 #include "SkGrPriv.h"
+#include "SkTypes.h"
 
 #include "effects/GrConfigConversionEffect.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 #define RETURN_IF_ABANDONED if (fDrawingManager->abandoned()) { return; }
 #define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->abandoned()) { return false; }
 #define RETURN_NULL_IF_ABANDONED if (fDrawingManager->abandoned()) { return nullptr; }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 185 matching lines @@
     dstPI.fColorType = srcPI.fColorType;
     dstPI.fAlphaType = kPremul_SkAlphaType;
     dstPI.fPixels = outPixels;
     dstPI.fRowBytes = outRowBytes;
 
     return srcPI.convertPixelsTo(&dstPI, width, height);
 }
 
 bool GrContext::writeSurfacePixels(GrSurface* surface,
                                    int left, int top, int width, int height,
-                                   GrPixelConfig srcConfig, const void* buffer, size_t rowBytes,
+                                   GrPixelConfig srcConfig, const SkTArray<SkMipMapLevel>& texels,
                                    uint32_t pixelOpsFlags) {
     RETURN_FALSE_IF_ABANDONED
     ASSERT_OWNED_RESOURCE(surface);
     SkASSERT(surface);
 
+    SkTArray<SkMipMapLevel> texelsCopy(texels);
+
     this->testPMConversionsIfNecessary(pixelOpsFlags);
 
     // Trim the params here so that if we wind up making a temporary surface it can be as small as
     // necessary and because GrGpu::getWritePixelsInfo requires it.
-    if (!GrSurfacePriv::AdjustWritePixelParams(surface->width(), surface->height(),
-                                               GrBytesPerPixel(srcConfig), &left, &top, &width,
-                                               &height, &buffer, &rowBytes)) {
-        return false;
+    for (int currentMipLevel = texelsCopy.count() - 1; currentMipLevel >= 0; currentMipLevel--) {
+        // make sure the texelmap's size range is within int range
+        if (texelsCopy[currentMipLevel].fWidth > SK_MaxS32
+            || texelsCopy[currentMipLevel].fHeight > SK_MaxS32) {

[bsalomon, 2015/10/28 16:40:44]

|| on prev line

Does SkMipMapLevel need to use uints for sizes? We generally use signed ints for
widths and heights and it seems like SkMipMapLevel should fall in line unless
there is a reason for it to disagree.

[cblume, 2015/10/28 22:49:40]

Okay, I'll make them ints and remove the range checks.

+            return false;
+        }
+        int currentMipWidth = texelsCopy[currentMipLevel].fWidth;
+        int currentMipHeight = texelsCopy[currentMipLevel].fHeight;
+
+        SkMipMapLevel& currentMipMap = texelsCopy[currentMipLevel];
+        if (!GrSurfacePriv::AdjustWritePixelParams(surface->width(), surface->height(),
+                                                   GrBytesPerPixel(srcConfig), &left, &top,
+                                                   &currentMipWidth, &currentMipHeight,
+                                                   &currentMipMap.fTexels,
+                                                   &currentMipMap.fRowBytes)) {
+            return false;
+        }
+
+        // make sure the size range is within the texelmap's size range
+        if (currentMipWidth < 0 || currentMipHeight < 0) {
+            return false;
+        }
+        texelsCopy[currentMipLevel].fWidth = currentMipWidth;
+        texelsCopy[currentMipLevel].fHeight = currentMipHeight;
     }
 
     bool applyPremulToSrc = false;
     if (kUnpremul_PixelOpsFlag & pixelOpsFlags) {
         if (!GrPixelConfigIs8888(srcConfig)) {
             return false;
         }
         applyPremulToSrc = true;
     }
 
     GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
     // Don't prefer to draw for the conversion (and thereby access a texture from the cache) when
     // we've already determined that there isn't a roundtrip preserving conversion processor pair.
     if (applyPremulToSrc && !this->didFailPMUPMConversionTest()) {
         drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
     }
 
     GrGpu::WritePixelTempDrawInfo tempDrawInfo;
-    if (!fGpu->getWritePixelsInfo(surface, width, height, rowBytes, srcConfig, &drawPreference,
+    if (!fGpu->getWritePixelsInfo(surface, width, height, srcConfig, &drawPreference,
                                   &tempDrawInfo)) {
         return false;
     }
 
     if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && surface->surfacePriv().hasPendingIO()) {
         this->flush();
     }
 
     SkAutoTUnref<GrTexture> tempTexture;
     if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
@@ skipping 35 matching lines @@
                 if (!fp) {
                     return false;
                 }
             }
             GrRenderTarget* renderTarget = surface->asRenderTarget();
             SkASSERT(renderTarget);
             if (tempTexture->surfacePriv().hasPendingIO()) {
                 this->flush();
             }
             if (applyPremulToSrc) {
-                size_t tmpRowBytes = 4 * width;
-                tmpPixels.reset(width * height);
-                if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
-                                          tmpPixels.get())) {
-                    return false;
+                for (int currentMipLevel = texelsCopy.count() - 1; currentMipLevel >= 0;
+                     currentMipLevel--) {
+                    SkMipMapLevel& currentMipMap = texelsCopy[currentMipLevel];
+                    int currentWidth = currentMipMap.fWidth;
+                    int currentHeight = currentMipMap.fHeight;
+                    size_t tmpRowBytes = 4 * currentWidth;
+                    tmpPixels.reset(currentWidth * currentHeight);
+                    if (!sw_convert_to_premul(srcConfig, currentWidth, currentHeight,
+                                              currentMipMap.fRowBytes,
+                                              currentMipMap.fTexels, tmpRowBytes,
+                                              tmpPixels.get())) {
+                        return false;
+                    }
+                    currentMipMap.fRowBytes = tmpRowBytes;
+                    currentMipMap.fTexels = tmpPixels.get();
                 }
-                rowBytes = tmpRowBytes;
-                buffer = tmpPixels.get();
                 applyPremulToSrc = false;
             }
             if (!fGpu->writePixels(tempTexture, 0, 0, width, height,
-                                   tempDrawInfo.fTempSurfaceDesc.fConfig, buffer,
-                                   rowBytes)) {
+                                   tempDrawInfo.fTempSurfaceDesc.fConfig, texelsCopy)) {
                 return false;
             }
             SkMatrix matrix;
             matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
             SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(renderTarget));
             if (!drawContext) {
                 return false;
             }
             paint.addColorFragmentProcessor(fp);
             SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
             drawContext->drawRect(GrClip::WideOpen(), paint, matrix, rect, nullptr);

[bsalomon, 2015/10/28 16:40:44]

Seems like we will populate a mip chain on the temp texture and then do a draw
just to the base of the destination texture. I don't think the upper levels of
the dst will be updated.  Maybe we need a test to cover this.

Actually I take that back. The draw will dirty the upper levels on the dst,
causing us to call glGenerateMipMaps() which is what we're trying to avoid here.

I'm not exactly sure how to handle this without a lot more complication to this
change (binding each level of the dst as an fbo and drawing to them one by one).
Maybe this is the right long term approach but there would be a fair amount of
plumbing work to get that hooked up.

Perhaps GrContext::writeSurfacePixels shouldn't expose explicit mip level source
pixels for now? I don't think it affects the use case of sw-backed
SkBitmap/SkImages *if* we make GrTextureProvider always create a new texture
when the source data contains levels beyond 0 instead of the current behavior of
attempting to grab a scratch texture and calling writeSurfacePixels on it. Would
that work?

In light of comments I made below another approach would be to check whether the
caller gave us multiple levels. If so we only use a temp texture if the
drawPreference is kRequire (which should be rare) and document that in some
cases we will ignore the caller's upper levels and generate them in the 3D API.
(kRequire indicates that the underlying API [GL] doesn't support directly
uploading the level data to the texture because of API/extension restrictions so
we have to do some gymnastics by going through a temp, kPrefer indicates that
performance is better if we use a temp but it can be done without one).

[cblume, 2015/10/28 22:49:40]

You are correct. In this case, it populates the mip chain on the temp texture
then renders to the base level of the render target.

IIRC we had talked about any time we have a render target destination we would
prefer to call glGenerateMipMaps to prevent reading the texture back out to the
CPU. I think we wanted to avoid the call to glGenerateMipMaps if we could but in
the case of a render target we couldn't. I think I like the idea of documenting
that mip levels other than 0 will be ignored if we are using the temp texture.

I am okay with making GrTextureProvider always create a new texture when there
are more than the base mip level provided. It is unlikely that there will be a
texture that can be reused in those cases anyway. All the extra work is for the
case when a mipmapped texture is reused, right? So if we feel that it is
unlikely to be reused we might save a lot of trouble.

 
             if (kFlushWrites_PixelOp & pixelOpsFlags) {
                 this->flushSurfaceWrites(surface);
             }
         }
     }
     if (!tempTexture) {
         if (applyPremulToSrc) {
-            size_t tmpRowBytes = 4 * width;
-            tmpPixels.reset(width * height);
-            if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
-                                      tmpPixels.get())) {
-                return false;
+            for (int currentMipLevel = texelsCopy.count() - 1; currentMipLevel >= 0;
+                 currentMipLevel--) {
+                SkMipMapLevel& currentMipMap = texelsCopy[currentMipLevel];
+                int currentMipWidth = currentMipMap.fWidth;
+                int currentMipHeight = currentMipMap.fHeight;
+                size_t tmpRowBytes = 4 * currentMipWidth;
+                tmpPixels.reset(currentMipWidth * currentMipHeight);
+                if (!sw_convert_to_premul(srcConfig, currentMipWidth, currentMipHeight,
+                                          currentMipMap.fRowBytes, currentMipMap.fTexels,
+                                          tmpRowBytes, tmpPixels.get())) {
+                    return false;
+                }
+                currentMipMap.fRowBytes = tmpRowBytes;
+                currentMipMap.fTexels = tmpPixels.get();
             }
-            rowBytes = tmpRowBytes;
-            buffer = tmpPixels.get();
             applyPremulToSrc = false;
         }
-        return fGpu->writePixels(surface, left, top, width, height, srcConfig, buffer, rowBytes);
+        return fGpu->writePixels(surface, left, top, width, height, srcConfig, texelsCopy);
     }
     return true;
 }
 
+bool GrContext::writeSurfacePixels(GrSurface* surface,
+                                   int left, int top, int width, int height,
+                                   GrPixelConfig srcConfig, const void* buffer, size_t rowBytes,
+                                   uint32_t pixelOpsFlags) {
+    if (width <= 0 || height <= 0) {
+        return false;
+    }
+    const uint32_t baseLevelWidth = width;
+    const uint32_t baseLevelHeight = height;
+
+    SkMipMapLevel level(buffer, rowBytes, baseLevelWidth, baseLevelHeight);
+    const int mipLevelCount = 1;
+    SkTArray<SkMipMapLevel> texels(mipLevelCount);
+    texels.push_back(level);
+
+    return this->writeSurfacePixels(surface, left, top, width, height, srcConfig, texels,
+                                    pixelOpsFlags);
+}
+
 bool GrContext::readSurfacePixels(GrSurface* src,
                                   int left, int top, int width, int height,
                                   GrPixelConfig dstConfig, void* buffer, size_t rowBytes,
                                   uint32_t flags) {
     RETURN_FALSE_IF_ABANDONED
     ASSERT_OWNED_RESOURCE(src);
     SkASSERT(src);
 
     this->testPMConversionsIfNecessary(flags);
     SkAutoMutexAcquire ama(fReadPixelsMutex);
@@ skipping 294 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }