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

Commit 576b6a8a authored by John Reck's avatar John Reck
Browse files

Revert "Fix recent apps in system UI for Skia pipeline" 

This reverts commit 625dd56a.

Reason for revert: Caused a memory leak, b/38330767
Bug: 38136140
Bug: 38330767
Test: manual, verified memory isn't leaking doing the steps in b/38330767

Change-Id: I998bea04788d58ba6bad71c1691d5a3b33190c1b
Merged-In: I98b2dfd750be57a15785808e2d5723616e2ce20a
parent 625dd56a

core/jni/android/graphics/Shader.cpp

+3 −6
Original line number Diff line number Diff line
@@ -60,17 +60,14 @@ static void Shader_safeUnref(JNIEnv* env, jobject o, jlong shaderHandle) { 
static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap,

        jint tileModeX, jint tileModeY) {

    const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);

    sk_sp<SkImage> image;

    SkBitmap bitmap;

    if (jbitmap) {

        // Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise,

        // we'll pass an empty SkBitmap to avoid crashing/excepting for compatibility.

        image = android::bitmap::toBitmap(env, jbitmap).makeImage(nullptr);

        android::bitmap::toBitmap(env, jbitmap).getSkBitmapForShaders(&bitmap);

    }



    if (!image.get()) {

        SkBitmap bitmap;

        image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);

    }

    sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);

    sk_sp<SkShader> baseShader = image->makeShader(

            (SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY);

libs/hwui/hwui/Bitmap.cpp

+3 −38
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 
#include "Bitmap.h"



#include "Caches.h"

#include "pipeline/skia/SkiaOpenGLPipeline.h"

#include "renderthread/EglManager.h"

#include "renderthread/RenderThread.h"

#include "renderthread/RenderProxy.h"
@@ -35,15 +34,11 @@ 
#include <private/gui/ComposerService.h>

#include <binder/IServiceManager.h>

#include <ui/PixelFormat.h>

#include <GrTexture.h>



#include <SkCanvas.h>

#include <SkImagePriv.h>



namespace android {



Mutex Bitmap::gLock;



static bool computeAllocationSize(size_t rowBytes, int height, size_t* size) {

    int32_t rowBytes32 = SkToS32(rowBytes);

    int64_t bigSize = (int64_t) height * rowBytes32;
@@ -322,7 +317,8 @@ sk_sp<Bitmap> Bitmap::createFrom(sp<GraphicBuffer> graphicBuffer) { 
        return nullptr;

    }

    SkImageInfo info = SkImageInfo::Make(graphicBuffer->getWidth(), graphicBuffer->getHeight(),

            kRGBA_8888_SkColorType, kPremul_SkAlphaType, SkColorSpace::MakeSRGB());

            kRGBA_8888_SkColorType, kPremul_SkAlphaType,

            SkColorSpace::MakeSRGB());

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

}
@@ -397,7 +393,6 @@ Bitmap::Bitmap(GraphicBuffer* buffer, const SkImageInfo& info) 
    mPixelStorage.hardware.buffer = buffer;

    buffer->incStrong(buffer);

    mRowBytes = bytesPerPixel(buffer->getPixelFormat()) * buffer->getStride();

    setImmutable(); // HW bitmaps are always immutable

}



Bitmap::~Bitmap() {
@@ -491,13 +486,7 @@ void Bitmap::setAlphaType(SkAlphaType 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;

    }
@@ -523,28 +512,4 @@ GraphicBuffer* Bitmap::graphicBuffer() { 
    return nullptr;

}



sk_sp<SkImage> Bitmap::makeImage(const uirenderer::renderthread::RenderThread* renderThread) {

    AutoMutex _lock(gLock); //TODO: implement lock free solution

    auto image = mImage;

    //TODO: use new API SkImage::isValid() instead of SkImage::getTexture()->getContext()

    if (!image.get() || (image->getTexture() && nullptr == image->getTexture()->getContext())) {

        if (isHardware() && uirenderer::RenderPipelineType::SkiaGL

                == uirenderer::Properties::getRenderPipelineType()) {

            //TODO: add Vulkan support

            if (renderThread) {

                image = uirenderer::skiapipeline::SkiaOpenGLPipeline::makeTextureImage(

                        *renderThread, this);

            } else {

                image = uirenderer::renderthread::RenderProxy::makeTextureImage(this);

            }

        } else {

            SkBitmap skiaBitmap;

            getSkBitmapForShaders(&skiaBitmap);

            image = SkMakeImageFromRasterBitmap(skiaBitmap, kNever_SkCopyPixelsMode);

        }

        mImage = image;

    }

    return image;

}



} // namespace android

libs/hwui/hwui/Bitmap.h

+0 −12
Original line number Diff line number Diff line
@@ -22,8 +22,6 @@ 
#include <SkPixelRef.h>

#include <cutils/compiler.h>

#include <ui/GraphicBuffer.h>

#include <utils/Mutex.h>

#include <SkImage.h>



