Vulkan: Implement EXT_texture_sRGB_decode

Implement EXT_texture_sRGB_decode. This builds on the existing
functionality from EXT_texture_sRGB_override, with 2 major edge
cases:
1. sRGB_decode allows the texture state to be overridden by
sampler state, which is implemented by forcing a a texture state
sync during updateActiveTextures if a texture is bound to the same
unit as a sampler with that state
2. texelFetch calls require us to reenable decoding, regardless
of decode state. We add a new compiler pass
(FlagSamplersWithTexelFetch) to mark samplers that are used with
texelFetch in order to support this.
This change also re-enables EXT_texture_sRGB_R8, which was disabled
due to a dEQP bug that this change will bypass.

Bug: angleproject:3609
Bug: angleproject:4503
Test: dEQP.GLES31/functional_srgb_texture_decode_skip_decode_*
Test: GLES31/functional_state_query_texture_*_srgb_decode_*
Test: GLES31/functional_state_query_sampler_*_srgb_decode_*
Test: GLES31/functional_debug_negative_coverage_*_srgb_decode_*
Test: GLES31/functional_android_extension_pack_extensions_ext_texture_srgb_decode
Test: angle_end2end_tests --gtest_filter=SRGBTextureTest.*Vulkan*
Change-Id: I4a67e487dc82e2f57c8c87d4bcd8ef442b6fe220
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2359481
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Tim Van Patten <timvp@google.com>

Author: Mohan Maiya

include/GLSLANG/ShaderVars.h

@@ -200,6 +200,9 @@ struct ShaderVariable
     // Deprecated version of isSameVaryingAtLinkTime, which assumes ESSL1.
     bool isSameVaryingAtLinkTime(const ShaderVariable &other) const;
 
+    // If the variable is a sampler that has ever been statically used with texelFetch
+    bool texelFetchInvoked;
+
   protected:
     bool isSameVariableAtLinkTime(const ShaderVariable &other,
                                   bool matchPrecision,

src/common/utilities.h

@@ -223,12 +223,19 @@ const char *GetDebugMessageTypeString(GLenum type);
 const char *GetDebugMessageSeverityString(GLenum severity);
 
 // For use with EXT_texture_format_sRGB_override and EXT_texture_sRGB_decode
-// A texture may either have SRGB decoding forced on, or use whatever decode state is default for
-// the texture format.
+// A texture may be forced to decode to a nonlinear colorspace, to a linear colorspace, or to the
+// default colorspace of its current format.
+//
+// Default corresponds to "the texture should use the imageview that corresponds to its format"
+// Linear corresponds to "the texture has sRGB decoding disabled by extension, and should use a
+// linear imageview even if it is in a nonlinear format" NonLinear corresponds to "the texture has
+// sRGB override enabled by extension, and should use a nonlinear imageview even if it is in a
+// linear format"
 enum class SrgbOverride
 {
     Default = 0,
-    Enabled
+    Linear,
+    NonLinear
 };
 
 }  // namespace gl

src/compiler.gni

@@ -134,6 +134,8 @@ angle_translator_sources = [
   "src/compiler/translator/tree_ops/EmulatePrecision.h",
   "src/compiler/translator/tree_ops/ExpandIntegerPowExpressions.cpp",
   "src/compiler/translator/tree_ops/ExpandIntegerPowExpressions.h",
+  "src/compiler/translator/tree_ops/FlagSamplersWithTexelFetch.cpp",
+  "src/compiler/translator/tree_ops/FlagSamplersWithTexelFetch.h",
   "src/compiler/translator/tree_ops/FoldExpressions.cpp",
   "src/compiler/translator/tree_ops/FoldExpressions.h",
   "src/compiler/translator/tree_ops/InitializeVariables.cpp",

src/compiler/translator/ShaderVars.cpp

@@ -48,6 +48,7 @@ ShaderVariable::ShaderVariable(GLenum typeIn)
       index(-1),
       interpolation(INTERPOLATION_SMOOTH),
       isInvariant(false),
+      texelFetchInvoked(false),
       flattenedOffsetInParentArrays(-1)
 {}
 
@@ -79,6 +80,7 @@ ShaderVariable::ShaderVariable(const ShaderVariable &other)
       index(other.index),
       interpolation(other.interpolation),
       isInvariant(other.isInvariant),
+      texelFetchInvoked(other.texelFetchInvoked),
       flattenedOffsetInParentArrays(other.flattenedOffsetInParentArrays)
 {}
 
@@ -104,6 +106,7 @@ ShaderVariable &ShaderVariable::operator=(const ShaderVariable &other)
     index                         = other.index;
     interpolation                 = other.interpolation;
     isInvariant                   = other.isInvariant;
+    texelFetchInvoked             = other.texelFetchInvoked;
     return *this;
 }
 
