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

Commit 1e77925b authored by Marissa Wall's avatar Marissa Wall
Browse files

gralloc: move gralloc2 code inside gralloc2 

Move Gralloc2 code and types from GraphicBufferAllocator and
GraphicBufferMapper into Gralloc2.h/.cpp.

Bug: 120493579
Test: manual
Change-Id: I1268b0fd1a0645ce3dc4782a23d6d5fe83a4ba27
parent 49a99b9f

libs/ui/Gralloc2.cpp

+120 −77
Original line number Diff line number Diff line
@@ -27,6 +27,12 @@ 
#include <sync/sync.h>

#pragma clang diagnostic pop



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;



namespace android {



namespace Gralloc2 {
@@ -59,6 +65,15 @@ uint64_t getValid11UsageBits() { 
    return valid11UsageBits;

}



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

    Gralloc2::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() {
@@ -79,30 +94,31 @@ Mapper::Mapper() 
    mMapperV2_1 = IMapper::castFrom(mMapper);

}



Gralloc2::Error Mapper::validateBufferDescriptorInfo(

        const IMapper::BufferDescriptorInfo& descriptorInfo) const {

status_t Mapper::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 Mapper::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 +131,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 Mapper::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,7 +160,7 @@ 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
@@ -158,18 +173,24 @@ 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 Mapper::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,
@@ -195,19 +216,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 Mapper::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 +253,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 Mapper::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 +275,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,15 +286,24 @@ 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
@@ -299,10 +332,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);

    }
@@ -330,23 +360,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 Allocator::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,7 +404,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

libs/ui/GraphicBufferAllocator.cpp

+3 −9
Original line number Diff line number Diff line
@@ -104,15 +104,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);

libs/ui/GraphicBufferMapper.cpp

