Add deferred texture upload API.

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
 
 #include "SkFilterQuality.h"
 #include "SkImageInfo.h"
 #include "SkImageEncoder.h"
 #include "SkRefCnt.h"
 #include "SkScalar.h"
 #include "SkShader.h"
 
 class SkData;
 class SkCanvas;
 class SkColorTable;
 class SkImageGenerator;
 class SkPaint;
 class SkPicture;
 class SkPixelSerializer;
 class SkString;
 class SkSurface;
 class GrContext;
+class GrContextThreadSafeProxy;
 class GrTexture;
 
 /**
  *  SkImage is an abstraction for drawing a rectagle of pixels, though the
  *  particular type of image could be actually storing its data on the GPU, or
  *  as drawing commands (picture or PDF or otherwise), ready to be played back
  *  into another canvas.
  *
  *  The content of SkImage is always immutable, though the actual storage may
  *  change, if for example that image can be re-created via encoded data or
@@ skipping 100 matching lines @@
      *  deleted after the function returns. The image will have the dimensions of the y texture.
      */
     static SkImage* NewFromYUVTexturesCopy(GrContext*, SkYUVColorSpace,
                                            const GrBackendObject yuvTextureHandles[3],
                                            const SkISize yuvSizes[3],
                                            GrSurfaceOrigin);
 
     static SkImage* NewFromPicture(const SkPicture*, const SkISize& dimensions,
                                    const SkMatrix*, const SkPaint*);
 
+    static SkImage* NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted);
+
     ///////////////////////////////////////////////////////////////////////////////////////////////
 
     int width() const { return fWidth; }
     int height() const { return fHeight; }
     SkISize dimensions() const { return SkISize::Make(fWidth, fHeight); }
     SkIRect bounds() const { return SkIRect::MakeWH(fWidth, fHeight); }
     uint32_t uniqueID() const { return fUniqueID; }
     virtual bool isOpaque() const { return false; }
 
     /**
@@ skipping 149 matching lines @@
      */
     SkImage* newSubset(const SkIRect& subset) const;
 
     /**
      *  Ensures that an image is backed by a texture (when GrContext is non-null). If no
      *  transformation is required, the returned image may be the same as this image. If the this
      *  image is from a different GrContext, this will fail.
      */
     SkImage* newTextureImage(GrContext*) const;
 
+    /**
+     * This captures the data necessary to turn a SkImage into a texture-backed image. If the image
+     * is codec-backed decoding into the format desired to create a texture-backed image is
+     * performed. Constructing one of these does not make calls to the underlying 3D API

[robertphillips, 2016/03/08 18:43:10]

the of - the ?

[bsalomon, 2016/03/08 19:49:31]

Done.

+     * (e.g. OpenGL). Clients allocate and manage the of storage for the DeferredTextureImage and
+     * control its lifetime. No cleanup is required, thus it is safe to simply free the memory
+     * associated with a DeferredTextureImage.
+     */
+    class DeferredTextureImage;
+
+    /** Drawing params for which a DeferredTextureImage should be optimized. */
+    struct DeferredTextureImageUsageParams {
+        SkMatrix        fViewMatrix;
+        SkFilterQuality fQuality;
+        SkRect          fSrcRect;
+        SkRect          fDstRect;
+    };
+

[robertphillips, 2016/03/08 18:43:10]

Are their any constraints on the proxy we hand to getDeferredTextureImageSize
and createDeferredTextureImageInClientStorage (i.e., that have to be the same)?

[bsalomon, 2016/03/08 19:49:31]

Added comment that the size of the buffer must be at least as big as that the
getSize function with the same proxy.

+    /**
+     * Computes the size that the client must allocate in order to create a DeferredTextureImage

[robertphillips, 2016/03/08 18:43:10]

tee -> te ?

[bsalomon, 2016/03/08 19:49:31]

Done.

+     * for this image (or zero if this is an inappropriatee candidate for a DeferredTextureImage).
+     */
+    size_t getDeferredTextureImageSize(const GrContextThreadSafeProxy&,

[robertphillips, 2016/03/08 18:43:10]

Why an array of usage parameters?

[bsalomon, 2016/03/08 19:49:31]

The client may have multiple draws with the same image.

+                                       const DeferredTextureImageUsageParams[],
+                                       int paramCnt) const;
+
+    /**
+     * Creates a DeferredTextureImage for this image (or returns nullptr if this is an inappropriate
+     * candidate for a DeferredTextureImage or the provided buffer is too small).
+     */
+    const DeferredTextureImage* createDeferredTextureImageInClientStorage(
+            const GrContextThreadSafeProxy&,
+            const DeferredTextureImageUsageParams[],
+            int paramCnt,
+            void* imageTextureDataBuffer,
+            size_t imageTextureDataBufferSize) const;
+
+    static SkImage* NewFromDeferredTextureImage(GrContext*, const DeferredTextureImage&,
+                                                SkBudgeted);
+
     // Helper functions to convert to SkBitmap
 
     enum LegacyBitmapMode {
         kRO_LegacyBitmapMode,
         kRW_LegacyBitmapMode,
     };
 
     /**
      *  Attempt to create a bitmap with the same pixels as the image. The result will always be
      *  a raster-backed bitmap (texture-backed bitmaps are DEPRECATED, and not supported here).
@@ skipping 16 matching lines @@
 
 private:
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif