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

Commit 8572ab42 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 7283897 from ec5a9cc9 to sc-release 

Change-Id: I55f2a6043b29e4423a5e025d350a5df1d8d82e11
parents 2cec1805 ec5a9cc9

libs/binder/tests/binderSafeInterfaceTest.cpp

+14 −14
Original line number Diff line number Diff line
@@ -226,7 +226,7 @@ public: 
        IncrementNativeHandle,

        IncrementNoCopyNoMove,

        IncrementParcelableVector,

        ToUpper,

        DoubleString,

        CallMeBack,

        IncrementInt32,

        IncrementUint32,
@@ -256,7 +256,7 @@ public: 
    virtual status_t increment(const NoCopyNoMove& a, NoCopyNoMove* aPlusOne) const = 0;

    virtual status_t increment(const std::vector<TestParcelable>& a,

                               std::vector<TestParcelable>* aPlusOne) const = 0;

    virtual status_t toUpper(const String8& str, String8* upperStr) const = 0;

    virtual status_t doubleString(const String8& str, String8* doubleStr) const = 0;

    // As mentioned above, sp<IBinder> is already tested by setDeathToken

    virtual void callMeBack(const sp<ICallback>& callback, int32_t a) const = 0;

    virtual status_t increment(int32_t a, int32_t* aPlusOne) const = 0;
@@ -329,9 +329,10 @@ public: 
                                                           std::vector<TestParcelable>*);

        return callRemote<Signature>(Tag::IncrementParcelableVector, a, aPlusOne);

    }

    status_t toUpper(const String8& str, String8* upperStr) const override {

    status_t doubleString(const String8& str, String8* doubleStr) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        return callRemote<decltype(&ISafeInterfaceTest::toUpper)>(Tag::ToUpper, str, upperStr);

        return callRemote<decltype(&ISafeInterfaceTest::doubleString)>(Tag::DoubleString, str,

                                                                       doubleStr);

    }

    void callMeBack(const sp<ICallback>& callback, int32_t a) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);
@@ -454,10 +455,9 @@ public: 
        }

        return NO_ERROR;

    }

    status_t toUpper(const String8& str, String8* upperStr) const override {

    status_t doubleString(const String8& str, String8* doubleStr) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        *upperStr = str;

        upperStr->toUpper();

        *doubleStr = str + str;

        return NO_ERROR;

    }

    void callMeBack(const sp<ICallback>& callback, int32_t a) const override {
@@ -548,8 +548,8 @@ public: 
                                                         std::vector<TestParcelable>*) const;

                return callLocal<Signature>(data, reply, &ISafeInterfaceTest::increment);

            }

            case ISafeInterfaceTest::Tag::ToUpper: {

                return callLocal(data, reply, &ISafeInterfaceTest::toUpper);

            case ISafeInterfaceTest::Tag::DoubleString: {

                return callLocal(data, reply, &ISafeInterfaceTest::doubleString);

            }

            case ISafeInterfaceTest::Tag::CallMeBack: {

                return callLocalAsync(data, reply, &ISafeInterfaceTest::callMeBack);
@@ -726,12 +726,12 @@ TEST_F(SafeInterfaceTest, TestIncremementParcelableVector) { 
    }

}



TEST_F(SafeInterfaceTest, TestToUpper) {

    const String8 str{"Hello, world!"};

    String8 upperStr;

    status_t result = mSafeInterfaceTest->toUpper(str, &upperStr);

TEST_F(SafeInterfaceTest, TestDoubleString) {

    const String8 str{"asdf"};

    String8 doubleStr;

    status_t result = mSafeInterfaceTest->doubleString(str, &doubleStr);

    ASSERT_EQ(NO_ERROR, result);

    ASSERT_TRUE(upperStr == String8{"HELLO, WORLD!"});

    ASSERT_TRUE(doubleStr == String8{"asdfasdf"});

}



TEST_F(SafeInterfaceTest, TestCallMeBack) {

libs/renderengine/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -48,6 +48,7 @@ filegroup { 
    name: "librenderengine_sources",

    srcs: [

        "Description.cpp",

        "ExternalTexture.cpp",

        "Mesh.cpp",

        "RenderEngine.cpp",

        "Texture.cpp",

libs/renderengine/ExternalTexture.cpp

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

 * Copyright 2021 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 <renderengine/ExternalTexture.h>

#include <renderengine/RenderEngine.h>

#include <ui/GraphicBuffer.h>



#include "log/log_main.h"



namespace android::renderengine {



ExternalTexture::ExternalTexture(const sp<GraphicBuffer>& buffer, RenderEngine& renderEngine,

                                 uint32_t usage)

      : mBuffer(buffer), mRenderEngine(renderEngine) {

    LOG_ALWAYS_FATAL_IF(buffer == nullptr,

                        "Attempted to bind a null buffer to an external texture!");

    // GLESRenderEngine has a separate texture cache for output buffers,

    if (usage == Usage::WRITEABLE &&

        (mRenderEngine.getRenderEngineType() == RenderEngine::RenderEngineType::GLES ||

         mRenderEngine.getRenderEngineType() == RenderEngine::RenderEngineType::THREADED)) {

        return;

    }

    mRenderEngine.mapExternalTextureBuffer(mBuffer, usage & Usage::WRITEABLE);

}



ExternalTexture::~ExternalTexture() {

    mRenderEngine.unmapExternalTextureBuffer(mBuffer);

}



} // namespace android::renderengine

libs/renderengine/gl/GLESRenderEngine.cpp

+17 −13
Original line number Diff line number Diff line
@@ -746,7 +746,8 @@ void GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, const sp<Grap 
    return;

}



void GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {

void GLESRenderEngine::mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,

                                                bool /*isRenderable*/) {

    ATRACE_CALL();

    mImageManager->cacheAsync(buffer, nullptr);

}
@@ -797,8 +798,8 @@ status_t GLESRenderEngine::cacheExternalTextureBufferInternal(const sp<GraphicBu 
    return NO_ERROR;

}



void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {

    mImageManager->releaseAsync(bufferId, nullptr);

void GLESRenderEngine::unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {

    mImageManager->releaseAsync(buffer->getId(), nullptr);

}



std::shared_ptr<ImageManager::Barrier> GLESRenderEngine::unbindExternalTextureBufferForTesting(
@@ -1102,7 +1103,7 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer 


status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,

                                      const std::vector<const LayerSettings*>& layers,

                                      const sp<GraphicBuffer>& buffer,

                                      const std::shared_ptr<ExternalTexture>& buffer,

                                      const bool useFramebufferCache, base::unique_fd&& bufferFence,

                                      base::unique_fd* drawFence) {

    ATRACE_CALL();
@@ -1125,7 +1126,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
        return BAD_VALUE;

    }



    validateOutputBufferUsage(buffer);

    validateOutputBufferUsage(buffer->getBuffer());



    std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;

    // Gathering layers that requested blur, we'll need them to decide when to render to an
@@ -1142,11 +1143,13 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 


    if (blurLayersSize == 0) {

        fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this,

                                                              buffer.get()->getNativeBuffer(),

                                                              buffer->getBuffer()

                                                                      .get()

                                                                      ->getNativeBuffer(),

                                                              useFramebufferCache);

        if (fbo->getStatus() != NO_ERROR) {

            ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",

                  buffer->handle);

                  buffer->getBuffer()->handle);

            checkErrors();

            return fbo->getStatus();

        }
@@ -1157,7 +1160,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
                mBlurFilter->setAsDrawTarget(display, blurLayers.front()->backgroundBlurRadius);

        if (status != NO_ERROR) {

            ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",

                  buffer->handle);

                  buffer->getBuffer()->handle);

            checkErrors();

            return status;

        }
@@ -1194,7 +1197,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            auto status = mBlurFilter->prepare();

            if (status != NO_ERROR) {

                ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",

                      buffer->handle);

                      buffer->getBuffer()->handle);

                checkErrors("Can't render first blur pass");

                return status;

            }