+8 −42
Original line number Diff line number Diff line
@@ -59,22 +59,15 @@ status_t GraphicBufferMapper::importBuffer(buffer_handle_t rawHandle, 
    ATRACE_CALL();



    buffer_handle_t bufferHandle;

    Gralloc2::Error error = mMapper->importBuffer(

            hardware::hidl_handle(rawHandle), &bufferHandle);

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

    status_t error = mMapper->importBuffer(hardware::hidl_handle(rawHandle), &bufferHandle);

    if (error != NO_ERROR) {

        ALOGW("importBuffer(%p) failed: %d", rawHandle, error);

        return static_cast<status_t>(error);

        return error;

    }



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

    info.width = width;

    info.height = height;

    info.layerCount = layerCount;

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

    info.usage = usage;



    error = mMapper->validateBufferSize(bufferHandle, info, stride);

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

    error = mMapper->validateBufferSize(bufferHandle, width, height, format, layerCount, usage,

                                        stride);

    if (error != NO_ERROR) {

        ALOGE("validateBufferSize(%p) failed: %d", rawHandle, error);

        freeBuffer(bufferHandle);

        return static_cast<status_t>(error);
@@ -100,15 +93,6 @@ status_t GraphicBufferMapper::freeBuffer(buffer_handle_t handle) 
    return NO_ERROR;

}



static inline Gralloc2::IMapper::Rect asGralloc2Rect(const Rect& rect) {

    Gralloc2::IMapper::Rect outRect{};

    outRect.left = rect.left;

    outRect.top = rect.top;

    outRect.width = rect.width();

    outRect.height = rect.height();

    return outRect;

}



status_t GraphicBufferMapper::lock(buffer_handle_t handle, uint32_t usage,

        const Rect& bounds, void** vaddr)

{
@@ -146,13 +130,7 @@ status_t GraphicBufferMapper::lockAsync(buffer_handle_t handle, 


    const uint64_t usage = static_cast<uint64_t>(

            android_convertGralloc1To0Usage(producerUsage, consumerUsage));

    Gralloc2::Error error = mMapper->lock(handle, usage,

            asGralloc2Rect(bounds), fenceFd, vaddr);



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

            handle, error);



    return static_cast<status_t>(error);

    return mMapper->lock(handle, usage, bounds, fenceFd, vaddr);

}



status_t GraphicBufferMapper::lockAsyncYCbCr(buffer_handle_t handle,
@@ -160,19 +138,7 @@ status_t GraphicBufferMapper::lockAsyncYCbCr(buffer_handle_t handle, 
{

    ATRACE_CALL();



    Gralloc2::YCbCrLayout layout;

    Gralloc2::Error error = mMapper->lock(handle, usage,

            asGralloc2Rect(bounds), fenceFd, &layout);

    if (error == Gralloc2::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);

    }



    return static_cast<status_t>(error);

    return mMapper->lock(handle, usage, bounds, fenceFd, ycbcr);

}



status_t GraphicBufferMapper::unlockAsync(buffer_handle_t handle, int *fenceFd)

libs/ui/include/ui/Gralloc2.h

+17 −47
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 
#include <android/hardware/graphics/common/1.1/types.h>

#include <android/hardware/graphics/mapper/2.0/IMapper.h>

#include <android/hardware/graphics/mapper/2.1/IMapper.h>

#include <ui/PixelFormat.h>

#include <ui/Rect.h>

#include <utils/StrongPointer.h>



namespace android {
@@ -30,12 +32,7 @@ namespace android { 
namespace Gralloc2 {



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

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

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

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

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

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

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



// A wrapper to IMapper

class Mapper {
@@ -44,21 +41,19 @@ public: 


    Mapper();



    Error createDescriptor(

            const IMapper::BufferDescriptorInfo& descriptorInfo,

            BufferDescriptor* outDescriptor) const;

    status_t createDescriptor(void* bufferDescriptorInfo, void* outBufferDescriptor) const;



    // Import a buffer that is from another HAL, another process, or is

    // cloned.

    //

    // The returned handle must be freed with freeBuffer.

    Error importBuffer(const hardware::hidl_handle& rawHandle,

    status_t importBuffer(const hardware::hidl_handle& rawHandle,

                          buffer_handle_t* outBufferHandle) const;



    void freeBuffer(buffer_handle_t bufferHandle) const;



    Error validateBufferSize(buffer_handle_t bufferHandle,

            const IMapper::BufferDescriptorInfo& descriptorInfo,

    status_t validateBufferSize(buffer_handle_t bufferHandle, uint32_t width, uint32_t height,

                                android::PixelFormat format, uint32_t layerCount, uint64_t usage,

                                uint32_t stride) const;



    void getTransportSize(buffer_handle_t bufferHandle,
@@ -66,15 +61,13 @@ public: 


    // The ownership of acquireFence is always transferred to the callee, even

    // on errors.

    Error lock(buffer_handle_t bufferHandle, uint64_t usage,

            const IMapper::Rect& accessRegion,

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

                  int acquireFence, void** outData) const;



    // The ownership of acquireFence is always transferred to the callee, even

    // on errors.

    Error lock(buffer_handle_t bufferHandle, uint64_t usage,

            const IMapper::Rect& accessRegion,

            int acquireFence, YCbCrLayout* outLayout) const;

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

                  int acquireFence, android_ycbcr* ycbcr) const;



    // unlock returns a fence sync object (or -1) and the fence sync object is

    // owned by the caller
@@ -82,8 +75,7 @@ public: 


private:

    // Determines whether the passed info is compatible with the mapper.

    Error validateBufferDescriptorInfo(

            const IMapper::BufferDescriptorInfo& descriptorInfo) const;

    status_t validateBufferDescriptorInfo(IMapper::BufferDescriptorInfo* descriptorInfo) const;



    sp<hardware::graphics::mapper::V2_0::IMapper> mMapper;

    sp<IMapper> mMapperV2_1;
@@ -101,33 +93,11 @@ public: 
    /*

     * The returned buffers are already imported and must not be imported

     * again.  outBufferHandles must point to a space that can contain at

     * least "count" buffer_handle_t.

     * least "bufferCount" buffer_handle_t.

     */

    Error allocate(BufferDescriptor descriptor, uint32_t count,

            uint32_t* outStride, buffer_handle_t* outBufferHandles) const;



    Error allocate(BufferDescriptor descriptor,

            uint32_t* outStride, buffer_handle_t* outBufferHandle) const

    {

        return allocate(descriptor, 1, outStride, outBufferHandle);

    }



    Error allocate(const IMapper::BufferDescriptorInfo& descriptorInfo, uint32_t count,

            uint32_t* outStride, buffer_handle_t* outBufferHandles) const

    {

        BufferDescriptor descriptor;

        Error error = mMapper.createDescriptor(descriptorInfo, &descriptor);

        if (error == Error::NONE) {

            error = allocate(descriptor, count, outStride, outBufferHandles);

        }

        return error;

    }



    Error allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,

            uint32_t* outStride, buffer_handle_t* outBufferHandle) const

    {

        return allocate(descriptorInfo, 1, outStride, outBufferHandle);

    }

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



private:

    const Mapper& mMapper;