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..82dd90aa5fde59e332eb86dfab0c89e825dbce74
--- /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 {
+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;
+        }
+
+        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(
+            *context->threadSafeProxy(), 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(
+            *context->threadSafeProxy(), 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