@@ -1203,6 +1206,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
                // Done blurring, time to bind the native FBO and render our blur onto it.

                fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this,

                                                                      buffer.get()

                                                                              ->getBuffer()

                                                                              ->getNativeBuffer(),

                                                                      useFramebufferCache);

                status = fbo->getStatus();
@@ -1215,7 +1219,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            }

            if (status != NO_ERROR) {

                ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",

                      buffer->handle);

                      buffer->getBuffer()->handle);

                checkErrors("Can't bind native framebuffer");

                return status;

            }
@@ -1223,7 +1227,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            status = mBlurFilter->render(blurLayersSize > 1);

            if (status != NO_ERROR) {

                ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",

                      buffer->handle);

                      buffer->getBuffer()->handle);

                checkErrors("Can't render blur filter");

                return status;

            }
@@ -1250,7 +1254,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            disableTexture = false;

            isOpaque = layer->source.buffer.isOpaque;



            sp<GraphicBuffer> gBuf = layer->source.buffer.buffer;

            sp<GraphicBuffer> gBuf = layer->source.buffer.buffer->getBuffer();

            validateInputBufferUsage(gBuf);

            bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,

                                      layer->source.buffer.fence);
@@ -1274,7 +1278,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 


            // Do not cache protected EGLImage, protected memory is limited.

            if (gBuf->getUsage() & GRALLOC_USAGE_PROTECTED) {

                unbindExternalTextureBuffer(gBuf->getId());

                unmapExternalTextureBuffer(gBuf);

            }

        }

libs/renderengine/gl/GLESRenderEngine.h

+6 −5
Original line number Diff line number Diff line
@@ -60,16 +60,14 @@ public: 
    void primeCache() override;

    void genTextures(size_t count, uint32_t* names) override;

    void deleteTextures(size_t count, uint32_t const* names) override;

    void cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) EXCLUDES(mRenderingMutex);

    void unbindExternalTextureBuffer(uint64_t bufferId) EXCLUDES(mRenderingMutex);



    bool isProtected() const override { return mInProtectedContext; }

    bool supportsProtectedContent() const override;

    bool useProtectedContext(bool useProtectedContext) override;

    status_t 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) override;

                        const std::shared_ptr<ExternalTexture>& buffer,

                        const bool useFramebufferCache, base::unique_fd&& bufferFence,

                        base::unique_fd* drawFence) override;

    bool cleanupPostRender(CleanupMode mode) override;

    int getContextPriority() override;

    bool supportsBackgroundBlur() override { return mBlurFilter != nullptr; }
@@ -105,6 +103,9 @@ protected: 
            EXCLUDES(mFramebufferImageCacheMutex);

    size_t getMaxTextureSize() const override;

    size_t getMaxViewportDims() const override;

    void mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer, bool isRenderable)

            EXCLUDES(mRenderingMutex);

    void unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) EXCLUDES(mRenderingMutex);



private:

    friend class BindNativeBufferAsFramebuffer;