Reopened: Caching the result of readPixelsSupported

src/gpu/gl/GrGLCaps.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 "GrGLCaps.h"
 #include "GrGLContext.h"
@@ skipping 30 matching lines @@
     fTexStorageSupport = false;
     fTextureRedSupport = false;
     fImagingSupport = false;
     fTwoFormatLimit = false;
     fFragCoordsConventionSupport = false;
     fVertexArrayObjectSupport = false;
     fUseNonVBOVertexAndIndexDynamicData = false;
     fIsCoreProfile = false;
     fFullClearIsFree = false;
     fDropsTileOnZeroDivide = false;
+
+    fReadPixelsSupportedCache.clear();
 }
 
 GrGLCaps::GrGLCaps(const GrGLCaps& caps) : GrDrawTargetCaps() {
     *this = caps;
 }
 
 GrGLCaps& GrGLCaps::operator= (const GrGLCaps& caps) {
     INHERITED::operator=(caps);
     fVerifiedColorConfigs = caps.fVerifiedColorConfigs;
     fStencilFormats = caps.fStencilFormats;
@@ skipping 417 matching lines @@
     // glCompressedTexImage2D is available on all OpenGL ES devices...
     // however, it is only available on standard OpenGL after version 1.3
     bool hasCompressTex2D = (kGL_GrGLStandard != standard || version >= GR_GL_VER(1, 3));
 
     // Check for ETC1
     bool hasETC1 = false;
 
     // First check version for support
     if (kGL_GrGLStandard == standard) {
         hasETC1 = hasCompressTex2D &&
-            (version >= GR_GL_VER(4, 3) || 
+            (version >= GR_GL_VER(4, 3) ||
              ctxInfo.hasExtension("GL_ARB_ES3_compatibility"));
     } else {
         hasETC1 = hasCompressTex2D &&
             (version >= GR_GL_VER(3, 0) ||
              ctxInfo.hasExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
              // ETC2 is a superset of ETC1, so we can just check for that, too.
              (ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGB8_texture") &&
               ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGBA8_texture")));
     }
     fConfigTextureSupport[kETC1_GrPixelConfig] = hasETC1;
@@ skipping 35 matching lines @@
 
     // Check for R11_EAC
     if (kGL_GrGLStandard == standard) {
         fConfigTextureSupport[kR11_EAC_GrPixelConfig] =
             version >= GR_GL_VER(4, 3) || ctxInfo.hasExtension("GL_ARB_ES3_compatibility");
     } else {
         fConfigTextureSupport[kR11_EAC_GrPixelConfig] = version >= GR_GL_VER(3, 0);
     }
 }
 
-bool GrGLCaps::readPixelsSupported(const GrGLInterface* intf,
-                                   GrGLenum format,
-                                   GrGLenum type) const {
+bool GrGLCaps::doReadPixelsSupported(const GrGLInterface* intf,
+                                     GrGLenum format,
+                                     GrGLenum type) const {
     if (GR_GL_RGBA == format && GR_GL_UNSIGNED_BYTE == type) {
         // ES 2 guarantees this format is supported
         return true;
     }
 
     if (!fTwoFormatLimit) {
         // not limited by ES 2's constraints
         return true;
     }
 
     GrGLint otherFormat = GR_GL_RGBA;
     GrGLint otherType = GR_GL_UNSIGNED_BYTE;
 
     // The other supported format/type combo supported for ReadPixels
     // can change based on which render target is bound
     GR_GL_GetIntegerv(intf,
                       GR_GL_IMPLEMENTATION_COLOR_READ_FORMAT,
                       &otherFormat);
 
     GR_GL_GetIntegerv(intf,
                       GR_GL_IMPLEMENTATION_COLOR_READ_TYPE,
                       &otherType);
 
     return (GrGLenum)otherFormat == format && (GrGLenum)otherType == type;
 }
 
+bool GrGLCaps::readPixelsSupported(const GrGLInterface* intf,
+                                   GrGLenum format,
+                                   GrGLenum type,
+                                   GrGLenum currFboFormat) const {
+
+    ReadPixelsSupportedFormatsKey key = {format, type, currFboFormat};
+
+    ReadPixelsSupportedFormats* cachedValue = fReadPixelsSupportedCache.find(key);
+
+    if (NULL == cachedValue) {
+        bool value = doReadPixelsSupported(intf, format, type);
+        cachedValue = new ReadPixelsSupportedFormats(key, value);
+        fReadPixelsSupportedCache.put(cachedValue);
+    }
+
+    return cachedValue->value();
+}
+
 void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
 
     fMSFBOType = kNone_MSFBOType;
     if (kGL_GrGLStandard != ctxInfo.standard()) {
         // We prefer the EXT/IMG extension over ES3 MSAA because we've observed
         // ES3 driver bugs on at least one device with a tiled GPU (N10).
         if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) {
             fMSFBOType = kES_EXT_MsToTexture_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) {
             fMSFBOType = kES_IMG_MsToTexture_MSFBOType;
@@ skipping 208 matching lines @@
     r.appendf("Two Format Limit: %s\n", (fTwoFormatLimit ? "YES": "NO"));
     r.appendf("Fragment coord conventions support: %s\n",
              (fFragCoordsConventionSupport ? "YES": "NO"));
     r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
     r.appendf("Use non-VBO for dynamic data: %s\n",
              (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
     r.appendf("Full screen clear is free: %s\n", (fFullClearIsFree ? "YES" : "NO"));
     r.appendf("Drops tile on zero divide: %s\n", (fDropsTileOnZeroDivide ? "YES" : "NO"));
     return r;
 }
+
+//Computes a hash based on the three values in the key struct
+// bits 31------------15---------7---------------0
+//      fFormat(15:0) fType(7:0) fFboFormat(7:0)
+uint32_t GrGLCaps::ReadPixelsSupportedFormats::Hash(const ReadPixelsSupportedFormatsKey& key) {
+    // fFormat has different values like 0x190X or 0x8XXX: 16 bits are required
+    uint32_t hash = ((static_cast<uint32_t>(key.fFormat) & 0xFFFF) << 16);
+    // fType is 0x14XX: 8 lower bits are enough
+    hash |= ((static_cast<uint32_t>(key.fType) & 0xFF) << 8);
+    // fFboFormat is enum GrPixelConfig which has less than 15 values: 8 bits OK
+    hash |= (static_cast<uint32_t>(key.fFboFormat) & 0xFF);
+
+    return hash;
+}