@@ -117,7 +120,7 @@ bool ShaderVariable::operator==(const ShaderVariable &other) const
         binding != other.binding || imageUnitFormat != other.imageUnitFormat ||
         offset != other.offset || readonly != other.readonly || writeonly != other.writeonly ||
         index != other.index || interpolation != other.interpolation ||
-        isInvariant != other.isInvariant)
+        isInvariant != other.isInvariant || texelFetchInvoked != other.texelFetchInvoked)
     {
         return false;
     }

src/compiler/translator/TranslatorVulkan.cpp

@@ -18,6 +18,7 @@
 #include "compiler/translator/ImmutableStringBuilder.h"
 #include "compiler/translator/OutputVulkanGLSL.h"
 #include "compiler/translator/StaticType.h"
+#include "compiler/translator/tree_ops/FlagSamplersWithTexelFetch.h"
 #include "compiler/translator/tree_ops/NameEmbeddedUniformStructs.h"
 #include "compiler/translator/tree_ops/RemoveAtomicCounterBuiltins.h"
 #include "compiler/translator/tree_ops/RemoveInactiveInterfaceVariables.h"
@@ -848,6 +849,11 @@ bool TranslatorVulkan::translateImpl(TIntermBlock *root,
         }
     }
 
+    if (!FlagSamplersForTexelFetch(this, root, &getSymbolTable(), &mUniforms))
+    {
+        return false;
+    }
+
     if (defaultUniformCount > 0)
     {
         gl::ShaderType shaderType = gl::FromGLenum<gl::ShaderType>(getShaderType());

src/compiler/translator/tree_ops/FlagSamplersWithTexelFetch.cpp

@@ -0,0 +1,100 @@
+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FlagSamplersForTexelFetch.cpp: finds all instances of texelFetch used with a static reference to
+// a sampler uniform, and flag that uniform as having been used with texelFetch
+//
+
+#include "compiler/translator/tree_ops/FlagSamplersWithTexelFetch.h"
+
+#include "angle_gl.h"
+#include "common/utilities.h"
+
+#include "compiler/translator/SymbolTable.h"
+#include "compiler/translator/tree_util/IntermNode_util.h"
+#include "compiler/translator/tree_util/IntermTraverse.h"
+#include "compiler/translator/tree_util/ReplaceVariable.h"
+
+namespace sh
+{
+namespace
+{
+
+// gvec4 texelFetch(gsamplerXD sampler, ivecX P, int lod)
+constexpr uint32_t kTexelFetchSequenceLength = 3u;
+
+// gvec4 texelFetchOffset(gsamplerXD sampler, ivecX P, int lod, ivecX offset)
+constexpr uint32_t kTexelFetchOffsetSequenceLength = 4u;
+
+class FlagSamplersWithTexelFetchTraverser : public TIntermTraverser
+{
+  public:
+    FlagSamplersWithTexelFetchTraverser(TSymbolTable *symbolTable,
+                                        std::vector<ShaderVariable> *uniforms)
+        : TIntermTraverser(true, true, true, symbolTable), mUniforms(uniforms)
+    {}
+
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override
+    {
+        // Decide if the node is a call to texelFetch[Offset]
+        if (node->getOp() != EOpCallBuiltInFunction)
+        {
+            return true;
+        }
+
+        ASSERT(node->getFunction()->symbolType() == SymbolType::BuiltIn);
+        if (node->getFunction()->name() != "texelFetch" &&
+            node->getFunction()->name() != "texelFetchOffset")
+        {
+            return true;
+        }
+
+        const TIntermSequence *sequence = node->getSequence();
+
+        // This must be a valid texelFetch invokation with the required number of arguments
+        ASSERT(sequence->size() == (node->getFunction()->name() == "texelFetch"
+                                        ? kTexelFetchSequenceLength
+                                        : kTexelFetchOffsetSequenceLength));
+
+        TIntermSymbol *samplerSymbol = sequence->at(0)->getAsSymbolNode();
+        ASSERT(samplerSymbol != nullptr);
+
+        const TVariable &samplerVariable = samplerSymbol->variable();
+
+        for (ShaderVariable &uniform : *mUniforms)
+        {
+            if (samplerVariable.name() == uniform.name)
+            {
+                ASSERT(gl::IsSamplerType(uniform.type));
+                uniform.texelFetchInvoked = true;
+                break;
+            }
+        }
+
+        return true;
+    }
+
+  private:
+    std::vector<ShaderVariable> *mUniforms;
+};
+
+}  // anonymous namespace
+
+bool FlagSamplersForTexelFetch(TCompiler *compiler,
+                               TIntermBlock *root,
+                               TSymbolTable *symbolTable,
+                               std::vector<ShaderVariable> *uniforms)
+{
+    ASSERT(uniforms != nullptr);
+    if (uniforms->size() > 0)
+    {
+        FlagSamplersWithTexelFetchTraverser traverser(symbolTable, uniforms);
+        root->traverse(&traverser);
+    }
+
+    return true;
+}
+
+}  // namespace sh

src/compiler/translator/tree_ops/FlagSamplersWithTexelFetch.h

@@ -0,0 +1,31 @@
+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// FlagSamplersForTexelFetch.h: finds all instances of texelFetch used with a static reference to a
+// sampler uniform, and flag that uniform as having been used with texelFetch
+//
+
+#ifndef COMPILER_TRANSLATOR_TREEOPS_FLAGSAMPLERSWITHTEXELFETCH_H_
+#define COMPILER_TRANSLATOR_TREEOPS_FLAGSAMPLERSWITHTEXELFETCH_H_
+
+#include "GLSLANG/ShaderVars.h"
+#include "common/angleutils.h"
+
+namespace sh
+{
+class TCompiler;
+class TIntermBlock;
+class TSymbolTable;
+
+// This flags all samplers which are statically accessed by a texelFetch invokation- that is, the
+// sampler is used as a direct argument to the call to texelFetch. Dynamic accesses, or accesses
+// with any amount of indirection, are not counted.
+ANGLE_NO_DISCARD bool FlagSamplersForTexelFetch(TCompiler *compiler,
+                                                TIntermBlock *root,
+                                                TSymbolTable *symbolTable,
+                                                std::vector<sh::ShaderVariable> *uniforms);
+}  // namespace sh
+
+#endif  // COMPILER_TRANSLATOR_TREEOPS_FLAGSAMPLERSWITHTEXELFETCH_H_

src/libANGLE/Context.cpp

@@ -5611,7 +5611,7 @@ void Context::texImage2DExternal(TextureTarget target,
 void Context::invalidateTexture(TextureType target)
 {
     mImplementation->invalidateTexture(target);
-    mState.invalidateTexture(target);
+    mState.invalidateTextureBindings(target);
 }
 
 void Context::getMultisamplefv(GLenum pname, GLuint index, GLfloat *val)

src/libANGLE/Program.cpp

@@ -889,6 +889,7 @@ void WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var)
     stream->writeInt(var.offset);
     stream->writeInt(var.readonly);
     stream->writeInt(var.writeonly);
+    stream->writeInt(var.texelFetchInvoked);
 
     ASSERT(var.fields.empty());
 }
