Creating functions for uploading a mipmapped texture.

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGr.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
+#include "SkMath.h"
+#include "SkMipMapLevel.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
+#include "SkTypes.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrDitherEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 #include "effects/GrYUVtoRGBEffect.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "ktx.h"
@@ skipping 239 matching lines @@
         explicit Invalidator(const GrUniqueKey& key) : fMsg(key) {}
     private:
         GrUniqueKeyInvalidatedMessage fMsg;
 
         void onChange() override { SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg); }
     };
 
     pixelRef->addGenIDChangeListener(new Invalidator(key));
 }
 
+GrTexture* GrGenerateMipMapsAndUploadToTexture(GrContext* ctx, const SkBitmap& bitmap)
+{
+    GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap.info());
+    if (kIndex_8_SkColorType != bitmap.colorType() && !bitmap.readyToDraw()) {
+        GrTexture *texture = load_etc1_texture(ctx, bitmap, desc);
+        if (texture) {
+            return texture;
+        }
+    }
+
+    GrTexture *texture = create_texture_from_yuv(ctx, bitmap, desc);
+    if (texture) {
+        return texture;
+    }
+
+    SkASSERT(sizeof(int) <= sizeof(uint32_t));
+    if (bitmap.width() < 0 || bitmap.height() < 0) {
+        return nullptr;
+    }
+    const uint32_t baseWidth = static_cast<uint32_t>(bitmap.width());
+    const uint32_t baseHeight = static_cast<uint32_t>(bitmap.height());
+
+    // OpenGL's spec requires that each mipmap level have height/width equal to
+    // max(1, floor(original_height / 2^i)
+    // (or original_width) where i is the mipmap level.
+    // Continue scaling down until both axes are size 1.
+
+    const uint32_t largestAxis = SkTMax(baseWidth, baseHeight);
+    const int leadingZeros = SkCLZ(largestAxis);
+    // If the value 00011010 has 3 leading 0s then it has 5 significant bits
+    // (the bits which are not leading zeros)
+    const int significantBits = (sizeof(uint32_t) * 8) - leadingZeros;
+    // This is making the assumption that the size of a byte is 8 bits
+    // and that sizeof(uint32_t)'s implementation-defined behavior is 4.
+    if (significantBits < 0) {
+        return nullptr;
+    }
+    const int mipLevelCount = significantBits;
+
+    const bool isMipMapped = mipLevelCount > 1;
+    desc.fIsMipMapped = isMipMapped;
+
+    SkTArray<SkBitmap> mipLevelBitmaps(mipLevelCount - 1);
+    mipLevelBitmaps.push_back_n(mipLevelCount - 1);
+
+    SkTArray<SkMipMapLevel> texels(mipLevelCount);
+
+    SkAutoLockPixels alp(bitmap);
+    if (!bitmap.readyToDraw()) {
+        return nullptr;
+    }
+
+    SkMipMapLevel baseLevel(bitmap.getPixels(), bitmap.rowBytes(), baseWidth, baseHeight);
+    texels.push_back(baseLevel);
+
+    SkPaint paint;
+    paint.setFilterQuality(kMedium_SkFilterQuality);
+
+    for (int i = 1; i < mipLevelCount; i++) {
+        SkBitmap& currentMipBitmap = mipLevelBitmaps[i - 1];
+
+        uint32_t twoToTheMipLevel = 1 << i;
+        uint32_t currentMipLevelWidth = SkTMax(1u, baseWidth / twoToTheMipLevel);
+        uint32_t currentMipLevelHeight = SkTMax(1u, baseHeight / twoToTheMipLevel);
+
+        SkImageInfo info = SkImageInfo::Make(currentMipLevelWidth, currentMipLevelHeight,
+                                             bitmap.colorType(), bitmap.alphaType());
+        if (!currentMipBitmap.tryAllocPixels(info)) {
+            return nullptr;
+        }
+
+        SkCanvas canvas(currentMipBitmap);
+        canvas.clear(SK_ColorTRANSPARENT);
+
+        SkMatrix matrix;
+        matrix.setScale(static_cast<float>(currentMipLevelWidth) / baseWidth,
+                        static_cast<float>(currentMipLevelHeight) / baseHeight);
+        canvas.save();
+        canvas.concat(matrix);
+        canvas.drawBitmap(bitmap, SkIntToScalar(0), SkIntToScalar(0), &paint);

[bsalomon, 2016/01/14 13:57:23]

Mike pointed out to me that this will generate MIP maps in the CPU backend in
order to create MIP maps for the GPU backend :)

I'm not sure Mike is still following the details on this Issue. Could you
contact him to figure out the best way to generate the SkMipMapLevels using the
cpu backend toolkit?

[Chris Blume, 2016/01/20 06:15:08]

I talked to Mike, asking for clarification on the CPU v. GPU issue. I added that
for Chrome, we specifically wanted to not use GPU (like how we were previously
calling glGenerateMipmap and blocking the critical GPU thread). Mike clarified
that (I believe, he can correct me) it was more to do with SkCanvas calls and
not using SkMipMap.

I had explained that we previously used SkMipMap but found two things: 1.) the
resulting image quality wasn't the quality we wanted, and 2.) the dimensions
didn't match what OpenGL required.

I believe #1 was actually because of a bug in my code. I had fixed the bug after
moving away from SkMipMap. So #1 might actually be okay.

So I reran dm --src gm with some SkMipMap code in place to see the dimensions
generated. And it turns out the dimensions are correct for what OpenGL would
want. I am unsure if 1.) I simply measured wrong originally or recalled
incorrectly, or 2.) the dimension issue has been fixed, or 3.) (the scary one) a
test which exposed bad dimensions may have been fixed to no longer expose the
problem. Right now, I'm leaning towards #1. Things seem good.

So I put the SkMipMap code back in. It is working well on my local machine, with
good quality images. We can look at Gold to see if the other platforms look good
as well. I believe they will.

+        canvas.restore();
+
+        SkMipMapLevel currentMipLevel(currentMipBitmap.getPixels(),
+                                      currentMipBitmap.rowBytes(),
+                                      currentMipLevelWidth, currentMipLevelHeight);
+        texels.push_back(currentMipLevel);
+    }
+
+    return ctx->textureProvider()->createTexture(desc, true, texels);
+}
+
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
                                     const GrTextureParams& params) {
     if (bitmap.getTexture()) {
         return GrBitmapTextureAdjuster(&bitmap).refTextureSafeForParams(params, nullptr);
     }
     return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 329 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }