API to support native scaling by image-generator

gm/image.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 "gm.h"
 #include "SkData.h"
 #include "SkCanvas.h"
@@ skipping 282 matching lines @@
                 show_scaled_pixels(canvas, image);
             }
             canvas->translate(0, 120);
         }
     }
     
 private:
     typedef skiagm::GM INHERITED;
 };
 DEF_GM( return new ScalePixelsGM; )
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkImageGenerator.h"
+
+static SkImageInfo make_info(SkImage* img) {
+    return SkImageInfo::MakeN32Premul(img->width(), img->height());
+}
+
+class ImageGeneratorFromImage : public SkImageGenerator {
+public:
+    ImageGeneratorFromImage(SkImage* img) : INHERITED(make_info(img)), fImg(SkRef(img)) {}
+
+protected:
+    bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, SkPMColor ctable[],
+                     int* ctableCount) override {
+        SkBitmap bm;
+        bm.installPixels(info, pixels, rowBytes);
+        bm.eraseColor(0);
+        SkCanvas canvas(bm);
+        canvas.drawImage(fImg, 0, 0, nullptr);
+        return true;
+    }
+
+private:
+    SkAutoTUnref<SkImage> fImg;
+
+    typedef SkImageGenerator INHERITED;
+};
+
+static SkImageGenerator* gen_raster(const SkImageInfo& info, GrContext*) {
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
+    draw_contents(surface->getCanvas());
+    SkAutoTUnref<SkImage> img(surface->newImageSnapshot());
+    return new ImageGeneratorFromImage(img);
+}
+
+static SkImageGenerator* gen_picture(const SkImageInfo& info, GrContext*) {
+    SkPictureRecorder recorder;
+    draw_contents(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height())));
+    SkAutoTUnref<SkPicture> pict(recorder.endRecording());
+    return SkImageGenerator::NewFromPicture(info.dimensions(), pict, nullptr, nullptr);
+}
+
+static SkImageGenerator* gen_png(const SkImageInfo& info, GrContext*) {
+    SkAutoTUnref<SkImage> image(make_raster(info, nullptr));
+    SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100));
+    return SkImageGenerator::NewFromEncoded(data);
+}
+
+static SkImageGenerator* gen_jpg(const SkImageInfo& info, GrContext*) {

[msarett, 2015/11/30 23:00:32]

I'm not sure this is working right.  JPEGs must be opaque.

[reed1, 2015/12/01 03:31:47]

You're right. The test will be changed to present an opaque image.

+    SkAutoTUnref<SkImage> image(make_raster(info, nullptr));
+    SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kJPEG_Type, 100));
+    return SkImageGenerator::NewFromEncoded(data);
+}
+
+typedef SkImageGenerator* (*GeneratorMakerProc)(const SkImageInfo&, GrContext*);
+
+static void show_scaled_generator(SkCanvas* canvas, SkImageGenerator* gen) {
+    const SkImageInfo genInfo = gen->getInfo();
+
+    SkAutoCanvasRestore acr(canvas, true);
+
+    SkBitmap bm;
+    bm.allocPixels(genInfo);
+    if (gen->getPixels(bm.info(), bm.getPixels(), bm.rowBytes())) {
+        canvas->drawBitmap(bm, 0, 0, nullptr);
+    }
+    canvas->translate(110, 0);
+
+    const float scales[] = { 0.75f, 0.5f, 0.25f };
+    for (auto scale : scales) {
+        SkImageGenerator::SupportedSizes sizes;
+        if (gen->computeScaledDimensions(scale, &sizes)) {
+            const SkImageInfo info = SkImageInfo::MakeN32Premul(sizes.fSizes[0].width(),

[scroggo, 2015/12/02 15:04:44]

Why not draw both sizes?

[reed1, 2015/12/02 21:37:05]

Could, but I thought the key here was to see the "best" answer, or at least that
the generate returned "an" answer (as some of them won't).

+                                                                sizes.fSizes[0].height());
+            bm.allocPixels(info);
+            SkPixmap pmap;
+            bm.peekPixels(&pmap);
+            if (gen->generateScaledPixels(pmap)) {
+                canvas->drawBitmap(bm, 0, SkIntToScalar(genInfo.height() - info.height())/2);
+            }
+        }
+        canvas->translate(100, 0);
+    }
+}
+
+class ScaleGeneratorGM : public skiagm::GM {
+public:
+    ScaleGeneratorGM() {}
+
+protected:
+    SkString onShortName() override {
+        return SkString("scale-generator");
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(960, 1200);
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);

[msarett, 2015/11/30 23:00:32]

SkCodec fails if we attempt to decode a jpeg to kPremul_SkAlphaType.

[scroggo, 2015/12/02 15:04:44]

I've gone back and forth on whether that's the right behavior. An opaque image
is legitimately premul or unpremul, so we *could* support it, and I thought I
saw somewhere else where we support such a "conversion".

IIRC, the motivation behind failing is that it forces the client to use opaque,
which will allow us to draw faster.

[reed1, 2015/12/02 21:37:05]

I think encode+premul -> jpeg can fail (or not, your call)
I think decode+jpeg -> premul should definitely succeed, knowing that the query
on the code/geneartor will "claim" to be opaque

+
+        const GeneratorMakerProc procs[] = {
+            gen_raster, gen_picture, gen_png, gen_jpg,
+        };
+        for (auto& proc : procs) {
+            SkAutoTDelete<SkImageGenerator> gen(proc(info, canvas->getGrContext()));
+            if (gen) {
+                show_scaled_generator(canvas, gen);
+            }
+            canvas->translate(0, 120);
+        }
+    }
+
+private:
+    typedef skiagm::GM INHERITED;
+};
+DEF_GM( return new ScaleGeneratorGM; )