Capture/Replay: Fix GetTexImage on Luminance

src/libANGLE/formatutils.cpp

@@ -1468,6 +1468,22 @@ bool CompressedFormatRequiresWholeImage(GLenum internalFormat)
     }
 }
 
+void MaybeOverrideLuminance(GLenum &format, GLenum &type, GLenum actualFormat, GLenum actualType)
+{
+    gl::InternalFormat internalFormat = gl::GetInternalFormatInfo(format, type);
+    if (internalFormat.isLUMA())
+    {
+        // Ensure the format and type are compatible
+        ASSERT(internalFormat.pixelBytes ==
+               gl::GetInternalFormatInfo(actualFormat, actualType).pixelBytes);
+
+        // For Luminance formats, override with the internal format. Since this is not
+        // renderable, our pixel pack routines don't handle it correctly.
+        format = actualFormat;
+        type   = actualType;
+    }
+}
+
 const FormatSet &GetAllSizedInternalFormats()
 {
     static angle::base::NoDestructor<FormatSet> formatSet(BuildAllSizedInternalFormatSet());

src/libANGLE/formatutils.h

@@ -267,6 +267,9 @@ GLenum GetUnsizedFormat(GLenum internalFormat);
 // Return whether the compressed format requires whole image/mip level to be uploaded to texture.
 bool CompressedFormatRequiresWholeImage(GLenum internalFormat);
 
+// In support of GetImage, check for LUMA formats and override with real format
+void MaybeOverrideLuminance(GLenum &format, GLenum &type, GLenum actualFormat, GLenum actualType);
+
 typedef std::set<GLenum> FormatSet;
 const FormatSet &GetAllSizedInternalFormats();
 

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -234,6 +234,10 @@ angle::Result RenderbufferVk::getRenderbufferImage(const gl::Context *context,
 
     ContextVk *contextVk = vk::GetImpl(context);
     ANGLE_TRY(mImage->flushAllStagedUpdates(contextVk));
+
+    gl::MaybeOverrideLuminance(format, type, getColorReadFormat(context),
+                               getColorReadType(context));
+
     return mImage->readPixelsForGetImage(contextVk, packState, packBuffer, 0, 0, format, type,
                                          pixels);
 }

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -2423,6 +2423,10 @@ angle::Result TextureVk::getTexImage(const gl::Context *context,
 
     size_t layer =
         gl::IsCubeMapFaceTarget(target) ? gl::CubeMapTextureTargetToFaceIndex(target) : 0;
+
+    gl::MaybeOverrideLuminance(format, type, getColorReadFormat(context),
+                               getColorReadType(context));
+
     return mImage->readPixelsForGetImage(contextVk, packState, packBuffer, level,
                                          static_cast<uint32_t>(layer), format, type, pixels);
 }

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -4578,7 +4578,7 @@ angle::Result ImageHelper::readPixelsForGetImage(ContextVk *contextVk,
 
     VkImageAspectFlagBits aspectFlags = {};
     if (angleFormat.redBits > 0 || angleFormat.blueBits > 0 || angleFormat.greenBits > 0 ||
-        angleFormat.alphaBits > 0)
+        angleFormat.alphaBits > 0 || angleFormat.luminanceBits > 0)
     {
         aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
     }

src/tests/gl_tests/GetImageTest.cpp

@@ -17,6 +17,9 @@ namespace
 constexpr uint32_t kSize        = 32;
 constexpr char kExtensionName[] = "GL_ANGLE_get_image";
 constexpr uint32_t kSmallSize   = 2;
+constexpr uint8_t kUNormZero    = 0x00;
+constexpr uint8_t kUNormHalf    = 0x7F;
+constexpr uint8_t kUNormFull    = 0xFF;
 
 class GetImageTest : public ANGLETest
 {
@@ -38,6 +41,16 @@ class GetImageTestNoExtensions : public ANGLETest
     GetImageTestNoExtensions() { setExtensionsEnabled(false); }
 };
 
+GLTexture InitTextureWithFormatAndSize(GLenum format, uint32_t size, void *pixelData)
+{
+    GLTexture tex;
+    glBindTexture(GL_TEXTURE_2D, tex);
+    glTexImage2D(GL_TEXTURE_2D, 0, format, size, size, 0, format, GL_UNSIGNED_BYTE, pixelData);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    return tex;
+}
+
 GLTexture InitTextureWithSize(uint32_t size, void *pixelData)
 {
     // Create a simple texture.
@@ -292,6 +305,111 @@ TEST_P(GetImageTestNoExtensions, EntryPointsInactive)
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }
 
+// Test LUMINANCE_ALPHA (non-renderable) format with GetTexImage
+TEST_P(GetImageTest, GetTexImageLuminanceAlpha)
+{
+    // Verify the extension is enabled.
+    ASSERT_TRUE(IsGLExtensionEnabled(kExtensionName));
+
+    constexpr GLColorRG kMediumLumAlpha = GLColorRG(kUNormHalf, kUNormHalf);
+    std::vector<GLColorRG> expectedData = {kMediumLumAlpha, kMediumLumAlpha, kMediumLumAlpha,
+                                           kMediumLumAlpha};
+
+    glViewport(0, 0, kSmallSize, kSmallSize);
+
+    // Set up a simple LUMINANCE_ALPHA texture
+    GLTexture tex =
+        InitTextureWithFormatAndSize(GL_LUMINANCE_ALPHA, kSmallSize, expectedData.data());
+
+    // Draw once with simple texture.
+    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Texture2D(), essl1_shaders::fs::Texture2D());
+    drawQuad(program, essl1_shaders::PositionAttrib(), 0.5, 1.0f, true);
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(kUNormHalf, kUNormHalf, kUNormHalf, kUNormHalf));
+    ASSERT_GL_NO_ERROR();
+
+    // Pack pixels tightly.
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    // Verify GetImage.
+    std::vector<GLColorRG> actualData(kSmallSize * kSmallSize);
+    glGetTexImageANGLE(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, actualData.data());
+    EXPECT_GL_NO_ERROR();
+    for (uint32_t i = 0; i < kSmallSize * kSmallSize; ++i)
+    {
+        EXPECT_EQ(expectedData[i].R, actualData[i].R);
+        EXPECT_EQ(expectedData[i].G, actualData[i].G);
+    }
+}
+
+// Test LUMINANCE (non-renderable) format with GetTexImage
+TEST_P(GetImageTest, GetTexImageLuminance)
+{
+    // Verify the extension is enabled.
+    ASSERT_TRUE(IsGLExtensionEnabled(kExtensionName));
+
+    constexpr GLColorR kMediumLuminance = GLColorR(kUNormHalf);
+    std::vector<GLColorR> expectedData  = {kMediumLuminance, kMediumLuminance, kMediumLuminance,
+                                          kMediumLuminance};
+
+    glViewport(0, 0, kSmallSize, kSmallSize);
+
+    // Set up a simple LUMINANCE texture
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    GLTexture tex = InitTextureWithFormatAndSize(GL_LUMINANCE, kSmallSize, expectedData.data());
+
+    // Draw once with simple texture.
+    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Texture2D(), essl1_shaders::fs::Texture2D());
+    drawQuad(program, essl1_shaders::PositionAttrib(), 0.5, 1.0f, true);
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(kUNormHalf, kUNormHalf, kUNormHalf, kUNormFull));
+    ASSERT_GL_NO_ERROR();
+
+    // Pack pixels tightly.
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    // Verify GetImage.
+    std::vector<GLColorR> actualData(kSmallSize * kSmallSize);
+    glGetTexImageANGLE(GL_TEXTURE_2D, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, actualData.data());
+    EXPECT_GL_NO_ERROR();
+    for (uint32_t i = 0; i < kSmallSize * kSmallSize; ++i)
+    {
+        EXPECT_EQ(expectedData[i].R, actualData[i].R);
+    }
+}
+
+// Test ALPHA (non-renderable) format with GetTexImage
+TEST_P(GetImageTest, GetTexImageAlpha)
+{
+    // Verify the extension is enabled.
+    ASSERT_TRUE(IsGLExtensionEnabled(kExtensionName));
+
+    constexpr GLColorR kMediumAlpha    = GLColorR(kUNormHalf);
+    std::vector<GLColorR> expectedData = {kMediumAlpha, kMediumAlpha, kMediumAlpha, kMediumAlpha};
+
+    glViewport(0, 0, kSmallSize, kSmallSize);
+
+    // Set up a simple ALPHA texture
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    GLTexture tex = InitTextureWithFormatAndSize(GL_ALPHA, kSmallSize, expectedData.data());
+
+    // Draw once with simple texture
+    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Texture2D(), essl1_shaders::fs::Texture2D());
+    drawQuad(program, essl1_shaders::PositionAttrib(), 0.5, 1.0f, true);
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(kUNormZero, kUNormZero, kUNormZero, kUNormHalf));
+    ASSERT_GL_NO_ERROR();
+
+    // Pack pixels tightly.
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    // Verify we get back the correct pixels from GetTexImage
+    std::vector<GLColorR> actualData(kSmallSize * kSmallSize);
+    glGetTexImageANGLE(GL_TEXTURE_2D, 0, GL_ALPHA, GL_UNSIGNED_BYTE, actualData.data());
+    EXPECT_GL_NO_ERROR();
+    for (uint32_t i = 0; i < kSmallSize * kSmallSize; ++i)
+    {
+        EXPECT_EQ(expectedData[i].R, actualData[i].R);
+    }
+}
+
 ANGLE_INSTANTIATE_TEST(GetImageTest, ES2_VULKAN(), ES3_VULKAN());
 ANGLE_INSTANTIATE_TEST(GetImageTestNoExtensions, ES2_VULKAN(), ES3_VULKAN());
 }  // namespace
\ No newline at end of file

src/tests/test_utils/ANGLETest.h

@@ -94,6 +94,30 @@ struct GLColorRGB
     static const GLColorRGB yellow;
 };
 
+struct GLColorRG
+{
+    constexpr GLColorRG() : R(0), G(0) {}
+    constexpr GLColorRG(GLubyte r, GLubyte g) : R(r), G(g) {}
+    GLColorRG(const angle::Vector2 &floatColor);
+
+    const GLubyte *data() const { return &R; }
+    GLubyte *data() { return &R; }
+
+    GLubyte R, G;
+};
+
+struct GLColorR
+{
+    constexpr GLColorR() : R(0) {}
+    constexpr GLColorR(GLubyte r) : R(r) {}
+    GLColorR(const float floatColor);
+
+    const GLubyte *data() const { return &R; }
+    GLubyte *data() { return &R; }
+
+    GLubyte R;
+};
+
 struct GLColor
 {
     constexpr GLColor() : R(0), G(0), B(0), A(0) {}