Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e170fb66 authored by John Reck's avatar John Reck
Browse files

A better HW Bitmap uploader 

Move all HW bitmap upload operations off of RenderThread.
Ensure EGL context outlives all upload requests

Bug: 79250950
Test: builds, boots, systrace is good, CTS bitmap tests pass

Change-Id: I5ace6c516d33b1afdf1a407cd8b183f6b60c22c1
parent 33f4f1cb

libs/hwui/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -206,6 +206,7 @@ cc_defaults { 
        "FrameInfoVisualizer.cpp",

        "GlLayer.cpp",

        "GpuMemoryTracker.cpp",

        "HardwareBitmapUploader.cpp",

        "Interpolator.cpp",

        "JankTracker.cpp",

        "Layer.cpp",

libs/hwui/Caches.cpp

+2 −5
Original line number Diff line number Diff line
@@ -44,9 +44,7 @@ Caches* Caches::sInstance = nullptr; 
// Constructors/destructor

///////////////////////////////////////////////////////////////////////////////



Caches::Caches(RenderState& renderState)

        : mRenderState(&renderState)

        , mInitialized(false) {

Caches::Caches(RenderState& renderState) : mRenderState(&renderState), mInitialized(false) {

    INIT_LOGD("Creating OpenGL renderer caches");

    init();

    initConstraints();
@@ -153,8 +151,7 @@ void Caches::dumpMemoryUsage(String8& log) { 
// Memory management

///////////////////////////////////////////////////////////////////////////////



void Caches::clearGarbage() {

}

void Caches::clearGarbage() {}



void Caches::flush(FlushMode mode) {

    clearGarbage();

libs/hwui/EglReadback.cpp

+3 −5
Original line number Diff line number Diff line
@@ -25,8 +25,7 @@ 
namespace android {

namespace uirenderer {



CopyResult EglReadback::copySurfaceInto(Surface& surface, const Rect& srcRect,

                                           SkBitmap* bitmap) {

CopyResult EglReadback::copySurfaceInto(Surface& surface, const Rect& srcRect, SkBitmap* bitmap) {

    ATRACE_CALL();

    // Setup the source

    sp<GraphicBuffer> sourceBuffer;
@@ -55,9 +54,8 @@ CopyResult EglReadback::copySurfaceInto(Surface& surface, const Rect& srcRect, 
    return copyGraphicBufferInto(sourceBuffer.get(), texTransform, srcRect, bitmap);

}



CopyResult EglReadback::copyGraphicBufferInto(GraphicBuffer* graphicBuffer,

                                                 Matrix4& texTransform, const Rect& srcRect,

                                                 SkBitmap* bitmap) {

CopyResult EglReadback::copyGraphicBufferInto(GraphicBuffer* graphicBuffer, Matrix4& texTransform,

                                              const Rect& srcRect, SkBitmap* bitmap) {

    mRenderThread.requireGlContext();

    // TODO: Can't use Image helper since it forces GL_TEXTURE_2D usage via

    // GL_OES_EGL_image, which doesn't work since we need samplerExternalOES

libs/hwui/HardwareBitmapUploader.cpp

0 → 100644
+292 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 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 "HardwareBitmapUploader.h"



#include "hwui/Bitmap.h"

#include "renderthread/EglManager.h"

#include "thread/ThreadBase.h"

#include "utils/TimeUtils.h"



#include <EGL/eglext.h>

#include <GLES2/gl2.h>

#include <GLES2/gl2ext.h>

#include <GLES3/gl3.h>

#include <SkCanvas.h>

#include <utils/GLUtils.h>

#include <utils/Trace.h>

#include <utils/TraceUtils.h>

#include <thread>



namespace android::uirenderer {



static std::mutex sLock{};

static ThreadBase* sUploadThread = nullptr;

static renderthread::EglManager sEglManager;

static int sPendingUploads = 0;

static nsecs_t sLastUpload = 0;



static bool shouldTimeOutLocked() {

    nsecs_t durationSince = systemTime() - sLastUpload;

    return durationSince > 2000_ms;

}



static void checkIdleTimeout() {

    std::lock_guard{sLock};

    if (sPendingUploads == 0 && shouldTimeOutLocked()) {

        sEglManager.destroy();

    } else {

        sUploadThread->queue().postDelayed(5000_ms, checkIdleTimeout);

    }

}



static void beginUpload() {

    std::lock_guard{sLock};

    sPendingUploads++;



    if (!sUploadThread) {

        sUploadThread = new ThreadBase{};

    }



    if (!sUploadThread->isRunning()) {

        sUploadThread->start("GrallocUploadThread");

    }



    if (!sEglManager.hasEglContext()) {

        sUploadThread->queue().runSync([]() {

            sEglManager.initialize();

            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

        });

        sUploadThread->queue().postDelayed(5000_ms, checkIdleTimeout);

    }

}



static void endUpload() {

    std::lock_guard{sLock};

    sPendingUploads--;

    sLastUpload = systemTime();

}



static EGLDisplay getUploadEglDisplay() {

    std::lock_guard{sLock};

    LOG_ALWAYS_FATAL_IF(!sEglManager.hasEglContext(), "Forgot to begin an upload?");

    return sEglManager.eglDisplay();

}



static bool hasFP16Support() {

    static std::once_flag sOnce;

    static bool hasFP16Support = false;



    // Gralloc shouldn't let us create a USAGE_HW_TEXTURE if GLES is unable to consume it, so

    // we don't need to double-check the GLES version/extension.

    std::call_once(sOnce, []() {

        sp<GraphicBuffer> buffer = new GraphicBuffer(1, 1, PIXEL_FORMAT_RGBA_FP16,

                                                     GraphicBuffer::USAGE_HW_TEXTURE |

                                                             GraphicBuffer::USAGE_SW_WRITE_NEVER |

                                                             GraphicBuffer::USAGE_SW_READ_NEVER,

                                                     "tempFp16Buffer");

        status_t error = buffer->initCheck();

        hasFP16Support = !error;

    });



    return hasFP16Support;

}



#define FENCE_TIMEOUT 2000000000



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 AutoSkiaGlTexture {

public:

    AutoSkiaGlTexture() {

        glGenTextures(1, &mTexture);

        glBindTexture(GL_TEXTURE_2D, mTexture);

    }



    ~AutoSkiaGlTexture() { glDeleteTextures(1, &mTexture); }



private:

    GLuint mTexture = 0;

};



struct FormatInfo {

    PixelFormat pixelFormat;

    GLint format, type;

    bool isSupported = false;

    bool valid = true;

};



static FormatInfo determineFormat(const SkBitmap& skBitmap) {

    FormatInfo formatInfo;

    // TODO: add support for linear blending (when ANDROID_ENABLE_LINEAR_BLENDING is defined)

    switch (skBitmap.info().colorType()) {

        case kRGBA_8888_SkColorType:

            formatInfo.isSupported = true;

        // ARGB_4444 is upconverted to RGBA_8888

        case kARGB_4444_SkColorType:

            formatInfo.pixelFormat = PIXEL_FORMAT_RGBA_8888;

            formatInfo.format = GL_RGBA;

            formatInfo.type = GL_UNSIGNED_BYTE;

            break;

        case kRGBA_F16_SkColorType:

            formatInfo.isSupported = hasFP16Support();

            if (formatInfo.isSupported) {

                formatInfo.type = GL_HALF_FLOAT;

                formatInfo.pixelFormat = PIXEL_FORMAT_RGBA_FP16;

            } else {

                formatInfo.type = GL_UNSIGNED_BYTE;

                formatInfo.pixelFormat = PIXEL_FORMAT_RGBA_8888;

            }

            formatInfo.format = GL_RGBA;

            break;

        case kRGB_565_SkColorType:

            formatInfo.isSupported = true;

            formatInfo.pixelFormat = PIXEL_FORMAT_RGB_565;

            formatInfo.format = GL_RGB;

            formatInfo.type = GL_UNSIGNED_SHORT_5_6_5;

            break;

        case kGray_8_SkColorType:

            formatInfo.isSupported = true;

            formatInfo.pixelFormat = PIXEL_FORMAT_RGBA_8888;

            formatInfo.format = GL_LUMINANCE;

            formatInfo.type = GL_UNSIGNED_BYTE;

            break;

        default:

            ALOGW("unable to create hardware bitmap of colortype: %d", skBitmap.info().colorType());

            formatInfo.valid = false;

    }

    return formatInfo;

}



static SkBitmap makeHwCompatible(const FormatInfo& format, const SkBitmap& source) {

    if (format.isSupported) {

        return source;

    } else {

        SkBitmap bitmap;

        const SkImageInfo& info = source.info();

        bitmap.allocPixels(

                SkImageInfo::MakeN32(info.width(), info.height(), info.alphaType(), nullptr));

        bitmap.eraseColor(0);

        if (info.colorType() == kRGBA_F16_SkColorType) {

            // Drawing RGBA_F16 onto ARGB_8888 is not supported

            source.readPixels(bitmap.info().makeColorSpace(SkColorSpace::MakeSRGB()),

                              bitmap.getPixels(), bitmap.rowBytes(), 0, 0);

        } else {

            SkCanvas canvas(bitmap);

            canvas.drawBitmap(source, 0.0f, 0.0f, nullptr);

        }

        return bitmap;

    }

}



class ScopedUploadRequest {

public:

    ScopedUploadRequest() { beginUpload(); }

    ~ScopedUploadRequest() { endUpload(); }

};



sk_sp<Bitmap> HardwareBitmapUploader::allocateHardwareBitmap(const SkBitmap& sourceBitmap) {

    ATRACE_CALL();



    FormatInfo format = determineFormat(sourceBitmap);

    if (!format.valid) {

        return nullptr;

    }



    ScopedUploadRequest _uploadRequest{};



    SkBitmap bitmap = makeHwCompatible(format, sourceBitmap);

    sp<GraphicBuffer> buffer = new GraphicBuffer(

            static_cast<uint32_t>(bitmap.width()), static_cast<uint32_t>(bitmap.height()),

            format.pixelFormat,

            GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_SW_WRITE_NEVER |

                    GraphicBuffer::USAGE_SW_READ_NEVER,

            std::string("Bitmap::allocateSkiaHardwareBitmap pid [") + std::to_string(getpid()) +

                    "]");



    status_t error = buffer->initCheck();

    if (error < 0) {

        ALOGW("createGraphicBuffer() failed in GraphicBuffer.create()");

        return nullptr;

    }



    EGLDisplay display = getUploadEglDisplay();



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

    }



    {

        ATRACE_FORMAT("CPU -> gralloc transfer (%dx%d)", bitmap.width(), bitmap.height());

        EGLSyncKHR fence = sUploadThread->queue().runSync([&]() -> EGLSyncKHR {

            AutoSkiaGlTexture glTexture;

            glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, autoImage.image);

            GL_CHECKPOINT(MODERATE);



            // glTexSubImage2D is synchronous in sense that it memcpy() from pointer that we

            // provide.

            // But asynchronous in sense that driver may upload texture onto hardware buffer when we

            // first

            // use it in drawing

            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width(), bitmap.height(), format.format,

                            format.type, bitmap.getPixels());

            GL_CHECKPOINT(MODERATE);



            EGLSyncKHR uploadFence =

                    eglCreateSyncKHR(eglGetCurrentDisplay(), EGL_SYNC_FENCE_KHR, NULL);

            LOG_ALWAYS_FATAL_IF(uploadFence == EGL_NO_SYNC_KHR, "Could not create sync fence %#x",

                                eglGetError());

            glFlush();

            return uploadFence;

        });



        EGLint waitStatus = eglClientWaitSyncKHR(display, fence, 0, FENCE_TIMEOUT);

        LOG_ALWAYS_FATAL_IF(waitStatus != EGL_CONDITION_SATISFIED_KHR,

                            "Failed to wait for the fence %#x", eglGetError());



        eglDestroySyncKHR(display, fence);

    }



    return sk_sp<Bitmap>(new Bitmap(buffer.get(), bitmap.info()));

}



};  // namespace android::uirenderer

libs/hwui/HardwareBitmapUploader.h

0 → 100644
+28 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 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.

 */



#pragma once



#include <hwui/Bitmap.h>



namespace android::uirenderer {



class HardwareBitmapUploader {

public:

    static sk_sp<Bitmap> allocateHardwareBitmap(const SkBitmap& sourceBitmap);

};



};  // namespace android::uirenderer