Make compressed texture format extensions enableable.

src/libANGLE/Caps.cpp

@@ -629,13 +629,13 @@ const ExtensionInfoMap &GetExtensionInfoMap()
         map["GL_OES_texture_float"] = enableableExtension(&Extensions::textureFloat);
         map["GL_OES_texture_float_linear"] = enableableExtension(&Extensions::textureFloatLinear);
         map["GL_EXT_texture_rg"] = enableableExtension(&Extensions::textureRG);
-        map["GL_EXT_texture_compression_dxt1"] = esOnlyExtension(&Extensions::textureCompressionDXT1);
-        map["GL_ANGLE_texture_compression_dxt3"] = esOnlyExtension(&Extensions::textureCompressionDXT3);
-        map["GL_ANGLE_texture_compression_dxt5"] = esOnlyExtension(&Extensions::textureCompressionDXT5);
-        map["GL_EXT_texture_compression_s3tc_srgb"] = esOnlyExtension(&Extensions::textureCompressionS3TCsRGB);
-        map["GL_KHR_texture_compression_astc_hdr"] = esOnlyExtension(&Extensions::textureCompressionASTCHDR);
-        map["GL_KHR_texture_compression_astc_ldr"] = esOnlyExtension(&Extensions::textureCompressionASTCLDR);
-        map["GL_OES_compressed_ETC1_RGB8_texture"] = esOnlyExtension(&Extensions::compressedETC1RGB8Texture);
+        map["GL_EXT_texture_compression_dxt1"] = enableableExtension(&Extensions::textureCompressionDXT1);
+        map["GL_ANGLE_texture_compression_dxt3"] = enableableExtension(&Extensions::textureCompressionDXT3);
+        map["GL_ANGLE_texture_compression_dxt5"] = enableableExtension(&Extensions::textureCompressionDXT5);
+        map["GL_EXT_texture_compression_s3tc_srgb"] = enableableExtension(&Extensions::textureCompressionS3TCsRGB);
+        map["GL_KHR_texture_compression_astc_hdr"] = enableableExtension(&Extensions::textureCompressionASTCHDR);
+        map["GL_KHR_texture_compression_astc_ldr"] = enableableExtension(&Extensions::textureCompressionASTCLDR);
+        map["GL_OES_compressed_ETC1_RGB8_texture"] = enableableExtension(&Extensions::compressedETC1RGB8Texture);
         map["GL_EXT_sRGB"] = enableableExtension(&Extensions::sRGB);
         map["GL_ANGLE_depth_texture"] = esOnlyExtension(&Extensions::depthTextures);
         map["GL_OES_depth32"] = esOnlyExtension(&Extensions::depth32);
@@ -673,7 +673,7 @@ const ExtensionInfoMap &GetExtensionInfoMap()
         map["GL_KHR_debug"] = esOnlyExtension(&Extensions::debug);
         // TODO(jmadill): Enable this when complete.
         //map["GL_KHR_no_error"] = esOnlyExtension(&Extensions::noError);
-        map["GL_ANGLE_lossy_etc_decode"] = esOnlyExtension(&Extensions::lossyETCDecode);
+        map["GL_ANGLE_lossy_etc_decode"] = enableableExtension(&Extensions::lossyETCDecode);
         map["GL_CHROMIUM_bind_uniform_location"] = esOnlyExtension(&Extensions::bindUniformLocation);
         map["GL_CHROMIUM_sync_query"] = enableableExtension(&Extensions::syncQuery);
         map["GL_CHROMIUM_copy_texture"] = esOnlyExtension(&Extensions::copyTexture);

src/libANGLE/formatutils.cpp

@@ -766,7 +766,7 @@ static InternalFormatInfoMap BuildInternalFormatInfoMap()
     AddCompressedFormat(&map, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,   4, 4,  64, 4, GL_RGBA, GL_UNSIGNED_BYTE, false, RequireExt<&Extensions::textureCompressionDXT1>,    NeverSupported, AlwaysSupported);
 
     // From GL_ANGLE_texture_compression_dxt3
-    AddCompressedFormat(&map, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, 4, 4, 128, 4, GL_RGBA, GL_UNSIGNED_BYTE, false, RequireExt<&Extensions::textureCompressionDXT5>,    NeverSupported, AlwaysSupported);
+    AddCompressedFormat(&map, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, 4, 4, 128, 4, GL_RGBA, GL_UNSIGNED_BYTE, false, RequireExt<&Extensions::textureCompressionDXT3>,    NeverSupported, AlwaysSupported);
 
     // From GL_ANGLE_texture_compression_dxt5
     AddCompressedFormat(&map, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, 4, 4, 128, 4, GL_RGBA, GL_UNSIGNED_BYTE, false, RequireExt<&Extensions::textureCompressionDXT5>,    NeverSupported, AlwaysSupported);

src/libANGLE/renderer/null/ContextNULL.cpp

@@ -76,6 +76,14 @@ ContextNULL::ContextNULL(const gl::ContextState &state, AllocationTrackerNULL *a
     mExtensions.textureUsage          = true;
 
     mExtensions.rgb8rgba8 = true;
+    mExtensions.textureCompressionDXT1     = true;
+    mExtensions.textureCompressionDXT3     = true;
+    mExtensions.textureCompressionDXT5     = true;
+    mExtensions.textureCompressionS3TCsRGB = true;
+    mExtensions.textureCompressionASTCHDR  = true;
+    mExtensions.textureCompressionASTCLDR  = true;
+    mExtensions.compressedETC1RGB8Texture  = true;
+    mExtensions.lossyETCDecode             = true;
 
     const gl::Version maxClientVersion(3, 1);
     mCaps = GenerateMinimumCaps(maxClientVersion, mExtensions);

src/libANGLE/validationES.cpp

@@ -2442,7 +2442,8 @@ bool ValidateCopyTexImageParametersBase(ValidationContext *context,
     }
 
     const gl::InternalFormat &formatInfo =
-        gl::GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);
+        isSubImage ? *texture->getFormat(target, level).info
+                   : gl::GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);
 
     if (formatInfo.depthBits > 0 || formatInfo.compressed)
     {

src/libANGLE/validationES2.cpp

@@ -1173,7 +1173,7 @@ bool ValidateES2TexImageParameters(Context *context,
                 }
                 break;
             case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
-                if (!context->getExtensions().textureCompressionDXT1)
+                if (!context->getExtensions().textureCompressionDXT3)
                 {
                     ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidInternalFormat);
                     return false;
@@ -1202,6 +1202,11 @@ bool ValidateES2TexImageParameters(Context *context,
                     ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidInternalFormat);
                     return false;
                 }
+                if (isSubImage)
+                {
+                    ANGLE_VALIDATION_ERR(context, InvalidOperation(), InvalidInternalFormat);
+                    return false;
+                }
                 break;
             case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
             case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
@@ -1210,8 +1215,7 @@ bool ValidateES2TexImageParameters(Context *context,
             case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
                 if (!context->getExtensions().lossyETCDecode)
                 {
-                    context->handleError(InvalidEnum()
-                                         << "ANGLE_lossy_etc_decode extension is not supported");
+                    ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidInternalFormat);
                     return false;
                 }
                 break;

src/libANGLE/validationES3.cpp

@@ -362,6 +362,12 @@ bool ValidateES3TexImageParametersBase(Context *context,
                                      << "Format must match the internal format of the texture.");
                 return false;
             }
+
+            if (actualInternalFormat == GL_ETC1_RGB8_OES)
+            {
+                ANGLE_VALIDATION_ERR(context, InvalidOperation(), InvalidInternalFormat);
+                return false;
+            }
         }
         else
         {

src/tests/gl_tests/DXT1CompressedTextureTest.cpp

@@ -194,6 +194,22 @@ TEST_P(DXT1CompressedTextureTest, CompressedTexSubImageValidation)
     ASSERT_GL_ERROR(GL_INVALID_OPERATION);
 }
 
+// Test that it's not possible to call CopyTexSubImage2D on a compressed texture
+TEST_P(DXT1CompressedTextureTest, CopyTexSubImage2DDisallowed)
+{
+    ANGLE_SKIP_TEST_IF(!extensionEnabled("GL_EXT_texture_compression_dxt1"));
+
+    GLTexture texture;
+    glBindTexture(GL_TEXTURE_2D, texture.get());
+
+    glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, pixel_0_width,
+                           pixel_0_height, 0, pixel_0_size, nullptr);
+    ASSERT_GL_NO_ERROR();
+
+    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+}
+
 class DXT1CompressedTextureTestES3 : public DXT1CompressedTextureTest { };
 
 class DXT1CompressedTextureTestD3D11 : public DXT1CompressedTextureTest { };
@@ -350,6 +366,23 @@ TEST_P(DXT1CompressedTextureTestD3D11, PBOCompressedTexStorage)
     EXPECT_GL_NO_ERROR();
 }
 
+// Test validation of glCompressedTexSubImage3D with DXT formats
+TEST_P(DXT1CompressedTextureTestES3, CopyTexSubImage3DDisallowed)
+{
+    ANGLE_SKIP_TEST_IF(!extensionEnabled("GL_EXT_texture_compression_dxt1"));
+
+    GLTexture texture;
+    glBindTexture(GL_TEXTURE_2D_ARRAY, texture.get());
+
+    GLsizei depth = 4;
+    glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, pixel_0_width,
+                           pixel_0_height, depth, 0, pixel_0_size * depth, nullptr);
+    ASSERT_GL_NO_ERROR();
+
+    glCopyTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, 0, 0, 4, 4);
+    ASSERT_GL_ERROR(GL_INVALID_OPERATION);
+}
+
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 ANGLE_INSTANTIATE_TEST(DXT1CompressedTextureTest,
                        ES2_D3D9(),

src/tests/gl_tests/WebGLCompatibilityTest.cpp

@@ -235,8 +235,14 @@ class WebGLCompatibilityTest : public ANGLETest
                                  const std::array<GLenum, 2> &drawBuffers,
                                  GLenum expectedError);
 