@@ -906,10 +907,11 @@ void LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var)
     var->structName = stream->readString();
     var->setParentArrayIndex(stream->readInt<int>());
 
-    var->imageUnitFormat = stream->readInt<GLenum>();
-    var->offset          = stream->readInt<int>();
-    var->readonly        = stream->readBool();
-    var->writeonly       = stream->readBool();
+    var->imageUnitFormat   = stream->readInt<GLenum>();
+    var->offset            = stream->readInt<int>();
+    var->readonly          = stream->readBool();
+    var->writeonly         = stream->readBool();
+    var->texelFetchInvoked = stream->readBool();
 }
 
 // VariableLocation implementation.

src/libANGLE/ProgramLinkedResources.cpp

@@ -469,10 +469,11 @@ class FlattenUniformVisitor : public sh::VariableNameVisitor
             LinkedUniform linkedUniform(variable.type, variable.precision, fullNameWithArrayIndex,
                                         variable.arraySizes, getBinding(), getOffset(), mLocation,
                                         -1, sh::kDefaultBlockMemberInfo);
-            linkedUniform.mappedName      = fullMappedNameWithArrayIndex;
-            linkedUniform.active          = mMarkActive;
-            linkedUniform.staticUse       = mMarkStaticUse;
-            linkedUniform.outerArraySizes = arraySizes;
+            linkedUniform.mappedName        = fullMappedNameWithArrayIndex;
+            linkedUniform.active            = mMarkActive;
+            linkedUniform.staticUse         = mMarkStaticUse;
+            linkedUniform.outerArraySizes   = arraySizes;
+            linkedUniform.texelFetchInvoked = variable.texelFetchInvoked;
             if (variable.hasParentArrayIndex())
             {
                 linkedUniform.setParentArrayIndex(variable.parentArrayIndex());