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

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

Merge changes from topic "IA/IM-3.0-fw" 

* changes:
  gralloc: add allocator and mapper 3.0 support to SF
  gralloc: create a common gralloc interface
  gralloc: move gralloc2 code inside gralloc2
parents f166e913 925bf7fe

libs/ui/Android.bp

+4 −0
Original line number Diff line number Diff line
@@ -60,7 +60,9 @@ cc_library_shared { 
        "Fence.cpp",

        "FenceTime.cpp",

        "FrameStats.cpp",

        "Gralloc.cpp",

        "Gralloc2.cpp",

        "Gralloc3.cpp",

        "GraphicBuffer.cpp",

        "GraphicBufferAllocator.cpp",

        "GraphicBufferMapper.cpp",
@@ -79,9 +81,11 @@ cc_library_shared { 
    shared_libs: [

        "android.frameworks.bufferhub@1.0",

        "android.hardware.graphics.allocator@2.0",

        "android.hardware.graphics.allocator@3.0",

        "android.hardware.graphics.common@1.2",

        "android.hardware.graphics.mapper@2.0",

        "android.hardware.graphics.mapper@2.1",

        "android.hardware.graphics.mapper@3.0",

        "android.hardware.configstore@1.0",

        "android.hardware.configstore-utils",

        "libbase",

libs/ui/Gralloc.cpp

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

 * Copyright 2016 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.

 */



#define LOG_TAG "Gralloc"



#include <ui/Gralloc.h>



namespace android {



GrallocMapper::~GrallocMapper() {}



GrallocAllocator::~GrallocAllocator() {}



} // namespace android

libs/ui/Gralloc2.cpp

+145 −98
Original line number Diff line number Diff line
@@ -27,9 +27,15 @@ 
#include <sync/sync.h>

#pragma clang diagnostic pop



namespace android {

using android::hardware::graphics::allocator::V2_0::IAllocator;

using android::hardware::graphics::common::V1_1::BufferUsage;

using android::hardware::graphics::common::V1_1::PixelFormat;

using android::hardware::graphics::mapper::V2_0::BufferDescriptor;

using android::hardware::graphics::mapper::V2_0::Error;

using android::hardware::graphics::mapper::V2_0::YCbCrLayout;

using android::hardware::graphics::mapper::V2_1::IMapper;



namespace Gralloc2 {

namespace android {



namespace {
@@ -59,17 +65,26 @@ uint64_t getValid11UsageBits() { 
    return valid11UsageBits;

}



static inline IMapper::Rect sGralloc2Rect(const Rect& rect) {

    IMapper::Rect outRect{};

    outRect.left = rect.left;

    outRect.top = rect.top;

    outRect.width = rect.width();

    outRect.height = rect.height();

    return outRect;

}



}  // anonymous namespace



void Mapper::preload() {

void Gralloc2Mapper::preload() {

    android::hardware::preloadPassthroughService<hardware::graphics::mapper::V2_0::IMapper>();

}



Mapper::Mapper()

{

Gralloc2Mapper::Gralloc2Mapper() {

    mMapper = hardware::graphics::mapper::V2_0::IMapper::getService();

    if (mMapper == nullptr) {

        LOG_ALWAYS_FATAL("gralloc-mapper is missing");

        ALOGW("mapper 2.x is not supported");

        return;

    }

    if (mMapper->isRemote()) {

        LOG_ALWAYS_FATAL("gralloc-mapper must be in passthrough mode");
@@ -79,30 +94,37 @@ Mapper::Mapper() 
    mMapperV2_1 = IMapper::castFrom(mMapper);

}



Gralloc2::Error Mapper::validateBufferDescriptorInfo(

        const IMapper::BufferDescriptorInfo& descriptorInfo) const {

bool Gralloc2Mapper::isSupported() const {

    return mMapper != nullptr;

}



status_t Gralloc2Mapper::validateBufferDescriptorInfo(

        IMapper::BufferDescriptorInfo* descriptorInfo) const {

    uint64_t validUsageBits = getValid10UsageBits();

    if (mMapperV2_1 != nullptr) {

        validUsageBits = validUsageBits | getValid11UsageBits();

    }



    if (descriptorInfo.usage & ~validUsageBits) {

    if (descriptorInfo->usage & ~validUsageBits) {

        ALOGE("buffer descriptor contains invalid usage bits 0x%" PRIx64,

              descriptorInfo.usage & ~validUsageBits);

        return Error::BAD_VALUE;

              descriptorInfo->usage & ~validUsageBits);

        return BAD_VALUE;

    }

    return Error::NONE;

    return NO_ERROR;

}



Error Mapper::createDescriptor(

        const IMapper::BufferDescriptorInfo& descriptorInfo,

        BufferDescriptor* outDescriptor) const

{

    Error error = validateBufferDescriptorInfo(descriptorInfo);

    if (error != Error::NONE) {

        return error;

status_t Gralloc2Mapper::createDescriptor(void* bufferDescriptorInfo,

                                          void* outBufferDescriptor) const {

    IMapper::BufferDescriptorInfo* descriptorInfo =

            static_cast<IMapper::BufferDescriptorInfo*>(bufferDescriptorInfo);

    BufferDescriptor* outDescriptor = static_cast<BufferDescriptor*>(outBufferDescriptor);



    status_t status = validateBufferDescriptorInfo(descriptorInfo);

    if (status != NO_ERROR) {

        return status;

    }



    Error error;

    auto hidl_cb = [&](const auto& tmpError, const auto& tmpDescriptor)

                   {

                       error = tmpError;
@@ -115,24 +137,23 @@ Error Mapper::createDescriptor( 


    hardware::Return<void> ret;

    if (mMapperV2_1 != nullptr) {

        ret = mMapperV2_1->createDescriptor_2_1(descriptorInfo, hidl_cb);

        ret = mMapperV2_1->createDescriptor_2_1(*descriptorInfo, hidl_cb);

    } else {

        const hardware::graphics::mapper::V2_0::IMapper::BufferDescriptorInfo info = {

            descriptorInfo.width,

            descriptorInfo.height,

            descriptorInfo.layerCount,

            static_cast<hardware::graphics::common::V1_0::PixelFormat>(descriptorInfo.format),

            descriptorInfo.usage,

                descriptorInfo->width,

                descriptorInfo->height,

                descriptorInfo->layerCount,

                static_cast<hardware::graphics::common::V1_0::PixelFormat>(descriptorInfo->format),

                descriptorInfo->usage,

        };

        ret = mMapper->createDescriptor(info, hidl_cb);

    }



    return (ret.isOk()) ? error : kTransactionError;

    return static_cast<status_t>((ret.isOk()) ? error : kTransactionError);

}



Error Mapper::importBuffer(const hardware::hidl_handle& rawHandle,

        buffer_handle_t* outBufferHandle) const

{

status_t Gralloc2Mapper::importBuffer(const hardware::hidl_handle& rawHandle,

                                      buffer_handle_t* outBufferHandle) const {

    Error error;

    auto ret = mMapper->importBuffer(rawHandle,

            [&](const auto& tmpError, const auto& tmpBuffer)
@@ -145,11 +166,10 @@ Error Mapper::importBuffer(const hardware::hidl_handle& rawHandle, 
                *outBufferHandle = static_cast<buffer_handle_t>(tmpBuffer);

            });



    return (ret.isOk()) ? error : kTransactionError;

    return static_cast<status_t>((ret.isOk()) ? error : kTransactionError);

}



void Mapper::freeBuffer(buffer_handle_t bufferHandle) const

{

void Gralloc2Mapper::freeBuffer(buffer_handle_t bufferHandle) const {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);

    auto ret = mMapper->freeBuffer(buffer);
@@ -158,23 +178,29 @@ void Mapper::freeBuffer(buffer_handle_t bufferHandle) const 
            buffer, error);

}



Error Mapper::validateBufferSize(buffer_handle_t bufferHandle,

        const IMapper::BufferDescriptorInfo& descriptorInfo,

        uint32_t stride) const

{

status_t Gralloc2Mapper::validateBufferSize(buffer_handle_t bufferHandle, uint32_t width,

                                            uint32_t height, android::PixelFormat format,

                                            uint32_t layerCount, uint64_t usage,

                                            uint32_t stride) const {

    if (mMapperV2_1 == nullptr) {

        return Error::NONE;

        return NO_ERROR;

    }



    IMapper::BufferDescriptorInfo descriptorInfo = {};

    descriptorInfo.width = width;

    descriptorInfo.height = height;

    descriptorInfo.layerCount = layerCount;

    descriptorInfo.format = static_cast<hardware::graphics::common::V1_1::PixelFormat>(format);

    descriptorInfo.usage = usage;



    auto buffer = const_cast<native_handle_t*>(bufferHandle);

    auto ret = mMapperV2_1->validateBufferSize(buffer, descriptorInfo, stride);



    return (ret.isOk()) ? static_cast<Error>(ret) : kTransactionError;

    return static_cast<status_t>((ret.isOk()) ? static_cast<Error>(ret) : kTransactionError);

}



void Mapper::getTransportSize(buffer_handle_t bufferHandle,

        uint32_t* outNumFds, uint32_t* outNumInts) const

{

void Gralloc2Mapper::getTransportSize(buffer_handle_t bufferHandle, uint32_t* outNumFds,

                                      uint32_t* outNumInts) const {

    *outNumFds = uint32_t(bufferHandle->numFds);

    *outNumInts = uint32_t(bufferHandle->numInts);
@@ -195,19 +221,17 @@ void Mapper::getTransportSize(buffer_handle_t bufferHandle, 
                *outNumInts = tmpNumInts;

            });



    if (!ret.isOk()) {

        error = kTransactionError;

    }

    ALOGE_IF(error != Error::NONE, "getTransportSize(%p) failed with %d",

            buffer, error);

    error = (ret.isOk()) ? error : kTransactionError;



    ALOGE_IF(error != Error::NONE, "getTransportSize(%p) failed with %d", buffer, error);

}



Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage,

        const IMapper::Rect& accessRegion,

        int acquireFence, void** outData) const

{

status_t Gralloc2Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, const Rect& bounds,

                              int acquireFence, void** outData) const {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    IMapper::Rect accessRegion = sGralloc2Rect(bounds);



    // put acquireFence in a hidl_handle

    hardware::hidl_handle acquireFenceHandle;

    NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0);
@@ -234,15 +258,19 @@ Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, 
        close(acquireFence);

    }



    return (ret.isOk()) ? error : kTransactionError;

    error = (ret.isOk()) ? error : kTransactionError;



    ALOGW_IF(error != Error::NONE, "lock(%p, ...) failed: %d", bufferHandle, error);



    return static_cast<status_t>(error);

}



Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage,

        const IMapper::Rect& accessRegion,

        int acquireFence, YCbCrLayout* outLayout) const

{

status_t Gralloc2Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, const Rect& bounds,

                              int acquireFence, android_ycbcr* ycbcr) const {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    IMapper::Rect accessRegion = sGralloc2Rect(bounds);



    // put acquireFence in a hidl_handle

    hardware::hidl_handle acquireFenceHandle;

    NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0);
@@ -252,6 +280,7 @@ Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, 
        acquireFenceHandle = h;

    }



    YCbCrLayout layout;

    Error error;

    auto ret = mMapper->lockYCbCr(buffer, usage, accessRegion,

            acquireFenceHandle,
@@ -262,19 +291,27 @@ Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, 
                    return;

                }



                *outLayout = tmpLayout;

                layout = tmpLayout;

            });



    if (error == Error::NONE) {

        ycbcr->y = layout.y;

        ycbcr->cb = layout.cb;

        ycbcr->cr = layout.cr;

        ycbcr->ystride = static_cast<size_t>(layout.yStride);

        ycbcr->cstride = static_cast<size_t>(layout.cStride);

        ycbcr->chroma_step = static_cast<size_t>(layout.chromaStep);

    }



    // we own acquireFence even on errors

    if (acquireFence >= 0) {

        close(acquireFence);

    }



    return (ret.isOk()) ? error : kTransactionError;

    return static_cast<status_t>((ret.isOk()) ? error : kTransactionError);

}



int Mapper::unlock(buffer_handle_t bufferHandle) const

{

int Gralloc2Mapper::unlock(buffer_handle_t bufferHandle) const {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    int releaseFence = -1;
@@ -299,10 +336,7 @@ int Mapper::unlock(buffer_handle_t bufferHandle) const 
                }

            });



    if (!ret.isOk()) {

        error = kTransactionError;

    }



    error = (ret.isOk()) ? error : kTransactionError;

    if (error != Error::NONE) {

        ALOGE("unlock(%p) failed with %d", buffer, error);

    }
@@ -310,17 +344,19 @@ int Mapper::unlock(buffer_handle_t bufferHandle) const 
    return releaseFence;

}



Allocator::Allocator(const Mapper& mapper)

    : mMapper(mapper)

{

Gralloc2Allocator::Gralloc2Allocator(const Gralloc2Mapper& mapper) : mMapper(mapper) {

    mAllocator = IAllocator::getService();

    if (mAllocator == nullptr) {

        LOG_ALWAYS_FATAL("gralloc-alloc is missing");

        ALOGW("allocator 2.x is not supported");

        return;

    }

}



std::string Allocator::dumpDebugInfo() const

{

bool Gralloc2Allocator::isSupported() const {

    return mAllocator != nullptr;

}



std::string Gralloc2Allocator::dumpDebugInfo() const {

    std::string debugInfo;



    mAllocator->dumpDebugInfo([&](const auto& tmpDebugInfo) {
@@ -330,23 +366,36 @@ std::string Allocator::dumpDebugInfo() const 
    return debugInfo;

}



Error Allocator::allocate(BufferDescriptor descriptor, uint32_t count,

        uint32_t* outStride, buffer_handle_t* outBufferHandles) const

{

    Error error;

    auto ret = mAllocator->allocate(descriptor, count,

status_t Gralloc2Allocator::allocate(uint32_t width, uint32_t height, PixelFormat format,

                                     uint32_t layerCount, uint64_t usage, uint32_t bufferCount,

                                     uint32_t* outStride, buffer_handle_t* outBufferHandles) const {

    IMapper::BufferDescriptorInfo descriptorInfo = {};

    descriptorInfo.width = width;

    descriptorInfo.height = height;

    descriptorInfo.layerCount = layerCount;

    descriptorInfo.format = static_cast<hardware::graphics::common::V1_1::PixelFormat>(format);

    descriptorInfo.usage = usage;



    BufferDescriptor descriptor;

    status_t error = mMapper.createDescriptor(static_cast<void*>(&descriptorInfo),

                                              static_cast<void*>(&descriptor));

    if (error != NO_ERROR) {

        return error;

    }



    auto ret = mAllocator->allocate(descriptor, bufferCount,

                                    [&](const auto& tmpError, const auto& tmpStride,

                                        const auto& tmpBuffers) {

                error = tmpError;

                                        error = static_cast<status_t>(tmpError);

                                        if (tmpError != Error::NONE) {

                                            return;

                                        }



                                        // import buffers

                for (uint32_t i = 0; i < count; i++) {

                                        for (uint32_t i = 0; i < bufferCount; i++) {

                                            error = mMapper.importBuffer(tmpBuffers[i],

                                                                         &outBufferHandles[i]);

                    if (error != Error::NONE) {

                                            if (error != NO_ERROR) {

                                                for (uint32_t j = 0; j < i; j++) {

                                                    mMapper.freeBuffer(outBufferHandles[j]);

                                                    outBufferHandles[j] = nullptr;
@@ -361,9 +410,7 @@ Error Allocator::allocate(BufferDescriptor descriptor, uint32_t count, 
    // make sure the kernel driver sees BC_FREE_BUFFER and closes the fds now

    hardware::IPCThreadState::self()->flushCommands();



    return (ret.isOk()) ? error : kTransactionError;

    return (ret.isOk()) ? error : static_cast<status_t>(kTransactionError);

}



} // namespace Gralloc2



} // namespace android

libs/ui/Gralloc3.cpp

0 → 100644
+371 −0

File added.

Preview size limit exceeded, changes collapsed.

libs/ui/GraphicBufferAllocator.cpp

+16 −14
Original line number Diff line number Diff line
@@ -29,7 +29,9 @@ 
#include <utils/Singleton.h>

#include <utils/Trace.h>



#include <ui/Gralloc.h>

#include <ui/Gralloc2.h>

#include <ui/Gralloc3.h>

#include <ui/GraphicBufferMapper.h>



namespace android {
@@ -43,11 +45,17 @@ Mutex GraphicBufferAllocator::sLock; 
KeyedVector<buffer_handle_t,

    GraphicBufferAllocator::alloc_rec_t> GraphicBufferAllocator::sAllocList;



GraphicBufferAllocator::GraphicBufferAllocator()

  : mMapper(GraphicBufferMapper::getInstance()),

    mAllocator(std::make_unique<Gralloc2::Allocator>(

                mMapper.getGrallocMapper()))

{

GraphicBufferAllocator::GraphicBufferAllocator() : mMapper(GraphicBufferMapper::getInstance()) {

    mAllocator = std::make_unique<const Gralloc3Allocator>(

            reinterpret_cast<const Gralloc3Mapper&>(mMapper.getGrallocMapper()));

    if (!mAllocator->isSupported()) {

        mAllocator = std::make_unique<const Gralloc2Allocator>(

                reinterpret_cast<const Gralloc2Mapper&>(mMapper.getGrallocMapper()));

    }



    if (!mAllocator->isSupported()) {

        LOG_ALWAYS_FATAL("gralloc-allocator is missing");

    }

}



GraphicBufferAllocator::~GraphicBufferAllocator() {}
@@ -104,15 +112,9 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, 
    // TODO(b/72323293, b/72703005): Remove these invalid bits from callers

    usage &= ~static_cast<uint64_t>((1 << 10) | (1 << 13));



    Gralloc2::IMapper::BufferDescriptorInfo info = {};

    info.width = width;

    info.height = height;

    info.layerCount = layerCount;

    info.format = static_cast<Gralloc2::PixelFormat>(format);

    info.usage = usage;



    Gralloc2::Error error = mAllocator->allocate(info, stride, handle);

    if (error == Gralloc2::Error::NONE) {

    status_t error =

            mAllocator->allocate(width, height, format, layerCount, usage, 1, stride, handle);

    if (error == NO_ERROR) {

        Mutex::Autolock _l(sLock);

        KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);

        uint32_t bpp = bytesPerPixel(format);