scaling API on SkPixmap

src/image/SkImage.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapCache.h"
 #include "SkCanvas.h"
@@ skipping 30 matching lines @@
     if (nullptr == info) {
         info = &infoStorage;
     }
     if (nullptr == rowBytes) {
         rowBytes = &rowBytesStorage;
     }
     return as_IB(this)->onPeekPixels(info, rowBytes);
 }
 
 bool SkImage::readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
-                           int srcX, int srcY) const {
+                           int srcX, int srcY, CachingHint chint) const {
     SkReadPixelsRec rec(dstInfo, dstPixels, dstRowBytes, srcX, srcY);
     if (!rec.trim(this->width(), this->height())) {
         return false;
     }
-    return as_IB(this)->onReadPixels(rec.fInfo, rec.fPixels, rec.fRowBytes, rec.fX, rec.fY);
+    return as_IB(this)->onReadPixels(rec.fInfo, rec.fPixels, rec.fRowBytes, rec.fX, rec.fY, chint);
+}
+
+bool SkImage::scalePixels(const SkPixmap& dst, SkFilterQuality quality, CachingHint chint) const {
+    // Idea: If/when SkImageGenerator supports a native-scaling API (where the generator itself
+    //       can scale more efficiently) we should take advantage of it here.
+    //
+    SkBitmap bm;
+    if (as_IB(this)->getROPixels(&bm, chint)) {
+        bm.lockPixels();
+        SkPixmap pmap;
+        // Note: By calling the pixmap scaler, we never cache the final result, so the chint
+        //       is (currently) only being applied to the getROPixels. If we get a request to
+        //       also attempt to cache the final (scaled) result, we would add that logic here.
+        //
+        return bm.peekPixels(&pmap) && pmap.scalePixels(dst, quality);
+    }
+    return false;
 }
 
 void SkImage::preroll(GrContext* ctx) const {
     // For now, and to maintain parity w/ previous pixelref behavior, we just force the image
     // to produce a cached raster-bitmap form, so that drawing to a raster canvas should be fast.
     //
     SkBitmap bm;
     if (as_IB(this)->getROPixels(&bm)) {
         bm.lockPixels();
         bm.unlockPixels();
@@ skipping 212 matching lines @@
     , fAddedToCache(false)
 {}
 
 SkImage_Base::~SkImage_Base() {
     if (fAddedToCache.load()) {
         SkNotifyBitmapGenIDIsStale(this->uniqueID());
     }
 }
 
 bool SkImage_Base::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
-                                int srcX, int srcY) const {
+                                int srcX, int srcY, CachingHint) const {
     if (!raster_canvas_supports(dstInfo)) {
         return false;
     }
 
     SkBitmap bm;
     bm.installPixels(dstInfo, dstPixels, dstRowBytes);
     SkCanvas canvas(bm);
 
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
@@ skipping 10 matching lines @@
     const void* pixels = this->peekPixels(&info, &rowBytes);
     if (pixels) {
         if (pmap) {
             pmap->reset(info, pixels, rowBytes);
         }
         return true;
     }
     return false;
 }
 
-bool SkImage::readPixels(const SkPixmap& pmap, int srcX, int srcY) const {
-    return this->readPixels(pmap.info(), pmap.writable_addr(), pmap.rowBytes(), srcX, srcY);
+bool SkImage::readPixels(const SkPixmap& pmap, int srcX, int srcY, CachingHint chint) const {
+    return this->readPixels(pmap.info(), pmap.writable_addr(), pmap.rowBytes(), srcX, srcY, chint);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
     SkPixelRef* pr = bm.pixelRef();
     if (nullptr == pr) {
         return nullptr;
     }
 
@@ skipping 64 matching lines @@
 
 SkImage* SkImage::NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
     return nullptr;
 }
 
 SkImage* SkImage::NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
     return nullptr;
 }
 
 #endif