Move config table to GrGLCaps from GrGLGpu.

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
@@ skipping 10 matching lines @@
 
 /**
  * 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 GrCaps {
 public:
     typedef GrGLStencilAttachment::Format StencilFormat;
 
+    /** Provides information about the mappiing from GrPixelConfig to GL formats. */
+    struct ConfigFormats {
+        ConfigFormats() {
+            // Inits to known bad GL enum values.
+            memset(this, 0xAB, sizeof(ConfigFormats));
+        }
+        GrGLenum fBaseInternalFormat;
+        GrGLenum fSizedInternalFormat;
+        GrGLenum fExternalFormat;
+        GrGLenum fExternalType;
+
+        // The <format> parameter to use for glTexImage and glTexSubImage.
+        // This is usually the same as fExternalFormat except for kSRGBA on some GL contexts.
+        GrGLenum fExternalFormatForTexImage;
+        // Either the base or sized internal format depending on the GL and config.
+        GrGLenum fInternalFormatTexImage;
+    };
+
     /**
      * The type of MSAA for FBOs supported. Different extensions have different
      * semantics of how / when a resolve is performed.
      */
     enum MSFBOType {
         /**
          * no support for MSAA FBOs
          */
         kNone_MSFBOType = 0,
         /**
@@ skipping 57 matching lines @@
         kLast_TransferBufferType = kChromium_TransferBufferType,
     };
 
     /**
      * Initializes the GrGLCaps to the set of features supported in the current
      * OpenGL context accessible via ctxInfo.
      */
     GrGLCaps(const GrContextOptions& contextOptions, const GrGLContextInfo& ctxInfo,
              const GrGLInterface* glInterface);
 
+    /** Returns conversions to various GL format parameters for a GrPixelCfonig. */
+    const ConfigFormats& configGLFormats(GrPixelConfig config) const {
+        return fConfigTable[config].fFormats;
+    }
+
+
+    /**
+    * Gets an array of legal stencil formats. These formats are not guaranteed
+    * to be supported by the driver but are legal GLenum names given the GL
+    * version and extensions supported.
+    */
+    const SkTArray<StencilFormat, true>& stencilFormats() const {
+        return fStencilFormats;
+    }
+
+    /**
+     * Has a stencil format index been found for the config (or we've found that no format works).
+     */
+    bool hasStencilFormatBeenDeterminedForConfig(GrPixelConfig config) const {
+        return fConfigTable[config].fStencilFormatIndex != ConfigInfo::kUnknown_StencilIndex;
+    }
+
+    /**
+     * Gets the stencil format index for the config. This assumes
+     * hasStencilFormatBeenDeterminedForConfig has already been checked. Returns false if
+     * no stencil format is supported with the config. The returned index refers to the array
+     * returned by stencilFormats().
+     */
+    bool getStencilFormatIndexForConfig(GrPixelConfig config, int* index) const {
+        SkASSERT(this->hasStencilFormatBeenDeterminedForConfig(config));
+        if (ConfigInfo::kUnsupported_StencilFormatIndex ==
+            fConfigTable[config].fStencilFormatIndex) {
+            return false;
+        } else {
+            *index = fConfigTable[config].fStencilFormatIndex;

[egdaniel, 2015/12/21 15:10:44]

is it worth asserting that index > 0 here. Thus we know index is either a valid
value or unsupported.

[bsalomon, 2015/12/21 15:59:43]

Took your other suggestion to just return an int here rather than a bool

+            return true;
+        }
+    }
+
+    /**
+     * If index is >= 0 this records an index into stencilFormats() as the best stencil format for
+     * the config. If < 0 it records that the config has no supported stencil format index.
+     */
+    void setStencilFormatIndexForConfig(GrPixelConfig config, int index) {
+        SkASSERT(!this->hasStencilFormatBeenDeterminedForConfig(config));
+        if (index < 0) {
+            fConfigTable[config].fStencilFormatIndex = ConfigInfo::kUnsupported_StencilFormatIndex;
+        } else {
+            fConfigTable[config].fStencilFormatIndex = index;
+        }
+    }
+
     /**
      * Call to note that a color config has been verified as a valid color
      * attachment. This may save future calls to glCheckFramebufferStatus
      * using isConfigVerifiedColorAttachment().
      */
     void markConfigAsValidColorAttachment(GrPixelConfig config) {
         fVerifiedColorConfigs.markVerified(config);
     }
 
     /**
@@ skipping 29 matching lines @@
     }
 
     InvalidateFBType invalidateFBType() const { return fInvalidateFBType; }
 
     /// What type of buffer mapping is supported?
     MapBufferType mapBufferType() const { return fMapBufferType; }
 
     /// What type of transfer buffer is supported?
     TransferBufferType transferBufferType() const { return fTransferBufferType; }
 
-    /**
-     * Gets an array of legal stencil formats. These formats are not guaranteed
-     * to be supported by the driver but are legal GLenum names given the GL
-     * version and extensions supported.
-     */
-    const SkTArray<StencilFormat, true>& stencilFormats() const {
-        return fStencilFormats;
-    }
-
     /// The maximum number of fragment uniform vectors (GLES has min. 16).
     int maxFragmentUniformVectors() const { return fMaxFragmentUniformVectors; }
 
     /// maximum number of attribute values per vertex
     int maxVertexAttributes() const { return fMaxVertexAttributes; }
 
     /// maximum number of texture units accessible in the fragment shader.
     int maxFragmentTextureUnits() const { return fMaxFragmentTextureUnits; }
 
     /// ES requires an extension to support RGBA8 in RenderBufferStorage
@@ skipping 149 matching lines @@
     void initConfigTexturableTable(const GrGLContextInfo&, const GrGLInterface*, bool srgbSupport);
 
     bool doReadPixelsSupported(const GrGLInterface* intf, GrGLenum format, GrGLenum type) const;
 
     void initShaderPrecisionTable(const GrGLContextInfo& ctxInfo,
                                   const GrGLInterface* intf,
                                   GrGLSLCaps* glslCaps);
 
     void initConfigSwizzleTable(const GrGLContextInfo& ctxInfo, GrGLSLCaps* glslCaps);
 
+    void initConfigTable(const GrGLContextInfo&);
+
     // tracks configs that have been verified to pass the FBO completeness when
     // used as a color attachment
     VerifiedColorConfigs fVerifiedColorConfigs;
 
     SkTArray<StencilFormat, true> fStencilFormats;
 
     int fMaxFragmentUniformVectors;
     int fMaxVertexAttributes;
     int fMaxFragmentTextureUnits;
 
@@ skipping 21 matching lines @@
     bool fMultisampleDisableSupport : 1;
     bool fUseNonVBOVertexAndIndexDynamicData : 1;
     bool fIsCoreProfile : 1;
     bool fBindFragDataLocationSupport : 1;
     bool fSRGBWriteControl : 1;
     bool fRGBA8888PixelsOpsAreSlow : 1;
     bool fPartialFBOReadIsSlow : 1;
     bool fBindUniformLocationSupport : 1;
     bool fExternalTextureSupport : 1;
 
+    struct ConfigInfo {
+        ConfigInfo() : fStencilFormatIndex(kUnknown_StencilIndex) {};
+
+        ConfigFormats fFormats;
+
+        // Index into GrGLCaps's list of stencil formats. Support is determined experimentally and
+        // lazily.
+        int      fStencilFormatIndex;
+
+        enum {
+            // This indicates that a stencil format has not yet been determined for the config.
+            kUnknown_StencilIndex = -1,
+            // This indicates that there is no supported stencil format for the config.
+            kUnsupported_StencilFormatIndex = -2
+        };
+    };
+
+    ConfigInfo fConfigTable[kGrPixelConfigCnt];
+
     struct ReadPixelsSupportedFormat {
         GrGLenum fFormat;
         GrGLenum fType;
         GrGLenum fFboFormat;
 
         bool operator==(const ReadPixelsSupportedFormat& rhs) const {
             return fFormat    == rhs.fFormat
                 && fType      == rhs.fType
                 && fFboFormat == rhs.fFboFormat;
         }
     };
     mutable SkTHashMap<ReadPixelsSupportedFormat, bool> fReadPixelsSupportedCache;
 
     typedef GrCaps INHERITED;
 };
 
 #endif