libs/hwui/hwui/Bitmap.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include "Bitmap.h"

 #include "Caches.h"
 #include "renderthread/EglManager.h"
 #include "renderthread/RenderThread.h"
 #include "renderthread/RenderProxy.h"
 #include "utils/Color.h"

 #include <sys/mman.h>

 #include <log/log.h>
 #include <cutils/ashmem.h>

 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <EGL/egl.h>
 #include <EGL/eglext.h>

 #include <private/gui/ComposerService.h>
 #include <binder/IServiceManager.h>
 #include <ui/PixelFormat.h>

 #include <SkCanvas.h>

 namespace android {

 static bool computeAllocationSize(size_t rowBytes, int height, size_t* size) {
     int32_t rowBytes32 = SkToS32(rowBytes);
     int64_t bigSize = (int64_t) height * rowBytes32;
     if (rowBytes32 < 0 || !sk_64_isS32(bigSize)) {
         return false; // allocation will be too large
     }

     *size = sk_64_asS32(bigSize);
     return true;
 }

 typedef sk_sp<Bitmap> (*AllocPixeRef)(size_t allocSize, const SkImageInfo& info, size_t rowBytes,
         SkColorTable* ctable);

 static sk_sp<Bitmap> allocateBitmap(SkBitmap* bitmap, SkColorTable* ctable, AllocPixeRef alloc) {
     const SkImageInfo& info = bitmap->info();
     if (info.colorType() == kUnknown_SkColorType) {
         LOG_ALWAYS_FATAL("unknown bitmap configuration");
         return nullptr;
     }

     size_t size;

     // we must respect the rowBytes value already set on the bitmap instead of
     // attempting to compute our own.
     const size_t rowBytes = bitmap->rowBytes();
     if (!computeAllocationSize(rowBytes, bitmap->height(), &size)) {
         return nullptr;
     }

     auto wrapper = alloc(size, info, rowBytes, ctable);
     if (wrapper) {
         wrapper->getSkBitmap(bitmap);
         // since we're already allocated, we lockPixels right away
         // HeapAllocator behaves this way too
         bitmap->lockPixels();
     }
     return wrapper;
 }

 sk_sp<Bitmap> Bitmap::allocateAshmemBitmap(SkBitmap* bitmap, SkColorTable* ctable) {
    return allocateBitmap(bitmap, ctable, &Bitmap::allocateAshmemBitmap);
 }

 static sk_sp<Bitmap> allocateHeapBitmap(size_t size, const SkImageInfo& info, size_t rowBytes,
         SkColorTable* ctable) {
     void* addr = calloc(size, 1);
     if (!addr) {
         return nullptr;
     }
     return sk_sp<Bitmap>(new Bitmap(addr, size, info, rowBytes, ctable));
 }

 #define FENCE_TIMEOUT 2000000000

 // TODO: handle SRGB sanely
 static PixelFormat internalFormatToPixelFormat(GLint internalFormat) {
     switch (internalFormat) {
     case GL_LUMINANCE:
         return PIXEL_FORMAT_RGBA_8888;
     case GL_SRGB8_ALPHA8:
         return PIXEL_FORMAT_RGBA_8888;
     case GL_RGBA:
         return PIXEL_FORMAT_RGBA_8888;
     case GL_RGB:
         return PIXEL_FORMAT_RGB_565;
     case GL_RGBA16F:
         return PIXEL_FORMAT_RGBA_FP16;
     default:
         LOG_ALWAYS_FATAL("Unsupported bitmap colorType: %d", internalFormat);
         return PIXEL_FORMAT_UNKNOWN;
     }
 }

 class AutoEglFence {
 public:
     AutoEglFence(EGLDisplay display)
             : mDisplay(display) {
         fence = eglCreateSyncKHR(mDisplay, EGL_SYNC_FENCE_KHR, NULL);
     }

     ~AutoEglFence() {
         if (fence != EGL_NO_SYNC_KHR) {
             eglDestroySyncKHR(mDisplay, fence);
         }
     }

     EGLSyncKHR fence = EGL_NO_SYNC_KHR;
 private:
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
 };

 class AutoEglImage {
 public:
     AutoEglImage(EGLDisplay display, EGLClientBuffer clientBuffer)
             : mDisplay(display) {
         EGLint imageAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
         image = eglCreateImageKHR(display, EGL_NO_CONTEXT,
                 EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
     }

     ~AutoEglImage() {
         if (image != EGL_NO_IMAGE_KHR) {
             eglDestroyImageKHR(mDisplay, image);
         }
     }

     EGLImageKHR image = EGL_NO_IMAGE_KHR;
 private:
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
 };

 class AutoGlTexture {
 public:
     AutoGlTexture(uirenderer::Caches& caches)
             : mCaches(caches) {
         glGenTextures(1, &mTexture);
         caches.textureState().bindTexture(mTexture);
     }

     ~AutoGlTexture() {
         mCaches.textureState().deleteTexture(mTexture);
     }

 private:
     uirenderer::Caches& mCaches;
     GLuint mTexture = 0;
 };

 static bool uploadBitmapToGraphicBuffer(uirenderer::Caches& caches, SkBitmap& bitmap,
         GraphicBuffer& buffer, GLint format, GLint type) {
     SkAutoLockPixels alp(bitmap);
     EGLDisplay display = eglGetCurrentDisplay();
     LOG_ALWAYS_FATAL_IF(display == EGL_NO_DISPLAY,
                 "Failed to get EGL_DEFAULT_DISPLAY! err=%s",
                 uirenderer::renderthread::EglManager::eglErrorString());
     // We use an EGLImage to access the content of the GraphicBuffer
     // The EGL image is later bound to a 2D texture
     EGLClientBuffer clientBuffer = (EGLClientBuffer) buffer.getNativeBuffer();
     AutoEglImage autoImage(display, clientBuffer);
     if (autoImage.image == EGL_NO_IMAGE_KHR) {
         ALOGW("Could not create EGL image, err =%s",
                 uirenderer::renderthread::EglManager::eglErrorString());
         return false;
     }
     AutoGlTexture glTexture(caches);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, autoImage.image);

     GL_CHECKPOINT(MODERATE);

     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width(), bitmap.height(),
             format, type, bitmap.getPixels());

     GL_CHECKPOINT(MODERATE);

     // The fence is used to wait for the texture upload to finish
     // properly. We cannot rely on glFlush() and glFinish() as
     // some drivers completely ignore these API calls
     AutoEglFence autoFence(display);
     if (autoFence.fence == EGL_NO_SYNC_KHR) {
         LOG_ALWAYS_FATAL("Could not create sync fence %#x", eglGetError());
         return false;
     }
     // The flag EGL_SYNC_FLUSH_COMMANDS_BIT_KHR will trigger a
     // pipeline flush (similar to what a glFlush() would do.)
     EGLint waitStatus = eglClientWaitSyncKHR(display, autoFence.fence,
             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, FENCE_TIMEOUT);
     if (waitStatus != EGL_CONDITION_SATISFIED_KHR) {
         LOG_ALWAYS_FATAL("Failed to wait for the fence %#x", eglGetError());
         return false;
     }
     return true;
 }

 sk_sp<Bitmap> Bitmap::allocateHardwareBitmap(uirenderer::renderthread::RenderThread& renderThread,
         SkBitmap& skBitmap) {
     renderThread.eglManager().initialize();
     uirenderer::Caches& caches = uirenderer::Caches::getInstance();

     const SkImageInfo& info = skBitmap.info();
     if (info.colorType() == kUnknown_SkColorType || info.colorType() == kAlpha_8_SkColorType) {
         ALOGW("unable to create hardware bitmap of colortype: %d", info.colorType());
         return nullptr;
     }

     bool needSRGB = uirenderer::transferFunctionCloseToSRGB(skBitmap.info().colorSpace());
     bool hasLinearBlending = caches.extensions().hasLinearBlending();
     GLint format, type, internalFormat;
     uirenderer::Texture::colorTypeToGlFormatAndType(caches, skBitmap.colorType(),
             needSRGB && hasLinearBlending, &internalFormat, &format, &type);

     PixelFormat pixelFormat = internalFormatToPixelFormat(internalFormat);
     sp<GraphicBuffer> buffer = new GraphicBuffer(info.width(), info.height(), pixelFormat,
             GraphicBuffer::USAGE_HW_TEXTURE |
             GraphicBuffer::USAGE_SW_WRITE_NEVER |
             GraphicBuffer::USAGE_SW_READ_NEVER,
             std::string("Bitmap::allocateHardwareBitmap pid [") + std::to_string(getpid()) + "]");

     status_t error = buffer->initCheck();
     if (error < 0) {
         ALOGW("createGraphicBuffer() failed in GraphicBuffer.create()");
         return nullptr;
     }

     SkBitmap bitmap;
     if (CC_UNLIKELY(uirenderer::Texture::hasUnsupportedColorType(skBitmap.info(),
             hasLinearBlending))) {
         sk_sp<SkColorSpace> sRGB = SkColorSpace::MakeSRGB();
         bitmap = uirenderer::Texture::uploadToN32(skBitmap, hasLinearBlending, std::move(sRGB));
     } else {
         bitmap = skBitmap;
     }

     if (!uploadBitmapToGraphicBuffer(caches, bitmap, *buffer, format, type)) {
         return nullptr;
     }
     return sk_sp<Bitmap>(new Bitmap(buffer.get(), bitmap.info()));
 }

 sk_sp<Bitmap> Bitmap::allocateHardwareBitmap(SkBitmap& bitmap) {
     return uirenderer::renderthread::RenderProxy::allocateHardwareBitmap(bitmap);
 }

 sk_sp<Bitmap> Bitmap::allocateHeapBitmap(SkBitmap* bitmap, SkColorTable* ctable) {
    return allocateBitmap(bitmap, ctable, &android::allocateHeapBitmap);
 }

 sk_sp<Bitmap> Bitmap::allocateHeapBitmap(const SkImageInfo& info) {
     size_t size;
     if (!computeAllocationSize(info.minRowBytes(), info.height(), &size)) {
         LOG_ALWAYS_FATAL("trying to allocate too large bitmap");
         return nullptr;
     }
     return android::allocateHeapBitmap(size, info, info.minRowBytes(), nullptr);
 }

 sk_sp<Bitmap> Bitmap::allocateAshmemBitmap(size_t size, const SkImageInfo& info,
         size_t rowBytes, SkColorTable* ctable) {
     // Create new ashmem region with read/write priv
     int fd = ashmem_create_region("bitmap", size);
     if (fd < 0) {
         return nullptr;
     }

     void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (addr == MAP_FAILED) {
         close(fd);
         return nullptr;
     }

     if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
         munmap(addr, size);
         close(fd);
         return nullptr;
     }
     return sk_sp<Bitmap>(new Bitmap(addr, fd, size, info, rowBytes, ctable));
 }

 void FreePixelRef(void* addr, void* context) {
     auto pixelRef = (SkPixelRef*) context;
     pixelRef->unlockPixels();
     pixelRef->unref();
 }

 sk_sp<Bitmap> Bitmap::createFrom(const SkImageInfo& info, SkPixelRef& pixelRef) {
     pixelRef.ref();
     pixelRef.lockPixels();
     return sk_sp<Bitmap>(new Bitmap((void*) pixelRef.pixels(), (void*) &pixelRef, FreePixelRef,
             info, pixelRef.rowBytes(), pixelRef.colorTable()));
 }

 sk_sp<Bitmap> Bitmap::createFrom(sp<GraphicBuffer> graphicBuffer) {
     PixelFormat format = graphicBuffer->getPixelFormat();
     if (!graphicBuffer.get() ||
             (format != PIXEL_FORMAT_RGBA_8888 && format != PIXEL_FORMAT_RGBA_FP16)) {
         return nullptr;
     }
     SkImageInfo info = SkImageInfo::Make(graphicBuffer->getWidth(), graphicBuffer->getHeight(),
             kRGBA_8888_SkColorType, kPremul_SkAlphaType,
             SkColorSpace::MakeSRGB());
     return sk_sp<Bitmap>(new Bitmap(graphicBuffer.get(), info));
 }

 void Bitmap::setColorSpace(sk_sp<SkColorSpace> colorSpace) {
     // TODO: See todo in reconfigure() below
     SkImageInfo* myInfo = const_cast<SkImageInfo*>(&this->info());
     *myInfo = info().makeColorSpace(std::move(colorSpace));
 }

 void Bitmap::reconfigure(const SkImageInfo& newInfo, size_t rowBytes, SkColorTable* ctable) {
     if (kIndex_8_SkColorType != newInfo.colorType()) {
         ctable = nullptr;
     }
     mRowBytes = rowBytes;
     if (mColorTable.get() != ctable) {
         mColorTable.reset(SkSafeRef(ctable));
     }

     // Need to validate the alpha type to filter against the color type
     // to prevent things like a non-opaque RGB565 bitmap
     SkAlphaType alphaType;
     LOG_ALWAYS_FATAL_IF(!SkColorTypeValidateAlphaType(
             newInfo.colorType(), newInfo.alphaType(), &alphaType),
             "Failed to validate alpha type!");

     // Dirty hack is dirty
     // TODO: Figure something out here, Skia's current design makes this
     // really hard to work with. Skia really, really wants immutable objects,
     // but with the nested-ref-count hackery going on that's just not
     // feasible without going insane trying to figure it out
     SkImageInfo* myInfo = const_cast<SkImageInfo*>(&this->info());
     *myInfo = newInfo;
     changeAlphaType(alphaType);

     // Docs say to only call this in the ctor, but we're going to call
     // it anyway even if this isn't always the ctor.
     // TODO: Fix this too as part of the above TODO
     setPreLocked(getStorage(), mRowBytes, mColorTable.get());
 }

 Bitmap::Bitmap(void* address, size_t size, const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
             : SkPixelRef(info)
             , mPixelStorageType(PixelStorageType::Heap) {
     mPixelStorage.heap.address = address;
     mPixelStorage.heap.size = size;
     reconfigure(info, rowBytes, ctable);
 }

 Bitmap::Bitmap(void* address, void* context, FreeFunc freeFunc,
                 const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
             : SkPixelRef(info)
             , mPixelStorageType(PixelStorageType::External) {
     mPixelStorage.external.address = address;
     mPixelStorage.external.context = context;
     mPixelStorage.external.freeFunc = freeFunc;
     reconfigure(info, rowBytes, ctable);
 }

 Bitmap::Bitmap(void* address, int fd, size_t mappedSize,
                 const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
             : SkPixelRef(info)
             , mPixelStorageType(PixelStorageType::Ashmem) {
     mPixelStorage.ashmem.address = address;
     mPixelStorage.ashmem.fd = fd;
     mPixelStorage.ashmem.size = mappedSize;
     reconfigure(info, rowBytes, ctable);
 }

 Bitmap::Bitmap(GraphicBuffer* buffer, const SkImageInfo& info)
         : SkPixelRef(info)
         , mPixelStorageType(PixelStorageType::Hardware) {
     mPixelStorage.hardware.buffer = buffer;
     buffer->incStrong(buffer);
     mRowBytes = bytesPerPixel(buffer->getPixelFormat()) * buffer->getStride();
 }

 Bitmap::~Bitmap() {
     switch (mPixelStorageType) {
     case PixelStorageType::External:
         mPixelStorage.external.freeFunc(mPixelStorage.external.address,
                 mPixelStorage.external.context);
         break;
     case PixelStorageType::Ashmem:
         munmap(mPixelStorage.ashmem.address, mPixelStorage.ashmem.size);
         close(mPixelStorage.ashmem.fd);
         break;
     case PixelStorageType::Heap:
         free(mPixelStorage.heap.address);
         break;
     case PixelStorageType::Hardware:
         auto buffer = mPixelStorage.hardware.buffer;
         buffer->decStrong(buffer);
         mPixelStorage.hardware.buffer = nullptr;
         break;

     }

     android::uirenderer::renderthread::RenderProxy::onBitmapDestroyed(getStableID());
 }

 bool Bitmap::hasHardwareMipMap() const {
     return mHasHardwareMipMap;
 }

 void Bitmap::setHasHardwareMipMap(bool hasMipMap) {
     mHasHardwareMipMap = hasMipMap;
 }

 void* Bitmap::getStorage() const {
     switch (mPixelStorageType) {
     case PixelStorageType::External:
         return mPixelStorage.external.address;
     case PixelStorageType::Ashmem:
         return mPixelStorage.ashmem.address;
     case PixelStorageType::Heap:
         return mPixelStorage.heap.address;
     case PixelStorageType::Hardware:
         return nullptr;
     }
 }

 bool Bitmap::onNewLockPixels(LockRec* rec) {
     rec->fPixels = getStorage();
     rec->fRowBytes = mRowBytes;
     rec->fColorTable = mColorTable.get();
     return true;
 }

 size_t Bitmap::getAllocatedSizeInBytes() const {
     return info().getSafeSize(mRowBytes);
 }

 int Bitmap::getAshmemFd() const {
     switch (mPixelStorageType) {
     case PixelStorageType::Ashmem:
         return mPixelStorage.ashmem.fd;
     default:
         return -1;
     }
 }

 size_t Bitmap::getAllocationByteCount() const {
     switch (mPixelStorageType) {
     case PixelStorageType::Heap:
         return mPixelStorage.heap.size;
     default:
         return rowBytes() * height();
     }
 }

 void Bitmap::reconfigure(const SkImageInfo& info) {
     reconfigure(info, info.minRowBytes(), nullptr);
 }

 void Bitmap::setAlphaType(SkAlphaType alphaType) {
     if (!SkColorTypeValidateAlphaType(info().colorType(), alphaType, &alphaType)) {
         return;
     }

     changeAlphaType(alphaType);
 }

 void Bitmap::getSkBitmap(SkBitmap* outBitmap) {
     outBitmap->setHasHardwareMipMap(mHasHardwareMipMap);
     if (isHardware()) {
         if (uirenderer::Properties::isSkiaEnabled()) {
             // TODO: add color correctness for Skia pipeline - pass null color space for now
             outBitmap->allocPixels(SkImageInfo::Make(info().width(), info().height(),
                     info().colorType(), info().alphaType(), nullptr));
         } else {
             outBitmap->allocPixels(info());
         }
         uirenderer::renderthread::RenderProxy::copyGraphicBufferInto(graphicBuffer(), outBitmap);
         return;
     }
     outBitmap->setInfo(info(), rowBytes());
     outBitmap->setPixelRef(this);
 }

 void Bitmap::getSkBitmapForShaders(SkBitmap* outBitmap) {
     if (isHardware() && uirenderer::Properties::isSkiaEnabled()) {
         getSkBitmap(outBitmap);
     } else {
         outBitmap->setInfo(info(), rowBytes());
         outBitmap->setPixelRef(this);
         outBitmap->setHasHardwareMipMap(mHasHardwareMipMap);
     }
 }

 void Bitmap::getBounds(SkRect* bounds) const {
     SkASSERT(bounds);
     bounds->set(0, 0, SkIntToScalar(info().width()), SkIntToScalar(info().height()));
 }

 GraphicBuffer* Bitmap::graphicBuffer() {
     if (isHardware()) {
         return mPixelStorage.hardware.buffer;
     }
     return nullptr;
 }

 } // namespace android
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include "Bitmap.h"

	#include "Caches.h"
	#include "renderthread/EglManager.h"
	#include "renderthread/RenderThread.h"
	#include "renderthread/RenderProxy.h"
	#include "utils/Color.h"

	#include <sys/mman.h>

	#include <log/log.h>
	#include <cutils/ashmem.h>

	#include <GLES2/gl2.h>
	#include <GLES2/gl2ext.h>
	#include <EGL/egl.h>
	#include <EGL/eglext.h>

	#include <private/gui/ComposerService.h>
	#include <binder/IServiceManager.h>
	#include <ui/PixelFormat.h>

	#include <SkCanvas.h>

	namespace android {

	static bool computeAllocationSize(size_t rowBytes, int height, size_t* size) {
	int32_t rowBytes32 = SkToS32(rowBytes);
	int64_t bigSize = (int64_t) height * rowBytes32;
	if (rowBytes32 < 0 \|\| !sk_64_isS32(bigSize)) {
	return false; // allocation will be too large
	}

	*size = sk_64_asS32(bigSize);
	return true;
	}

	typedef sk_sp<Bitmap> (*AllocPixeRef)(size_t allocSize, const SkImageInfo& info, size_t rowBytes,
	SkColorTable* ctable);

	static sk_sp<Bitmap> allocateBitmap(SkBitmap* bitmap, SkColorTable* ctable, AllocPixeRef alloc) {
	const SkImageInfo& info = bitmap->info();
	if (info.colorType() == kUnknown_SkColorType) {
	LOG_ALWAYS_FATAL("unknown bitmap configuration");
	return nullptr;
	}

	size_t size;

	// we must respect the rowBytes value already set on the bitmap instead of
	// attempting to compute our own.
	const size_t rowBytes = bitmap->rowBytes();
	if (!computeAllocationSize(rowBytes, bitmap->height(), &size)) {
	return nullptr;
	}

	auto wrapper = alloc(size, info, rowBytes, ctable);
	if (wrapper) {
	wrapper->getSkBitmap(bitmap);
	// since we're already allocated, we lockPixels right away
	// HeapAllocator behaves this way too
	bitmap->lockPixels();
	}
	return wrapper;
	}

	sk_sp<Bitmap> Bitmap::allocateAshmemBitmap(SkBitmap* bitmap, SkColorTable* ctable) {
	return allocateBitmap(bitmap, ctable, &Bitmap::allocateAshmemBitmap);
	}

	static sk_sp<Bitmap> allocateHeapBitmap(size_t size, const SkImageInfo& info, size_t rowBytes,
	SkColorTable* ctable) {
	void* addr = calloc(size, 1);
	if (!addr) {
	return nullptr;
	}
	return sk_sp<Bitmap>(new Bitmap(addr, size, info, rowBytes, ctable));
	}

	#define FENCE_TIMEOUT 2000000000

	// TODO: handle SRGB sanely
	static PixelFormat internalFormatToPixelFormat(GLint internalFormat) {
	switch (internalFormat) {
	case GL_LUMINANCE:
	return PIXEL_FORMAT_RGBA_8888;
	case GL_SRGB8_ALPHA8:
	return PIXEL_FORMAT_RGBA_8888;
	case GL_RGBA:
	return PIXEL_FORMAT_RGBA_8888;
	case GL_RGB:
	return PIXEL_FORMAT_RGB_565;
	case GL_RGBA16F:
	return PIXEL_FORMAT_RGBA_FP16;
	default:
	LOG_ALWAYS_FATAL("Unsupported bitmap colorType: %d", internalFormat);
	return PIXEL_FORMAT_UNKNOWN;
	}
	}

	class AutoEglFence {
	public:
	AutoEglFence(EGLDisplay display)
	: mDisplay(display) {
	fence = eglCreateSyncKHR(mDisplay, EGL_SYNC_FENCE_KHR, NULL);
	}

	~AutoEglFence() {
	if (fence != EGL_NO_SYNC_KHR) {
	eglDestroySyncKHR(mDisplay, fence);
	}
	}

	EGLSyncKHR fence = EGL_NO_SYNC_KHR;
	private:
	EGLDisplay mDisplay = EGL_NO_DISPLAY;
	};

	class AutoEglImage {
	public:
	AutoEglImage(EGLDisplay display, EGLClientBuffer clientBuffer)
	: mDisplay(display) {
	EGLint imageAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
	image = eglCreateImageKHR(display, EGL_NO_CONTEXT,
	EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
	}

	~AutoEglImage() {
	if (image != EGL_NO_IMAGE_KHR) {
	eglDestroyImageKHR(mDisplay, image);
	}
	}

	EGLImageKHR image = EGL_NO_IMAGE_KHR;
	private:
	EGLDisplay mDisplay = EGL_NO_DISPLAY;
	};

	class AutoGlTexture {
	public:
	AutoGlTexture(uirenderer::Caches& caches)
	: mCaches(caches) {
	glGenTextures(1, &mTexture);
	caches.textureState().bindTexture(mTexture);
	}

	~AutoGlTexture() {
	mCaches.textureState().deleteTexture(mTexture);
	}

	private:
	uirenderer::Caches& mCaches;
	GLuint mTexture = 0;
	};

	static bool uploadBitmapToGraphicBuffer(uirenderer::Caches& caches, SkBitmap& bitmap,
	GraphicBuffer& buffer, GLint format, GLint type) {
	SkAutoLockPixels alp(bitmap);
	EGLDisplay display = eglGetCurrentDisplay();
	LOG_ALWAYS_FATAL_IF(display == EGL_NO_DISPLAY,
	"Failed to get EGL_DEFAULT_DISPLAY! err=%s",
	uirenderer::renderthread::EglManager::eglErrorString());
	// We use an EGLImage to access the content of the GraphicBuffer
	// The EGL image is later bound to a 2D texture
	EGLClientBuffer clientBuffer = (EGLClientBuffer) buffer.getNativeBuffer();
	AutoEglImage autoImage(display, clientBuffer);
	if (autoImage.image == EGL_NO_IMAGE_KHR) {
	ALOGW("Could not create EGL image, err =%s",
	uirenderer::renderthread::EglManager::eglErrorString());
	return false;
	}
	AutoGlTexture glTexture(caches);
	glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, autoImage.image);

	GL_CHECKPOINT(MODERATE);

	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width(), bitmap.height(),
	format, type, bitmap.getPixels());

	GL_CHECKPOINT(MODERATE);

	// The fence is used to wait for the texture upload to finish
	// properly. We cannot rely on glFlush() and glFinish() as
	// some drivers completely ignore these API calls
	AutoEglFence autoFence(display);
	if (autoFence.fence == EGL_NO_SYNC_KHR) {
	LOG_ALWAYS_FATAL("Could not create sync fence %#x", eglGetError());
	return false;
	}
	// The flag EGL_SYNC_FLUSH_COMMANDS_BIT_KHR will trigger a
	// pipeline flush (similar to what a glFlush() would do.)
	EGLint waitStatus = eglClientWaitSyncKHR(display, autoFence.fence,
	EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, FENCE_TIMEOUT);
	if (waitStatus != EGL_CONDITION_SATISFIED_KHR) {
	LOG_ALWAYS_FATAL("Failed to wait for the fence %#x", eglGetError());
	return false;
	}
	return true;
	}

	sk_sp<Bitmap> Bitmap::allocateHardwareBitmap(uirenderer::renderthread::RenderThread& renderThread,
	SkBitmap& skBitmap) {
	renderThread.eglManager().initialize();
	uirenderer::Caches& caches = uirenderer::Caches::getInstance();

	const SkImageInfo& info = skBitmap.info();
	if (info.colorType() == kUnknown_SkColorType \|\| info.colorType() == kAlpha_8_SkColorType) {
	ALOGW("unable to create hardware bitmap of colortype: %d", info.colorType());
	return nullptr;
	}

	bool needSRGB = uirenderer::transferFunctionCloseToSRGB(skBitmap.info().colorSpace());
	bool hasLinearBlending = caches.extensions().hasLinearBlending();
	GLint format, type, internalFormat;
	uirenderer::Texture::colorTypeToGlFormatAndType(caches, skBitmap.colorType(),
	needSRGB && hasLinearBlending, &internalFormat, &format, &type);

	PixelFormat pixelFormat = internalFormatToPixelFormat(internalFormat);
	sp<GraphicBuffer> buffer = new GraphicBuffer(info.width(), info.height(), pixelFormat,
	GraphicBuffer::USAGE_HW_TEXTURE \|
	GraphicBuffer::USAGE_SW_WRITE_NEVER \|
	GraphicBuffer::USAGE_SW_READ_NEVER,
	std::string("Bitmap::allocateHardwareBitmap pid [") + std::to_string(getpid()) + "]");

	status_t error = buffer->initCheck();
	if (error < 0) {
	ALOGW("createGraphicBuffer() failed in GraphicBuffer.create()");
	return nullptr;
	}

	SkBitmap bitmap;
	if (CC_UNLIKELY(uirenderer::Texture::hasUnsupportedColorType(skBitmap.info(),
	hasLinearBlending))) {
	sk_sp<SkColorSpace> sRGB = SkColorSpace::MakeSRGB();
	bitmap = uirenderer::Texture::uploadToN32(skBitmap, hasLinearBlending, std::move(sRGB));
	} else {
	bitmap = skBitmap;
	}

	if (!uploadBitmapToGraphicBuffer(caches, bitmap, *buffer, format, type)) {
	return nullptr;
	}
	return sk_sp<Bitmap>(new Bitmap(buffer.get(), bitmap.info()));
	}

	sk_sp<Bitmap> Bitmap::allocateHardwareBitmap(SkBitmap& bitmap) {
	return uirenderer::renderthread::RenderProxy::allocateHardwareBitmap(bitmap);
	}

	sk_sp<Bitmap> Bitmap::allocateHeapBitmap(SkBitmap* bitmap, SkColorTable* ctable) {
	return allocateBitmap(bitmap, ctable, &android::allocateHeapBitmap);
	}

	sk_sp<Bitmap> Bitmap::allocateHeapBitmap(const SkImageInfo& info) {
	size_t size;
	if (!computeAllocationSize(info.minRowBytes(), info.height(), &size)) {
	LOG_ALWAYS_FATAL("trying to allocate too large bitmap");
	return nullptr;
	}
	return android::allocateHeapBitmap(size, info, info.minRowBytes(), nullptr);
	}

	sk_sp<Bitmap> Bitmap::allocateAshmemBitmap(size_t size, const SkImageInfo& info,
	size_t rowBytes, SkColorTable* ctable) {
	// Create new ashmem region with read/write priv
	int fd = ashmem_create_region("bitmap", size);
	if (fd < 0) {
	return nullptr;
	}

	void* addr = mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0);
	if (addr == MAP_FAILED) {
	close(fd);
	return nullptr;
	}

	if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
	munmap(addr, size);
	close(fd);
	return nullptr;
	}
	return sk_sp<Bitmap>(new Bitmap(addr, fd, size, info, rowBytes, ctable));
	}

	void FreePixelRef(void* addr, void* context) {
	auto pixelRef = (SkPixelRef*) context;
	pixelRef->unlockPixels();
	pixelRef->unref();
	}

	sk_sp<Bitmap> Bitmap::createFrom(const SkImageInfo& info, SkPixelRef& pixelRef) {
	pixelRef.ref();
	pixelRef.lockPixels();
	return sk_sp<Bitmap>(new Bitmap((void) pixelRef.pixels(), (void) &pixelRef, FreePixelRef,
	info, pixelRef.rowBytes(), pixelRef.colorTable()));
	}

	sk_sp<Bitmap> Bitmap::createFrom(sp<GraphicBuffer> graphicBuffer) {
	PixelFormat format = graphicBuffer->getPixelFormat();
	if (!graphicBuffer.get() \|\|
	(format != PIXEL_FORMAT_RGBA_8888 && format != PIXEL_FORMAT_RGBA_FP16)) {
	return nullptr;
	}
	SkImageInfo info = SkImageInfo::Make(graphicBuffer->getWidth(), graphicBuffer->getHeight(),
	kRGBA_8888_SkColorType, kPremul_SkAlphaType,
	SkColorSpace::MakeSRGB());
	return sk_sp<Bitmap>(new Bitmap(graphicBuffer.get(), info));
	}

	void Bitmap::setColorSpace(sk_sp<SkColorSpace> colorSpace) {
	// TODO: See todo in reconfigure() below
	SkImageInfo* myInfo = const_cast<SkImageInfo*>(&this->info());
	*myInfo = info().makeColorSpace(std::move(colorSpace));
	}

	void Bitmap::reconfigure(const SkImageInfo& newInfo, size_t rowBytes, SkColorTable* ctable) {
	if (kIndex_8_SkColorType != newInfo.colorType()) {
	ctable = nullptr;
	}
	mRowBytes = rowBytes;
	if (mColorTable.get() != ctable) {
	mColorTable.reset(SkSafeRef(ctable));
	}

	// Need to validate the alpha type to filter against the color type
	// to prevent things like a non-opaque RGB565 bitmap
	SkAlphaType alphaType;
	LOG_ALWAYS_FATAL_IF(!SkColorTypeValidateAlphaType(
	newInfo.colorType(), newInfo.alphaType(), &alphaType),
	"Failed to validate alpha type!");

	// Dirty hack is dirty
	// TODO: Figure something out here, Skia's current design makes this
	// really hard to work with. Skia really, really wants immutable objects,
	// but with the nested-ref-count hackery going on that's just not
	// feasible without going insane trying to figure it out
	SkImageInfo* myInfo = const_cast<SkImageInfo*>(&this->info());
	*myInfo = newInfo;
	changeAlphaType(alphaType);

	// Docs say to only call this in the ctor, but we're going to call
	// it anyway even if this isn't always the ctor.
	// TODO: Fix this too as part of the above TODO
	setPreLocked(getStorage(), mRowBytes, mColorTable.get());
	}

	Bitmap::Bitmap(void* address, size_t size, const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
	: SkPixelRef(info)
	, mPixelStorageType(PixelStorageType::Heap) {
	mPixelStorage.heap.address = address;
	mPixelStorage.heap.size = size;
	reconfigure(info, rowBytes, ctable);
	}

	Bitmap::Bitmap(void* address, void* context, FreeFunc freeFunc,
	const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
	: SkPixelRef(info)
	, mPixelStorageType(PixelStorageType::External) {
	mPixelStorage.external.address = address;
	mPixelStorage.external.context = context;
	mPixelStorage.external.freeFunc = freeFunc;
	reconfigure(info, rowBytes, ctable);
	}

	Bitmap::Bitmap(void* address, int fd, size_t mappedSize,
	const SkImageInfo& info, size_t rowBytes, SkColorTable* ctable)
	: SkPixelRef(info)
	, mPixelStorageType(PixelStorageType::Ashmem) {
	mPixelStorage.ashmem.address = address;
	mPixelStorage.ashmem.fd = fd;
	mPixelStorage.ashmem.size = mappedSize;
	reconfigure(info, rowBytes, ctable);
	}

	Bitmap::Bitmap(GraphicBuffer* buffer, const SkImageInfo& info)
	: SkPixelRef(info)
	, mPixelStorageType(PixelStorageType::Hardware) {
	mPixelStorage.hardware.buffer = buffer;
	buffer->incStrong(buffer);
	mRowBytes = bytesPerPixel(buffer->getPixelFormat()) * buffer->getStride();
	}

	Bitmap::~Bitmap() {
	switch (mPixelStorageType) {
	case PixelStorageType::External:
	mPixelStorage.external.freeFunc(mPixelStorage.external.address,
	mPixelStorage.external.context);
	break;
	case PixelStorageType::Ashmem:
	munmap(mPixelStorage.ashmem.address, mPixelStorage.ashmem.size);
	close(mPixelStorage.ashmem.fd);
	break;
	case PixelStorageType::Heap:
	free(mPixelStorage.heap.address);
	break;
	case PixelStorageType::Hardware:
	auto buffer = mPixelStorage.hardware.buffer;
	buffer->decStrong(buffer);
	mPixelStorage.hardware.buffer = nullptr;
	break;

	}

	android::uirenderer::renderthread::RenderProxy::onBitmapDestroyed(getStableID());
	}

	bool Bitmap::hasHardwareMipMap() const {
	return mHasHardwareMipMap;
	}

	void Bitmap::setHasHardwareMipMap(bool hasMipMap) {
	mHasHardwareMipMap = hasMipMap;
	}

	void* Bitmap::getStorage() const {
	switch (mPixelStorageType) {
	case PixelStorageType::External:
	return mPixelStorage.external.address;
	case PixelStorageType::Ashmem:
	return mPixelStorage.ashmem.address;
	case PixelStorageType::Heap:
	return mPixelStorage.heap.address;
	case PixelStorageType::Hardware:
	return nullptr;
	}
	}

	bool Bitmap::onNewLockPixels(LockRec* rec) {
	rec->fPixels = getStorage();
	rec->fRowBytes = mRowBytes;
	rec->fColorTable = mColorTable.get();
	return true;
	}

	size_t Bitmap::getAllocatedSizeInBytes() const {
	return info().getSafeSize(mRowBytes);
	}

	int Bitmap::getAshmemFd() const {
	switch (mPixelStorageType) {
	case PixelStorageType::Ashmem:
	return mPixelStorage.ashmem.fd;
	default:
	return -1;
	}
	}

	size_t Bitmap::getAllocationByteCount() const {
	switch (mPixelStorageType) {
	case PixelStorageType::Heap:
	return mPixelStorage.heap.size;
	default:
	return rowBytes() * height();
	}
	}

	void Bitmap::reconfigure(const SkImageInfo& info) {
	reconfigure(info, info.minRowBytes(), nullptr);
	}

	void Bitmap::setAlphaType(SkAlphaType alphaType) {
	if (!SkColorTypeValidateAlphaType(info().colorType(), alphaType, &alphaType)) {
	return;
	}

	changeAlphaType(alphaType);
	}

	void Bitmap::getSkBitmap(SkBitmap* outBitmap) {
	outBitmap->setHasHardwareMipMap(mHasHardwareMipMap);
	if (isHardware()) {
	if (uirenderer::Properties::isSkiaEnabled()) {
	// TODO: add color correctness for Skia pipeline - pass null color space for now
	outBitmap->allocPixels(SkImageInfo::Make(info().width(), info().height(),
	info().colorType(), info().alphaType(), nullptr));
	} else {
	outBitmap->allocPixels(info());
	}
	uirenderer::renderthread::RenderProxy::copyGraphicBufferInto(graphicBuffer(), outBitmap);
	return;
	}
	outBitmap->setInfo(info(), rowBytes());
	outBitmap->setPixelRef(this);
	}

	void Bitmap::getSkBitmapForShaders(SkBitmap* outBitmap) {
	if (isHardware() && uirenderer::Properties::isSkiaEnabled()) {
	getSkBitmap(outBitmap);
	} else {
	outBitmap->setInfo(info(), rowBytes());
	outBitmap->setPixelRef(this);
	outBitmap->setHasHardwareMipMap(mHasHardwareMipMap);
	}
	}

	void Bitmap::getBounds(SkRect* bounds) const {
	SkASSERT(bounds);
	bounds->set(0, 0, SkIntToScalar(info().width()), SkIntToScalar(info().height()));
	}

	GraphicBuffer* Bitmap::graphicBuffer() {
	if (isHardware()) {
	return mPixelStorage.hardware.buffer;
	}
	return nullptr;
	}

	} // namespace android