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

Commit 9363d332 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Revert "Fix recent apps in system UI for Skia pipeline"" into oc-dev

parents 8b81a0a1 576b6a8a

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;