| /* |
| * Copyright 2013 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. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #undef LOG_TAG |
| #define LOG_TAG "RenderEngine" |
| #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| |
| #include "GLESRenderEngine.h" |
| |
| #include <math.h> |
| #include <fstream> |
| #include <sstream> |
| #include <unordered_set> |
| |
| #include <GLES2/gl2.h> |
| #include <GLES2/gl2ext.h> |
| #include <android-base/stringprintf.h> |
| #include <cutils/compiler.h> |
| #include <cutils/properties.h> |
| #include <renderengine/Mesh.h> |
| #include <renderengine/Texture.h> |
| #include <renderengine/private/Description.h> |
| #include <sync/sync.h> |
| #include <ui/ColorSpace.h> |
| #include <ui/DebugUtils.h> |
| #include <ui/GraphicBuffer.h> |
| #include <ui/Rect.h> |
| #include <ui/Region.h> |
| #include <utils/KeyedVector.h> |
| #include <utils/Trace.h> |
| #include "GLExtensions.h" |
| #include "GLFramebuffer.h" |
| #include "GLImage.h" |
| #include "Program.h" |
| #include "ProgramCache.h" |
| |
| extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name); |
| |
| bool checkGlError(const char* op, int lineNumber) { |
| bool errorFound = false; |
| GLint error = glGetError(); |
| while (error != GL_NO_ERROR) { |
| errorFound = true; |
| error = glGetError(); |
| ALOGV("after %s() (line # %d) glError (0x%x)\n", op, lineNumber, error); |
| } |
| return errorFound; |
| } |
| |
| static constexpr bool outputDebugPPMs = false; |
| |
| void writePPM(const char* basename, GLuint width, GLuint height) { |
| ALOGV("writePPM #%s: %d x %d", basename, width, height); |
| |
| std::vector<GLubyte> pixels(width * height * 4); |
| std::vector<GLubyte> outBuffer(width * height * 3); |
| |
| // TODO(courtneygo): We can now have float formats, need |
| // to remove this code or update to support. |
| // Make returned pixels fit in uint32_t, one byte per component |
| glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); |
| if (checkGlError(__FUNCTION__, __LINE__)) { |
| return; |
| } |
| |
| std::string filename(basename); |
| filename.append(".ppm"); |
| std::ofstream file(filename.c_str(), std::ios::binary); |
| if (!file.is_open()) { |
| ALOGE("Unable to open file: %s", filename.c_str()); |
| ALOGE("You may need to do: \"adb shell setenforce 0\" to enable " |
| "surfaceflinger to write debug images"); |
| return; |
| } |
| |
| file << "P6\n"; |
| file << width << "\n"; |
| file << height << "\n"; |
| file << 255 << "\n"; |
| |
| auto ptr = reinterpret_cast<char*>(pixels.data()); |
| auto outPtr = reinterpret_cast<char*>(outBuffer.data()); |
| for (int y = height - 1; y >= 0; y--) { |
| char* data = ptr + y * width * sizeof(uint32_t); |
| |
| for (GLuint x = 0; x < width; x++) { |
| // Only copy R, G and B components |
| outPtr[0] = data[0]; |
| outPtr[1] = data[1]; |
| outPtr[2] = data[2]; |
| data += sizeof(uint32_t); |
| outPtr += 3; |
| } |
| } |
| file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size()); |
| } |
| |
| namespace android { |
| namespace renderengine { |
| namespace gl { |
| |
| using base::StringAppendF; |
| using ui::Dataspace; |
| |
| static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute, |
| EGLint wanted, EGLConfig* outConfig) { |
| EGLint numConfigs = -1, n = 0; |
| eglGetConfigs(dpy, nullptr, 0, &numConfigs); |
| std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR); |
| eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n); |
| configs.resize(n); |
| |
| if (!configs.empty()) { |
| if (attribute != EGL_NONE) { |
| for (EGLConfig config : configs) { |
| EGLint value = 0; |
| eglGetConfigAttrib(dpy, config, attribute, &value); |
| if (wanted == value) { |
| *outConfig = config; |
| return NO_ERROR; |
| } |
| } |
| } else { |
| // just pick the first one |
| *outConfig = configs[0]; |
| return NO_ERROR; |
| } |
| } |
| |
| return NAME_NOT_FOUND; |
| } |
| |
| class EGLAttributeVector { |
| struct Attribute; |
| class Adder; |
| friend class Adder; |
| KeyedVector<Attribute, EGLint> mList; |
| struct Attribute { |
| Attribute() : v(0){}; |
| explicit Attribute(EGLint v) : v(v) {} |
| EGLint v; |
| bool operator<(const Attribute& other) const { |
| // this places EGL_NONE at the end |
| EGLint lhs(v); |
| EGLint rhs(other.v); |
| if (lhs == EGL_NONE) lhs = 0x7FFFFFFF; |
| if (rhs == EGL_NONE) rhs = 0x7FFFFFFF; |
| return lhs < rhs; |
| } |
| }; |
| class Adder { |
| friend class EGLAttributeVector; |
| EGLAttributeVector& v; |
| EGLint attribute; |
| Adder(EGLAttributeVector& v, EGLint attribute) : v(v), attribute(attribute) {} |
| |
| public: |
| void operator=(EGLint value) { |
| if (attribute != EGL_NONE) { |
| v.mList.add(Attribute(attribute), value); |
| } |
| } |
| operator EGLint() const { return v.mList[attribute]; } |
| }; |
| |
| public: |
| EGLAttributeVector() { mList.add(Attribute(EGL_NONE), EGL_NONE); } |
| void remove(EGLint attribute) { |
| if (attribute != EGL_NONE) { |
| mList.removeItem(Attribute(attribute)); |
| } |
| } |
| Adder operator[](EGLint attribute) { return Adder(*this, attribute); } |
| EGLint operator[](EGLint attribute) const { return mList[attribute]; } |
| // cast-operator to (EGLint const*) |
| operator EGLint const*() const { return &mList.keyAt(0).v; } |
| }; |
| |
| static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType, |
| EGLConfig* config) { |
| // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if |
| // it is to be used with WIFI displays |
| status_t err; |
| EGLint wantedAttribute; |
| EGLint wantedAttributeValue; |
| |
| EGLAttributeVector attribs; |
| if (renderableType) { |
| attribs[EGL_RENDERABLE_TYPE] = renderableType; |
| attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE; |
| attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT | EGL_PBUFFER_BIT; |
| attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE; |
| attribs[EGL_RED_SIZE] = 8; |
| attribs[EGL_GREEN_SIZE] = 8; |
| attribs[EGL_BLUE_SIZE] = 8; |
| attribs[EGL_ALPHA_SIZE] = 8; |
| wantedAttribute = EGL_NONE; |
| wantedAttributeValue = EGL_NONE; |
| } else { |
| // if no renderable type specified, fallback to a simplified query |
| wantedAttribute = EGL_NATIVE_VISUAL_ID; |
| wantedAttributeValue = format; |
| } |
| |
| err = selectConfigForAttribute(display, attribs, wantedAttribute, wantedAttributeValue, config); |
| if (err == NO_ERROR) { |
| EGLint caveat; |
| if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat)) |
| ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!"); |
| } |
| |
| return err; |
| } |
| |
| std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32_t featureFlags, |
| uint32_t imageCacheSize) { |
| // initialize EGL for the default display |
| EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); |
| if (!eglInitialize(display, nullptr, nullptr)) { |
| LOG_ALWAYS_FATAL("failed to initialize EGL"); |
| } |
| |
| GLExtensions& extensions = GLExtensions::getInstance(); |
| extensions.initWithEGLStrings(eglQueryStringImplementationANDROID(display, EGL_VERSION), |
| eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS)); |
| |
| // The code assumes that ES2 or later is available if this extension is |
| // supported. |
| EGLConfig config = EGL_NO_CONFIG; |
| if (!extensions.hasNoConfigContext()) { |
| config = chooseEglConfig(display, hwcFormat, /*logConfig*/ true); |
| } |
| |
| bool useContextPriority = extensions.hasContextPriority() && |
| (featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT); |
| EGLContext protectedContext = EGL_NO_CONTEXT; |
| if ((featureFlags & RenderEngine::ENABLE_PROTECTED_CONTEXT) && |
| extensions.hasProtectedContent()) { |
| protectedContext = createEglContext(display, config, nullptr, useContextPriority, |
| Protection::PROTECTED); |
| ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context"); |
| } |
| |
| EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority, |
| Protection::UNPROTECTED); |
| |
| // if can't create a GL context, we can only abort. |
| LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed"); |
| |
| EGLSurface dummy = EGL_NO_SURFACE; |
| if (!extensions.hasSurfacelessContext()) { |
| dummy = createDummyEglPbufferSurface(display, config, hwcFormat, Protection::UNPROTECTED); |
| LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer"); |
| } |
| EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt); |
| LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current"); |
| extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER), |
| glGetString(GL_VERSION), glGetString(GL_EXTENSIONS)); |
| |
| EGLSurface protectedDummy = EGL_NO_SURFACE; |
| if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) { |
| protectedDummy = |
| createDummyEglPbufferSurface(display, config, hwcFormat, Protection::PROTECTED); |
| ALOGE_IF(protectedDummy == EGL_NO_SURFACE, "can't create protected dummy pbuffer"); |
| } |
| |
| // now figure out what version of GL did we actually get |
| GlesVersion version = parseGlesVersion(extensions.getVersion()); |
| |
| // initialize the renderer while GL is current |
| std::unique_ptr<GLESRenderEngine> engine; |
| switch (version) { |
| case GLES_VERSION_1_0: |
| case GLES_VERSION_1_1: |
| LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run."); |
| break; |
| case GLES_VERSION_2_0: |
| case GLES_VERSION_3_0: |
| engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy, |
| protectedContext, protectedDummy, |
| imageCacheSize); |
| break; |
| } |
| |
| ALOGI("OpenGL ES informations:"); |
| ALOGI("vendor : %s", extensions.getVendor()); |
| ALOGI("renderer : %s", extensions.getRenderer()); |
| ALOGI("version : %s", extensions.getVersion()); |
| ALOGI("extensions: %s", extensions.getExtensions()); |
| ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize()); |
| ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims()); |
| |
| return engine; |
| } |
| |
| EGLConfig GLESRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) { |
| status_t err; |
| EGLConfig config; |
| |
| // First try to get an ES3 config |
| err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config); |
| if (err != NO_ERROR) { |
| // If ES3 fails, try to get an ES2 config |
| err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config); |
| if (err != NO_ERROR) { |
| // If ES2 still doesn't work, probably because we're on the emulator. |
| // try a simplified query |
| ALOGW("no suitable EGLConfig found, trying a simpler query"); |
| err = selectEGLConfig(display, format, 0, &config); |
| if (err != NO_ERROR) { |
| // this EGL is too lame for android |
| LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up"); |
| } |
| } |
| } |
| |
| if (logConfig) { |
| // print some debugging info |
| EGLint r, g, b, a; |
| eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r); |
| eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g); |
| eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b); |
| eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a); |
| ALOGI("EGL information:"); |
| ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR)); |
| ALOGI("version : %s", eglQueryString(display, EGL_VERSION)); |
| ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS)); |
| ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported"); |
| ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config); |
| } |
| |
| return config; |
| } |
| |
| GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config, |
| EGLContext ctxt, EGLSurface dummy, EGLContext protectedContext, |
| EGLSurface protectedDummy, uint32_t imageCacheSize) |
| : renderengine::impl::RenderEngine(featureFlags), |
| mEGLDisplay(display), |
| mEGLConfig(config), |
| mEGLContext(ctxt), |
| mDummySurface(dummy), |
| mProtectedEGLContext(protectedContext), |
| mProtectedDummySurface(protectedDummy), |
| mVpWidth(0), |
| mVpHeight(0), |
| mFramebufferImageCacheSize(imageCacheSize), |
| mUseColorManagement(featureFlags & USE_COLOR_MANAGEMENT) { |
| glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize); |
| glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims); |
| |
| glPixelStorei(GL_UNPACK_ALIGNMENT, 4); |
| glPixelStorei(GL_PACK_ALIGNMENT, 4); |
| |
| // Initialize protected EGL Context. |
| if (mProtectedEGLContext != EGL_NO_CONTEXT) { |
| EGLBoolean success = eglMakeCurrent(display, mProtectedDummySurface, mProtectedDummySurface, |
| mProtectedEGLContext); |
| ALOGE_IF(!success, "can't make protected context current"); |
| glPixelStorei(GL_UNPACK_ALIGNMENT, 4); |
| glPixelStorei(GL_PACK_ALIGNMENT, 4); |
| success = eglMakeCurrent(display, mDummySurface, mDummySurface, mEGLContext); |
| LOG_ALWAYS_FATAL_IF(!success, "can't make default context current"); |
| } |
| |
| const uint16_t protTexData[] = {0}; |
| glGenTextures(1, &mProtectedTexName); |
| glBindTexture(GL_TEXTURE_2D, mProtectedTexName); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, protTexData); |
| |
| // mColorBlindnessCorrection = M; |
| |
| if (mUseColorManagement) { |
| const ColorSpace srgb(ColorSpace::sRGB()); |
| const ColorSpace displayP3(ColorSpace::DisplayP3()); |
| const ColorSpace bt2020(ColorSpace::BT2020()); |
| |
| // no chromatic adaptation needed since all color spaces use D65 for their white points. |
| mSrgbToXyz = mat4(srgb.getRGBtoXYZ()); |
| mDisplayP3ToXyz = mat4(displayP3.getRGBtoXYZ()); |
| mBt2020ToXyz = mat4(bt2020.getRGBtoXYZ()); |
| mXyzToSrgb = mat4(srgb.getXYZtoRGB()); |
| mXyzToDisplayP3 = mat4(displayP3.getXYZtoRGB()); |
| mXyzToBt2020 = mat4(bt2020.getXYZtoRGB()); |
| |
| // Compute sRGB to Display P3 and BT2020 transform matrix. |
| // NOTE: For now, we are limiting output wide color space support to |
| // Display-P3 and BT2020 only. |
| mSrgbToDisplayP3 = mXyzToDisplayP3 * mSrgbToXyz; |
| mSrgbToBt2020 = mXyzToBt2020 * mSrgbToXyz; |
| |
| // Compute Display P3 to sRGB and BT2020 transform matrix. |
| mDisplayP3ToSrgb = mXyzToSrgb * mDisplayP3ToXyz; |
| mDisplayP3ToBt2020 = mXyzToBt2020 * mDisplayP3ToXyz; |
| |
| // Compute BT2020 to sRGB and Display P3 transform matrix |
| mBt2020ToSrgb = mXyzToSrgb * mBt2020ToXyz; |
| mBt2020ToDisplayP3 = mXyzToDisplayP3 * mBt2020ToXyz; |
| } |
| |
| char value[PROPERTY_VALUE_MAX]; |
| property_get("debug.egl.traceGpuCompletion", value, "0"); |
| if (atoi(value)) { |
| mTraceGpuCompletion = true; |
| mFlushTracer = std::make_unique<FlushTracer>(this); |
| } |
| mDrawingBuffer = createFramebuffer(); |
| } |
| |
| GLESRenderEngine::~GLESRenderEngine() { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| unbindFrameBuffer(mDrawingBuffer.get()); |
| mDrawingBuffer = nullptr; |
| while (!mFramebufferImageCache.empty()) { |
| EGLImageKHR expired = mFramebufferImageCache.front().second; |
| mFramebufferImageCache.pop_front(); |
| eglDestroyImageKHR(mEGLDisplay, expired); |
| } |
| mImageCache.clear(); |
| eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| eglTerminate(mEGLDisplay); |
| } |
| |
| std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() { |
| return std::make_unique<GLFramebuffer>(*this); |
| } |
| |
| std::unique_ptr<Image> GLESRenderEngine::createImage() { |
| return std::make_unique<GLImage>(*this); |
| } |
| |
| Framebuffer* GLESRenderEngine::getFramebufferForDrawing() { |
| return mDrawingBuffer.get(); |
| } |
| |
| void GLESRenderEngine::primeCache() const { |
| ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext, |
| mFeatureFlags & USE_COLOR_MANAGEMENT); |
| } |
| |
| bool GLESRenderEngine::isCurrent() const { |
| return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext(); |
| } |
| |
| base::unique_fd GLESRenderEngine::flush() { |
| ATRACE_CALL(); |
| if (!GLExtensions::getInstance().hasNativeFenceSync()) { |
| return base::unique_fd(); |
| } |
| |
| EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr); |
| if (sync == EGL_NO_SYNC_KHR) { |
| ALOGW("failed to create EGL native fence sync: %#x", eglGetError()); |
| return base::unique_fd(); |
| } |
| |
| // native fence fd will not be populated until flush() is done. |
| glFlush(); |
| |
| // get the fence fd |
| base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync)); |
| eglDestroySyncKHR(mEGLDisplay, sync); |
| if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) { |
| ALOGW("failed to dup EGL native fence sync: %#x", eglGetError()); |
| } |
| |
| // Only trace if we have a valid fence, as current usage falls back to |
| // calling finish() if the fence fd is invalid. |
| if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer) && fenceFd.get() >= 0) { |
| mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr)); |
| } |
| |
| return fenceFd; |
| } |
| |
| bool GLESRenderEngine::finish() { |
| ATRACE_CALL(); |
| if (!GLExtensions::getInstance().hasFenceSync()) { |
| ALOGW("no synchronization support"); |
| return false; |
| } |
| |
| EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr); |
| if (sync == EGL_NO_SYNC_KHR) { |
| ALOGW("failed to create EGL fence sync: %#x", eglGetError()); |
| return false; |
| } |
| |
| if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer)) { |
| mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr)); |
| } |
| |
| return waitSync(sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR); |
| } |
| |
| bool GLESRenderEngine::waitSync(EGLSyncKHR sync, EGLint flags) { |
| EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, flags, 2000000000 /*2 sec*/); |
| EGLint error = eglGetError(); |
| eglDestroySyncKHR(mEGLDisplay, sync); |
| if (result != EGL_CONDITION_SATISFIED_KHR) { |
| if (result == EGL_TIMEOUT_EXPIRED_KHR) { |
| ALOGW("fence wait timed out"); |
| } else { |
| ALOGW("error waiting on EGL fence: %#x", error); |
| } |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) { |
| if (!GLExtensions::getInstance().hasNativeFenceSync() || |
| !GLExtensions::getInstance().hasWaitSync()) { |
| return false; |
| } |
| |
| // release the fd and transfer the ownership to EGLSync |
| EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd.release(), EGL_NONE}; |
| EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs); |
| if (sync == EGL_NO_SYNC_KHR) { |
| ALOGE("failed to create EGL native fence sync: %#x", eglGetError()); |
| return false; |
| } |
| |
| // XXX: The spec draft is inconsistent as to whether this should return an |
| // EGLint or void. Ignore the return value for now, as it's not strictly |
| // needed. |
| eglWaitSyncKHR(mEGLDisplay, sync, 0); |
| EGLint error = eglGetError(); |
| eglDestroySyncKHR(mEGLDisplay, sync); |
| if (error != EGL_SUCCESS) { |
| ALOGE("failed to wait for EGL native fence sync: %#x", error); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) { |
| ATRACE_CALL(); |
| glDisable(GL_BLEND); |
| glClearColor(red, green, blue, alpha); |
| glClear(GL_COLOR_BUFFER_BIT); |
| } |
| |
| void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue, |
| float alpha) { |
| size_t c; |
| Rect const* r = region.getArray(&c); |
| Mesh mesh(Mesh::TRIANGLES, c * 6, 2); |
| Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); |
| for (size_t i = 0; i < c; i++, r++) { |
| position[i * 6 + 0].x = r->left; |
| position[i * 6 + 0].y = r->top; |
| position[i * 6 + 1].x = r->left; |
| position[i * 6 + 1].y = r->bottom; |
| position[i * 6 + 2].x = r->right; |
| position[i * 6 + 2].y = r->bottom; |
| position[i * 6 + 3].x = r->left; |
| position[i * 6 + 3].y = r->top; |
| position[i * 6 + 4].x = r->right; |
| position[i * 6 + 4].y = r->bottom; |
| position[i * 6 + 5].x = r->right; |
| position[i * 6 + 5].y = r->top; |
| } |
| setupFillWithColor(red, green, blue, alpha); |
| drawMesh(mesh); |
| } |
| |
| void GLESRenderEngine::setScissor(const Rect& region) { |
| glScissor(region.left, region.top, region.getWidth(), region.getHeight()); |
| glEnable(GL_SCISSOR_TEST); |
| } |
| |
| void GLESRenderEngine::disableScissor() { |
| glDisable(GL_SCISSOR_TEST); |
| } |
| |
| void GLESRenderEngine::genTextures(size_t count, uint32_t* names) { |
| glGenTextures(count, names); |
| } |
| |
| void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) { |
| glDeleteTextures(count, names); |
| } |
| |
| void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) { |
| ATRACE_CALL(); |
| const GLImage& glImage = static_cast<const GLImage&>(image); |
| const GLenum target = GL_TEXTURE_EXTERNAL_OES; |
| |
| glBindTexture(target, texName); |
| if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) { |
| glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage())); |
| } |
| } |
| |
| status_t GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| return cacheExternalTextureBufferLocked(buffer); |
| } |
| |
| status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, |
| const sp<GraphicBuffer>& buffer, |
| const sp<Fence>& bufferFence) { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| return bindExternalTextureBufferLocked(texName, buffer, bufferFence); |
| } |
| |
| status_t GLESRenderEngine::cacheExternalTextureBufferLocked(const sp<GraphicBuffer>& buffer) { |
| if (buffer == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| ATRACE_CALL(); |
| |
| if (mImageCache.count(buffer->getId()) > 0) { |
| return NO_ERROR; |
| } |
| |
| std::unique_ptr<Image> newImage = createImage(); |
| |
| bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(), |
| buffer->getUsage() & GRALLOC_USAGE_PROTECTED); |
| if (!created) { |
| ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d", |
| buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(), |
| buffer->getPixelFormat()); |
| return NO_INIT; |
| } |
| mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage))); |
| |
| return NO_ERROR; |
| } |
| |
| status_t GLESRenderEngine::bindExternalTextureBufferLocked(uint32_t texName, |
| const sp<GraphicBuffer>& buffer, |
| const sp<Fence>& bufferFence) { |
| ATRACE_CALL(); |
| status_t cacheResult = cacheExternalTextureBufferLocked(buffer); |
| |
| if (cacheResult != NO_ERROR) { |
| return cacheResult; |
| } |
| |
| auto cachedImage = mImageCache.find(buffer->getId()); |
| |
| if (cachedImage == mImageCache.end()) { |
| // We failed creating the image if we got here, so bail out. |
| bindExternalTextureImage(texName, *createImage()); |
| return NO_INIT; |
| } |
| |
| bindExternalTextureImage(texName, *cachedImage->second); |
| |
| // Wait for the new buffer to be ready. |
| if (bufferFence != nullptr && bufferFence->isValid()) { |
| if (GLExtensions::getInstance().hasWaitSync()) { |
| base::unique_fd fenceFd(bufferFence->dup()); |
| if (fenceFd == -1) { |
| ALOGE("error dup'ing fence fd: %d", errno); |
| return -errno; |
| } |
| if (!waitFence(std::move(fenceFd))) { |
| ALOGE("failed to wait on fence fd"); |
| return UNKNOWN_ERROR; |
| } |
| } else { |
| status_t err = bufferFence->waitForever("RenderEngine::bindExternalTextureBuffer"); |
| if (err != NO_ERROR) { |
| ALOGE("error waiting for fence: %d", err); |
| return err; |
| } |
| } |
| } |
| |
| return NO_ERROR; |
| } |
| |
| void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| const auto& cachedImage = mImageCache.find(bufferId); |
| if (cachedImage != mImageCache.end()) { |
| ALOGV("Destroying image for buffer: %" PRIu64, bufferId); |
| mImageCache.erase(bufferId); |
| return; |
| } |
| ALOGV("Failed to find image for buffer: %" PRIu64, bufferId); |
| } |
| |
| FloatRect GLESRenderEngine::setupLayerCropping(const LayerSettings& layer, Mesh& mesh) { |
| // Translate win by the rounded corners rect coordinates, to have all values in |
| // layer coordinate space. |
| FloatRect cropWin = layer.geometry.boundaries; |
| const FloatRect& roundedCornersCrop = layer.geometry.roundedCornersCrop; |
| cropWin.left -= roundedCornersCrop.left; |
| cropWin.right -= roundedCornersCrop.left; |
| cropWin.top -= roundedCornersCrop.top; |
| cropWin.bottom -= roundedCornersCrop.top; |
| Mesh::VertexArray<vec2> cropCoords(mesh.getCropCoordArray<vec2>()); |
| cropCoords[0] = vec2(cropWin.left, cropWin.top); |
| cropCoords[1] = vec2(cropWin.left, cropWin.top + cropWin.getHeight()); |
| cropCoords[2] = vec2(cropWin.right, cropWin.top + cropWin.getHeight()); |
| cropCoords[3] = vec2(cropWin.right, cropWin.top); |
| |
| setupCornerRadiusCropSize(roundedCornersCrop.getWidth(), roundedCornersCrop.getHeight()); |
| return cropWin; |
| } |
| |
| void GLESRenderEngine::handleRoundedCorners(const DisplaySettings& display, |
| const LayerSettings& layer, const Mesh& mesh) { |
| // We separate the layer into 3 parts essentially, such that we only turn on blending for the |
| // top rectangle and the bottom rectangle, and turn off blending for the middle rectangle. |
| FloatRect bounds = layer.geometry.roundedCornersCrop; |
| |
| // Firstly, we need to convert the coordination from layer native coordination space to |
| // device coordination space. |
| const auto transformMatrix = display.globalTransform * layer.geometry.positionTransform; |
| const vec4 leftTopCoordinate(bounds.left, bounds.top, 1.0, 1.0); |
| const vec4 rightBottomCoordinate(bounds.right, bounds.bottom, 1.0, 1.0); |
| const vec4 leftTopCoordinateInBuffer = transformMatrix * leftTopCoordinate; |
| const vec4 rightBottomCoordinateInBuffer = transformMatrix * rightBottomCoordinate; |
| bounds = FloatRect(leftTopCoordinateInBuffer[0], leftTopCoordinateInBuffer[1], |
| rightBottomCoordinateInBuffer[0], rightBottomCoordinateInBuffer[1]); |
| |
| // Secondly, if the display is rotated, we need to undo the rotation on coordination and |
| // align the (left, top) and (right, bottom) coordination with the device coordination |
| // space. |
| switch (display.orientation) { |
| case ui::Transform::ROT_90: |
| std::swap(bounds.left, bounds.right); |
| break; |
| case ui::Transform::ROT_180: |
| std::swap(bounds.left, bounds.right); |
| std::swap(bounds.top, bounds.bottom); |
| break; |
| case ui::Transform::ROT_270: |
| std::swap(bounds.top, bounds.bottom); |
| break; |
| default: |
| break; |
| } |
| |
| // Finally, we cut the layer into 3 parts, with top and bottom parts having rounded corners |
| // and the middle part without rounded corners. |
| const int32_t radius = ceil(layer.geometry.roundedCornersRadius); |
| const Rect topRect(bounds.left, bounds.top, bounds.right, bounds.top + radius); |
| setScissor(topRect); |
| drawMesh(mesh); |
| const Rect bottomRect(bounds.left, bounds.bottom - radius, bounds.right, bounds.bottom); |
| setScissor(bottomRect); |
| drawMesh(mesh); |
| |
| // The middle part of the layer can turn off blending. |
| const Rect middleRect(bounds.left, bounds.top + radius, bounds.right, bounds.bottom - radius); |
| setScissor(middleRect); |
| mState.cornerRadius = 0.0; |
| disableBlending(); |
| drawMesh(mesh); |
| disableScissor(); |
| } |
| |
| status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) { |
| ATRACE_CALL(); |
| GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer); |
| EGLImageKHR eglImage = glFramebuffer->getEGLImage(); |
| uint32_t textureName = glFramebuffer->getTextureName(); |
| uint32_t framebufferName = glFramebuffer->getFramebufferName(); |
| |
| // Bind the texture and turn our EGLImage into a texture |
| glBindTexture(GL_TEXTURE_2D, textureName); |
| glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage); |
| |
| // Bind the Framebuffer to render into |
| glBindFramebuffer(GL_FRAMEBUFFER, framebufferName); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0); |
| |
| uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER); |
| |
| ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d", |
| glStatus); |
| |
| return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE; |
| } |
| |
| void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) { |
| ATRACE_CALL(); |
| |
| // back to main framebuffer |
| glBindFramebuffer(GL_FRAMEBUFFER, 0); |
| } |
| |
| void GLESRenderEngine::checkErrors() const { |
| do { |
| // there could be more than one error flag |
| GLenum error = glGetError(); |
| if (error == GL_NO_ERROR) break; |
| ALOGE("GL error 0x%04x", int(error)); |
| } while (true); |
| } |
| |
| bool GLESRenderEngine::supportsProtectedContent() const { |
| return mProtectedEGLContext != EGL_NO_CONTEXT; |
| } |
| |
| bool GLESRenderEngine::useProtectedContext(bool useProtectedContext) { |
| if (useProtectedContext == mInProtectedContext) { |
| return true; |
| } |
| if (useProtectedContext && mProtectedEGLContext == EGL_NO_CONTEXT) { |
| return false; |
| } |
| const EGLSurface surface = useProtectedContext ? mProtectedDummySurface : mDummySurface; |
| const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext; |
| const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE; |
| if (success) { |
| mInProtectedContext = useProtectedContext; |
| } |
| return success; |
| } |
| EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer, |
| bool isProtected, |
| bool useFramebufferCache) { |
| sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer); |
| if (useFramebufferCache) { |
| for (const auto& image : mFramebufferImageCache) { |
| if (image.first == graphicBuffer->getId()) { |
| return image.second; |
| } |
| } |
| } |
| EGLint attributes[] = { |
| isProtected ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE, |
| isProtected ? EGL_TRUE : EGL_NONE, |
| EGL_NONE, |
| }; |
| EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, |
| nativeBuffer, attributes); |
| if (useFramebufferCache) { |
| if (image != EGL_NO_IMAGE_KHR) { |
| if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) { |
| EGLImageKHR expired = mFramebufferImageCache.front().second; |
| mFramebufferImageCache.pop_front(); |
| eglDestroyImageKHR(mEGLDisplay, expired); |
| } |
| mFramebufferImageCache.push_back({graphicBuffer->getId(), image}); |
| } |
| } |
| return image; |
| } |
| |
| status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, |
| const std::vector<LayerSettings>& layers, |
| ANativeWindowBuffer* const buffer, |
| const bool useFramebufferCache, base::unique_fd&& bufferFence, |
| base::unique_fd* drawFence) { |
| ATRACE_CALL(); |
| if (layers.empty()) { |
| ALOGV("Drawing empty layer stack"); |
| return NO_ERROR; |
| } |
| |
| if (bufferFence.get() >= 0 && !waitFence(std::move(bufferFence))) { |
| ATRACE_NAME("Waiting before draw"); |
| sync_wait(bufferFence.get(), -1); |
| } |
| |
| if (buffer == nullptr) { |
| ALOGE("No output buffer provided. Aborting GPU composition."); |
| return BAD_VALUE; |
| } |
| |
| { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| |
| BindNativeBufferAsFramebuffer fbo(*this, buffer, useFramebufferCache); |
| |
| if (fbo.getStatus() != NO_ERROR) { |
| ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).", |
| buffer->handle); |
| checkErrors(); |
| return fbo.getStatus(); |
| } |
| |
| // clear the entire buffer, sometimes when we reuse buffers we'd persist |
| // ghost images otherwise. |
| // we also require a full transparent framebuffer for overlays. This is |
| // probably not quite efficient on all GPUs, since we could filter out |
| // opaque layers. |
| clearWithColor(0.0, 0.0, 0.0, 0.0); |
| |
| setViewportAndProjection(display.physicalDisplay, display.clip); |
| |
| setOutputDataSpace(display.outputDataspace); |
| setDisplayMaxLuminance(display.maxLuminance); |
| |
| mat4 projectionMatrix = mState.projectionMatrix * display.globalTransform; |
| mState.projectionMatrix = projectionMatrix; |
| if (!display.clearRegion.isEmpty()) { |
| glDisable(GL_BLEND); |
| fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0); |
| } |
| |
| Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2); |
| for (auto layer : layers) { |
| mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform; |
| |
| const FloatRect bounds = layer.geometry.boundaries; |
| Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); |
| position[0] = vec2(bounds.left, bounds.top); |
| position[1] = vec2(bounds.left, bounds.bottom); |
| position[2] = vec2(bounds.right, bounds.bottom); |
| position[3] = vec2(bounds.right, bounds.top); |
| |
| setupLayerCropping(layer, mesh); |
| setColorTransform(display.colorTransform * layer.colorTransform); |
| |
| bool usePremultipliedAlpha = true; |
| bool disableTexture = true; |
| bool isOpaque = false; |
| |
| if (layer.source.buffer.buffer != nullptr) { |
| disableTexture = false; |
| isOpaque = layer.source.buffer.isOpaque; |
| |
| sp<GraphicBuffer> gBuf = layer.source.buffer.buffer; |
| bindExternalTextureBufferLocked(layer.source.buffer.textureName, gBuf, |
| layer.source.buffer.fence); |
| |
| usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha; |
| Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName); |
| mat4 texMatrix = layer.source.buffer.textureTransform; |
| |
| texture.setMatrix(texMatrix.asArray()); |
| texture.setFiltering(layer.source.buffer.useTextureFiltering); |
| |
| texture.setDimensions(gBuf->getWidth(), gBuf->getHeight()); |
| setSourceY410BT2020(layer.source.buffer.isY410BT2020); |
| |
| renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>()); |
| texCoords[0] = vec2(0.0, 0.0); |
| texCoords[1] = vec2(0.0, 1.0); |
| texCoords[2] = vec2(1.0, 1.0); |
| texCoords[3] = vec2(1.0, 0.0); |
| setupLayerTexturing(texture); |
| } |
| |
| const half3 solidColor = layer.source.solidColor; |
| const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha); |
| // Buffer sources will have a black solid color ignored in the shader, |
| // so in that scenario the solid color passed here is arbitrary. |
| setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color, |
| layer.geometry.roundedCornersRadius); |
| if (layer.disableBlending) { |
| glDisable(GL_BLEND); |
| } |
| setSourceDataSpace(layer.sourceDataspace); |
| |
| // We only want to do a special handling for rounded corners when having rounded corners |
| // is the only reason it needs to turn on blending, otherwise, we handle it like the |
| // usual way since it needs to turn on blending anyway. |
| if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) { |
| handleRoundedCorners(display, layer, mesh); |
| } else { |
| drawMesh(mesh); |
| } |
| |
| // Cleanup if there's a buffer source |
| if (layer.source.buffer.buffer != nullptr) { |
| disableBlending(); |
| setSourceY410BT2020(false); |
| disableTexturing(); |
| } |
| } |
| |
| if (drawFence != nullptr) { |
| *drawFence = flush(); |
| } |
| // If flush failed or we don't support native fences, we need to force the |
| // gl command stream to be executed. |
| if (drawFence == nullptr || drawFence->get() < 0) { |
| bool success = finish(); |
| if (!success) { |
| ALOGE("Failed to flush RenderEngine commands"); |
| checkErrors(); |
| // Chances are, something illegal happened (either the caller passed |
| // us bad parameters, or we messed up our shader generation). |
| return INVALID_OPERATION; |
| } |
| } |
| |
| checkErrors(); |
| } |
| return NO_ERROR; |
| } |
| |
| void GLESRenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop, |
| ui::Transform::orientation_flags rotation) { |
| setViewportAndProjection(Rect(vpw, vph), sourceCrop); |
| |
| if (rotation == ui::Transform::ROT_0) { |
| return; |
| } |
| |
| // Apply custom rotation to the projection. |
| float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f; |
| mat4 m = mState.projectionMatrix; |
| switch (rotation) { |
| case ui::Transform::ROT_90: |
| m = mat4::rotate(rot90InRadians, vec3(0, 0, 1)) * m; |
| break; |
| case ui::Transform::ROT_180: |
| m = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1)) * m; |
| break; |
| case ui::Transform::ROT_270: |
| m = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1)) * m; |
| break; |
| default: |
| break; |
| } |
| mState.projectionMatrix = m; |
| } |
| |
| void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) { |
| ATRACE_CALL(); |
| mVpWidth = viewport.getWidth(); |
| mVpHeight = viewport.getHeight(); |
| |
| // We pass the the top left corner instead of the bottom left corner, |
| // because since we're rendering off-screen first. |
| glViewport(viewport.left, viewport.top, mVpWidth, mVpHeight); |
| |
| mState.projectionMatrix = mat4::ortho(clip.left, clip.right, clip.top, clip.bottom, 0, 1); |
| } |
| |
| void GLESRenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture, |
| const half4& color, float cornerRadius) { |
| mState.isPremultipliedAlpha = premultipliedAlpha; |
| mState.isOpaque = opaque; |
| mState.color = color; |
| mState.cornerRadius = cornerRadius; |
| |
| if (disableTexture) { |
| mState.textureEnabled = false; |
| } |
| |
| if (color.a < 1.0f || !opaque || cornerRadius > 0.0f) { |
| glEnable(GL_BLEND); |
| glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
| } else { |
| glDisable(GL_BLEND); |
| } |
| } |
| |
| void GLESRenderEngine::setSourceY410BT2020(bool enable) { |
| mState.isY410BT2020 = enable; |
| } |
| |
| void GLESRenderEngine::setSourceDataSpace(Dataspace source) { |
| mDataSpace = source; |
| } |
| |
| void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) { |
| mOutputDataSpace = dataspace; |
| } |
| |
| void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) { |
| mState.displayMaxLuminance = maxLuminance; |
| } |
| |
| void GLESRenderEngine::setupLayerTexturing(const Texture& texture) { |
| GLuint target = texture.getTextureTarget(); |
| glBindTexture(target, texture.getTextureName()); |
| GLenum filter = GL_NEAREST; |
| if (texture.getFiltering()) { |
| filter = GL_LINEAR; |
| } |
| glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter); |
| glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter); |
| |
| mState.texture = texture; |
| mState.textureEnabled = true; |
| } |
| |
| void GLESRenderEngine::setupLayerBlackedOut() { |
| glBindTexture(GL_TEXTURE_2D, mProtectedTexName); |
| Texture texture(Texture::TEXTURE_2D, mProtectedTexName); |
| texture.setDimensions(1, 1); // FIXME: we should get that from somewhere |
| mState.texture = texture; |
| mState.textureEnabled = true; |
| } |
| |
| void GLESRenderEngine::setColorTransform(const mat4& colorTransform) { |
| mState.colorMatrix = colorTransform; |
| } |
| |
| void GLESRenderEngine::disableTexturing() { |
| mState.textureEnabled = false; |
| } |
| |
| void GLESRenderEngine::disableBlending() { |
| glDisable(GL_BLEND); |
| } |
| |
| void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) { |
| mState.isPremultipliedAlpha = true; |
| mState.isOpaque = false; |
| mState.color = half4(r, g, b, a); |
| mState.textureEnabled = false; |
| glDisable(GL_BLEND); |
| } |
| |
| void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) { |
| mState.cropSize = half2(width, height); |
| } |
| |
| void GLESRenderEngine::drawMesh(const Mesh& mesh) { |
| ATRACE_CALL(); |
| if (mesh.getTexCoordsSize()) { |
| glEnableVertexAttribArray(Program::texCoords); |
| glVertexAttribPointer(Program::texCoords, mesh.getTexCoordsSize(), GL_FLOAT, GL_FALSE, |
| mesh.getByteStride(), mesh.getTexCoords()); |
| } |
| |
| glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE, |
| mesh.getByteStride(), mesh.getPositions()); |
| |
| if (mState.cornerRadius > 0.0f) { |
| glEnableVertexAttribArray(Program::cropCoords); |
| glVertexAttribPointer(Program::cropCoords, mesh.getVertexSize(), GL_FLOAT, GL_FALSE, |
| mesh.getByteStride(), mesh.getCropCoords()); |
| } |
| |
| // By default, DISPLAY_P3 is the only supported wide color output. However, |
| // when HDR content is present, hardware composer may be able to handle |
| // BT2020 data space, in that case, the output data space is set to be |
| // BT2020_HLG or BT2020_PQ respectively. In GPU fall back we need |
| // to respect this and convert non-HDR content to HDR format. |
| if (mUseColorManagement) { |
| Description managedState = mState; |
| Dataspace inputStandard = static_cast<Dataspace>(mDataSpace & Dataspace::STANDARD_MASK); |
| Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK); |
| Dataspace outputStandard = |
| static_cast<Dataspace>(mOutputDataSpace & Dataspace::STANDARD_MASK); |
| Dataspace outputTransfer = |
| static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK); |
| bool needsXYZConversion = needsXYZTransformMatrix(); |
| |
| // NOTE: if the input standard of the input dataspace is not STANDARD_DCI_P3 or |
| // STANDARD_BT2020, it will be treated as STANDARD_BT709 |
| if (inputStandard != Dataspace::STANDARD_DCI_P3 && |
| inputStandard != Dataspace::STANDARD_BT2020) { |
| inputStandard = Dataspace::STANDARD_BT709; |
| } |
| |
| if (needsXYZConversion) { |
| // The supported input color spaces are standard RGB, Display P3 and BT2020. |
| switch (inputStandard) { |
| case Dataspace::STANDARD_DCI_P3: |
| managedState.inputTransformMatrix = mDisplayP3ToXyz; |
| break; |
| case Dataspace::STANDARD_BT2020: |
| managedState.inputTransformMatrix = mBt2020ToXyz; |
| break; |
| default: |
| managedState.inputTransformMatrix = mSrgbToXyz; |
| break; |
| } |
| |
| // The supported output color spaces are BT2020, Display P3 and standard RGB. |
| switch (outputStandard) { |
| case Dataspace::STANDARD_BT2020: |
| managedState.outputTransformMatrix = mXyzToBt2020; |
| break; |
| case Dataspace::STANDARD_DCI_P3: |
| managedState.outputTransformMatrix = mXyzToDisplayP3; |
| break; |
| default: |
| managedState.outputTransformMatrix = mXyzToSrgb; |
| break; |
| } |
| } else if (inputStandard != outputStandard) { |
| // At this point, the input data space and output data space could be both |
| // HDR data spaces, but they match each other, we do nothing in this case. |
| // In addition to the case above, the input data space could be |
| // - scRGB linear |
| // - scRGB non-linear |
| // - sRGB |
| // - Display P3 |
| // - BT2020 |
| // The output data spaces could be |
| // - sRGB |
| // - Display P3 |
| // - BT2020 |
| switch (outputStandard) { |
| case Dataspace::STANDARD_BT2020: |
| if (inputStandard == Dataspace::STANDARD_BT709) { |
| managedState.outputTransformMatrix = mSrgbToBt2020; |
| } else if (inputStandard == Dataspace::STANDARD_DCI_P3) { |
| managedState.outputTransformMatrix = mDisplayP3ToBt2020; |
| } |
| break; |
| case Dataspace::STANDARD_DCI_P3: |
| if (inputStandard == Dataspace::STANDARD_BT709) { |
| managedState.outputTransformMatrix = mSrgbToDisplayP3; |
| } else if (inputStandard == Dataspace::STANDARD_BT2020) { |
| managedState.outputTransformMatrix = mBt2020ToDisplayP3; |
| } |
| break; |
| default: |
| if (inputStandard == Dataspace::STANDARD_DCI_P3) { |
| managedState.outputTransformMatrix = mDisplayP3ToSrgb; |
| } else if (inputStandard == Dataspace::STANDARD_BT2020) { |
| managedState.outputTransformMatrix = mBt2020ToSrgb; |
| } |
| break; |
| } |
| } |
| |
| // we need to convert the RGB value to linear space and convert it back when: |
| // - there is a color matrix that is not an identity matrix, or |
| // - there is an output transform matrix that is not an identity matrix, or |
| // - the input transfer function doesn't match the output transfer function. |
| if (managedState.hasColorMatrix() || managedState.hasOutputTransformMatrix() || |
| inputTransfer != outputTransfer) { |
| managedState.inputTransferFunction = |
| Description::dataSpaceToTransferFunction(inputTransfer); |
| managedState.outputTransferFunction = |
| Description::dataSpaceToTransferFunction(outputTransfer); |
| } |
| |
| ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext |
| : mEGLContext, |
| managedState); |
| |
| glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount()); |
| |
| if (outputDebugPPMs) { |
| static uint64_t managedColorFrameCount = 0; |
| std::ostringstream out; |
| out << "/data/texture_out" << managedColorFrameCount++; |
| writePPM(out.str().c_str(), mVpWidth, mVpHeight); |
| } |
| } else { |
| ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext |
| : mEGLContext, |
| mState); |
| |
| glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount()); |
| } |
| |
| if (mesh.getTexCoordsSize()) { |
| glDisableVertexAttribArray(Program::texCoords); |
| } |
| |
| if (mState.cornerRadius > 0.0f) { |
| glDisableVertexAttribArray(Program::cropCoords); |
| } |
| } |
| |
| size_t GLESRenderEngine::getMaxTextureSize() const { |
| return mMaxTextureSize; |
| } |
| |
| size_t GLESRenderEngine::getMaxViewportDims() const { |
| return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1]; |
| } |
| |
| void GLESRenderEngine::dump(std::string& result) { |
| const GLExtensions& extensions = GLExtensions::getInstance(); |
| ProgramCache& cache = ProgramCache::getInstance(); |
| |
| StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion()); |
| StringAppendF(&result, "%s\n", extensions.getEGLExtensions()); |
| StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(), |
| extensions.getVersion()); |
| StringAppendF(&result, "%s\n", extensions.getExtensions()); |
| StringAppendF(&result, "RenderEngine supports protected context: %d\n", |
| supportsProtectedContent()); |
| StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext); |
| StringAppendF(&result, "RenderEngine program cache size for unprotected context: %zu\n", |
| cache.getSize(mEGLContext)); |
| StringAppendF(&result, "RenderEngine program cache size for protected context: %zu\n", |
| cache.getSize(mProtectedEGLContext)); |
| StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n", |
| dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(), |
| dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str()); |
| } |
| |
| GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) { |
| int major, minor; |
| if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) { |
| if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) { |
| ALOGW("Unable to parse GL_VERSION string: \"%s\"", str); |
| return GLES_VERSION_1_0; |
| } |
| } |
| |
| if (major == 1 && minor == 0) return GLES_VERSION_1_0; |
| if (major == 1 && minor >= 1) return GLES_VERSION_1_1; |
| if (major == 2 && minor >= 0) return GLES_VERSION_2_0; |
| if (major == 3 && minor >= 0) return GLES_VERSION_3_0; |
| |
| ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor); |
| return GLES_VERSION_1_0; |
| } |
| |
| EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config, |
| EGLContext shareContext, bool useContextPriority, |
| Protection protection) { |
| EGLint renderableType = 0; |
| if (config == EGL_NO_CONFIG) { |
| renderableType = EGL_OPENGL_ES3_BIT; |
| } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) { |
| LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE"); |
| } |
| EGLint contextClientVersion = 0; |
| if (renderableType & EGL_OPENGL_ES3_BIT) { |
| contextClientVersion = 3; |
| } else if (renderableType & EGL_OPENGL_ES2_BIT) { |
| contextClientVersion = 2; |
| } else if (renderableType & EGL_OPENGL_ES_BIT) { |
| contextClientVersion = 1; |
| } else { |
| LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs"); |
| } |
| |
| std::vector<EGLint> contextAttributes; |
| contextAttributes.reserve(7); |
| contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION); |
| contextAttributes.push_back(contextClientVersion); |
| if (useContextPriority) { |
| contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG); |
| contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG); |
| } |
| if (protection == Protection::PROTECTED) { |
| contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT); |
| contextAttributes.push_back(EGL_TRUE); |
| } |
| contextAttributes.push_back(EGL_NONE); |
| |
| EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data()); |
| |
| if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) { |
| // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus |
| // EGL_NO_CONTEXT so that we can abort. |
| if (config != EGL_NO_CONFIG) { |
| return context; |
| } |
| // If |config| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should |
| // try to fall back to GLES 2. |
| contextAttributes[1] = 2; |
| context = eglCreateContext(display, config, shareContext, contextAttributes.data()); |
| } |
| |
| return context; |
| } |
| |
| EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config, |
| int hwcFormat, Protection protection) { |
| EGLConfig dummyConfig = config; |
| if (dummyConfig == EGL_NO_CONFIG) { |
| dummyConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true); |
| } |
| std::vector<EGLint> attributes; |
| attributes.reserve(7); |
| attributes.push_back(EGL_WIDTH); |
| attributes.push_back(1); |
| attributes.push_back(EGL_HEIGHT); |
| attributes.push_back(1); |
| if (protection == Protection::PROTECTED) { |
| attributes.push_back(EGL_PROTECTED_CONTENT_EXT); |
| attributes.push_back(EGL_TRUE); |
| } |
| attributes.push_back(EGL_NONE); |
| |
| return eglCreatePbufferSurface(display, dummyConfig, attributes.data()); |
| } |
| |
| bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const { |
| const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK); |
| const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK); |
| return standard == Dataspace::STANDARD_BT2020 && |
| (transfer == Dataspace::TRANSFER_ST2084 || transfer == Dataspace::TRANSFER_HLG); |
| } |
| |
| // For convenience, we want to convert the input color space to XYZ color space first, |
| // and then convert from XYZ color space to output color space when |
| // - SDR and HDR contents are mixed, either SDR content will be converted to HDR or |
| // HDR content will be tone-mapped to SDR; Or, |
| // - there are HDR PQ and HLG contents presented at the same time, where we want to convert |
| // HLG content to PQ content. |
| // In either case above, we need to operate the Y value in XYZ color space. Thus, when either |
| // input data space or output data space is HDR data space, and the input transfer function |
| // doesn't match the output transfer function, we would enable an intermediate transfrom to |
| // XYZ color space. |
| bool GLESRenderEngine::needsXYZTransformMatrix() const { |
| const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace); |
| const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace); |
| const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK); |
| const Dataspace outputTransfer = |
| static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK); |
| |
| return (isInputHdrDataSpace || isOutputHdrDataSpace) && inputTransfer != outputTransfer; |
| } |
| |
| bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| const auto& cachedImage = mImageCache.find(bufferId); |
| return cachedImage != mImageCache.end(); |
| } |
| |
| bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) { |
| std::lock_guard<std::mutex> lock(mRenderingMutex); |
| return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(), |
| [=](std::pair<uint64_t, EGLImageKHR> image) { |
| return image.first == bufferId; |
| }); |
| } |
| |
| // FlushTracer implementation |
| GLESRenderEngine::FlushTracer::FlushTracer(GLESRenderEngine* engine) : mEngine(engine) { |
| mThread = std::thread(&GLESRenderEngine::FlushTracer::loop, this); |
| } |
| |
| GLESRenderEngine::FlushTracer::~FlushTracer() { |
| { |
| std::lock_guard<std::mutex> lock(mMutex); |
| mRunning = false; |
| } |
| mCondition.notify_all(); |
| if (mThread.joinable()) { |
| mThread.join(); |
| } |
| } |
| |
| void GLESRenderEngine::FlushTracer::queueSync(EGLSyncKHR sync) { |
| std::lock_guard<std::mutex> lock(mMutex); |
| char name[64]; |
| const uint64_t frameNum = mFramesQueued++; |
| snprintf(name, sizeof(name), "Queueing sync for frame: %lu", |
| static_cast<unsigned long>(frameNum)); |
| ATRACE_NAME(name); |
| mQueue.push({sync, frameNum}); |
| ATRACE_INT("GPU Frames Outstanding", mQueue.size()); |
| mCondition.notify_one(); |
| } |
| |
| void GLESRenderEngine::FlushTracer::loop() { |
| while (mRunning) { |
| QueueEntry entry; |
| { |
| std::lock_guard<std::mutex> lock(mMutex); |
| |
| mCondition.wait(mMutex, |
| [&]() REQUIRES(mMutex) { return !mQueue.empty() || !mRunning; }); |
| |
| if (!mRunning) { |
| // if mRunning is false, then FlushTracer is being destroyed, so |
| // bail out now. |
| break; |
| } |
| entry = mQueue.front(); |
| mQueue.pop(); |
| } |
| { |
| char name[64]; |
| snprintf(name, sizeof(name), "waiting for frame %lu", |
| static_cast<unsigned long>(entry.mFrameNum)); |
| ATRACE_NAME(name); |
| mEngine->waitSync(entry.mSync, 0); |
| } |
| } |
| } |
| |
| } // namespace gl |
| } // namespace renderengine |
| } // namespace android |