-    // Called from InvalidTextureFormat
+    // Called from Enable[Compressed]TextureFormatExtensions
     void validateTexImageExtensionFormat(GLenum format, const std::string &extName);
+    void validateCompressedTexImageExtensionFormat(GLenum format,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLsizei blockSize,
+                                                   const std::string &extName,
+                                                   bool subImageAllowed);
 
     PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
 };
@@ -3643,8 +3649,8 @@ void WebGLCompatibilityTest::validateTexImageExtensionFormat(GLenum format,
     }
 }
 
-// Verify that only valid texture formats are allowed.
-TEST_P(WebGLCompatibilityTest, InvalidTextureFormat)
+// Test enabling various non-compressed texture format extensions
+TEST_P(WebGLCompatibilityTest, EnableTextureFormatExtensions)
 {
     ANGLE_SKIP_TEST_IF(IsOzone());
     ANGLE_SKIP_TEST_IF(getClientMajorVersion() != 2);
@@ -3670,6 +3676,114 @@ TEST_P(WebGLCompatibilityTest, InvalidTextureFormat)
     validateTexImageExtensionFormat(GL_BGRA_EXT, "GL_EXT_texture_format_BGRA8888");
 }
 
+void WebGLCompatibilityTest::validateCompressedTexImageExtensionFormat(GLenum format,
+                                                                       GLsizei width,
+                                                                       GLsizei height,
+                                                                       GLsizei blockSize,
+                                                                       const std::string &extName,
+                                                                       bool subImageAllowed)
+{
+    std::vector<GLubyte> data(blockSize, 0u);
+
+    GLTexture texture;
+    glBindTexture(GL_TEXTURE_2D, texture.get());
+
+    // Verify texture format fails by default.
+    glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, blockSize, data.data());
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    if (extensionRequestable(extName))
+    {
+        // Verify texture format is allowed once extension is enabled.
+        glRequestExtensionANGLE(extName.c_str());
+        EXPECT_TRUE(extensionEnabled(extName));
+
+        glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, blockSize, data.data());
+        EXPECT_GL_NO_ERROR();
+
+        glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, blockSize,
+                                  data.data());
+        if (subImageAllowed)
+        {
+            EXPECT_GL_NO_ERROR();
+        }
+        else
+        {
+            EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+        }
+    }
+}
+
+// Test enabling GL_EXT_texture_compression_dxt1 for GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT1RGB)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 8,
+                                              "GL_EXT_texture_compression_dxt1", true);
+}
+
+// Test enabling GL_EXT_texture_compression_dxt1 for GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT1RGBA)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 4, 4, 8,
+                                              "GL_EXT_texture_compression_dxt1", true);
+}
+
+// Test enabling GL_ANGLE_texture_compression_dxt3
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT3)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, 4, 4, 16,
+                                              "GL_ANGLE_texture_compression_dxt3", true);
+}
+
+// Test enabling GL_ANGLE_texture_compression_dxt5
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT5)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, 4, 4, 16,
+                                              "GL_ANGLE_texture_compression_dxt5", true);
+}
+
+// Test enabling GL_EXT_texture_compression_s3tc_srgb for GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT1SRGB)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 4, 4, 8,
+                                              "GL_EXT_texture_compression_s3tc_srgb", true);
+}
+
+// Test enabling GL_EXT_texture_compression_s3tc_srgb for GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT1SRGBA)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 4, 4, 8,
+                                              "GL_EXT_texture_compression_s3tc_srgb", true);
+}
+
+// Test enabling GL_EXT_texture_compression_s3tc_srgb for GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT3SRGBA)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 4, 4, 16,
+                                              "GL_EXT_texture_compression_s3tc_srgb", true);
+}
+
+// Test enabling GL_EXT_texture_compression_s3tc_srgb for GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionDXT5SRGBA)
+{
+    validateCompressedTexImageExtensionFormat(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 4, 4, 16,
+                                              "GL_EXT_texture_compression_s3tc_srgb", true);
+}
+
+// Test enabling GL_OES_compressed_ETC1_RGB8_texture
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionETC1)
+{
+    validateCompressedTexImageExtensionFormat(GL_ETC1_RGB8_OES, 4, 4, 8,
+                                              "GL_OES_compressed_ETC1_RGB8_texture", false);
+}
+
+// Test enabling GL_ANGLE_lossy_etc_decode
+TEST_P(WebGLCompatibilityTest, EnableCompressedTextureExtensionLossyDecode)
+{
+    validateCompressedTexImageExtensionFormat(GL_ETC1_RGB8_LOSSY_DECODE_ANGLE, 4, 4, 8,
+                                              "GL_ANGLE_lossy_etc_decode", true);
+}
+
 // Linking should fail when corresponding vertex/fragment uniform blocks have different precision
 // qualifiers.
 TEST_P(WebGL2CompatibilityTest, UniformBlockPrecisionMismatch)