Hide formats in GrGLCaps and use specific getters for different GL functions.

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
@@ skipping 724 matching lines @@
 
     // in case we need a temporary, trimmed copy of the src pixels
 #if defined(GOOGLE3)
     // Stack frame size is limited in GOOGLE3.
     SkAutoSMalloc<64 * 128> tempStorage;
 #else
     SkAutoSMalloc<128 * 128> tempStorage;
 #endif
 
     // Internal format comes from the texture desc.
-    GrGLenum internalFormat =
-        this->glCaps().configGLFormats(desc.fConfig).fInternalFormatTexImage;
-
+    GrGLenum internalFormat;
     // External format and type come from the upload data.
-    GrGLenum externalFormat =
-        this->glCaps().configGLFormats(dataConfig).fExternalFormatForTexImage;
-    GrGLenum externalType = this->glCaps().configGLFormats(dataConfig).fExternalType;
-
+    GrGLenum externalFormat;
+    GrGLenum externalType;
+    if (!this->glCaps().getTexImageFormats(desc.fConfig, dataConfig, &internalFormat,
+                                           &externalFormat, &externalType)) {
+        return false;
+    }
     /*
      *  Check whether to allocate a temporary buffer for flipping y or
      *  because our srcData has extra bytes past each row. If so, we need
      *  to trim those off here, since GL ES may not let us specify
      *  GL_UNPACK_ROW_LENGTH.
      */
     bool restoreGLRowLength = false;
     bool swFlipY = false;
     bool glFlipY = false;
     if (dataOrOffset) {
@@ skipping 41 matching lines @@
         GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, config_alignment(dataConfig)));
     }
     bool succeeded = true;
     if (kNewTexture_UploadType == uploadType) {
         if (dataOrOffset && 
             !(0 == left && 0 == top && desc.fWidth == width && desc.fHeight == height)) {
             succeeded = false;
         } else {
             CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
             GL_ALLOC_CALL(this->glInterface(), TexImage2D(target, 0, internalFormat, desc.fWidth,
-                                                          desc.fHeight, 0,  externalFormat,
+                                                          desc.fHeight, 0, externalFormat,
                                                           externalType, dataOrOffset));
             GrGLenum error = check_alloc_error(desc, this->glInterface());
             if (error != GR_GL_NO_ERROR) {
                 succeeded = false;
             }
         }
     } else {
         if (swFlipY || glFlipY) {
             top = desc.fHeight - (top + height);
         }
@@ skipping 46 matching lines @@
 #ifdef SK_DEBUG
     else {
         SkASSERT(height <= desc.fHeight);
     }
 #endif
 
     // Make sure that the width and height that we pass to OpenGL
     // is a multiple of the block size.
     size_t dataSize = GrCompressedFormatDataSize(desc.fConfig, width, height);
 
-    // We only need the internal format for compressed 2D textures. There is on
-    // sized vs base internal format distinction for compressed textures.
-    GrGLenum internalFormat =this->glCaps().configGLFormats(desc.fConfig).fSizedInternalFormat;
+    // We only need the internal format for compressed 2D textures.
+    GrGLenum internalFormat;
+    if (!this->glCaps().getCompressedTexImageFormats(desc.fConfig, &internalFormat)) {
+        return false;
+    }
 
     if (kNewTexture_UploadType == uploadType) {
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(),
                       CompressedTexImage2D(target,
                                            0, // level
                                            internalFormat,
                                            width, height,
                                            0, // border
                                            SkToInt(dataSize),
@@ skipping 87 matching lines @@
     // the texture bound to the other. The exception is the IMG multisample extension. With this
     // extension the texture is multisampled when rendered to and then auto-resolves it when it is
     // rendered from.
     if (desc.fSampleCnt > 0 && this->glCaps().usesMSAARenderBuffers()) {
         GL_CALL(GenFramebuffers(1, &idDesc->fRTFBOID));
         GL_CALL(GenRenderbuffers(1, &idDesc->fMSColorRenderbufferID));
         if (!idDesc->fRTFBOID ||
             !idDesc->fMSColorRenderbufferID) {
             goto FAILED;
         }
-        // All ES versions (thus far) require sized internal formats for render buffers.
-        // TODO: Always use sized internal format?
-        // If this rule gets more complicated, add a field to ConfigEntry rather than logic here.
-        colorRenderbufferFormat = kGLES_GrGLStandard == this->glStandard() ?
-                            this->glCaps().configGLFormats(desc.fConfig).fSizedInternalFormat :
-                            this->glCaps().configGLFormats(desc.fConfig).fBaseInternalFormat;
+        if (!this->glCaps().getRenderbufferFormat(desc.fConfig, &colorRenderbufferFormat)) {
+            return false;
+        }
     } else {
         idDesc->fRTFBOID = idDesc->fTexFBOID;
     }
 
     // below here we may bind the FBO
     fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     if (idDesc->fRTFBOID != idDesc->fTexFBOID) {
         SkASSERT(desc.fSampleCnt > 0);
         GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, idDesc->fMSColorRenderbufferID));
         if (!renderbuffer_storage_msaa(*fGLContext,
@@ skipping 253 matching lines @@
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_MIN_FILTER,
                               GR_GL_NEAREST));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_WRAP_S,
                               GR_GL_CLAMP_TO_EDGE));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_WRAP_T,
                               GR_GL_CLAMP_TO_EDGE));
 
