API to support native scaling by image-generator

src/core/SkPictureImageGenerator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageGenerator.h"
 #include "SkCanvas.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkSurface.h"
 #include "SkTLazy.h"
 
 class SkPictureImageGenerator : SkImageGenerator {
 public:
     static SkImageGenerator* Create(const SkISize&, const SkPicture*, const SkMatrix*,
                                     const SkPaint*);
 
 protected:
     bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, SkPMColor ctable[],
                      int* ctableCount) override;
+    bool onComputeScaledDimensions(SkScalar scale, SupportedSizes*) override;
+    bool onGenerateScaledPixels(const SkISize&, const SkIPoint&, const SkPixmap&) override;
+
 #if SK_SUPPORT_GPU
     GrTexture* onGenerateTexture(GrContext*, const SkIRect*) override;
 #endif
 
 private:
     SkPictureImageGenerator(const SkISize&, const SkPicture*, const SkMatrix*, const SkPaint*);
 
     SkAutoTUnref<const SkPicture> fPicture;
     SkMatrix                      fMatrix;
     SkTLazy<SkPaint>              fPaint;
@@ skipping 37 matching lines @@
         return false;
     }
 
     bitmap.eraseColor(SK_ColorTRANSPARENT);
     SkCanvas canvas(bitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
     canvas.drawPicture(fPicture, &fMatrix, fPaint.getMaybeNull());
 
     return true;
 }
 
+bool SkPictureImageGenerator::onComputeScaledDimensions(SkScalar scale,

[msarett, 2015/11/30 21:24:26]

This can be implemented for SkCodec by:

SkISize scaledSize = codec->getScaledDimensions(scale);
if (scaledSize == codec->getInfo().dimensions) {
  return false;
}
// You could also check that scaledSize isn't zero (since we return zero for
// invalid scales),  but you already check for invalid scales, so I think this
// is enough.

sizes->fSizes[0] = scaledSize;
sizes->fSizes[1] = scaledSize;

SkCodec isn't ready to provide a smaller and a larger size option.

[reed1, 2015/11/30 21:29:20]

Ack.

That said, I think returning 2 sizes will be sort of valuable for JPEG, which
might want to return POW2 answers.

+                                                        SupportedSizes* sizes) {
+    const int w = this->getInfo().width();
+    const int h = this->getInfo().height();
+    const int sw = SkMin32(SkScalarRoundToInt(scale * w), w);

[msarett, 2015/11/30 21:24:26]

Won't SkMin32 be unnecessary, since invalid scales will be caught in
computeScaledDimensions()?

[reed1, 2015/11/30 21:29:19]

Good catch.

+    const int sh = SkMin32(SkScalarRoundToInt(scale * h), h);
+    if (sw > 0 && sh > 0) {
+        sizes->fSizes[0].set(sw, sh);
+        sizes->fSizes[1].set(sw, sh);
+        return true;
+    }
+    return false;
+}
+
+bool SkPictureImageGenerator::onGenerateScaledPixels(const SkISize& scaledSize,

[msarett, 2015/11/30 21:24:26]

This can be implemented for SkCodec by:

codec->getPixels(scaledPixels.info(), <memory>, scaledPixels.rowBytes());
(or using a more complicated version if you want kIndex8)

But subsets aren't ready yet.  scaledSize will need to match scaledPixels.size()
and scaledOrigin will need to be (0, 0).

[reed1, 2015/11/30 21:29:19]

Acknowledged.

+                                                     const SkIPoint& scaledOrigin,
+                                                     const SkPixmap& scaledPixels) {
+    int w = scaledSize.width();
+    int h = scaledSize.height();
+
+    const SkScalar scaleX = SkIntToScalar(w) / this->getInfo().width();
+    const SkScalar scaleY = SkIntToScalar(h) / this->getInfo().height();
+    SkMatrix matrix = SkMatrix::MakeScale(scaleX, scaleY);
+    matrix.postTranslate(-SkIntToScalar(scaledOrigin.x()), -SkIntToScalar(scaledOrigin.y()));
+
+    SkBitmap bitmap;
+    if (!bitmap.installPixels(scaledPixels.info(), scaledPixels.writable_addr(),
+                              scaledPixels.rowBytes())) {
+        return false;
+    }
+
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    SkCanvas canvas(bitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
+    matrix.preConcat(fMatrix);
+    canvas.drawPicture(fPicture, &matrix, fPaint.getMaybeNull());
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 SkImageGenerator* SkImageGenerator::NewFromPicture(const SkISize& size, const SkPicture* picture,
                                                    const SkMatrix* matrix, const SkPaint* paint) {
     return SkPictureImageGenerator::Create(size, picture, matrix, paint);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 #include "GrTexture.h"
 
@@ skipping 17 matching lines @@
     }
     surface->getCanvas()->clear(0); // does NewRenderTarget promise to do this for us?
     surface->getCanvas()->drawPicture(fPicture, &matrix, fPaint.getMaybeNull());
     SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
     if (!image.get()) {
         return nullptr;
     }
     return SkSafeRef(image->getTexture());
 }
 #endif