Store mipmap levels in deferred texture image

gm/deferredtextureimage.cpp

Index: gm/deferredtextureimage.cpp
diff --git a/gm/deferredtextureimage.cpp b/gm/deferredtextureimage.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2d3cb1e8be70a45cede3d8616ebb66d19ff42aa2
--- /dev/null
+++ b/gm/deferredtextureimage.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include <vector>
+
+#include "gm.h"
+#include "GrContext.h"
+#include "SkMipMap.h"
+#include "Resources.h"
+
+#if SK_SUPPORT_GPU
+
+class DeferredTextureImage_Medium : public skiagm::GM {

[bsalomon, 2016/07/29 14:12:35]

Should we replace the existing deferred_image_data GM with this one? Seems like
they are overlapping quite a bit. This one uses a more sensible image. It seems
like if we added an encoded image case here it would do everything the other GM
does.

[cblume, 2016/07/29 20:14:13]

I was planning to integrate the two somehow.
This test is specific to mipmaps, showing the tree.
I would be happy to add the other qualities here and an encoded image. Although,
since they test different things (this one is specifically testing that the
mipmaps are generated and serialized and deserialized in that different code
path) it would mostly just be merging the files, right?

[cblume, 2016/07/30 02:28:40]

I merged the two and added unit tests for low / high qualities. The tests now
use the mandrill image as well.

+protected:
+    SkString onShortName() override {
+        return SkString("deferredtextureimage_medium");
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(512 + 512 + 30, 1110);
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        GrContext* context = canvas->getGrContext();
+        if (!context) {
+            skiagm::GM::DrawGpuOnlyMessage(canvas);
+            return;
+        }
+        SkAutoTUnref<GrContextThreadSafeProxy> proxy(context->threadSafeProxy());
+
+        SkPaint paint;
+        paint.setFilterQuality(kMedium_SkFilterQuality);
+
+        int mipLevelCount = SkMipMap::ComputeLevelCount(512, 512);
+
+        // create the deferred texture image
+        SkImage::DeferredTextureImageUsageParams params[1];
+        // These should cause mipmaps to be generated
+        params[0].fMatrix = SkMatrix::MakeScale(0.25f, 0.25f);
+        params[0].fQuality = kMedium_SkFilterQuality;
+        size_t requiredMemoryInBytes = fDecodedImage->getDeferredTextureImageData(
+            *proxy, params, 1, nullptr, SkSourceGammaTreatment::kRespect);
+        if (requiredMemoryInBytes == 0) {
+            SkDebugf("\nCould not create DeferredTextureImageData.\n");
+            return;
+        }
+
+        std::vector<uint8_t> memory;
+        memory.resize(requiredMemoryInBytes);
+        fDecodedImage->getDeferredTextureImageData(
+            *proxy, params, 1, memory.data(), SkSourceGammaTreatment::kRespect);
+        sk_sp<SkImage> uploadedImage = SkImage::MakeFromDeferredTextureImageData(
+            context, memory.data(), SkBudgeted::kNo);
+
+        // draw a column using deferred texture images
+        SkScalar offsetHeight = 10.f;
+        // handle base mipmap level
+        canvas->save();
+        canvas->translate(10.f, offsetHeight);
+        canvas->drawImage(uploadedImage, 0, 0, &paint);
+        canvas->restore();
+        offsetHeight += 512 + 10;
+        // handle generated mipmap levels
+        for (int i = 0; i < mipLevelCount; i++) {
+            SkISize mipSize = SkMipMap::ComputeLevelSize(512, 512, i);
+            canvas->save();
+            canvas->translate(10.f, offsetHeight);
+            canvas->scale(mipSize.width() / 512.f, mipSize.height() / 512.f);
+            canvas->drawImage(uploadedImage, 0, 0, &paint);
+            canvas->restore();
+            offsetHeight += mipSize.height() + 10;
+        }
+
+        // draw a column using SkImage
+        offsetHeight = 10;
+        // handle base mipmap level
+        canvas->save();
+        canvas->translate(512.f + 20.f, offsetHeight);
+        canvas->drawImage(fDecodedImage, 0, 0, &paint);
+        canvas->restore();
+        offsetHeight += 512 + 10;
+        // handle generated mipmap levels
+        for (int i = 0; i < mipLevelCount; i++) {
+            SkISize mipSize = SkMipMap::ComputeLevelSize(512, 512, i);
+            canvas->save();
+            canvas->translate(512.f + 20.f, offsetHeight);
+            canvas->scale(mipSize.width() / 512.f, mipSize.height() / 512.f);
+            canvas->drawImage(fDecodedImage, 0, 0, &paint);
+            canvas->restore();
+            offsetHeight += mipSize.height() + 10;
+        }
+    }
+
+private:
+
+    void onOnceBeforeDraw() override {
+        SkBitmap bitmap;
+        if (!GetResourceAsBitmap("mandrill_512.png", &bitmap)) {
+            bitmap.allocN32Pixels(1, 1);
+            bitmap.eraseARGB(255, 255, 0, 0); // red == bad
+        }
+        fDecodedImage = SkImage::MakeFromBitmap(bitmap);
+    }
+
+    sk_sp<SkImage> fDecodedImage;
+
+    typedef skiagm::GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+DEF_GM( return new DeferredTextureImage_Medium; )
+
+#endif