YUV planes cache

src/core/SkYUVPlanesCache.h

Index: src/core/SkYUVPlanesCache.h
diff --git a/src/core/SkYUVPlanesCache.h b/src/core/SkYUVPlanesCache.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa9b89e2a55ae7c945f92469797a4d257af6e5c6
--- /dev/null
+++ b/src/core/SkYUVPlanesCache.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkYUVPlanesCache_DEFINED
+#define SkYUVPlanesCache_DEFINED
+
+#include "SkCachedData.h"
+#include "SkImageInfo.h"
+
+class SkResourceCache;
+
+class SkYUVPlanesCache {
+public:
+    /**
+     * The Info struct contains data about the 3 Y, U and V planes of memory stored
+     * contiguously, in that order, as a single block of memory within SkYUVPlanesCache.

[reed2, 2015/01/19 19:09:09]

Well, I thought it was contiguous, but now perhaps there are gaps, given the
comment about sizesinmemory?

How big are these "gaps" in practice? Its seems like perhaps we could just
require that the blocks really are contiguous, in which case we don't even need
the fSizeInMemory array at all.

[sugoi1, 2015/01/19 19:28:56]

Typically, block sizes are 8 and width and height are also multiples of 8, so in
that case, there would be no gap, but, for an extreme example, a 9x9 JPEG would
be read into a 16x16 memory buffer (rounded up to the next multiple of the JPEG
block size). In that case, assuming 8 bit data, rowBytes could be 16, rowBytes *
height would be 144 and sizeInMemory would be 256. We can allocate less, the
price to pay is an extra temp buffer allocation at decode time, to read the last
row of blocks, and some added memcpy() calls to copy the memory back into the
YUV plane memory buffer.

+     *
+     * fSize: Width and height of each of the 3 planes (in pixels).
+     * fSizeInMemory: Amount of memory allocated for each plane (may be different from
+                      "height * rowBytes", depending on the jpeg decoder's block size).
+     *                The sum of these is the total size stored within SkYUVPlanesCache.
+     * fRowBytes: rowBytes for each of the 3 planes (in bytes).
+     * fColorSpace: color space that will be used for the YUV -> RGB conversion.
+     */
+    struct Info {
+        SkISize fSize[3];
+        size_t  fSizeInMemory[3];
+        size_t  fRowBytes[3];
+        SkYUVColorSpace fColorSpace;
+    };
+    /**
+     * On success, return a ref to the SkCachedData that holds the pixels.
+     *
+     * On failure, return NULL.
+     */
+    static SkCachedData* FindAndRef(uint32_t genID, Info* info,
+                                    SkResourceCache* localCache = NULL);
+
+    /**
+     * Add a pixelRef ID and its YUV planes data to the cache.
+     */
+    static void Add(uint32_t genID, SkCachedData* data, Info* info,
+                    SkResourceCache* localCache = NULL);
+};
+
+#endif