-        const GrGLCaps::ConfigFormats colorFormats = this->glCaps().configGLFormats(config);
-
+        GrGLenum internalFormat;
+        GrGLenum externalFormat;
+        GrGLenum externalType;
+        if (!this->glCaps().getTexImageFormats(config, config, &internalFormat, &externalFormat,
+                                               &externalType)) {
+            return false;
+        }
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(), TexImage2D(GR_GL_TEXTURE_2D,
                                                       0,
-                                                      colorFormats.fInternalFormatTexImage,
+                                                      internalFormat,
                                                       kSize,
                                                       kSize,
                                                       0,
-                                                      colorFormats.fExternalFormatForTexImage,
-                                                      colorFormats.fExternalType,
+                                                      externalFormat,
+                                                      externalType,
                                                       NULL));
         if (GR_GL_NO_ERROR != CHECK_ALLOC_ERROR(this->glInterface())) {
             GL_CALL(DeleteTextures(1, &colorID));
             return -1;
         }
 
         // unbind the texture from the texture unit before binding it to the frame buffer
         GL_CALL(BindTexture(GR_GL_TEXTURE_2D, 0));
 
         // Create Framebuffer
@@ skipping 718 matching lines @@
     GrGLRenderTarget* tgt = static_cast<GrGLRenderTarget*>(surface->asRenderTarget());
     if (!tgt) {
         return false;
     }
 
     // OpenGL doesn't do sRGB <-> linear conversions when reading and writing pixels.
     if (GrPixelConfigIsSRGB(surface->config()) != GrPixelConfigIsSRGB(config)) {
         return false;
     }
 
