scaling API on SkPixmap

include/core/SkImage.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImage_DEFINED
 #define SkImage_DEFINED
 
@@ skipping 190 matching lines @@
     bool isTextureBacked() const;
 
     /**
      *  Retrieves the backend API handle of the texture. If flushPendingGrContextIO then the
      *  GrContext will issue to the backend API any deferred IO operations on the texture before
      *  returning.
      */
     GrBackendObject getTextureHandle(bool flushPendingGrContextIO) const;
 
     /**
+     *  Hints to image calls where the system might cache computed intermediates (e.g. the results
+     *  of decoding or a read-back from the GPU. Passing kAllow signals that the system's default
+     *  behavior is fine. Passing kDisallow signals that caching should be avoided.
+     */
+     enum CachingHint {
+        kAllow_CachingHint,
+        kDisallow_CachingHint,
+    };
+
+    /**
      *  Copy the pixels from the image into the specified buffer (pixels + rowBytes),
      *  converting them into the requested format (dstInfo). The image pixels are read
      *  starting at the specified (srcX,srcY) location.
      *
      *  The specified ImageInfo and (srcX,srcY) offset specifies a source rectangle
      *
      *      srcR.setXYWH(srcX, srcY, dstInfo.width(), dstInfo.height());
      *
      *  srcR is intersected with the bounds of the image. If this intersection is not empty,
      *  then we have two sets of pixels (of equal size). Replace the dst pixels with the
      *  corresponding src pixels, performing any colortype/alphatype transformations needed
      *  (in the case where the src and dst have different colortypes or alphatypes).
      *
      *  This call can fail, returning false, for several reasons:
      *  - If srcR does not intersect the image bounds.
      *  - If the requested colortype/alphatype cannot be converted from the image's types.
      */
     bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
-                    int srcX, int srcY) const;
+                    int srcX, int srcY, CachingHint = kAllow_CachingHint) const;
 
-    bool readPixels(const SkPixmap& dst, int srcX, int srcY) const;
+    bool readPixels(const SkPixmap& dst, int srcX, int srcY,
+                    CachingHint = kAllow_CachingHint) const;
+
+    /**
+     *  Copy the pixels from this image into the dst pixmap, converting as needed into dst's
+     *  colortype/alphatype. If the conversion cannot be performed, false is returned.
+     *
+     *  If dst's dimensions differ from the src dimension, the image will be scaled, applying the
+     *  specified filter-quality.
+     */
+    bool scalePixels(const SkPixmap& dst, SkFilterQuality, CachingHint = kAllow_CachingHint) const;
 
     /**
      *  Encode the image's pixels and return the result as a new SkData, which
      *  the caller must manage (i.e. call unref() when they are done).
      *
      *  If the image type cannot be encoded, or the requested encoder type is
      *  not supported, this will return NULL.
      *
      *  Note: this will attempt to encode the image's pixels in the specified format,
      *  even if the image returns a data from refEncoded(). That data will be ignored.
@@ skipping 89 matching lines @@
 
 private:
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif