diff options
Diffstat (limited to 'opengl')
26 files changed, 831 insertions, 288 deletions
diff --git a/opengl/Android.bp b/opengl/Android.bp index c520bda140..aec5a95628 100644 --- a/opengl/Android.bp +++ b/opengl/Android.bp @@ -52,6 +52,12 @@ ndk_headers { license: "include/KHR/NOTICE", } +cc_library_headers { + name: "gl_headers", + vendor_available: true, + export_include_dirs: ["include"], +} + subdirs = [ "*", ] diff --git a/opengl/include/EGL/eglext.h b/opengl/include/EGL/eglext.h index 466768ae2c..c4073a9505 100644 --- a/opengl/include/EGL/eglext.h +++ b/opengl/include/EGL/eglext.h @@ -534,6 +534,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglPresentationTimeANDROID (EGLDisplay dpy, EGLSur #endif #endif /* EGL_ANDROID_presentation_time */ +#ifndef EGL_KHR_no_config_context +#define EGL_KHR_no_config_context 1 +#define EGL_NO_CONFIG_KHR EGL_CAST(EGLConfig,0) +#endif /* EGL_KHR_no_config_context */ + #ifndef EGL_ANDROID_get_frame_timestamps #define EGL_ANDROID_get_frame_timestamps 1 #define EGL_TIMESTAMPS_ANDROID 0x3430 diff --git a/opengl/libagl/Android.mk b/opengl/libagl/Android.mk index 4b08749b22..c7635e27c7 100644 --- a/opengl/libagl/Android.mk +++ b/opengl/libagl/Android.mk @@ -26,7 +26,7 @@ LOCAL_CFLAGS += -DLOG_TAG=\"libagl\" LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES LOCAL_CFLAGS += -fvisibility=hidden -LOCAL_SHARED_LIBRARIES := libcutils libhardware libutils liblog libpixelflinger libETC1 libui +LOCAL_SHARED_LIBRARIES := libcutils libhardware libutils liblog libpixelflinger libETC1 libui libnativewindow LOCAL_SRC_FILES_arm += fixed_asm.S iterators.S LOCAL_CFLAGS_arm += -fstrict-aliasing diff --git a/opengl/libagl/egl.cpp b/opengl/libagl/egl.cpp index 04f6d6d1a3..b79051c499 100644 --- a/opengl/libagl/egl.cpp +++ b/opengl/libagl/egl.cpp @@ -56,6 +56,24 @@ EGLBoolean EGLAPI eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height); + +typedef struct egl_native_pixmap_t +{ + int32_t version; /* must be 32 */ + int32_t width; + int32_t height; + int32_t stride; + uint8_t* data; + uint8_t format; + uint8_t rfu[3]; + union { + uint32_t compressedFormat; + int32_t vstride; + }; + int32_t reserved; +} egl_native_pixmap_t; + + // ---------------------------------------------------------------------------- namespace android { diff --git a/opengl/libs/Android.bp b/opengl/libs/Android.bp index d6bdc81020..b4cc2113e9 100644 --- a/opengl/libs/Android.bp +++ b/opengl/libs/Android.bp @@ -64,6 +64,16 @@ cc_defaults { "liblog", "libdl", ], + static_libs: [ + "libarect", + ], + header_libs: [ + "gl_headers", + "libsystem_headers", + "libhardware_headers", + "libnativebase_headers", + ], + export_header_lib_headers: ["gl_headers"], // we need to access the private Bionic header <bionic_tls.h> include_dirs: ["bionic/libc/private"], @@ -75,16 +85,22 @@ cc_defaults { cc_defaults { name: "egl_libs_defaults", defaults: ["gl_libs_defaults"], + vendor_available: true, cflags: [ "-DLOG_TAG=\"libEGL\"", ], shared_libs: [ // ***** DO NOT ADD NEW DEPENDENCIES HERE ***** // In particular, DO NOT add libutils nor anything "above" libui - "libui", + "libgraphicsenv", "libnativewindow", "libbacktrace", ], + target: { + vendor: { + exclude_shared_libs: ["libgraphicsenv"], + }, + }, } cc_library_static { @@ -111,7 +127,14 @@ cc_library_shared { "EGL/Loader.cpp", "EGL/BlobCache.cpp", ], - shared_libs: ["libvndksupport"], + shared_libs: [ + "libvndksupport", + "android.hardware.configstore@1.0", + "android.hardware.configstore-utils", + "libhidlbase", + "libhidltransport", + "libutils", + ], static_libs: ["libEGL_getProcAddress"], ldflags: ["-Wl,--exclude-libs=ALL"], export_include_dirs: ["EGL/include"], @@ -129,6 +152,7 @@ cc_test { cc_defaults { name: "gles_libs_defaults", defaults: ["gl_libs_defaults"], + vendor_available: true, arch: { arm: { instruction_set: "arm", diff --git a/opengl/libs/EGL/Loader.cpp b/opengl/libs/EGL/Loader.cpp index 823b502ad8..32f8caa989 100644 --- a/opengl/libs/EGL/Loader.cpp +++ b/opengl/libs/EGL/Loader.cpp @@ -28,7 +28,9 @@ #include <cutils/properties.h> #include <log/log.h> -#include <ui/GraphicsEnv.h> +#ifndef __ANDROID_VNDK__ +#include <graphicsenv/GraphicsEnv.h> +#endif #include <vndksupport/linker.h> #include "egl_trace.h" @@ -477,10 +479,12 @@ void *Loader::load_driver(const char* kind, ATRACE_CALL(); void* dso = nullptr; +#ifndef __ANDROID_VNDK__ android_namespace_t* ns = android_getDriverNamespace(); if (ns) { dso = load_updated_driver(kind, ns); } +#endif if (!dso) { dso = load_system_driver(kind); if (!dso) diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp index ba3a5f91a3..0214b0eb56 100644 --- a/opengl/libs/EGL/eglApi.cpp +++ b/opengl/libs/EGL/eglApi.cpp @@ -79,6 +79,7 @@ struct extention_map_t { extern char const * const gBuiltinExtensionString; extern char const * const gExtensionString; +// clang-format off char const * const gBuiltinExtensionString = "EGL_KHR_get_all_proc_addresses " "EGL_ANDROID_presentation_time " @@ -123,6 +124,7 @@ char const * const gExtensionString = "EGL_IMG_context_priority " "EGL_KHR_no_config_context " ; +// clang-format on // extensions not exposed to applications but used by the ANDROID system // "EGL_ANDROID_blob_cache " // strongly recommended @@ -452,16 +454,216 @@ EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, // EGL_GL_COLORSPACE_SRGB_KHR, or turn sRGB formats into corresponding linear // formats when colorspace is EGL_GL_COLORSPACE_LINEAR_KHR. In any cases where // the modification isn't possible, the original dataSpace is returned. -static android_dataspace modifyBufferDataspace( android_dataspace dataSpace, - EGLint colorspace) { +static android_dataspace modifyBufferDataspace(android_dataspace dataSpace, + EGLint colorspace) { if (colorspace == EGL_GL_COLORSPACE_LINEAR_KHR) { return HAL_DATASPACE_SRGB_LINEAR; } else if (colorspace == EGL_GL_COLORSPACE_SRGB_KHR) { return HAL_DATASPACE_SRGB; + } else if (colorspace == EGL_GL_COLORSPACE_DISPLAY_P3_EXT) { + return HAL_DATASPACE_DISPLAY_P3; + } else if (colorspace == EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT) { + return HAL_DATASPACE_DISPLAY_P3_LINEAR; + } else if (colorspace == EGL_GL_COLORSPACE_SCRGB_EXT) { + return HAL_DATASPACE_V0_SCRGB; + } else if (colorspace == EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT) { + return HAL_DATASPACE_V0_SCRGB_LINEAR; } return dataSpace; } +// Return true if we stripped any EGL_GL_COLORSPACE_KHR attributes. +static EGLBoolean stripColorSpaceAttribute(egl_display_ptr dp, const EGLint* attrib_list, + EGLint format, + std::vector<EGLint>& stripped_attrib_list) { + std::vector<EGLint> allowedColorSpaces; + switch (format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + case HAL_PIXEL_FORMAT_RGB_565: + // driver okay with linear & sRGB for 8888, but can't handle + // Display-P3 or other spaces. + allowedColorSpaces.push_back(EGL_GL_COLORSPACE_SRGB_KHR); + allowedColorSpaces.push_back(EGL_GL_COLORSPACE_LINEAR_KHR); + break; + + case HAL_PIXEL_FORMAT_RGBA_FP16: + case HAL_PIXEL_FORMAT_RGBA_1010102: + default: + // driver does not want to see colorspace attributes for 1010102 or fp16. + // Future: if driver supports XXXX extension, we can pass down that colorspace + break; + } + + bool stripped = false; + if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) { + for (const EGLint* attr = attrib_list; attr[0] != EGL_NONE; attr += 2) { + if (attr[0] == EGL_GL_COLORSPACE_KHR) { + EGLint colorSpace = attr[1]; + bool found = false; + // Verify that color space is allowed + for (auto it : allowedColorSpaces) { + if (colorSpace == it) { + found = true; + } + } + if (!found) { + stripped = true; + } else { + stripped_attrib_list.push_back(attr[0]); + stripped_attrib_list.push_back(attr[1]); + } + } else { + stripped_attrib_list.push_back(attr[0]); + stripped_attrib_list.push_back(attr[1]); + } + } + } + if (stripped) { + stripped_attrib_list.push_back(EGL_NONE); + stripped_attrib_list.push_back(EGL_NONE); + } + return stripped; +} + +static EGLBoolean getColorSpaceAttribute(egl_display_ptr dp, NativeWindowType window, + const EGLint* attrib_list, EGLint& colorSpace, + android_dataspace& dataSpace) { + colorSpace = EGL_GL_COLORSPACE_LINEAR_KHR; + dataSpace = HAL_DATASPACE_UNKNOWN; + + if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) { + for (const EGLint* attr = attrib_list; *attr != EGL_NONE; attr += 2) { + if (*attr == EGL_GL_COLORSPACE_KHR) { + colorSpace = attr[1]; + bool found = false; + bool verify = true; + // Verify that color space is allowed + if (colorSpace == EGL_GL_COLORSPACE_SRGB_KHR || + colorSpace == EGL_GL_COLORSPACE_LINEAR_KHR) { + // SRGB and LINEAR are always supported when EGL_KHR_gl_colorspace + // is available, so no need to verify. + found = true; + verify = false; + } else if (colorSpace == EGL_EXT_gl_colorspace_bt2020_linear && + dp->haveExtension("EGL_EXT_gl_colorspace_bt2020_linear")) { + found = true; + } else if (colorSpace == EGL_EXT_gl_colorspace_bt2020_pq && + dp->haveExtension("EGL_EXT_gl_colorspace_bt2020_pq")) { + found = true; + } else if (colorSpace == EGL_GL_COLORSPACE_SCRGB_EXT && + dp->haveExtension("EGL_EXT_gl_colorspace_scrgb")) { + found = true; + } else if (colorSpace == EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT && + dp->haveExtension("EGL_EXT_gl_colorspace_scrgb_linear")) { + found = true; + } else if (colorSpace == EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT && + dp->haveExtension("EGL_EXT_gl_colorspace_display_p3_linear")) { + found = true; + } else if (colorSpace == EGL_GL_COLORSPACE_DISPLAY_P3_EXT && + dp->haveExtension("EGL_EXT_gl_colorspace_display_p3")) { + found = true; + } + if (!found) { + return false; + } + if (verify && window) { + bool wide_color_support = true; + // Ordinarily we'd put a call to native_window_get_wide_color_support + // at the beginning of the function so that we'll have the + // result when needed elsewhere in the function. + // However, because eglCreateWindowSurface is called by SurfaceFlinger and + // SurfaceFlinger is required to answer the call below we would + // end up in a deadlock situation. By moving the call to only happen + // if the application has specifically asked for wide-color we avoid + // the deadlock with SurfaceFlinger since it will not ask for a + // wide-color surface. + int err = native_window_get_wide_color_support(window, &wide_color_support); + + if (err) { + ALOGE("getColorSpaceAttribute: invalid window (win=%p) " + "failed (%#x) (already connected to another API?)", + window, err); + return false; + } + if (!wide_color_support) { + // Application has asked for a wide-color colorspace but + // wide-color support isn't available on the display the window is on. + return false; + } + } + // Only change the dataSpace from default if the application + // has explicitly set the color space with a EGL_GL_COLORSPACE_KHR attribute. + dataSpace = modifyBufferDataspace(dataSpace, colorSpace); + } + } + } + return true; +} + +static EGLBoolean getColorSpaceAttribute(egl_display_ptr dp, const EGLint* attrib_list, + EGLint& colorSpace, android_dataspace& dataSpace) { + return getColorSpaceAttribute(dp, NULL, attrib_list, colorSpace, dataSpace); +} + +void getNativePixelFormat(EGLDisplay dpy, egl_connection_t* cnx, EGLConfig config, EGLint& format) { + // Set the native window's buffers format to match what this config requests. + // Whether to use sRGB gamma is not part of the EGLconfig, but is part + // of our native format. So if sRGB gamma is requested, we have to + // modify the EGLconfig's format before setting the native window's + // format. + + EGLint componentType = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT; + cnx->egl.eglGetConfigAttrib(dpy, config, EGL_COLOR_COMPONENT_TYPE_EXT, &componentType); + + EGLint a = 0; + EGLint r, g, b; + r = g = b = 0; + cnx->egl.eglGetConfigAttrib(dpy, config, EGL_RED_SIZE, &r); + cnx->egl.eglGetConfigAttrib(dpy, config, EGL_GREEN_SIZE, &g); + cnx->egl.eglGetConfigAttrib(dpy, config, EGL_BLUE_SIZE, &b); + cnx->egl.eglGetConfigAttrib(dpy, config, EGL_ALPHA_SIZE, &a); + EGLint colorDepth = r + g + b; + + // Today, the driver only understands sRGB and linear on 888X + // formats. Strip other colorspaces from the attribute list and + // only use them to set the dataspace via + // native_window_set_buffers_dataspace + // if pixel format is RGBX 8888 + // TBD: Can test for future extensions that indicate that driver + // handles requested color space and we can let it through. + // allow SRGB and LINEAR. All others need to be stripped. + // else if 565, 4444 + // TBD: Can we assume these are supported if 8888 is? + // else if FP16 or 1010102 + // strip colorspace from attribs. + // endif + if (a == 0) { + if (colorDepth <= 16) { + format = HAL_PIXEL_FORMAT_RGB_565; + } else { + if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) { + if (colorDepth > 24) { + format = HAL_PIXEL_FORMAT_RGBA_1010102; + } else { + format = HAL_PIXEL_FORMAT_RGBX_8888; + } + } else { + format = HAL_PIXEL_FORMAT_RGBA_FP16; + } + } + } else { + if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) { + if (colorDepth > 24) { + format = HAL_PIXEL_FORMAT_RGBA_1010102; + } else { + format = HAL_PIXEL_FORMAT_RGBA_8888; + } + } else { + format = HAL_PIXEL_FORMAT_RGBA_FP16; + } + } +} + EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list) @@ -491,60 +693,22 @@ EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config, return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE); } - // Set the native window's buffers format to match what this config requests. - // Whether to use sRGB gamma is not part of the EGLconfig, but is part - // of our native format. So if sRGB gamma is requested, we have to - // modify the EGLconfig's format before setting the native window's - // format. - - EGLint componentType = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT; - cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_COLOR_COMPONENT_TYPE_EXT, - &componentType); - EGLint format; - android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN; - EGLint a = 0; - EGLint r, g, b; - r = g = b = 0; - cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_RED_SIZE, &r); - cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_GREEN_SIZE, &g); - cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_BLUE_SIZE, &b); - cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_ALPHA_SIZE, &a); - EGLint colorDepth = r + g + b; - - if (a == 0) { - if (colorDepth <= 16) { - format = HAL_PIXEL_FORMAT_RGB_565; - } else { - if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) { - if (colorDepth > 24) { - format = HAL_PIXEL_FORMAT_RGBA_1010102; - } else { - format = HAL_PIXEL_FORMAT_RGBX_8888; - } - } else { - format = HAL_PIXEL_FORMAT_RGBA_FP16; - } - } - } else { - if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) { - if (colorDepth > 24) { - format = HAL_PIXEL_FORMAT_RGBA_1010102; - } else { - format = HAL_PIXEL_FORMAT_RGBA_8888; - } - } else { - format = HAL_PIXEL_FORMAT_RGBA_FP16; - } + getNativePixelFormat(iDpy, cnx, config, format); + + // now select correct colorspace and dataspace based on user's attribute list + EGLint colorSpace; + android_dataspace dataSpace; + if (!getColorSpaceAttribute(dp, window, attrib_list, colorSpace, dataSpace)) { + ALOGE("error invalid colorspace: %d", colorSpace); + return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); } - // now select a corresponding sRGB format if needed - if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) { - for (const EGLint* attr = attrib_list; *attr != EGL_NONE; attr += 2) { - if (*attr == EGL_GL_COLORSPACE_KHR) { - dataSpace = modifyBufferDataspace(dataSpace, *(attr+1)); - } - } + std::vector<EGLint> strippedAttribList; + if (stripColorSpaceAttribute(dp, attrib_list, format, strippedAttribList)) { + // Had to modify the attribute list due to use of color space. + // Use modified list from here on. + attrib_list = strippedAttribList.data(); } if (format != 0) { @@ -575,8 +739,8 @@ EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config, EGLSurface surface = cnx->egl.eglCreateWindowSurface( iDpy, config, window, attrib_list); if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, window, - surface, cnx); + egl_surface_t* s = + new egl_surface_t(dp.get(), config, window, surface, colorSpace, cnx); return s; } @@ -595,12 +759,19 @@ EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config, egl_connection_t* cnx = NULL; egl_display_ptr dp = validate_display_connection(dpy, cnx); + EGLint colorSpace; + android_dataspace dataSpace; if (dp) { + // now select a corresponding sRGB format if needed + if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) { + ALOGE("error invalid colorspace: %d", colorSpace); + return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); + } + EGLSurface surface = cnx->egl.eglCreatePixmapSurface( dp->disp.dpy, config, pixmap, attrib_list); if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, - surface, cnx); + egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx); return s; } } @@ -615,11 +786,32 @@ EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config, egl_connection_t* cnx = NULL; egl_display_ptr dp = validate_display_connection(dpy, cnx); if (dp) { + EGLDisplay iDpy = dp->disp.dpy; + EGLint format; + getNativePixelFormat(iDpy, cnx, config, format); + + // now select correct colorspace and dataspace based on user's attribute list + EGLint colorSpace; + android_dataspace dataSpace; + if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) { + ALOGE("error invalid colorspace: %d", colorSpace); + return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); + } + + // Pbuffers are not displayed so we don't need to store the + // colorspace. We do need to filter out color spaces the + // driver doesn't know how to process. + std::vector<EGLint> strippedAttribList; + if (stripColorSpaceAttribute(dp, attrib_list, format, strippedAttribList)) { + // Had to modify the attribute list due to use of color space. + // Use modified list from here on. + attrib_list = strippedAttribList.data(); + } + EGLSurface surface = cnx->egl.eglCreatePbufferSurface( dp->disp.dpy, config, attrib_list); if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, - surface, cnx); + egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx); return s; } } @@ -658,6 +850,10 @@ EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface, return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); + if (attribute == EGL_GL_COLORSPACE_KHR) { + *value = s->getColorSpace(); + return EGL_TRUE; + } return s->cnx->egl.eglQuerySurface( dp->disp.dpy, s->surface, attribute, value); } @@ -1729,13 +1925,22 @@ EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, egl_display_ptr dp = validate_display(dpy); if (!dp) return EGL_NO_SURFACE; + EGLint colorSpace = EGL_GL_COLORSPACE_LINEAR_KHR; + android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN; + // TODO: Probably need to update EGL_KHR_stream_producer_eglsurface to + // indicate support for EGL_GL_COLORSPACE_KHR. + // now select a corresponding sRGB format if needed + if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) { + ALOGE("error invalid colorspace: %d", colorSpace); + return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); + } + egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglCreateStreamProducerSurfaceKHR) { EGLSurface surface = cnx->egl.eglCreateStreamProducerSurfaceKHR( dp->disp.dpy, config, stream, attrib_list); if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, - surface, cnx); + egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx); return s; } } @@ -1886,8 +2091,15 @@ EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface, EGLClientBuffer eglGetNativeClientBufferANDROID(const AHardwareBuffer *buffer) { clearError(); + // AHardwareBuffer_to_ANativeWindowBuffer is a platform-only symbol and thus + // this function cannot be implemented when this libEGL is built for + // vendors. +#ifndef __ANDROID_VNDK__ if (!buffer) return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0); return const_cast<ANativeWindowBuffer *>(AHardwareBuffer_to_ANativeWindowBuffer(buffer)); +#else + return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0); +#endif } // ---------------------------------------------------------------------------- diff --git a/opengl/libs/EGL/egl_cache.cpp b/opengl/libs/EGL/egl_cache.cpp index dc1a4af46e..579e422c1a 100644 --- a/opengl/libs/EGL/egl_cache.cpp +++ b/opengl/libs/EGL/egl_cache.cpp @@ -26,6 +26,7 @@ #include <inttypes.h> #include <sys/mman.h> #include <sys/stat.h> +#include <unistd.h> #include <thread> diff --git a/opengl/libs/EGL/egl_display.cpp b/opengl/libs/EGL/egl_display.cpp index b696920023..4e5833ab12 100644 --- a/opengl/libs/EGL/egl_display.cpp +++ b/opengl/libs/EGL/egl_display.cpp @@ -30,6 +30,12 @@ #include "Loader.h" #include <cutils/properties.h> +#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h> +#include <configstore/Utils.h> + +using namespace android::hardware::configstore; +using namespace android::hardware::configstore::V1_0; + // ---------------------------------------------------------------------------- namespace android { // ---------------------------------------------------------------------------- @@ -192,6 +198,18 @@ EGLBoolean egl_display_t::initialize(EGLint *major, EGLint *minor) { mClientApiString = sClientApiString; mExtensionString = gBuiltinExtensionString; + + bool wideColorBoardConfig = + getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>( + false); + + // Add wide-color extensions if device can support wide-color + if (wideColorBoardConfig) { + mExtensionString.append( + "EGL_EXT_gl_colorspace_scrgb EGL_EXT_gl_colorspace_scrgb_linear " + "EGL_EXT_gl_colorspace_display_p3_linear EGL_EXT_gl_colorspace_display_p3 "); + } + char const* start = gExtensionString; do { // length of the extension name diff --git a/opengl/libs/EGL/egl_object.cpp b/opengl/libs/EGL/egl_object.cpp index 623878062b..837cfa92ca 100644 --- a/opengl/libs/EGL/egl_object.cpp +++ b/opengl/libs/EGL/egl_object.cpp @@ -55,12 +55,15 @@ bool egl_object_t::get(egl_display_t const* display, egl_object_t* object) { // ---------------------------------------------------------------------------- -egl_surface_t::egl_surface_t(egl_display_t* dpy, EGLConfig config, - EGLNativeWindowType win, EGLSurface surface, - egl_connection_t const* cnx) : - egl_object_t(dpy), surface(surface), config(config), win(win), cnx(cnx), - connected(true) -{ +egl_surface_t::egl_surface_t(egl_display_t* dpy, EGLConfig config, EGLNativeWindowType win, + EGLSurface surface, EGLint colorSpace, egl_connection_t const* cnx) + : egl_object_t(dpy), + surface(surface), + config(config), + win(win), + cnx(cnx), + connected(true), + colorSpace(colorSpace) { if (win) { win->incStrong(this); } diff --git a/opengl/libs/EGL/egl_object.h b/opengl/libs/EGL/egl_object.h index 8988905a25..7c3075c9fc 100644 --- a/opengl/libs/EGL/egl_object.h +++ b/opengl/libs/EGL/egl_object.h @@ -131,12 +131,12 @@ protected: public: typedef egl_object_t::LocalRef<egl_surface_t, EGLSurface> Ref; - egl_surface_t(egl_display_t* dpy, EGLConfig config, - EGLNativeWindowType win, EGLSurface surface, - egl_connection_t const* cnx); + egl_surface_t(egl_display_t* dpy, EGLConfig config, EGLNativeWindowType win, EGLSurface surface, + EGLint colorSpace, egl_connection_t const* cnx); ANativeWindow* getNativeWindow() { return win; } ANativeWindow* getNativeWindow() const { return win; } + EGLint getColorSpace() const { return colorSpace; } // Try to keep the order of these fields and size unchanged. It's not public API, but // it's not hard to imagine native games accessing them. @@ -149,6 +149,7 @@ public: private: bool connected; void disconnect(); + EGLint colorSpace; }; class egl_context_t: public egl_object_t { diff --git a/opengl/tests/Android.bp b/opengl/tests/Android.bp new file mode 100644 index 0000000000..bf7aeb117f --- /dev/null +++ b/opengl/tests/Android.bp @@ -0,0 +1,4 @@ +subdirs = [ + "hwc", + "lib", +] diff --git a/opengl/tests/Android.mk b/opengl/tests/Android.mk index 3ae3b4eaef..92d223cc7e 100644 --- a/opengl/tests/Android.mk +++ b/opengl/tests/Android.mk @@ -12,7 +12,6 @@ dirs := \ gl_perf \ gl_yuvtex \ gralloc \ - hwc \ include \ lib \ linetex \ diff --git a/opengl/tests/EGLTest/EGL_test.cpp b/opengl/tests/EGLTest/EGL_test.cpp index 24b131539a..62e6bd3055 100644 --- a/opengl/tests/EGLTest/EGL_test.cpp +++ b/opengl/tests/EGLTest/EGL_test.cpp @@ -28,18 +28,17 @@ #include <gui/IGraphicBufferConsumer.h> #include <gui/BufferQueue.h> -#define PIXEL_FORMAT_FLOAT "EGL_EXT_pixel_format_float" - -bool hasEglPixelFormatFloat() { - EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); +bool hasEglExtension(EGLDisplay dpy, const char* extensionName) { const char* exts = eglQueryString(dpy, EGL_EXTENSIONS); - size_t cropExtLen = strlen(PIXEL_FORMAT_FLOAT); + size_t cropExtLen = strlen(extensionName); size_t extsLen = strlen(exts); - bool equal = !strcmp(PIXEL_FORMAT_FLOAT, exts); - bool atStart = !strncmp(PIXEL_FORMAT_FLOAT " ", exts, cropExtLen + 1); + bool equal = !strcmp(extensionName, exts); + android::String8 extString(extensionName); + android::String8 space(" "); + bool atStart = !strncmp(extString + space, exts, cropExtLen + 1); bool atEnd = (cropExtLen + 1) < extsLen && - !strcmp(" " PIXEL_FORMAT_FLOAT, exts + extsLen - (cropExtLen + 1)); - bool inMiddle = strstr(exts, " " PIXEL_FORMAT_FLOAT " "); + !strcmp(space + extString, exts + extsLen - (cropExtLen + 1)); + bool inMiddle = strstr(exts, space + extString + space); return equal || atStart || atEnd || inMiddle; } @@ -194,6 +193,176 @@ TEST_F(EGLTest, EGLConfigRGBA8888First) { EXPECT_GE(components[3], 8); } +TEST_F(EGLTest, EGLDisplayP3) { + EGLint numConfigs; + EGLConfig config; + EGLBoolean success; + + if (!hasWideColorDisplay) { + // skip this test if device does not have wide-color display + return; + } + + // Test that display-p3 extensions exist + ASSERT_TRUE(hasEglExtension(mEglDisplay, "EGL_EXT_gl_colorspace_display_p3")); + ASSERT_TRUE(hasEglExtension(mEglDisplay, "EGL_EXT_gl_colorspace_display_p3_linear")); + + // Use 8-bit to keep forcus on Display-P3 aspect + EGLint attrs[] = { + // clang-format off + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT, + EGL_RED_SIZE, 8, + EGL_GREEN_SIZE, 8, + EGL_BLUE_SIZE, 8, + EGL_ALPHA_SIZE, 8, + EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FIXED_EXT, + EGL_NONE, EGL_NONE + // clang-format on + }; + success = eglChooseConfig(mEglDisplay, attrs, &config, 1, &numConfigs); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(1, numConfigs); + + EGLint components[4]; + EGLint value; + eglGetConfigAttrib(mEglDisplay, config, EGL_CONFIG_ID, &value); + + success = eglGetConfigAttrib(mEglDisplay, config, EGL_RED_SIZE, &components[0]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_GREEN_SIZE, &components[1]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_BLUE_SIZE, &components[2]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_ALPHA_SIZE, &components[3]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + + EXPECT_EQ(components[0], 8); + EXPECT_EQ(components[1], 8); + EXPECT_EQ(components[2], 8); + EXPECT_EQ(components[3], 8); + + struct DummyConsumer : public BnConsumerListener { + void onFrameAvailable(const BufferItem& /* item */) override {} + void onBuffersReleased() override {} + void onSidebandStreamChanged() override {} + }; + + // Create a EGLSurface + sp<IGraphicBufferProducer> producer; + sp<IGraphicBufferConsumer> consumer; + BufferQueue::createBufferQueue(&producer, &consumer); + consumer->consumerConnect(new DummyConsumer, false); + sp<Surface> mSTC = new Surface(producer); + sp<ANativeWindow> mANW = mSTC; + EGLint winAttrs[] = { + // clang-format off + EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, + EGL_NONE, EGL_NONE + // clang-format on + }; + + EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, config, mANW.get(), winAttrs); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + ASSERT_NE(EGL_NO_SURFACE, eglSurface); + + success = eglQuerySurface(mEglDisplay, eglSurface, EGL_GL_COLORSPACE_KHR, &value); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_GL_COLORSPACE_DISPLAY_P3_EXT, value); + + EXPECT_TRUE(eglDestroySurface(mEglDisplay, eglSurface)); +} + +TEST_F(EGLTest, EGLDisplayP31010102) { + EGLint numConfigs; + EGLConfig config; + EGLBoolean success; + + if (!hasWideColorDisplay) { + // skip this test if device does not have wide-color display + return; + } + + // Test that display-p3 extensions exist + ASSERT_TRUE(hasEglExtension(mEglDisplay, "EGL_EXT_gl_colorspace_display_p3")); + ASSERT_TRUE(hasEglExtension(mEglDisplay, "EGL_EXT_gl_colorspace_display_p3_linear")); + + // Use 8-bit to keep forcus on Display-P3 aspect + EGLint attrs[] = { + // clang-format off + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT, + EGL_RED_SIZE, 10, + EGL_GREEN_SIZE, 10, + EGL_BLUE_SIZE, 10, + EGL_ALPHA_SIZE, 2, + EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FIXED_EXT, + EGL_NONE, EGL_NONE + // clang-format on + }; + success = eglChooseConfig(mEglDisplay, attrs, &config, 1, &numConfigs); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(1, numConfigs); + + EGLint components[4]; + EGLint value; + eglGetConfigAttrib(mEglDisplay, config, EGL_CONFIG_ID, &value); + + success = eglGetConfigAttrib(mEglDisplay, config, EGL_RED_SIZE, &components[0]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_GREEN_SIZE, &components[1]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_BLUE_SIZE, &components[2]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_ALPHA_SIZE, &components[3]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + + EXPECT_EQ(components[0], 10); + EXPECT_EQ(components[1], 10); + EXPECT_EQ(components[2], 10); + EXPECT_EQ(components[3], 2); + + struct DummyConsumer : public BnConsumerListener { + void onFrameAvailable(const BufferItem& /* item */) override {} + void onBuffersReleased() override {} + void onSidebandStreamChanged() override {} + }; + + // Create a EGLSurface + sp<IGraphicBufferProducer> producer; + sp<IGraphicBufferConsumer> consumer; + BufferQueue::createBufferQueue(&producer, &consumer); + consumer->consumerConnect(new DummyConsumer, false); + sp<Surface> mSTC = new Surface(producer); + sp<ANativeWindow> mANW = mSTC; + EGLint winAttrs[] = { + // clang-format off + EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_DISPLAY_P3_EXT, + EGL_NONE, EGL_NONE + // clang-format on + }; + + EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, config, mANW.get(), winAttrs); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + ASSERT_NE(EGL_NO_SURFACE, eglSurface); + + success = eglQuerySurface(mEglDisplay, eglSurface, EGL_GL_COLORSPACE_KHR, &value); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_GL_COLORSPACE_DISPLAY_P3_EXT, value); + + EXPECT_TRUE(eglDestroySurface(mEglDisplay, eglSurface)); +} + TEST_F(EGLTest, EGLConfigFP16) { EGLint numConfigs; EGLConfig config; @@ -204,23 +373,20 @@ TEST_F(EGLTest, EGLConfigFP16) { return; } - ASSERT_TRUE(hasEglPixelFormatFloat()); - - EGLint attrs[] = {EGL_SURFACE_TYPE, - EGL_WINDOW_BIT, - EGL_RENDERABLE_TYPE, - EGL_OPENGL_ES2_BIT, - EGL_RED_SIZE, - 16, - EGL_GREEN_SIZE, - 16, - EGL_BLUE_SIZE, - 16, - EGL_ALPHA_SIZE, - 16, - EGL_COLOR_COMPONENT_TYPE_EXT, - EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT, - EGL_NONE}; + ASSERT_TRUE(hasEglExtension(mEglDisplay, "EGL_EXT_pixel_format_float")); + + EGLint attrs[] = { + // clang-format off + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_RED_SIZE, 16, + EGL_GREEN_SIZE, 16, + EGL_BLUE_SIZE, 16, + EGL_ALPHA_SIZE, 16, + EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT, + EGL_NONE, EGL_NONE + // clang-format on + }; success = eglChooseConfig(mEglDisplay, attrs, &config, 1, &numConfigs); ASSERT_EQ(EGL_UNSIGNED_TRUE, success); ASSERT_EQ(1, numConfigs); @@ -251,6 +417,108 @@ TEST_F(EGLTest, EGLConfigFP16) { void onSidebandStreamChanged() override {} }; + sp<IGraphicBufferProducer> producer; + sp<IGraphicBufferConsumer> consumer; + BufferQueue::createBufferQueue(&producer, &consumer); + consumer->consumerConnect(new DummyConsumer, false); + sp<Surface> mSTC = new Surface(producer); + sp<ANativeWindow> mANW = mSTC; + + EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, config, mANW.get(), NULL); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + ASSERT_NE(EGL_NO_SURFACE, eglSurface); + + EXPECT_TRUE(eglDestroySurface(mEglDisplay, eglSurface)); +} + +TEST_F(EGLTest, EGL_KHR_no_config_context) { + if (!hasWideColorDisplay) { + // skip this test if device does not have wide-color display + return; + } + + ASSERT_TRUE(hasEglExtension(mEglDisplay, "EGL_KHR_no_config_context")); + + struct DummyConsumer : public BnConsumerListener { + void onFrameAvailable(const BufferItem& /* item */) override {} + void onBuffersReleased() override {} + void onSidebandStreamChanged() override {} + }; + + std::vector<EGLint> contextAttributes; + contextAttributes.reserve(4); + contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION); + contextAttributes.push_back(2); + contextAttributes.push_back(EGL_NONE); + contextAttributes.push_back(EGL_NONE); + + EGLContext eglContext = eglCreateContext(mEglDisplay, EGL_NO_CONFIG_KHR, EGL_NO_CONTEXT, + contextAttributes.data()); + EXPECT_NE(EGL_NO_CONTEXT, eglContext); + EXPECT_EQ(EGL_SUCCESS, eglGetError()); + + if (eglContext != EGL_NO_CONTEXT) { + eglDestroyContext(mEglDisplay, eglContext); + } +} + +// Emulate what a native application would do to create a +// 10:10:10:2 surface. +TEST_F(EGLTest, EGLConfig1010102) { + EGLint numConfigs; + EGLConfig config; + EGLBoolean success; + + if (!hasWideColorDisplay) { + // skip this test if device does not have wide-color display + return; + } + + EGLint attrs[] = { + // clang-format off + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT, + EGL_RED_SIZE, 10, + EGL_GREEN_SIZE, 10, + EGL_BLUE_SIZE, 10, + EGL_ALPHA_SIZE, 2, + EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FIXED_EXT, + EGL_NONE, EGL_NONE + // clang-format on + }; + success = eglChooseConfig(mEglDisplay, attrs, &config, 1, &numConfigs); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(1, numConfigs); + + EGLint components[4]; + EGLint value; + eglGetConfigAttrib(mEglDisplay, config, EGL_CONFIG_ID, &value); + + success = eglGetConfigAttrib(mEglDisplay, config, EGL_RED_SIZE, &components[0]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_GREEN_SIZE, &components[1]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_BLUE_SIZE, &components[2]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + success = eglGetConfigAttrib(mEglDisplay, config, EGL_ALPHA_SIZE, &components[3]); + ASSERT_EQ(EGL_UNSIGNED_TRUE, success); + ASSERT_EQ(EGL_SUCCESS, eglGetError()); + + EXPECT_EQ(components[0], 10); + EXPECT_EQ(components[1], 10); + EXPECT_EQ(components[2], 10); + EXPECT_EQ(components[3], 2); + + struct DummyConsumer : public BnConsumerListener { + void onFrameAvailable(const BufferItem& /* item */) override {} + void onBuffersReleased() override {} + void onSidebandStreamChanged() override {} + }; + // Create a EGLSurface sp<IGraphicBufferProducer> producer; sp<IGraphicBufferConsumer> consumer; diff --git a/opengl/tests/configdump/configdump.cpp b/opengl/tests/configdump/configdump.cpp index 2a945982a9..c423105a11 100644 --- a/opengl/tests/configdump/configdump.cpp +++ b/opengl/tests/configdump/configdump.cpp @@ -66,8 +66,7 @@ Attribute attributes[] = { }; // clang-format on -int main(int argc, char** argv) -{ +int main(int /*argc*/, char** /*argv*/) { EGLConfig* configs; EGLint n; diff --git a/opengl/tests/gl2_basic/gl2_basic.cpp b/opengl/tests/gl2_basic/gl2_basic.cpp index 9f8d166c7a..ee88667328 100644 --- a/opengl/tests/gl2_basic/gl2_basic.cpp +++ b/opengl/tests/gl2_basic/gl2_basic.cpp @@ -30,6 +30,7 @@ #include <EGLUtils.h> using namespace android; +EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name); static void printGLString(const char *name, GLenum s) { // fprintf(stderr, "printGLString %s, %d\n", name, s); @@ -46,7 +47,8 @@ static void printGLString(const char *name, GLenum s) { static void printEGLString(EGLDisplay dpy, const char *name, GLenum s) { const char *v = (const char *) eglQueryString(dpy, s); - fprintf(stderr, "GL %s = %s\n", name, v); + const char* va = (const char*)eglQueryStringImplementationANDROID(dpy, s); + fprintf(stderr, "GL %s = %s\nImplementationANDROID: %s\n", name, v, va); } static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { @@ -263,7 +265,7 @@ int printEGLConfigurations(EGLDisplay dpy) { return true; } -int main(int argc, char** argv) { +int main(int /*argc*/, char** /*argv*/) { EGLBoolean returnValue; EGLConfig myConfig = {0}; diff --git a/opengl/tests/gl2_yuvtex/gl2_yuvtex.cpp b/opengl/tests/gl2_yuvtex/gl2_yuvtex.cpp index 98d8aa8cbc..22128ab5ea 100644 --- a/opengl/tests/gl2_yuvtex/gl2_yuvtex.cpp +++ b/opengl/tests/gl2_yuvtex/gl2_yuvtex.cpp @@ -331,7 +331,7 @@ void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) { printf("\n"); } -int main(int argc, char** argv) { +int main(int /*argc*/, char** /*argv*/) { EGLBoolean returnValue; EGLConfig myConfig = {0}; diff --git a/opengl/tests/gl_yuvtex/gl_yuvtex.cpp b/opengl/tests/gl_yuvtex/gl_yuvtex.cpp index c923b07362..fad26a69c7 100644 --- a/opengl/tests/gl_yuvtex/gl_yuvtex.cpp +++ b/opengl/tests/gl_yuvtex/gl_yuvtex.cpp @@ -221,7 +221,7 @@ void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) { printf("\n"); } -int main(int argc, char** argv) { +int main(int /*argc*/, char** /*argv*/) { EGLBoolean returnValue; EGLConfig myConfig = {0}; diff --git a/opengl/tests/hwc/Android.bp b/opengl/tests/hwc/Android.bp new file mode 100644 index 0000000000..425f3740e4 --- /dev/null +++ b/opengl/tests/hwc/Android.bp @@ -0,0 +1,107 @@ +// Copyright (C) 2010 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. + +cc_defaults { + + name: "hwc_tests_defaults", + cflags: [ + "-DGL_GLEXT_PROTOTYPES", + "-DEGL_EGLEXT_PROTOTYPES", + "-Wall", + "-Wextra", + "-Werror", + ], +} + +cc_library_static { + + name: "libhwcTest", + srcs: ["hwcTestLib.cpp"], + + static_libs: [ + "libarect", + "libglTest", + "libtestUtil", + ], + shared_libs: [ + "libui", + "libnativewindow" + ], + defaults: ["hwc_tests_defaults"], +} + +cc_defaults { + + name: "hwc_lib_defaults", + shared_libs: [ + "libcutils", + "libEGL", + "libGLESv2", + "libhardware", + "liblog", + "libui", + "libutils", + "libnativewindow" + ], + + static_libs: [ + "libglTest", + "libhwcTest", + "libtestUtil", + ], +} + +cc_test { + + name: "hwcStress", + srcs: ["hwcStress.cpp"], + + defaults: [ + "hwc_lib_defaults", + "hwc_tests_defaults", + ], +} + +cc_test { + + name: "hwcRects", + srcs: ["hwcRects.cpp"], + + defaults: [ + "hwc_lib_defaults", + "hwc_tests_defaults", + ], +} + +cc_test { + + name: "hwcColorEquiv", + srcs: ["hwcColorEquiv.cpp"], + + defaults: [ + "hwc_lib_defaults", + "hwc_tests_defaults", + ], +} + +cc_test { + + name: "hwcCommit", + srcs: ["hwcCommit.cpp"], + + defaults: [ + "hwc_lib_defaults", + "hwc_tests_defaults", + ], +} diff --git a/opengl/tests/hwc/Android.mk b/opengl/tests/hwc/Android.mk deleted file mode 100644 index 13337c2753..0000000000 --- a/opengl/tests/hwc/Android.mk +++ /dev/null @@ -1,150 +0,0 @@ -# Copyright (C) 2010 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. - -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk - -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE:= libhwcTest -LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES -Wall -Wextra -Werror -LOCAL_CXX_STL := libc++ -LOCAL_SRC_FILES:= hwcTestLib.cpp -LOCAL_C_INCLUDES += system/extras/tests/include \ - $(call include-path-for, opengl-tests-includes) \ - -LOCAL_STATIC_LIBRARIES := libarect - -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk - -LOCAL_MODULE:= hwcStress -LOCAL_MODULE_TAGS := tests -LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES -Wall -Wextra -Werror -LOCAL_CXX_STL := libc++ -LOCAL_SRC_FILES:= hwcStress.cpp - -LOCAL_SHARED_LIBRARIES := \ - libcutils \ - libEGL \ - libGLESv2 \ - libutils \ - liblog \ - libui \ - libhardware \ - -LOCAL_STATIC_LIBRARIES := \ - libtestUtil \ - libglTest \ - libhwcTest \ - -LOCAL_C_INCLUDES += \ - system/extras/tests/include \ - hardware/libhardware/include \ - $(call include-path-for, opengl-tests-includes) \ - -include $(BUILD_NATIVE_TEST) - -include $(CLEAR_VARS) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk - -LOCAL_MODULE:= hwcRects -LOCAL_MODULE_TAGS := tests -LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES -Wall -Wextra -Werror -LOCAL_CXX_STL := libc++ -LOCAL_SRC_FILES:= hwcRects.cpp - -LOCAL_SHARED_LIBRARIES := \ - libcutils \ - libEGL \ - libGLESv2 \ - libutils \ - liblog \ - libui \ - libhardware \ - -LOCAL_STATIC_LIBRARIES := \ - libtestUtil \ - libglTest \ - libhwcTest \ - -LOCAL_C_INCLUDES += \ - system/extras/tests/include \ - hardware/libhardware/include \ - $(call include-path-for, opengl-tests-includes) \ - -include $(BUILD_NATIVE_TEST) - -include $(CLEAR_VARS) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk - -LOCAL_MODULE:= hwcColorEquiv -LOCAL_MODULE_TAGS := tests -LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES -Wall -Wextra -Werror -LOCAL_CXX_STL := libc++ -LOCAL_SRC_FILES:= hwcColorEquiv.cpp - -LOCAL_SHARED_LIBRARIES := \ - libcutils \ - libEGL \ - libGLESv2 \ - libutils \ - liblog \ - libui \ - libhardware \ - -LOCAL_STATIC_LIBRARIES := \ - libtestUtil \ - libglTest \ - libhwcTest \ - -LOCAL_C_INCLUDES += \ - system/extras/tests/include \ - hardware/libhardware/include \ - $(call include-path-for, opengl-tests-includes) \ - -include $(BUILD_NATIVE_TEST) - -include $(CLEAR_VARS) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk - -LOCAL_MODULE:= hwcCommit -LOCAL_MODULE_TAGS := tests -LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES -Wall -Wextra -Werror -LOCAL_CXX_STL := libc++ -LOCAL_SRC_FILES:= hwcCommit.cpp - -LOCAL_SHARED_LIBRARIES := \ - libcutils \ - libEGL \ - libGLESv2 \ - libutils \ - liblog \ - libui \ - libhardware \ - -LOCAL_STATIC_LIBRARIES := \ - libtestUtil \ - libglTest \ - libhwcTest \ - -LOCAL_C_INCLUDES += \ - system/extras/tests/include \ - hardware/libhardware/include \ - $(call include-path-for, opengl-tests-includes) \ - -include $(BUILD_NATIVE_TEST) diff --git a/opengl/tests/lib/Android.bp b/opengl/tests/lib/Android.bp new file mode 100644 index 0000000000..2f6095d8e7 --- /dev/null +++ b/opengl/tests/lib/Android.bp @@ -0,0 +1,38 @@ +// Copyright (C) 2010 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. + +cc_library_static { + + name: "libglTest", + srcs: [ + "glTestLib.cpp", + "WindowSurface.cpp", + ], + export_include_dirs: ["include"], + + cflags: [ + "-DGL_GLEXT_PROTOTYPES", + "-DEGL_EGLEXT_PROTOTYPES", + "-Wall", + "-Wextra", + "-Werror", + ], + + shared_libs: ["libgui"], + static_libs: [ + "libarect", + "libtestUtil", + ], + +} diff --git a/opengl/tests/lib/Android.mk b/opengl/tests/lib/Android.mk deleted file mode 100644 index ea94bc199f..0000000000 --- a/opengl/tests/lib/Android.mk +++ /dev/null @@ -1,30 +0,0 @@ -# Copyright (C) 2010 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. - -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_MODULE_TAGS := tests -LOCAL_MODULE:= libglTest -LOCAL_SRC_FILES:= glTestLib.cpp WindowSurface.cpp -LOCAL_C_INCLUDES += system/extras/tests/include \ - $(call include-path-for, opengl-tests-includes) - -LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES -Wall -Wextra -Werror - -LOCAL_SHARED_LIBRARIES += libgui -LOCAL_STATIC_LIBRARIES := libarect - -include $(BUILD_STATIC_LIBRARY) diff --git a/opengl/tests/include/EGLUtils.h b/opengl/tests/lib/include/EGLUtils.h index 014c2611ae..014c2611ae 100644 --- a/opengl/tests/include/EGLUtils.h +++ b/opengl/tests/lib/include/EGLUtils.h diff --git a/opengl/tests/include/WindowSurface.h b/opengl/tests/lib/include/WindowSurface.h index 0ec1404556..0ec1404556 100644 --- a/opengl/tests/include/WindowSurface.h +++ b/opengl/tests/lib/include/WindowSurface.h diff --git a/opengl/tests/include/glTestLib.h b/opengl/tests/lib/include/glTestLib.h index c91c594882..c91c594882 100644 --- a/opengl/tests/include/glTestLib.h +++ b/opengl/tests/lib/include/glTestLib.h diff --git a/opengl/tools/glgen2/registry/egl.xml b/opengl/tools/glgen2/registry/egl.xml index af13395bb1..c2d3494404 100755 --- a/opengl/tools/glgen2/registry/egl.xml +++ b/opengl/tools/glgen2/registry/egl.xml @@ -191,6 +191,7 @@ <enum value="((EGLSync)0)" name="EGL_NO_SYNC"/> <enum value="((EGLSyncKHR)0)" name="EGL_NO_SYNC_KHR" alias="EGL_NO_SYNC"/> <enum value="((EGLSyncNV)0)" name="EGL_NO_SYNC_NV" alias="EGL_NO_SYNC"/> + <enum value="EGL_CAST(EGLConfig,0)" name="EGL_NO_CONFIG_KHR"/> <enum value="10000" name="EGL_DISPLAY_SCALING"/> <enum value="0xFFFFFFFFFFFFFFFF" name="EGL_FOREVER" type="ull"/> <enum value="0xFFFFFFFFFFFFFFFF" name="EGL_FOREVER_KHR" type="ull" alias="EGL_FOREVER"/> @@ -739,7 +740,10 @@ <enum value="50000" name="EGL_METADATA_SCALING_EXT"/> <unused start="0x334B" end="0x334F"/> <enum value="0x3350" name="EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT"/> - <unused start="0x3351" end="0x339F"/> + <unused start="0x3351" end="0x3361"/> + <enum value="0x3362" name="EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT"/> + <enum value="0x3363" name="EGL_GL_COLORSPACE_DISPLAY_P3_EXT"/> + <unused start="0x3364" end="0x339F"/> </enums> <enums namespace="EGL" start="0x33A0" end="0x33AF" vendor="ANGLE" comment="Reserved for Shannon Woods (Bug 13175)"> @@ -1891,6 +1895,16 @@ <enum name="EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT"/> </require> </extension> + <extension name="EGL_EXT_gl_colorspace_display_p3_linear" supported="egl"> + <require> + <enum name="EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT"/> + </require> + </extension> + <extension name="EGL_EXT_gl_colorspace_display_p3" supported="egl"> + <require> + <enum name="EGL_GL_COLORSPACE_DISPLAY_P3_EXT"/> + </require> + </extension> <extension name="EGL_EXT_image_dma_buf_import" supported="egl"> <require> <enum name="EGL_LINUX_DMA_BUF_EXT"/> |