libs/renderengine/skia/SkiaGLRenderEngine.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright 2020 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 <cmath>

 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include <GLES2/gl2.h>
 #include <sync/sync.h>
 #include <ui/GraphicBuffer.h>
 #include <utils/Trace.h>
 #include "../gl/GLExtensions.h"
 #include "SkiaGLRenderEngine.h"

 #include <GrContextOptions.h>
 #include <gl/GrGLInterface.h>

 #include <SkCanvas.h>
 #include <SkImage.h>
 #include <SkSurface.h>

 extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);

 bool checkGlError(const char* op, int lineNumber);

 namespace android {
 namespace renderengine {
 namespace skia {

 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;
 }

 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;

     std::vector<EGLint> attribs;
     if (renderableType) {
         const ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(format);
         const bool is1010102 = pixelFormat == ui::PixelFormat::RGBA_1010102;

         // Default to 8 bits per channel.
         const EGLint tmpAttribs[] = {
                 EGL_RENDERABLE_TYPE,
                 renderableType,
                 EGL_RECORDABLE_ANDROID,
                 EGL_TRUE,
                 EGL_SURFACE_TYPE,
                 EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
                 EGL_FRAMEBUFFER_TARGET_ANDROID,
                 EGL_TRUE,
                 EGL_RED_SIZE,
                 is1010102 ? 10 : 8,
                 EGL_GREEN_SIZE,
                 is1010102 ? 10 : 8,
                 EGL_BLUE_SIZE,
                 is1010102 ? 10 : 8,
                 EGL_ALPHA_SIZE,
                 is1010102 ? 2 : 8,
                 EGL_NONE,
         };
         std::copy(tmpAttribs, tmpAttribs + (sizeof(tmpAttribs) / sizeof(EGLint)),
                   std::back_inserter(attribs));
         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.data(), 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<SkiaGLRenderEngine> SkiaGLRenderEngine::create(
         const RenderEngineCreationArgs& args) {
     // initialize EGL for the default display
     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
     if (!eglInitialize(display, nullptr, nullptr)) {
         LOG_ALWAYS_FATAL("failed to initialize EGL");
     }

     const auto eglVersion = eglQueryStringImplementationANDROID(display, EGL_VERSION);
     if (!eglVersion) {
         checkGlError(__FUNCTION__, __LINE__);
         LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_VERSION) failed");
     }

     const auto eglExtensions = eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS);
     if (!eglExtensions) {
         checkGlError(__FUNCTION__, __LINE__);
         LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_EXTENSIONS) failed");
     }

     auto& extensions = gl::GLExtensions::getInstance();
     extensions.initWithEGLStrings(eglVersion, eglExtensions);

     // The code assumes that ES2 or later is available if this extension is
     // supported.
     EGLConfig config = EGL_NO_CONFIG_KHR;
     if (!extensions.hasNoConfigContext()) {
         config = chooseEglConfig(display, args.pixelFormat, /*logConfig*/ true);
     }

     bool useContextPriority =
             extensions.hasContextPriority() && args.contextPriority == ContextPriority::HIGH;
     EGLContext protectedContext = EGL_NO_CONTEXT;
     if (args.enableProtectedContext && 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 placeholder = EGL_NO_SURFACE;
     if (!extensions.hasSurfacelessContext()) {
         placeholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
                                                          Protection::UNPROTECTED);
         LOG_ALWAYS_FATAL_IF(placeholder == EGL_NO_SURFACE, "can't create placeholder pbuffer");
     }
     EGLBoolean success = eglMakeCurrent(display, placeholder, placeholder, ctxt);
     LOG_ALWAYS_FATAL_IF(!success, "can't make placeholder pbuffer current");
     extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
                                  glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));

     EGLSurface protectedPlaceholder = EGL_NO_SURFACE;
     if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
         protectedPlaceholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
                                                                   Protection::PROTECTED);
         ALOGE_IF(protectedPlaceholder == EGL_NO_SURFACE,
                  "can't create protected placeholder pbuffer");
     }

     // initialize the renderer while GL is current
     std::unique_ptr<SkiaGLRenderEngine> engine =
             std::make_unique<SkiaGLRenderEngine>(args, display, config, ctxt, placeholder,
                                                  protectedContext, protectedPlaceholder);

     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 SkiaGLRenderEngine::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;
 }

 SkiaGLRenderEngine::SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
                                        EGLConfig config, EGLContext ctxt, EGLSurface placeholder,
                                        EGLContext protectedContext, EGLSurface protectedPlaceholder)
       : renderengine::skia::SkiaRenderEngine(args),
         mEGLDisplay(display),
         mEGLConfig(config),
         mEGLContext(ctxt),
         mPlaceholderSurface(placeholder),
         mProtectedEGLContext(protectedContext),
         mProtectedPlaceholderSurface(protectedPlaceholder) {
     // Suppress unused field warnings for things we definitely will need/use
     // These EGL fields will all be needed for toggling between protected & unprotected contexts
     // Or we need different RE instances for that
     (void)mEGLDisplay;
     (void)mEGLConfig;
     (void)mEGLContext;
     (void)mPlaceholderSurface;
     (void)mProtectedEGLContext;
     (void)mProtectedPlaceholderSurface;

     sk_sp<const GrGLInterface> glInterface(GrGLCreateNativeInterface());
     LOG_ALWAYS_FATAL_IF(!glInterface.get());

     GrContextOptions options;
     options.fPreferExternalImagesOverES3 = true;
     options.fDisableDistanceFieldPaths = true;
     mGrContext = GrDirectContext::MakeGL(std::move(glInterface), options);
 }

 base::unique_fd SkiaGLRenderEngine::flush() {
     ATRACE_CALL();
     if (!gl::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());
     }

     return fenceFd;
 }

 bool SkiaGLRenderEngine::waitFence(base::unique_fd fenceFd) {
     if (!gl::GLExtensions::getInstance().hasNativeFenceSync() ||
         !gl::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;
 }

 static bool hasUsage(const AHardwareBuffer_Desc& desc, uint64_t usage) {
     return !!(desc.usage & usage);
 }

 void SkiaGLRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
     std::lock_guard<std::mutex> lock(mRenderingMutex);
     mImageCache.erase(bufferId);
 }

 status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
                                         const std::vector<const LayerSettings*>& layers,
                                         const sp<GraphicBuffer>& buffer,
                                         const bool useFramebufferCache,
                                         base::unique_fd&& bufferFence, base::unique_fd* drawFence) {
     ATRACE_NAME("SkiaGL::drawLayers");
     std::lock_guard<std::mutex> lock(mRenderingMutex);
     if (layers.empty()) {
         ALOGV("Drawing empty layer stack");
         return NO_ERROR;
     }

     if (bufferFence.get() >= 0) {
         // Duplicate the fence for passing to waitFence.
         base::unique_fd bufferFenceDup(dup(bufferFence.get()));
         if (bufferFenceDup < 0 || !waitFence(std::move(bufferFenceDup))) {
             ATRACE_NAME("Waiting before draw");
             sync_wait(bufferFence.get(), -1);
         }
     }
     if (buffer == nullptr) {
         ALOGE("No output buffer provided. Aborting GPU composition.");
         return BAD_VALUE;
     }

     AHardwareBuffer_Desc bufferDesc;
     AHardwareBuffer_describe(buffer->toAHardwareBuffer(), &bufferDesc);

     LOG_ALWAYS_FATAL_IF(!hasUsage(bufferDesc, AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE),
                         "missing usage");

     sk_sp<SkSurface> surface;
     if (useFramebufferCache) {
         auto iter = mSurfaceCache.find(buffer->getId());
         if (iter != mSurfaceCache.end()) {
             ALOGV("Cache hit!");
             surface = iter->second;
         }
     }
     if (!surface) {
         surface = SkSurface::MakeFromAHardwareBuffer(mGrContext.get(), buffer->toAHardwareBuffer(),
                                                      GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
                                                      SkColorSpace::MakeSRGB(), nullptr);
         if (useFramebufferCache && surface) {
             ALOGD("Adding to cache");
             mSurfaceCache.insert({buffer->getId(), surface});
         }
     }
     if (!surface) {
         ALOGE("Failed to make surface");
         return BAD_VALUE;
     }
     auto canvas = surface->getCanvas();

     canvas->clipRect(SkRect::MakeLTRB(display.clip.left, display.clip.top, display.clip.right,
                                       display.clip.bottom));
     canvas->drawColor(0, SkBlendMode::kSrc);
     for (const auto& layer : layers) {
         if (layer->source.buffer.buffer) {
             ATRACE_NAME("DrawImage");
             const auto& item = layer->source.buffer;
             sk_sp<SkImage> image;
             auto iter = mImageCache.find(item.buffer->getId());
             if (iter != mImageCache.end()) {
                 image = iter->second;
             } else {
                 image = SkImage::MakeFromAHardwareBuffer(item.buffer->toAHardwareBuffer(),
                                                          item.usePremultipliedAlpha
                                                                  ? kPremul_SkAlphaType
                                                                  : kUnpremul_SkAlphaType);
                 mImageCache.insert({item.buffer->getId(), image});
             }
             const auto& bounds = layer->geometry.boundaries;
             SkRect dest = SkRect::MakeLTRB(bounds.left, bounds.top, bounds.right, bounds.bottom);
             canvas->drawImageRect(image, dest, nullptr);
         } else {
             ATRACE_NAME("DrawColor");
             SkPaint paint;
             const auto color = layer->source.solidColor;
             paint.setColor(SkColor4f{.fR = color.r, .fG = color.g, .fB = color.b, layer->alpha});
         }
     }
     {
         ATRACE_NAME("flush surface");
         surface->flush();
     }

     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.
     bool requireSync = drawFence == nullptr || drawFence->get() < 0;
     if (requireSync) {
         ATRACE_BEGIN("Submit(sync=true)");
     } else {
         ATRACE_BEGIN("Submit(sync=false)");
     }
     bool success = mGrContext->submit(requireSync);
     ATRACE_END();
     if (!success) {
         ALOGE("Failed to flush RenderEngine commands");
         // 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;
 }

 size_t SkiaGLRenderEngine::getMaxTextureSize() const {
     return mGrContext->maxTextureSize();
 }

 size_t SkiaGLRenderEngine::getMaxViewportDims() const {
     return mGrContext->maxRenderTargetSize();
 }

 EGLContext SkiaGLRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
                                                 EGLContext shareContext, bool useContextPriority,
                                                 Protection protection) {
     EGLint renderableType = 0;
     if (config == EGL_NO_CONFIG_KHR) {
         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_KHR) {
             return context;
         }
         // If |config| is EGL_NO_CONFIG_KHR, 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 SkiaGLRenderEngine::createPlaceholderEglPbufferSurface(EGLDisplay display,
                                                                   EGLConfig config, int hwcFormat,
                                                                   Protection protection) {
     EGLConfig placeholderConfig = config;
     if (placeholderConfig == EGL_NO_CONFIG_KHR) {
         placeholderConfig = 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, placeholderConfig, attributes.data());
 }

 void SkiaGLRenderEngine::cleanFramebufferCache() {
     mSurfaceCache.clear();
 }

 } // namespace skia
 } // namespace renderengine
 } // namespace android
	/*
	* Copyright 2020 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 <cmath>

	#include <EGL/egl.h>
	#include <EGL/eglext.h>
	#include <GLES2/gl2.h>
	#include <sync/sync.h>
	#include <ui/GraphicBuffer.h>
	#include <utils/Trace.h>
	#include "../gl/GLExtensions.h"
	#include "SkiaGLRenderEngine.h"

	#include <GrContextOptions.h>
	#include <gl/GrGLInterface.h>

	#include <SkCanvas.h>
	#include <SkImage.h>
	#include <SkSurface.h>

	extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);

	bool checkGlError(const char* op, int lineNumber);

	namespace android {
	namespace renderengine {
	namespace skia {

	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;
	}

	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;

	std::vector<EGLint> attribs;
	if (renderableType) {
	const ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(format);
	const bool is1010102 = pixelFormat == ui::PixelFormat::RGBA_1010102;

	// Default to 8 bits per channel.
	const EGLint tmpAttribs[] = {
	EGL_RENDERABLE_TYPE,
	renderableType,
	EGL_RECORDABLE_ANDROID,
	EGL_TRUE,
	EGL_SURFACE_TYPE,
	EGL_WINDOW_BIT \| EGL_PBUFFER_BIT,
	EGL_FRAMEBUFFER_TARGET_ANDROID,
	EGL_TRUE,
	EGL_RED_SIZE,
	is1010102 ? 10 : 8,
	EGL_GREEN_SIZE,
	is1010102 ? 10 : 8,
	EGL_BLUE_SIZE,
	is1010102 ? 10 : 8,
	EGL_ALPHA_SIZE,
	is1010102 ? 2 : 8,
	EGL_NONE,
	};
	std::copy(tmpAttribs, tmpAttribs + (sizeof(tmpAttribs) / sizeof(EGLint)),
	std::back_inserter(attribs));
	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.data(), 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<SkiaGLRenderEngine> SkiaGLRenderEngine::create(
	const RenderEngineCreationArgs& args) {
	// initialize EGL for the default display
	EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	if (!eglInitialize(display, nullptr, nullptr)) {
	LOG_ALWAYS_FATAL("failed to initialize EGL");
	}

	const auto eglVersion = eglQueryStringImplementationANDROID(display, EGL_VERSION);
	if (!eglVersion) {
	checkGlError(__FUNCTION__, __LINE__);
	LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_VERSION) failed");
	}

	const auto eglExtensions = eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS);
	if (!eglExtensions) {
	checkGlError(__FUNCTION__, __LINE__);
	LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_EXTENSIONS) failed");
	}

	auto& extensions = gl::GLExtensions::getInstance();
	extensions.initWithEGLStrings(eglVersion, eglExtensions);

	// The code assumes that ES2 or later is available if this extension is
	// supported.
	EGLConfig config = EGL_NO_CONFIG_KHR;
	if (!extensions.hasNoConfigContext()) {
	config = chooseEglConfig(display, args.pixelFormat, /logConfig/ true);
	}

	bool useContextPriority =
	extensions.hasContextPriority() && args.contextPriority == ContextPriority::HIGH;
	EGLContext protectedContext = EGL_NO_CONTEXT;
	if (args.enableProtectedContext && 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 placeholder = EGL_NO_SURFACE;
	if (!extensions.hasSurfacelessContext()) {
	placeholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
	Protection::UNPROTECTED);
	LOG_ALWAYS_FATAL_IF(placeholder == EGL_NO_SURFACE, "can't create placeholder pbuffer");
	}
	EGLBoolean success = eglMakeCurrent(display, placeholder, placeholder, ctxt);
	LOG_ALWAYS_FATAL_IF(!success, "can't make placeholder pbuffer current");
	extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
	glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));

	EGLSurface protectedPlaceholder = EGL_NO_SURFACE;
	if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
	protectedPlaceholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
	Protection::PROTECTED);
	ALOGE_IF(protectedPlaceholder == EGL_NO_SURFACE,
	"can't create protected placeholder pbuffer");
	}

	// initialize the renderer while GL is current
	std::unique_ptr<SkiaGLRenderEngine> engine =
	std::make_unique<SkiaGLRenderEngine>(args, display, config, ctxt, placeholder,
	protectedContext, protectedPlaceholder);

	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 SkiaGLRenderEngine::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;
	}

	SkiaGLRenderEngine::SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
	EGLConfig config, EGLContext ctxt, EGLSurface placeholder,
	EGLContext protectedContext, EGLSurface protectedPlaceholder)
	: renderengine::skia::SkiaRenderEngine(args),
	mEGLDisplay(display),
	mEGLConfig(config),
	mEGLContext(ctxt),
	mPlaceholderSurface(placeholder),
	mProtectedEGLContext(protectedContext),
	mProtectedPlaceholderSurface(protectedPlaceholder) {
	// Suppress unused field warnings for things we definitely will need/use
	// These EGL fields will all be needed for toggling between protected & unprotected contexts
	// Or we need different RE instances for that
	(void)mEGLDisplay;
	(void)mEGLConfig;
	(void)mEGLContext;
	(void)mPlaceholderSurface;
	(void)mProtectedEGLContext;
	(void)mProtectedPlaceholderSurface;

	sk_sp<const GrGLInterface> glInterface(GrGLCreateNativeInterface());
	LOG_ALWAYS_FATAL_IF(!glInterface.get());

	GrContextOptions options;
	options.fPreferExternalImagesOverES3 = true;
	options.fDisableDistanceFieldPaths = true;
	mGrContext = GrDirectContext::MakeGL(std::move(glInterface), options);
	}

	base::unique_fd SkiaGLRenderEngine::flush() {
	ATRACE_CALL();
	if (!gl::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());
	}

	return fenceFd;
	}

	bool SkiaGLRenderEngine::waitFence(base::unique_fd fenceFd) {
	if (!gl::GLExtensions::getInstance().hasNativeFenceSync() \|\|
	!gl::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;
	}

	static bool hasUsage(const AHardwareBuffer_Desc& desc, uint64_t usage) {
	return !!(desc.usage & usage);
	}

	void SkiaGLRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
	std::lock_guard<std::mutex> lock(mRenderingMutex);
	mImageCache.erase(bufferId);
	}

	status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
	const std::vector<const LayerSettings*>& layers,
	const sp<GraphicBuffer>& buffer,
	const bool useFramebufferCache,
	base::unique_fd&& bufferFence, base::unique_fd* drawFence) {
	ATRACE_NAME("SkiaGL::drawLayers");
	std::lock_guard<std::mutex> lock(mRenderingMutex);
	if (layers.empty()) {
	ALOGV("Drawing empty layer stack");
	return NO_ERROR;
	}

	if (bufferFence.get() >= 0) {
	// Duplicate the fence for passing to waitFence.
	base::unique_fd bufferFenceDup(dup(bufferFence.get()));
	if (bufferFenceDup < 0 \|\| !waitFence(std::move(bufferFenceDup))) {
	ATRACE_NAME("Waiting before draw");
	sync_wait(bufferFence.get(), -1);
	}
	}
	if (buffer == nullptr) {
	ALOGE("No output buffer provided. Aborting GPU composition.");
	return BAD_VALUE;
	}

	AHardwareBuffer_Desc bufferDesc;
	AHardwareBuffer_describe(buffer->toAHardwareBuffer(), &bufferDesc);

	LOG_ALWAYS_FATAL_IF(!hasUsage(bufferDesc, AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE),
	"missing usage");

	sk_sp<SkSurface> surface;
	if (useFramebufferCache) {
	auto iter = mSurfaceCache.find(buffer->getId());
	if (iter != mSurfaceCache.end()) {
	ALOGV("Cache hit!");
	surface = iter->second;
	}
	}
	if (!surface) {
	surface = SkSurface::MakeFromAHardwareBuffer(mGrContext.get(), buffer->toAHardwareBuffer(),
	GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
	SkColorSpace::MakeSRGB(), nullptr);
	if (useFramebufferCache && surface) {
	ALOGD("Adding to cache");
	mSurfaceCache.insert({buffer->getId(), surface});
	}
	}
	if (!surface) {
	ALOGE("Failed to make surface");
	return BAD_VALUE;
	}
	auto canvas = surface->getCanvas();

	canvas->clipRect(SkRect::MakeLTRB(display.clip.left, display.clip.top, display.clip.right,
	display.clip.bottom));
	canvas->drawColor(0, SkBlendMode::kSrc);
	for (const auto& layer : layers) {
	if (layer->source.buffer.buffer) {
	ATRACE_NAME("DrawImage");
	const auto& item = layer->source.buffer;
	sk_sp<SkImage> image;
	auto iter = mImageCache.find(item.buffer->getId());
	if (iter != mImageCache.end()) {
	image = iter->second;
	} else {
	image = SkImage::MakeFromAHardwareBuffer(item.buffer->toAHardwareBuffer(),
	item.usePremultipliedAlpha
	? kPremul_SkAlphaType
	: kUnpremul_SkAlphaType);
	mImageCache.insert({item.buffer->getId(), image});
	}
	const auto& bounds = layer->geometry.boundaries;
	SkRect dest = SkRect::MakeLTRB(bounds.left, bounds.top, bounds.right, bounds.bottom);
	canvas->drawImageRect(image, dest, nullptr);
	} else {
	ATRACE_NAME("DrawColor");
	SkPaint paint;
	const auto color = layer->source.solidColor;
	paint.setColor(SkColor4f{.fR = color.r, .fG = color.g, .fB = color.b, layer->alpha});
	}
	}
	{
	ATRACE_NAME("flush surface");
	surface->flush();
	}

	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.
	bool requireSync = drawFence == nullptr \|\| drawFence->get() < 0;
	if (requireSync) {
	ATRACE_BEGIN("Submit(sync=true)");
	} else {
	ATRACE_BEGIN("Submit(sync=false)");
	}
	bool success = mGrContext->submit(requireSync);
	ATRACE_END();
	if (!success) {
	ALOGE("Failed to flush RenderEngine commands");
	// 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;
	}

	size_t SkiaGLRenderEngine::getMaxTextureSize() const {
	return mGrContext->maxTextureSize();
	}

	size_t SkiaGLRenderEngine::getMaxViewportDims() const {
	return mGrContext->maxRenderTargetSize();
	}

	EGLContext SkiaGLRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
	EGLContext shareContext, bool useContextPriority,
	Protection protection) {
	EGLint renderableType = 0;
	if (config == EGL_NO_CONFIG_KHR) {
	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_KHR) {
	return context;
	}
	// If \|config\| is EGL_NO_CONFIG_KHR, 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 SkiaGLRenderEngine::createPlaceholderEglPbufferSurface(EGLDisplay display,
	EGLConfig config, int hwcFormat,
	Protection protection) {
	EGLConfig placeholderConfig = config;
	if (placeholderConfig == EGL_NO_CONFIG_KHR) {
	placeholderConfig = 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, placeholderConfig, attributes.data());
	}

	void SkiaGLRenderEngine::cleanFramebufferCache() {
	mSurfaceCache.clear();
	}

	} // namespace skia
	} // namespace renderengine
	} // namespace android