namespace android {
@@ -113,13 +111,6 @@ public: 
    }



    GraphicBuffer* graphicBuffer();



    // makeImage creates or returns a cached SkImage. Can be invoked from UI or render thread.

    // If invoked on the render thread, then RenderThread* argument is required.

    // If not invoked on the render thread, then RenderThread* must be nullptr.

    // makeImage is wrapping a gralloc buffer with an EGLImage and is passing a texture to Skia.

    // This is a temporary implementation until Skia can wrap the gralloc buffer in a SkImage.

    sk_sp<SkImage> makeImage(const uirenderer::renderthread::RenderThread*);

protected:

    virtual bool onNewLockPixels(LockRec* rec) override;

    virtual void onUnlockPixels() override { };
@@ -154,9 +145,6 @@ private: 
            GraphicBuffer* buffer;

        } hardware;

    } mPixelStorage;



    sk_sp<SkImage> mImage;

    static Mutex gLock;

};



} //namespace android
 
 No newline at end of file

libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp

+0 −83
Original line number Diff line number Diff line
@@ -28,8 +28,6 @@ 


#include <cutils/properties.h>

#include <strings.h>

#include <SkImagePriv.h>

#include <gl/GrGLTypes.h>



using namespace android::uirenderer::renderthread;
@@ -199,87 +197,6 @@ void SkiaOpenGLPipeline::invokeFunctor(const RenderThread& thread, Functor* func 
    }

}



static void deleteImageTexture(void* context) {

     EGLImageKHR EGLimage = reinterpret_cast<EGLImageKHR>(context);

     if (EGLimage != EGL_NO_IMAGE_KHR) {

        EGLDisplay display = eglGetCurrentDisplay();

        if (EGL_NO_DISPLAY == display) {

            display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

        }

        eglDestroyImageKHR(display, EGLimage);

     }

}



sk_sp<SkImage> SkiaOpenGLPipeline::makeTextureImage(

        const uirenderer::renderthread::RenderThread& renderThread, Bitmap* bitmap) {

    renderThread.eglManager().initialize();



    GraphicBuffer* buffer = bitmap->graphicBuffer();

    EGLDisplay display = eglGetCurrentDisplay();

    if (EGL_NO_DISPLAY == display) {

        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    }

    LOG_ALWAYS_FATAL_IF(!bitmap->isHardware(),

                "Texture image requires a HW bitmap.");

    // 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();

    EGLint imageAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };

    EGLImageKHR EGLimage = eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,

            clientBuffer, imageAttrs);

    if (EGLimage == EGL_NO_IMAGE_KHR) {

        ALOGW("Could not create EGL image, err =%s",

                uirenderer::renderthread::EglManager::eglErrorString());

        return nullptr;

    }



    GLuint textureId = 0;

    glGenTextures(1, &textureId);

    glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureId);

    glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, EGLimage);



    GLenum status = GL_NO_ERROR;

    while ((status = glGetError()) != GL_NO_ERROR) {

        ALOGW("glEGLImageTargetTexture2DOES failed (%#x)", status);

        eglDestroyImageKHR(display, EGLimage);

        return nullptr;

    }



    sk_sp<GrContext> grContext = sk_ref_sp(renderThread.getGrContext());

    grContext->resetContext();



    GrGLTextureInfo textureInfo;

    textureInfo.fTarget = GL_TEXTURE_EXTERNAL_OES;

    textureInfo.fID = textureId;



    GrBackendTextureDesc textureDescription;

    textureDescription.fWidth = bitmap->info().width();

    textureDescription.fHeight = bitmap->info().height();

    textureDescription.fOrigin = kTopLeft_GrSurfaceOrigin;

    textureDescription.fTextureHandle = reinterpret_cast<GrBackendObject>(&textureInfo);

    PixelFormat format = buffer->getPixelFormat();

    switch (format) {

    case PIXEL_FORMAT_RGBA_8888:

        textureDescription.fConfig = kRGBA_8888_GrPixelConfig;

        break;

    case PIXEL_FORMAT_RGBA_FP16:

        textureDescription.fConfig = kRGBA_half_GrPixelConfig;

        break;

    default:

        eglDestroyImageKHR(display, EGLimage);

        return nullptr;

    }



    // TODO: add color correctness - pass null color space for now

    sk_sp<SkImage> image = SkImage::MakeFromTexture(grContext.get(), textureDescription,

                bitmap->info().alphaType(), nullptr, deleteImageTexture, EGLimage);

    if (!image.get()) {

        eglDestroyImageKHR(display, EGLimage);

        return nullptr;

    }

    return image;

}



} /* namespace skiapipeline */

} /* namespace uirenderer */

} /* namespace android */

libs/hwui/pipeline/skia/SkiaOpenGLPipeline.h

+0 −2
Original line number Diff line number Diff line
@@ -46,8 +46,6 @@ public: 
    bool isContextReady() override;



    static void invokeFunctor(const renderthread::RenderThread& thread, Functor* functor);

    static sk_sp<SkImage> makeTextureImage(

            const uirenderer::renderthread::RenderThread& renderThread, Bitmap* bitmap);



private:

    renderthread::EglManager& mEglManager;