| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <EGL/egl.h> |
| #include <EGL/eglext.h> |
| #include <GLES2/gl2.h> |
| #include <GLES2/gl2ext.h> |
| #include <jni.h> |
| #include <stdlib.h> |
| #include <android/hardware_buffer.h> |
| #include <android/log.h> |
| #include <cmath> |
| #include <string> |
| #include <sstream> |
| |
| #define LOG_TAG "VrExtensionsJni" |
| #define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE,LOG_TAG,__VA_ARGS__) |
| |
| using PFNEGLGETNATIVECLIENTBUFFERANDROID = |
| EGLClientBuffer(EGLAPIENTRYP)(const AHardwareBuffer* buffer); |
| |
| using PFNGLEGLIMAGETARGETTEXTURE2DOESPROC = void(GL_APIENTRYP)(GLenum target, |
| void* image); |
| |
| using PFNGLBUFFERSTORAGEEXTERNALEXTPROC = |
| void(GL_APIENTRYP)(GLenum target, GLintptr offset, GLsizeiptr size, |
| void* clientBuffer, GLbitfield flags); |
| |
| using PFNGLMAPBUFFERRANGEPROC = void*(GL_APIENTRYP)(GLenum target, |
| GLintptr offset, |
| GLsizeiptr length, |
| GLbitfield access); |
| |
| using PFNGLUNMAPBUFFERPROC = void*(GL_APIENTRYP)(GLenum target); |
| |
| PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES; |
| PFNEGLGETNATIVECLIENTBUFFERANDROID eglGetNativeClientBufferANDROID; |
| PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR; |
| PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC glFramebufferTextureMultiviewOVR; |
| PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC |
| glFramebufferTextureMultisampleMultiviewOVR; |
| PFNGLBUFFERSTORAGEEXTERNALEXTPROC glBufferStorageExternalEXT; |
| PFNGLMAPBUFFERRANGEPROC glMapBufferRange; |
| PFNGLUNMAPBUFFERPROC glUnmapBuffer; |
| |
| #define NO_ERROR 0 |
| #define GL_UNIFORM_BUFFER 0x8A11 |
| |
| // Declare flags that are added to MapBufferRange via EXT_buffer_storage. |
| // https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_buffer_storage.txt |
| #define GL_MAP_PERSISTENT_BIT_EXT 0x0040 |
| #define GL_MAP_COHERENT_BIT_EXT 0x0080 |
| |
| // Declare tokens added as a part of EGL_EXT_image_gl_colorspace. |
| #define EGL_GL_COLORSPACE_DEFAULT_EXT 0x314D |
| |
| #define LOAD_PROC(NAME, TYPE) \ |
| NAME = reinterpret_cast<TYPE>(eglGetProcAddress(# NAME)) |
| |
| #define ASSERT(condition, format, args...) \ |
| if (!(condition)) { \ |
| fail(env, format, ## args); \ |
| return; \ |
| } |
| |
| #define ASSERT_TRUE(a) \ |
| ASSERT((a), "assert failed on (" #a ") at " __FILE__ ":%d", __LINE__) |
| #define ASSERT_FALSE(a) \ |
| ASSERT(!(a), "assert failed on (!" #a ") at " __FILE__ ":%d", __LINE__) |
| #define ASSERT_EQ(a, b) \ |
| ASSERT((a) == (b), "assert failed on (" #a ") at " __FILE__ ":%d", __LINE__) |
| #define ASSERT_NE(a, b) \ |
| ASSERT((a) != (b), "assert failed on (" #a ") at " __FILE__ ":%d", __LINE__) |
| #define ASSERT_GT(a, b) \ |
| ASSERT((a) > (b), "assert failed on (" #a ") at " __FILE__ ":%d", __LINE__) |
| #define ASSERT_NEAR_RGBA(a, b, delta) \ |
| ASSERT(areNearRgba(a, b, delta), \ |
| "assert failed on (" #a ") at " __FILE__ ":%d", __LINE__) |
| |
| bool areNearRgba(int32_t actual, int32_t expected, int delta) { |
| for (int shift = 0; shift < 32; shift += 8) { |
| if (std::abs((actual >> shift & 0xFF) - (expected >> shift & 0xFF)) > delta) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void fail(JNIEnv* env, const char* format, ...) { |
| va_list args; |
| va_start(args, format); |
| char* msg; |
| vasprintf(&msg, format, args); |
| va_end(args); |
| jclass exClass; |
| const char* className = "java/lang/AssertionError"; |
| exClass = env->FindClass(className); |
| env->ThrowNew(exClass, msg); |
| free(msg); |
| } |
| |
| static void testEglImageArray(JNIEnv* env, AHardwareBuffer_Desc desc, |
| int nsamples) { |
| ASSERT_GT(desc.layers, 1); |
| AHardwareBuffer* hwbuffer = nullptr; |
| // If the format is unsupported and allocation fails, skip the test. |
| if (AHardwareBuffer_allocate(&desc, &hwbuffer) != NO_ERROR) return; |
| // Create EGLClientBuffer from the AHardwareBuffer. |
| EGLClientBuffer native_buffer = eglGetNativeClientBufferANDROID(hwbuffer); |
| ASSERT_TRUE(native_buffer); |
| // Create EGLImage from EGLClientBuffer. |
| EGLint attrs[] = {EGL_NONE}; |
| EGLImageKHR image = |
| eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, |
| EGL_NATIVE_BUFFER_ANDROID, native_buffer, attrs); |
| ASSERT_TRUE(image); |
| // Create OpenGL texture from the EGLImage. |
| GLuint texid; |
| glGenTextures(1, &texid); |
| glBindTexture(GL_TEXTURE_2D_ARRAY, texid); |
| glEGLImageTargetTexture2DOES(GL_TEXTURE_2D_ARRAY, image); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| // Create FBO and add multiview attachment. |
| GLuint fboid; |
| glGenFramebuffers(1, &fboid); |
| glBindFramebuffer(GL_FRAMEBUFFER, fboid); |
| const GLint miplevel = 0; |
| const GLint base_view = 0; |
| const GLint num_views = desc.layers; |
| if (nsamples == 1) { |
| glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| texid, miplevel, base_view, num_views); |
| } else { |
| glFramebufferTextureMultisampleMultiviewOVR( |
| GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texid, miplevel, nsamples, |
| base_view, num_views); |
| } |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), |
| GL_FRAMEBUFFER_COMPLETE); |
| // Release memory. |
| glDeleteTextures(1, &texid); |
| glDeleteFramebuffers(1, &fboid); |
| AHardwareBuffer_release(hwbuffer); |
| } |
| |
| extern "C" JNIEXPORT void JNICALL |
| Java_android_vr_cts_VrExtensionBehaviorTest_nativeTestEglImageArray( |
| JNIEnv* env, jclass /* unused */) { |
| // First, load entry points provided by extensions. |
| LOAD_PROC(glEGLImageTargetTexture2DOES, |
| PFNGLEGLIMAGETARGETTEXTURE2DOESPROC); |
| ASSERT_NE(glEGLImageTargetTexture2DOES, nullptr); |
| LOAD_PROC(eglGetNativeClientBufferANDROID, |
| PFNEGLGETNATIVECLIENTBUFFERANDROID); |
| ASSERT_NE(eglGetNativeClientBufferANDROID, nullptr); |
| LOAD_PROC(eglCreateImageKHR, PFNEGLCREATEIMAGEKHRPROC); |
| ASSERT_NE(eglCreateImageKHR, nullptr); |
| LOAD_PROC(glFramebufferTextureMultiviewOVR, |
| PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC); |
| ASSERT_NE(glFramebufferTextureMultiviewOVR, nullptr); |
| LOAD_PROC(glFramebufferTextureMultisampleMultiviewOVR, |
| PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC); |
| ASSERT_NE(glFramebufferTextureMultisampleMultiviewOVR, nullptr); |
| // Try creating a 32x32 AHardwareBuffer and attaching it to a multiview |
| // framebuffer, with various formats and depths. |
| AHardwareBuffer_Desc desc = {}; |
| desc.width = 32; |
| desc.height = 32; |
| desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | |
| AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT; |
| const int layers[] = {2, 4}; |
| const int formats[] = { |
| AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM, |
| AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, |
| AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM, |
| AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT, |
| // Do not test AHARDWAREBUFFER_FORMAT_BLOB, it isn't color-renderable. |
| }; |
| const int samples[] = {1, 2, 4}; |
| for (int nsamples : samples) { |
| for (auto nlayers : layers) { |
| for (auto format : formats) { |
| desc.layers = nlayers; |
| desc.format = format; |
| testEglImageArray(env, desc, nsamples); |
| } |
| } |
| } |
| } |
| |
| static void testExternalBuffer(JNIEnv* env, uint64_t usage, bool write_hwbuffer, |
| const std::string& test_string) { |
| // Create a blob AHardwareBuffer suitable for holding the string. |
| AHardwareBuffer_Desc desc = {}; |
| desc.width = test_string.size(); |
| desc.height = 1; |
| desc.layers = 1; |
| desc.format = AHARDWAREBUFFER_FORMAT_BLOB; |
| desc.usage = usage; |
| AHardwareBuffer* hwbuffer = nullptr; |
| int error = AHardwareBuffer_allocate(&desc, &hwbuffer); |
| ASSERT_EQ(error, NO_ERROR); |
| // Create EGLClientBuffer from the AHardwareBuffer. |
| EGLClientBuffer native_buffer = eglGetNativeClientBufferANDROID(hwbuffer); |
| ASSERT_TRUE(native_buffer); |
| // Create uniform buffer from EGLClientBuffer. |
| const GLbitfield flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | |
| GL_MAP_COHERENT_BIT_EXT | GL_MAP_PERSISTENT_BIT_EXT; |
| GLuint buf = 0; |
| glGenBuffers(1, &buf); |
| glBindBuffer(GL_UNIFORM_BUFFER, buf); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| const GLsizeiptr bufsize = desc.width * desc.height; |
| glBufferStorageExternalEXT(GL_UNIFORM_BUFFER, 0, |
| bufsize, native_buffer, flags); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| // Obtain a writeable pointer using either OpenGL or the Android API, |
| // then copy the test string into it. |
| if (write_hwbuffer) { |
| void* data = nullptr; |
| error = AHardwareBuffer_lock(hwbuffer, |
| AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, -1, |
| NULL, &data); |
| ASSERT_EQ(error, NO_ERROR); |
| ASSERT_TRUE(data); |
| memcpy(data, test_string.c_str(), test_string.size()); |
| error = AHardwareBuffer_unlock(hwbuffer, nullptr); |
| ASSERT_EQ(error, NO_ERROR); |
| } else { |
| void* data = |
| glMapBufferRange(GL_UNIFORM_BUFFER, 0, bufsize, |
| GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT_EXT); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| ASSERT_TRUE(data); |
| memcpy(data, test_string.c_str(), test_string.size()); |
| glUnmapBuffer(GL_UNIFORM_BUFFER); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| } |
| // Obtain a readable pointer and verify the data. |
| void* data = glMapBufferRange(GL_UNIFORM_BUFFER, 0, bufsize, GL_MAP_READ_BIT); |
| ASSERT_TRUE(data); |
| ASSERT_EQ(strncmp(static_cast<char*>(data), test_string.c_str(), |
| test_string.size()), 0); |
| glUnmapBuffer(GL_UNIFORM_BUFFER); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| AHardwareBuffer_release(hwbuffer); |
| } |
| |
| extern "C" JNIEXPORT void JNICALL |
| Java_android_vr_cts_VrExtensionBehaviorTest_nativeTestExternalBuffer( |
| JNIEnv* env, jclass /* unused */) { |
| // First, check for EXT_external_buffer in the extension string. |
| auto exts = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)); |
| ASSERT_TRUE(exts); |
| if (strstr(exts, "GL_EXT_external_buffer") == nullptr) return; |
| // Next, load entry points provided by extensions. |
| LOAD_PROC(eglGetNativeClientBufferANDROID, PFNEGLGETNATIVECLIENTBUFFERANDROID); |
| ASSERT_NE(eglGetNativeClientBufferANDROID, nullptr); |
| LOAD_PROC(glBufferStorageExternalEXT, PFNGLBUFFERSTORAGEEXTERNALEXTPROC); |
| ASSERT_NE(glBufferStorageExternalEXT, nullptr); |
| LOAD_PROC(glMapBufferRange, PFNGLMAPBUFFERRANGEPROC); |
| ASSERT_NE(glMapBufferRange, nullptr); |
| LOAD_PROC(glUnmapBuffer, PFNGLUNMAPBUFFERPROC); |
| ASSERT_NE(glUnmapBuffer, nullptr); |
| const uint64_t usage = AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN | |
| AHARDWAREBUFFER_USAGE_CPU_READ_RARELY | |
| AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER | |
| AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA; |
| const std::string test_string = "Hello, world."; |
| // First try writing to the buffer using OpenGL, then try writing to it via |
| // the AHardwareBuffer API. |
| testExternalBuffer(env, usage, false, test_string); |
| testExternalBuffer(env, usage, true, test_string); |
| } |
| |
| const GLchar* const kSrgbVertexCode = R"( |
| // vertex position in clip space (-1..1) |
| attribute vec4 position; |
| varying mediump vec2 uv; |
| void main() { |
| gl_Position = position; |
| uv = vec2(0.5 * (position.x + 1.0), 0.5); |
| })"; |
| |
| const GLchar* const kSrgbFragmentCode = R"( |
| varying mediump vec2 uv; |
| uniform sampler2D tex; |
| void main() { |
| gl_FragColor = texture2D(tex, uv); |
| })"; |
| |
| static inline float SrgbChannelToLinear(float cs) { |
| if (cs <= 0.04045) |
| return cs / 12.92f; |
| else |
| return std::pow((cs + 0.055f) / 1.055f, 2.4f); |
| } |
| |
| static inline float LinearChannelToSrgb(float cs) { |
| if (cs <= 0.0f) |
| return 0.0f; |
| else if (cs < 0.0031308f) |
| return 12.92f * cs; |
| else if (cs < 1.0f) |
| return 1.055f * std::pow(cs, 0.41666f) - 0.055f; |
| else |
| return 1.0f; |
| } |
| |
| static uint32_t SrgbColorToLinear(uint32_t color) { |
| float r = SrgbChannelToLinear((color & 0xff) / 255.0f); |
| float g = SrgbChannelToLinear(((color >> 8) & 0xff) / 255.0f); |
| float b = SrgbChannelToLinear(((color >> 16) & 0xff) / 255.0f); |
| uint32_t r8 = r * 255.0f; |
| uint32_t g8 = g * 255.0f; |
| uint32_t b8 = b * 255.0f; |
| uint32_t a8 = color >> 24; |
| return (a8 << 24) | (b8 << 16) | (g8 << 8) | r8; |
| } |
| |
| static uint32_t LinearColorToSrgb(uint32_t color) { |
| float r = LinearChannelToSrgb((color & 0xff) / 255.0f); |
| float g = LinearChannelToSrgb(((color >> 8) & 0xff) / 255.0f); |
| float b = LinearChannelToSrgb(((color >> 16) & 0xff) / 255.0f); |
| uint32_t r8 = r * 255.0f; |
| uint32_t g8 = g * 255.0f; |
| uint32_t b8 = b * 255.0f; |
| uint32_t a8 = color >> 24; |
| return (a8 << 24) | (b8 << 16) | (g8 << 8) | r8; |
| } |
| |
| static uint32_t LerpColor(uint32_t color0, uint32_t color1, float t) { |
| float r0 = (color0 & 0xff) / 255.0f; |
| float g0 = ((color0 >> 8) & 0xff) / 255.0f; |
| float b0 = ((color0 >> 16) & 0xff) / 255.0f; |
| float a0 = ((color0 >> 24) & 0xff) / 255.0f; |
| float r1 = (color1 & 0xff) / 255.0f; |
| float g1 = ((color1 >> 8) & 0xff) / 255.0f; |
| float b1 = ((color1 >> 16) & 0xff) / 255.0f; |
| float a1 = ((color1 >> 24) & 0xff) / 255.0f; |
| uint32_t r8 = (r0 * (1.0f - t) + r1 * t) * 255.0f; |
| uint32_t g8 = (g0 * (1.0f - t) + g1 * t) * 255.0f; |
| uint32_t b8 = (b0 * (1.0f - t) + b1 * t) * 255.0f; |
| uint32_t a8 = (a0 * (1.0f - t) + a1 * t) * 255.0f; |
| return (a8 << 24) | (b8 << 16) | (g8 << 8) | r8; |
| } |
| |
| // Choose an odd-numbered framebuffer width so that we can |
| // extract the middle pixel of a gradient. |
| constexpr uint32_t kFramebufferWidth = 31; |
| |
| // Declare the pixel data for the 2x1 texture. |
| // Color components are ordered like this: AABBGGRR |
| constexpr uint32_t kTextureData[] = { |
| 0xff800000, // Half-Blue |
| 0xff000080, // Half-Red |
| }; |
| constexpr uint32_t kTextureWidth = sizeof(kTextureData) / sizeof(kTextureData[0]); |
| |
| // Declare expected values for the middle pixel for various sampling behaviors. |
| const uint32_t kExpectedMiddlePixel_NoSrgb = LerpColor(kTextureData[0], kTextureData[1], 0.5f); |
| const uint32_t kExpectedMiddlePixel_LinearizeAfterFiltering = |
| SrgbColorToLinear(kExpectedMiddlePixel_NoSrgb); |
| const uint32_t kExpectedMiddlePixel_LinearizeBeforeFiltering = |
| LerpColor(SrgbColorToLinear(kTextureData[0]), SrgbColorToLinear(kTextureData[1]), 0.5f); |
| |
| // Declare expected values for the final pixel color for various blending behaviors. |
| constexpr uint32_t kBlendDestColor = 0xff000080; |
| constexpr uint32_t kBlendSourceColor = 0x80800000; |
| const uint32_t kExpectedBlendedPixel_NoSrgb = LerpColor(kBlendSourceColor, kBlendDestColor, 0.5f); |
| const uint32_t kExpectedBlendedPixel_Srgb = |
| LinearColorToSrgb(LerpColor(kBlendSourceColor, SrgbColorToLinear(kBlendDestColor), 0.5f)); |
| |
| // Define a set of test flags. Not using an enum to avoid lots of casts. |
| namespace SrgbFlag { |
| constexpr uint32_t kHardwareBuffer = 1 << 0; |
| constexpr uint32_t kSrgbFormat = 1 << 1; |
| constexpr uint32_t kEglColorspaceDefault = 1 << 2; |
| constexpr uint32_t kEglColorspaceLinear = 1 << 3; |
| constexpr uint32_t kEglColorspaceSrgb = 1 << 4; |
| } // namespace SrgbFlag |
| |
| static void configureEglColorspace(EGLint attrs[4], uint32_t srgb_flags) { |
| if (srgb_flags & SrgbFlag::kEglColorspaceDefault) { |
| attrs[0] = EGL_GL_COLORSPACE_KHR; |
| attrs[1] = EGL_GL_COLORSPACE_DEFAULT_EXT; |
| } else if (srgb_flags & SrgbFlag::kEglColorspaceLinear) { |
| attrs[0] = EGL_GL_COLORSPACE_KHR; |
| attrs[1] = EGL_GL_COLORSPACE_LINEAR_KHR; |
| } else if (srgb_flags & SrgbFlag::kEglColorspaceSrgb) { |
| attrs[0] = EGL_GL_COLORSPACE_KHR; |
| attrs[1] = EGL_GL_COLORSPACE_SRGB_KHR; |
| } else { |
| attrs[0] = EGL_NONE; |
| attrs[1] = EGL_NONE; |
| } |
| attrs[2] = EGL_NONE; |
| attrs[3] = EGL_NONE; |
| } |
| |
| static void printSrgbFlags(std::ostream& out, uint32_t srgb_flags) { |
| if (srgb_flags & SrgbFlag::kHardwareBuffer) { |
| out << " AHardwareBuffer"; |
| } |
| if (srgb_flags & SrgbFlag::kSrgbFormat) { |
| out << " GL_SRGB_ALPHA"; |
| } |
| if (srgb_flags & SrgbFlag::kEglColorspaceDefault) { |
| out << " EGL_GL_COLORSPACE_DEFAULT_KHR"; |
| } |
| if (srgb_flags & SrgbFlag::kEglColorspaceLinear) { |
| out << " EGL_GL_COLORSPACE_LINEAR_KHR"; |
| } |
| if (srgb_flags & SrgbFlag::kEglColorspaceSrgb) { |
| out << " EGL_GL_COLORSPACE_SRGB_KHR"; |
| } |
| } |
| |
| // Draws a gradient and extracts the middle pixel. Returns void to allow ASSERT to work. |
| static void testLinearMagnification(JNIEnv* env, uint32_t flags, uint32_t* middle_pixel) { |
| const bool use_hwbuffer = flags & SrgbFlag::kHardwareBuffer; |
| const bool use_srgb_format = flags & SrgbFlag::kSrgbFormat; |
| GLuint srgbtex; |
| glGenTextures(1, &srgbtex); |
| glBindTexture(GL_TEXTURE_2D, srgbtex); |
| if (use_hwbuffer) { |
| // Create a one-dimensional AHardwareBuffer. |
| AHardwareBuffer_Desc desc = {}; |
| desc.width = kTextureWidth; |
| desc.height = 1; |
| desc.layers = 1; |
| desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM; |
| desc.usage = |
| AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT; |
| AHardwareBuffer* hwbuffer = nullptr; |
| int error = AHardwareBuffer_allocate(&desc, &hwbuffer); |
| ASSERT_EQ(error, NO_ERROR); |
| // Populate the pixels. |
| uint32_t* pixels = nullptr; |
| error = AHardwareBuffer_lock(hwbuffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1, nullptr, |
| reinterpret_cast<void**>(&pixels)); |
| ASSERT_EQ(error, NO_ERROR); |
| ASSERT_TRUE(pixels); |
| memcpy(pixels, kTextureData, sizeof(kTextureData)); |
| error = AHardwareBuffer_unlock(hwbuffer, nullptr); |
| ASSERT_EQ(error, NO_ERROR); |
| // Create EGLClientBuffer from the AHardwareBuffer. |
| EGLClientBuffer native_buffer = eglGetNativeClientBufferANDROID(hwbuffer); |
| ASSERT_TRUE(native_buffer); |
| // Create EGLImage from EGLClientBuffer. |
| EGLint attrs[4]; |
| configureEglColorspace(attrs, flags); |
| EGLImageKHR image = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, |
| EGL_NATIVE_BUFFER_ANDROID, native_buffer, attrs); |
| ASSERT_TRUE(image); |
| // Allocate the OpenGL texture using the EGLImage. |
| glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image); |
| } else { |
| GLenum internal_format = use_srgb_format ? GL_SRGB8_ALPHA8_EXT : GL_RGBA8_OES; |
| GLenum format = use_srgb_format ? GL_SRGB_ALPHA_EXT : GL_RGBA; |
| glTexImage2D(GL_TEXTURE_2D, 0, internal_format, kTextureWidth, 1, 0, format, |
| GL_UNSIGNED_BYTE, kTextureData); |
| } |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| // Clear to an interesting constant color to make it easier to spot bugs. |
| glClearColor(1.0, 0.0, 0.5, 0.25); |
| glClear(GL_COLOR_BUFFER_BIT); |
| // Draw the texture. |
| const float kTriangleCoords[] = {-1, -1, -1, 1, 1, -1, 1, 1}; |
| glBindTexture(GL_TEXTURE_2D, srgbtex); |
| const int kPositionSlot = 0; |
| glVertexAttribPointer(kPositionSlot, 2, GL_FLOAT, false, 0, kTriangleCoords); |
| glEnableVertexAttribArray(kPositionSlot); |
| glViewport(0, 0, kFramebufferWidth, 1); |
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
| // Read back the framebuffer. |
| glReadPixels(kFramebufferWidth / 2, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, middle_pixel); |
| std::ostringstream flag_string; |
| printSrgbFlags(flag_string, flags); |
| LOGV("Filtered Result: %8.8X Flags =%s", *middle_pixel, flag_string.str().c_str()); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| } |
| |
| // Blends a color into an (optionally) sRGB-encoded framebuffer and extracts the final color. |
| // Returns void to allow ASSERT to work. |
| static void testFramebufferBlending(JNIEnv* env, uint32_t flags, uint32_t* final_color) { |
| const bool use_hwbuffer = flags & SrgbFlag::kHardwareBuffer; |
| const bool use_srgb_format = flags & SrgbFlag::kSrgbFormat; |
| const bool override_egl_colorspace = use_hwbuffer && (flags & SrgbFlag::kEglColorspaceSrgb); |
| GLuint tex; |
| glGenTextures(1, &tex); |
| glBindTexture(GL_TEXTURE_2D, tex); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| // Create a 1x1 half-blue, half-opaque texture. |
| const uint32_t kTextureData[] = { |
| kBlendSourceColor, |
| }; |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, |
| GL_UNSIGNED_BYTE, kTextureData); |
| // Create 1x1 framebuffer object. |
| GLuint fbo; |
| glGenFramebuffers(1, &fbo); |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| GLuint fbotex; |
| glGenTextures(1, &fbotex); |
| glBindTexture(GL_TEXTURE_2D, fbotex); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| if (use_hwbuffer) { |
| AHardwareBuffer_Desc desc = {}; |
| desc.width = 1; |
| desc.height = 1; |
| desc.layers = 1; |
| desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM; |
| desc.usage = |
| AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT; |
| AHardwareBuffer* hwbuffer = nullptr; |
| int error = AHardwareBuffer_allocate(&desc, &hwbuffer); |
| ASSERT_EQ(error, NO_ERROR); |
| // Create EGLClientBuffer from the AHardwareBuffer. |
| EGLClientBuffer native_buffer = eglGetNativeClientBufferANDROID(hwbuffer); |
| ASSERT_TRUE(native_buffer); |
| // Create EGLImage from EGLClientBuffer. |
| EGLint attrs[4]; |
| configureEglColorspace(attrs, flags); |
| EGLImageKHR image = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT, |
| EGL_NATIVE_BUFFER_ANDROID, native_buffer, attrs); |
| ASSERT_TRUE(image); |
| // Allocate the OpenGL texture using the EGLImage. |
| glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image); |
| } else { |
| GLenum internal_format = use_srgb_format ? GL_SRGB8_ALPHA8_EXT : GL_RGBA8_OES; |
| GLenum format = use_srgb_format ? GL_SRGB_ALPHA_EXT : GL_RGBA; |
| glTexImage2D(GL_TEXTURE_2D, 0, internal_format, 1, 1, 0, format, |
| GL_UNSIGNED_BYTE, nullptr); |
| } |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, fbotex, 0); |
| ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GL_FRAMEBUFFER_COMPLETE); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| // Clear to half-red. |
| if (use_srgb_format || override_egl_colorspace) { |
| glClearColor(SrgbChannelToLinear(0.5), 0.0, 0.0, 1.0); |
| } else { |
| glClearColor(0.5, 0.0, 0.0, 1.0); |
| } |
| glClear(GL_COLOR_BUFFER_BIT); |
| // Sanity check the cleared color. |
| uint32_t cleared_color = 0; |
| glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &cleared_color); |
| LOGV(" Cleared Color: %8.8X", cleared_color); |
| ASSERT_NEAR_RGBA(cleared_color, kBlendDestColor, 1); |
| // Draw the texture. |
| glEnable(GL_BLEND); |
| glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
| const float kTriangleCoords[] = {-1, -1, -1, 1, 1, -1, 1, 1}; |
| glBindTexture(GL_TEXTURE_2D, tex); |
| const int kPositionSlot = 0; |
| glVertexAttribPointer(kPositionSlot, 2, GL_FLOAT, false, 0, kTriangleCoords); |
| glEnableVertexAttribArray(kPositionSlot); |
| glViewport(0, 0, 1, 1); |
| glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
| // Read back the framebuffer. |
| glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, final_color); |
| std::ostringstream flag_string; |
| printSrgbFlags(flag_string, flags); |
| LOGV("Blending Result: %8.8X Flags =%s", *final_color, flag_string.str().c_str()); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| } |
| |
| extern "C" JNIEXPORT void JNICALL |
| Java_android_vr_cts_VrExtensionBehaviorTest_nativeTestSrgbBuffer( |
| JNIEnv* env, jclass /* unused */) { |
| // First, check the published extension strings against expectations. |
| const char *egl_exts = |
| eglQueryString(eglGetCurrentDisplay(), EGL_EXTENSIONS); |
| LOGV("EGL Extensions: %s", egl_exts); |
| ASSERT_TRUE(egl_exts); |
| bool egl_colorspace_supported = strstr(egl_exts, "EGL_EXT_image_gl_colorspace"); |
| auto gl_exts = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)); |
| LOGV("OpenGL Extensions: %s", gl_exts); |
| ASSERT_TRUE(gl_exts); |
| // Load ancillary entry points provided by extensions. |
| LOAD_PROC(eglGetNativeClientBufferANDROID, |
| PFNEGLGETNATIVECLIENTBUFFERANDROID); |
| ASSERT_NE(eglGetNativeClientBufferANDROID, nullptr); |
| LOAD_PROC(eglCreateImageKHR, PFNEGLCREATEIMAGEKHRPROC); |
| ASSERT_NE(eglCreateImageKHR, nullptr); |
| LOAD_PROC(glEGLImageTargetTexture2DOES, |
| PFNGLEGLIMAGETARGETTEXTURE2DOESPROC); |
| ASSERT_NE(glEGLImageTargetTexture2DOES, nullptr); |
| // Create a plain old one-dimensional FBO to render to. |
| GLuint fbo; |
| glGenFramebuffers(1, &fbo); |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo); |
| GLuint fbotex; |
| glGenTextures(1, &fbotex); |
| glBindTexture(GL_TEXTURE_2D, fbotex); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kFramebufferWidth, 1, 0, GL_RGBA, |
| GL_UNSIGNED_BYTE, nullptr); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, fbotex, 0); |
| ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GL_FRAMEBUFFER_COMPLETE); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| // Compile and link shaders. |
| int program = glCreateProgram(); |
| int vshader = glCreateShader(GL_VERTEX_SHADER); |
| glShaderSource(vshader, 1, &kSrgbVertexCode, nullptr); |
| glCompileShader(vshader); |
| glAttachShader(program, vshader); |
| int fshader = glCreateShader(GL_FRAGMENT_SHADER); |
| glShaderSource(fshader, 1, &kSrgbFragmentCode, nullptr); |
| glCompileShader(fshader); |
| glAttachShader(program, fshader); |
| glLinkProgram(program); |
| int status; |
| glGetProgramiv(program, GL_LINK_STATUS, &status); |
| ASSERT_EQ(status, GL_TRUE); |
| glUseProgram(program); |
| ASSERT_EQ(glGetError(), GL_NO_ERROR); |
| |
| // Filtering test. |
| LOGV("Expected value for NoSrgb = %8.8X", kExpectedMiddlePixel_NoSrgb); |
| LOGV("Expected value for Srgb = %8.8X", kExpectedMiddlePixel_LinearizeBeforeFiltering); |
| uint32_t middle_pixel; |
| // First do a sanity check with plain old pre-linearized textures. |
| testLinearMagnification(env, 0, &middle_pixel); |
| ASSERT_NEAR_RGBA(middle_pixel, kExpectedMiddlePixel_NoSrgb, 1); |
| testLinearMagnification(env, SrgbFlag::kHardwareBuffer, &middle_pixel); |
| ASSERT_NEAR_RGBA(middle_pixel, kExpectedMiddlePixel_NoSrgb, 1); |
| // Try a "normally allocated" OpenGL texture with an sRGB source format. |
| testLinearMagnification(env, SrgbFlag::kSrgbFormat, &middle_pixel); |
| ASSERT_NEAR_RGBA(middle_pixel, kExpectedMiddlePixel_LinearizeBeforeFiltering, 1); |
| // Try EGL_EXT_image_gl_colorspace. |
| if (egl_colorspace_supported) { |
| testLinearMagnification(env, SrgbFlag::kHardwareBuffer | SrgbFlag::kEglColorspaceDefault, &middle_pixel); |
| ASSERT_NEAR_RGBA(middle_pixel, kExpectedMiddlePixel_NoSrgb, 1); |
| testLinearMagnification(env, SrgbFlag::kHardwareBuffer | SrgbFlag::kEglColorspaceLinear, &middle_pixel); |
| ASSERT_NEAR_RGBA(middle_pixel, kExpectedMiddlePixel_NoSrgb, 1); |
| testLinearMagnification(env, SrgbFlag::kHardwareBuffer | SrgbFlag::kEglColorspaceSrgb, &middle_pixel); |
| ASSERT_NEAR_RGBA(middle_pixel, kExpectedMiddlePixel_LinearizeBeforeFiltering, 1); |
| } |
| |
| // Blending test. |
| LOGV("Expected value for NoSrgb = %8.8X", kExpectedBlendedPixel_NoSrgb); |
| LOGV("Expected value for Srgb = %8.8X", kExpectedBlendedPixel_Srgb); |
| uint32_t final_color; |
| // First do a sanity check with plain old pre-linearized textures. |
| testFramebufferBlending(env, 0, &final_color); |
| ASSERT_NEAR_RGBA(final_color, kExpectedBlendedPixel_NoSrgb, 1); |
| testFramebufferBlending(env, SrgbFlag::kHardwareBuffer, &final_color); |
| ASSERT_NEAR_RGBA(final_color, kExpectedBlendedPixel_NoSrgb, 1); |
| // Try a "normally allocated" OpenGL texture with an sRGB source format. |
| testFramebufferBlending(env, SrgbFlag::kSrgbFormat, &final_color); |
| ASSERT_NEAR_RGBA(final_color, kExpectedBlendedPixel_Srgb, 1); |
| // Try EGL_EXT_image_gl_colorspace. |
| if (egl_colorspace_supported) { |
| testFramebufferBlending(env, SrgbFlag::kHardwareBuffer | SrgbFlag::kEglColorspaceDefault, &final_color); |
| ASSERT_NEAR_RGBA(final_color, kExpectedBlendedPixel_NoSrgb, 1); |
| testFramebufferBlending(env, SrgbFlag::kHardwareBuffer | SrgbFlag::kEglColorspaceLinear, &final_color); |
| ASSERT_NEAR_RGBA(final_color, kExpectedBlendedPixel_NoSrgb, 1); |
| testFramebufferBlending(env, SrgbFlag::kHardwareBuffer | SrgbFlag::kEglColorspaceSrgb, &final_color); |
| ASSERT_NEAR_RGBA(final_color, kExpectedBlendedPixel_Srgb, 1); |
| } |
| } |