-    GrGLenum format = this->glCaps().configGLFormats(config).fExternalFormat;
-    GrGLenum type = this->glCaps().configGLFormats(config).fExternalType;
+    GrGLenum externalFormat;
+    GrGLenum externalType;
+    if (!this->glCaps().getReadPixelsFormat(surface->config(), config, &externalFormat,
+                                            &externalType)) {
+        return false;
+    }
     bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
 
     // resolve the render target if necessary
     switch (tgt->getResolveType()) {
         case GrGLRenderTarget::kCantResolve_ResolveType:
             return false;
         case GrGLRenderTarget::kAutoResolves_ResolveType:
             this->flushRenderTarget(tgt, &SkIRect::EmptyIRect());
             break;
         case GrGLRenderTarget::kCanResolve_ResolveType:
@@ skipping 32 matching lines @@
             readDst = scratch.get();
         }
     }
     if (flipY && this->glCaps().packFlipYSupport()) {
         GL_CALL(PixelStorei(GR_GL_PACK_REVERSE_ROW_ORDER, 1));
     }
     GL_CALL(PixelStorei(GR_GL_PACK_ALIGNMENT, config_alignment(config)));
 
     GL_CALL(ReadPixels(readRect.fLeft, readRect.fBottom,
                        readRect.fWidth, readRect.fHeight,
-                       format, type, readDst));
+                       externalFormat, externalType, readDst));
     if (readDstRowBytes != tightRowBytes) {
         SkASSERT(this->glCaps().packRowLengthSupport());
         GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
     }
     if (flipY && this->glCaps().packFlipYSupport()) {
         GL_CALL(PixelStorei(GR_GL_PACK_REVERSE_ROW_ORDER, 0));
         flipY = false;
     }
 
     // now reverse the order of the rows, since GL's are bottom-to-top, but our
@@ skipping 352 matching lines @@
         fHWBlendState.fDstCoeff != dstCoeff) {
         GL_CALL(BlendFunc(gXfermodeCoeff2Blend[srcCoeff],
                           gXfermodeCoeff2Blend[dstCoeff]));
         fHWBlendState.fSrcCoeff = srcCoeff;
         fHWBlendState.fDstCoeff = dstCoeff;
     }
 
     GrColor blendConst = blendInfo.fBlendConstant;
     if ((BlendCoeffReferencesConstant(srcCoeff) ||
          BlendCoeffReferencesConstant(dstCoeff)) &&
-        (!fHWBlendState.fConstColorValid ||
-         fHWBlendState.fConstColor != blendConst)) {
+        (!fHWBlendState.fConstColorValid || fHWBlendState.fConstColor != blendConst)) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(blendConst, c);
         GL_CALL(BlendColor(c[0], c[1], c[2], c[3]));
         fHWBlendState.fConstColor = blendConst;
         fHWBlendState.fConstColorValid = true;
     }
 }
 
 static inline GrGLenum tile_to_gl_wrap(SkShader::TileMode tm) {
     static const GrGLenum gWrapModes[] = {
@@ skipping 861 matching lines @@
     info->fID = 0;
     GL_CALL(GenTextures(1, &info->fID));
     GL_CALL(ActiveTexture(GR_GL_TEXTURE0));
     GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, 1));
     GL_CALL(BindTexture(info->fTarget, info->fID));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_MAG_FILTER, GR_GL_NEAREST));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_MIN_FILTER, GR_GL_NEAREST));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_WRAP_S, GR_GL_CLAMP_TO_EDGE));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_WRAP_T, GR_GL_CLAMP_TO_EDGE));
 
-    GrGLenum internalFormat = this->glCaps().configGLFormats(config).fInternalFormatTexImage;
-    GrGLenum externalFormat = this->glCaps().configGLFormats(config).fExternalFormatForTexImage;
-    GrGLenum externalType = this->glCaps().configGLFormats(config).fExternalType;
+    GrGLenum internalFormat;
+    GrGLenum externalFormat;
+    GrGLenum externalType;
+
+    if (!this->glCaps().getTexImageFormats(config, config, &internalFormat, &externalFormat,
+                                           &externalType)) {
+        delete info;
+#ifdef SK_IGNORE_GL_TEXTURE_TARGET
+        return 0;
+#else
+        return reinterpret_cast<GrBackendObject>(nullptr);
+#endif
+    }
 
     GL_CALL(TexImage2D(info->fTarget, 0, internalFormat, w, h, 0, externalFormat,
                        externalType, pixels));
 
 #ifdef SK_IGNORE_GL_TEXTURE_TARGET
     GrGLuint id = info->fID;
     delete info;
     return id;
 #else
     return reinterpret_cast<GrBackendObject>(info);
@@ skipping 85 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }