Reopened: Caching the result of readPixelsSupported

src/gpu/gl/GrGLCaps.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 GrGLCaps_DEFINED
 #define GrGLCaps_DEFINED
 
 #include "GrDrawTargetCaps.h"
 #include "GrGLStencilBuffer.h"
+#include "SkTHashCache.h"
+#include "GrTHashTable.h"

[mtklein, 2014/07/11 17:08:08]

Do you still need this?

[Rémi Piotaix, 2014/07/11 17:45:01]

This one is not needed: "GrTHashTable.h"

Deleted.

 #include "SkTArray.h"
-#include "SkTDArray.h"
 
 class GrGLContextInfo;
 
 /**
  * Stores some capabilities of a GL context. Most are determined by the GL
  * version and the extensions string. It also tracks formats that have passed
  * the FBO completeness test.
  */
 class GrGLCaps : public GrDrawTargetCaps {
 public:
@@ skipping 220 matching lines @@
     bool vertexArrayObjectSupport() const { return fVertexArrayObjectSupport; }
 
     /// Use indices or vertices in CPU arrays rather than VBOs for dynamic content.
     bool useNonVBOVertexAndIndexDynamicData() const {
         return fUseNonVBOVertexAndIndexDynamicData;
     }
 
     /// Does ReadPixels support the provided format/type combo?
     bool readPixelsSupported(const GrGLInterface* intf,
                              GrGLenum format,
-                             GrGLenum type) const;
+                             GrGLenum type,
+                             GrGLenum currFboFormat) const;
 
     bool isCoreProfile() const { return fIsCoreProfile; }
 
 
     bool fullClearIsFree() const { return fFullClearIsFree; }
 
     bool dropsTileOnZeroDivide() const { return fDropsTileOnZeroDivide; }
 
     /**
      * Returns a string containing the caps info.
@@ skipping 50 matching lines @@
             return SkToBool(fVerifiedColorConfigs[u32Idx] & (1 << bitIdx));
         }
     };
 
     void initFSAASupport(const GrGLContextInfo&, const GrGLInterface*);
     void initStencilFormats(const GrGLContextInfo&);
     // This must be called after initFSAASupport().
     void initConfigRenderableTable(const GrGLContextInfo&);
     void initConfigTexturableTable(const GrGLContextInfo&, const GrGLInterface*);
 
+    bool doReadPixelsSupported(const GrGLInterface* intf,
+                                   GrGLenum format,
+                                   GrGLenum type) const;
+
     // tracks configs that have been verified to pass the FBO completeness when
     // used as a color attachment
     VerifiedColorConfigs fVerifiedColorConfigs;
 
     SkTArray<StencilFormat, true> fStencilFormats;
     // tracks configs that have been verified to pass the FBO completeness when
     // used as a color attachment when a particular stencil format is used
     // as a stencil attachment.
     SkTArray<VerifiedColorConfigs, true> fStencilVerifiedColorConfigs;
 
@@ skipping 20 matching lines @@
     bool fTextureRedSupport : 1;
     bool fImagingSupport  : 1;
     bool fTwoFormatLimit : 1;
     bool fFragCoordsConventionSupport : 1;
     bool fVertexArrayObjectSupport : 1;
     bool fUseNonVBOVertexAndIndexDynamicData : 1;
     bool fIsCoreProfile : 1;
     bool fFullClearIsFree : 1;
     bool fDropsTileOnZeroDivide : 1;
 
+    class ReadPixelsSupportedFormats {
+    public:
+        struct Key {
+            GrGLenum fFormat;
+            GrGLenum fType;
+            GrGLenum fFboFormat;
+
+            bool operator==(const Key& rhs) const {
+                return fFormat == rhs.fFormat
+                        && fType == rhs.fType
+                        && fFboFormat == rhs.fFboFormat;
+            }
+
+            uint32_t getHash() const {
+                // fFormat has different values like 0x190X or 0x8XXX: 16 bits are required
+                uint32_t hash = ((static_cast<uint32_t> (fFormat) & 0xFFFF) << 16);
+                // fType is 0x14XX: 8 lower bits are enough
+                hash |= ((static_cast<uint32_t> (fType) & 0xFF) << 8);
+                // fFboFormat is enum GrPixelConfig which has less than 15 values: 8 bits OK
+                hash |= (static_cast<uint32_t> (fFboFormat) & 0xFF);
+
+                return hash;
+            }
+        };
+        
+        ReadPixelsSupportedFormats(Key key,
+                bool value)
+        : fKey(key), fValue(value) {
+        }
+
+        static const Key& GetKey(const ReadPixelsSupportedFormats& element) {
+            return element.fKey;
+        }
+
+        static uint32_t Hash(const Key& key) {
+            return key.getHash();
+        }
+
+        bool value() const {
+            return fValue;
+        }
+    private:
+        Key fKey;
+        bool fValue;
+    };
+
+    mutable SkTHashCache<ReadPixelsSupportedFormats,
+                         ReadPixelsSupportedFormats::Key> fReadPixelsSupportedCache;
+
     typedef GrDrawTargetCaps INHERITED;
 };
 
 #endif