Add field for internalFormat param to glTexImage to GrGLGpu::ConfigEntry.

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 650 matching lines @@
 
 static inline GrGLenum check_alloc_error(const GrSurfaceDesc& desc,
                                          const GrGLInterface* interface) {
     if (SkToBool(desc.fFlags & kCheckAllocation_GrSurfaceFlag)) {
         return GR_GL_GET_ERROR(interface);
     } else {
         return CHECK_ALLOC_ERROR(interface);
     }
 }
 
-/**
- * Determines if sized internal formats are available for the texture being created.
- *
- * @param info          Info about the GL context.
- * @param textureConfig The pixel configuration for the texture being created.
- */
-static bool use_sized_format_for_texture(const GrGLContextInfo& info, GrPixelConfig textureConfig) {
-    // ES2 requires an unsized format for glTexImage, unlike ES3 and desktop.
-    bool useSizedFormat = false;
-    if (kGL_GrGLStandard == info.standard() ||
-        (info.version() >= GR_GL_VER(3, 0) &&
-         // ES3 only works with sized BGRA8 format if "GL_APPLE_texture_format_BGRA8888" enabled
-         (kBGRA_8888_GrPixelConfig != textureConfig || !info.caps()->bgraIsInternalFormat())))  {
-        useSizedFormat = true;
-    }
-    return useSizedFormat;
-}
-
 bool GrGLGpu::uploadTexData(const GrSurfaceDesc& desc,
                             GrGLenum target,
                             bool isNewTexture,
                             int left, int top, int width, int height,
                             GrPixelConfig dataConfig,
                             const void* data,
                             size_t rowBytes) {
     SkASSERT(data || isNewTexture);
 
     // If we're uploading compressed data then we should be using uploadCompressedTexData
     SkASSERT(!GrPixelConfigIsCompressed(dataConfig));
 
     SkASSERT(this->caps()->isConfigTexturable(desc.fConfig));
 
     size_t bpp = GrBytesPerPixel(dataConfig);
     if (!GrSurfacePriv::AdjustWritePixelParams(desc.fWidth, desc.fHeight, bpp, &left, &top,
                                                &width, &height, &data, &rowBytes)) {
         return false;
     }
     size_t trimRowBytes = width * bpp;
 
     // 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
 
-    bool useSizedFormat = use_sized_format_for_texture(this->ctxInfo(), desc.fConfig);
-
     // Internal format comes from the texture desc.
-    GrGLenum internalFormat = useSizedFormat ?
-                                fConfigTable[desc.fConfig].fSizedInternalFormat:
-                                fConfigTable[desc.fConfig].fBaseInternalFormat;
+    GrGLenum internalFormat = fConfigTable[desc.fConfig].fInternalFormatTexImage;
 
     // External format and type come from the upload data.
     GrGLenum externalFormat = fConfigTable[dataConfig].fExternalFormatForTexImage;
     GrGLenum externalType = fConfigTable[dataConfig].fExternalType;
 
     /*
      *  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.
@@ skipping 478 matching lines @@
             format->fTotalBits += format->fStencilBits;
         } else {
             format->fTotalBits = format->fStencilBits;
         }
     }
 }
 }
 
 int GrGLGpu::getCompatibleStencilIndex(GrPixelConfig config) {
     static const int kSize = 16;
+    SkASSERT(this->caps()->isConfigRenderable(config, false));

[egdaniel, 2015/12/18 01:31:15]

Do we know we will only get here for non-msaa?

[bsalomon, 2015/12/18 02:01:52]

No, but we know that any msaa renderable format is also renderable without msaa
(and the code below uses a non-msaa color attachment). 

     if (ConfigEntry::kUnknown_StencilIndex == fConfigTable[config].fStencilFormatIndex) {
         // Default to unsupported
         fConfigTable[config].fStencilFormatIndex = ConfigEntry::kUnsupported_StencilFormatIndex;
         // Create color texture
         GrGLuint colorID = 0;
         GL_CALL(GenTextures(1, &colorID));
         this->setScratchTextureUnit();
         GL_CALL(BindTexture(GR_GL_TEXTURE_2D, colorID));
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_MAG_FILTER,
                               GR_GL_NEAREST));
         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));
 
-        GrGLenum internalFormat = 0x0; // suppress warning
-        GrGLenum externalFormat = 0x0; // suppress warning
-        GrGLenum externalType = 0x0;   // suppress warning
-        bool useSizedFormat = use_sized_format_for_texture(this->ctxInfo(), config);
-        if (!this->configToGLFormats(config, useSizedFormat, &internalFormat,
-                                     &externalFormat, &externalType)) {
-            GL_CALL(DeleteTextures(1, &colorID));
-            return ConfigEntry::kUnsupported_StencilFormatIndex;
-        }
+        GrGLenum internalFormat = fConfigTable[config].fInternalFormatTexImage;
+        GrGLenum externalFormat = fConfigTable[config].fExternalFormatForTexImage;
+        GrGLenum externalType = fConfigTable[config].fExternalType;
 
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         GL_ALLOC_CALL(this->glInterface(), TexImage2D(GR_GL_TEXTURE_2D,
-                                                      0, internalFormat,
+                                                      0,
+                                                      internalFormat,
                                                       kSize,
                                                       kSize,
                                                       0,
                                                       externalFormat,
                                                       externalType,
                                                       NULL));
         if (GR_GL_NO_ERROR != GR_GL_GET_ERROR(this->glInterface())) {
             GL_CALL(DeleteTextures(1, &colorID));
             return ConfigEntry::kUnsupported_StencilFormatIndex;
         }
@@ skipping 1469 matching lines @@
     fConfigTable[kR11_EAC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_R11_EAC;
     fConfigTable[kR11_EAC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_R11_EAC;
     fConfigTable[kR11_EAC_GrPixelConfig].fExternalFormat = 0;
     fConfigTable[kR11_EAC_GrPixelConfig].fExternalType = 0;
 
     fConfigTable[kASTC_12x12_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12;
     fConfigTable[kASTC_12x12_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12;
     fConfigTable[kASTC_12x12_GrPixelConfig].fExternalFormat = 0;
     fConfigTable[kASTC_12x12_GrPixelConfig].fExternalType = 0;
 
+    // Bulk populate the texture internal/external formats here and then deal with exceptions below.
 
-    // Almost always we want to pass fExternalFormat as the <format> param to glTex[Sub]Image.
+    // ES 2.0 requires that the internal/external formats match.
+    bool useSizedFormats = (kGL_GrGLStandard == this->glStandard() ||
+                            this->glVersion() >= GR_GL_VER(3,0));
     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
+        // Almost always we want to pass fExternalFormat as the <format> param to glTex[Sub]Image.
         fConfigTable[i].fExternalFormatForTexImage = fConfigTable[i].fExternalFormat;
+        fConfigTable[i].fInternalFormatTexImage = useSizedFormats ?
+                                                        fConfigTable[i].fSizedInternalFormat :
+                                                        fConfigTable[i].fBaseInternalFormat;
     }
     // OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format>
     // param to Tex(Sub)Image. ES 2.0 requires the <internalFormat> and <format> params to match.
     // Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the <format> param.
     // On OpenGL and ES 3.0+ GL_SRGB_ALPHA does not work for the <format> param to glTexImage.
     if (this->glStandard() == kGLES_GrGLStandard && this->glVersion() == GR_GL_VER(2,0)) {
         fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalFormatForTexImage = GR_GL_SRGB_ALPHA;
     }
 
+    // If BGRA is supported as an internal format it must always be specified to glTex[Sub]Image
+    // as a base format.
+    // GL_EXT_texture_format_BGRA8888:
+    //      This extension GL_BGRA as an unsized internal format. However, it is written against ES
+    //      2.0 and therefore doesn't define a value for GL_BGRA8 as ES 2.0 uses unsized internal
+    //      formats.
+    // GL_APPLE_texture_format_BGRA8888: 
+    //     ES 2.0: the extension makes BGRA an external format but not an internal format.
+    //     ES 3.0: the extension explicitly states GL_BGRA8 is not a valid internal format for
+    //             glTexImage (just for glTexStorage).
+    if (useSizedFormats && this->glCaps().bgraIsInternalFormat())  {
+        fConfigTable[kBGRA_8888_GrPixelConfig].fInternalFormatTexImage = GR_GL_BGRA;
+    }
+
 #ifdef SK_DEBUG
     // Make sure we initialized everything.
     ConfigEntry defaultEntry;
     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
         SkASSERT(defaultEntry.fBaseInternalFormat != fConfigTable[i].fBaseInternalFormat);
         SkASSERT(defaultEntry.fSizedInternalFormat != fConfigTable[i].fSizedInternalFormat);
         SkASSERT(defaultEntry.fExternalFormat != fConfigTable[i].fExternalFormat);
         SkASSERT(defaultEntry.fExternalType != fConfigTable[i].fExternalType);
     }
 #endif
@@ skipping 697 matching lines @@
             SkASSERT(GrCaps::kAdvanced_BlendEquationSupport ==
                      this->caps()->blendEquationSupport());
             GL_CALL(BlendBarrier());
             return;
         default: break; // placate compiler warnings that kNone not handled
     }
 }
 
 GrBackendObject GrGLGpu::createTestingOnlyBackendTexture(void* pixels, int w, int h,
                                                          GrPixelConfig config) const {
+    if (!this->caps()->isConfigTexturable(config)) {
+        return false;
+    }
     GrGLTextureInfo* info = new GrGLTextureInfo;
     info->fTarget = GR_GL_TEXTURE_2D;
     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 = 0x0; // suppress warning
-    GrGLenum externalFormat = 0x0; // suppress warning
-    GrGLenum externalType = 0x0;   // suppress warning
-
-    bool useSizedFormat = use_sized_format_for_texture(this->ctxInfo(), config);
-    this->configToGLFormats(config, useSizedFormat, &internalFormat, &externalFormat,
-                            &externalType);
+    GrGLenum internalFormat = fConfigTable[config].fInternalFormatTexImage;
+    GrGLenum externalFormat = fConfigTable[config].fExternalFormatForTexImage;
+    GrGLenum externalType = fConfigTable[config].fExternalType;
 
     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;
 }