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

Commit 7f7311e3 authored by Chris Forbes's avatar Chris Forbes Committed by android-build-merger
Browse files

ui: Rework GraphicBuffer + Allocator for 64bit usage 

am: 82c04984

Change-Id: I3d036f07a8ee8a50aebeea700bc43933eb349443
parents 8dfcec80 82c04984

include/ui/GraphicBuffer.h

+9 −11
Original line number Diff line number Diff line
@@ -81,8 +81,8 @@ public: 
    // Create a GraphicBuffer by allocating and managing a buffer internally.

    // This function is privileged.  See reallocate for details.

    GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,

            uint32_t inLayerCount, uint64_t inProducerUsage,

            uint64_t inConsumerUsage, std::string requestorName = "<Unknown>");

            uint32_t inLayerCount, uint64_t inUsage,

            std::string requestorName = "<Unknown>");



    // Create a GraphicBuffer from an existing handle.

    enum HandleWrapMethod : uint8_t {
@@ -120,16 +120,15 @@ public: 
    GraphicBuffer(const native_handle_t* handle, HandleWrapMethod method,

            uint32_t width, uint32_t height,

            PixelFormat format, uint32_t layerCount,

            uint64_t producerUsage, uint64_t consumerUsage, uint32_t stride);

            uint64_t usage, uint32_t stride);



    // These functions are deprecated because they do not distinguish producer

    // and consumer usages.

    // These functions are deprecated because they only take 32 bits of usage

    GraphicBuffer(const native_handle_t* handle, HandleWrapMethod method,

            uint32_t width, uint32_t height,

            PixelFormat format, uint32_t layerCount,

            uint32_t usage, uint32_t stride)

        : GraphicBuffer(handle, method, width, height, format, layerCount,

                usage, usage, stride) {}

                static_cast<uint64_t>(usage), stride) {}

    GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,

            uint32_t inLayerCount, uint32_t inUsage, uint32_t inStride,

            native_handle_t* inHandle, bool keepOwnership);
@@ -157,10 +156,10 @@ public: 
    // device or service, which usually involves adding suitable selinux

    // rules.

    status_t reallocate(uint32_t inWidth, uint32_t inHeight,

            PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage);

            PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage);



    bool needsReallocation(uint32_t inWidth, uint32_t inHeight,

            PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage);

            PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage);



    status_t lock(uint32_t inUsage, void** vaddr);

    status_t lock(uint32_t inUsage, const Rect& rect, void** vaddr);
@@ -219,13 +218,12 @@ private: 


    status_t initWithSize(uint32_t inWidth, uint32_t inHeight,

            PixelFormat inFormat, uint32_t inLayerCount,

            uint64_t inProducerUsage, uint64_t inConsumerUsage,

            std::string requestorName);

            uint64_t inUsage, std::string requestorName);



    status_t initWithHandle(const native_handle_t* handle,

            HandleWrapMethod method, uint32_t width, uint32_t height,

            PixelFormat format, uint32_t layerCount,

            uint64_t producerUsage, uint64_t consumerUsage, uint32_t stride);

            uint64_t usage, uint32_t stride);



    void free_handle();

include/ui/GraphicBufferAllocator.h

+2 −3
Original line number Diff line number Diff line
@@ -49,7 +49,7 @@ public: 
    static inline GraphicBufferAllocator& get() { return getInstance(); }



    status_t allocate(uint32_t w, uint32_t h, PixelFormat format,

            uint32_t layerCount, uint64_t producerUsage, uint64_t consumerUsage,

            uint32_t layerCount, uint64_t usage,

            buffer_handle_t* handle, uint32_t* stride, uint64_t graphicBufferId,

            std::string requestorName);
@@ -65,8 +65,7 @@ private: 
        uint32_t stride;

        PixelFormat format;

        uint32_t layerCount;

        uint64_t producerUsage;

        uint64_t consumerUsage;

        uint64_t usage;

        size_t size;

        std::string requestorName;

    };

libs/ui/GraphicBuffer.cpp

+17 −19
Original line number Diff line number Diff line
@@ -59,18 +59,18 @@ GraphicBuffer::GraphicBuffer() 
// deprecated

GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight,

        PixelFormat inFormat, uint32_t inUsage, std::string requestorName)

    : GraphicBuffer(inWidth, inHeight, inFormat, 1, inUsage, inUsage,

    : GraphicBuffer(inWidth, inHeight, inFormat, 1, static_cast<uint64_t>(inUsage),

            requestorName)

{

}



GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight,

        PixelFormat inFormat, uint32_t inLayerCount, uint64_t producerUsage,

        uint64_t consumerUsage, std::string requestorName)

        PixelFormat inFormat, uint32_t inLayerCount, uint64_t usage,

        std::string requestorName)

    : GraphicBuffer()

{

    mInitCheck = initWithSize(inWidth, inHeight, inFormat, inLayerCount,

            producerUsage, consumerUsage, std::move(requestorName));

            usage, std::move(requestorName));

}



// deprecated
@@ -78,7 +78,7 @@ GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight, 
        PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage,

        uint32_t inStride, native_handle_t* inHandle, bool keepOwnership)

    : GraphicBuffer(inHandle, keepOwnership ? TAKE_HANDLE : WRAP_HANDLE,

            inWidth, inHeight, inFormat, inLayerCount, inUsage, inUsage,

            inWidth, inHeight, inFormat, inLayerCount, static_cast<uint64_t>(inUsage),

            inStride)

{

}
@@ -86,12 +86,12 @@ GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight, 
GraphicBuffer::GraphicBuffer(const native_handle_t* handle,

        HandleWrapMethod method, uint32_t width, uint32_t height,

        PixelFormat format, uint32_t layerCount,

        uint64_t producerUsage, uint64_t consumerUsage,

        uint64_t usage,

        uint32_t stride)

    : GraphicBuffer()

{

    mInitCheck = initWithHandle(handle, method, width, height, format,

            layerCount, producerUsage, consumerUsage, stride);

            layerCount, usage, stride);

}



GraphicBuffer::~GraphicBuffer()
@@ -129,7 +129,7 @@ ANativeWindowBuffer* GraphicBuffer::getNativeBuffer() const 
}



status_t GraphicBuffer::reallocate(uint32_t inWidth, uint32_t inHeight,

        PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage)

        PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage)

{

    if (mOwner != ownData)

        return INVALID_OPERATION;
@@ -148,11 +148,11 @@ status_t GraphicBuffer::reallocate(uint32_t inWidth, uint32_t inHeight, 
        handle = 0;

    }

    return initWithSize(inWidth, inHeight, inFormat, inLayerCount,

            inUsage, inUsage, "[Reallocation]");

            inUsage, "[Reallocation]");

}



bool GraphicBuffer::needsReallocation(uint32_t inWidth, uint32_t inHeight,

        PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage)

        PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage)

{

    if (static_cast<int>(inWidth) != width) return true;

    if (static_cast<int>(inHeight) != height) return true;
@@ -163,20 +163,20 @@ bool GraphicBuffer::needsReallocation(uint32_t inWidth, uint32_t inHeight, 
}



status_t GraphicBuffer::initWithSize(uint32_t inWidth, uint32_t inHeight,

        PixelFormat inFormat, uint32_t inLayerCount, uint64_t inProducerUsage,

        uint64_t inConsumerUsage, std::string requestorName)

        PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage,

        std::string requestorName)

{

    GraphicBufferAllocator& allocator = GraphicBufferAllocator::get();

    uint32_t outStride = 0;

    status_t err = allocator.allocate(inWidth, inHeight, inFormat, inLayerCount,

            inProducerUsage, inConsumerUsage, &handle, &outStride, mId,

            inUsage, &handle, &outStride, mId,

            std::move(requestorName));

    if (err == NO_ERROR) {

        width = static_cast<int>(inWidth);

        height = static_cast<int>(inHeight);

        format = inFormat;

        layerCount = inLayerCount;

        usage = android_convertGralloc1To0Usage(inProducerUsage, inConsumerUsage);

        usage = static_cast<int>(inUsage);

        stride = static_cast<int>(outStride);

    }

    return err;
@@ -184,16 +184,14 @@ status_t GraphicBuffer::initWithSize(uint32_t inWidth, uint32_t inHeight, 


status_t GraphicBuffer::initWithHandle(const native_handle_t* handle,

        HandleWrapMethod method, uint32_t width, uint32_t height,

        PixelFormat format, uint32_t layerCount,

        uint64_t producerUsage, uint64_t consumerUsage,

        PixelFormat format, uint32_t layerCount, uint64_t usage,

        uint32_t stride)

{

    ANativeWindowBuffer::width  = static_cast<int>(width);

    ANativeWindowBuffer::height = static_cast<int>(height);

    ANativeWindowBuffer::stride = static_cast<int>(stride);

    ANativeWindowBuffer::format = format;

    ANativeWindowBuffer::usage  =

        android_convertGralloc1To0Usage(producerUsage, consumerUsage);

    ANativeWindowBuffer::usage  = static_cast<int>(usage);



    ANativeWindowBuffer::layerCount = layerCount;
@@ -203,7 +201,7 @@ status_t GraphicBuffer::initWithHandle(const native_handle_t* handle, 
        buffer_handle_t importedHandle;

        status_t err = mBufferMapper.importBuffer(handle, &importedHandle);

        if (err != NO_ERROR) {

            initWithHandle(nullptr, WRAP_HANDLE, 0, 0, 0, 0, 0, 0, 0);

            initWithHandle(nullptr, WRAP_HANDLE, 0, 0, 0, 0, 0, 0);



            return err;

        }

libs/ui/GraphicBufferAllocator.cpp

+11 −15
Original line number Diff line number Diff line
@@ -64,18 +64,16 @@ void GraphicBufferAllocator::dump(String8& result) const 
        const alloc_rec_t& rec(list.valueAt(i));

        if (rec.size) {

            snprintf(buffer, SIZE, "%10p: %7.2f KiB | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64

                    ", 0x%" PRIx64 " | %s\n",

                    " | %s\n",

                    list.keyAt(i), rec.size/1024.0,

                    rec.width, rec.stride, rec.height, rec.layerCount, rec.format,

                    rec.producerUsage, rec.consumerUsage,

                    rec.requestorName.c_str());

                    rec.usage, rec.requestorName.c_str());

        } else {

            snprintf(buffer, SIZE, "%10p: unknown     | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64

                    ", 0x%" PRIx64 " | %s\n",

                    " | %s\n",

                    list.keyAt(i),

                    rec.width, rec.stride, rec.height, rec.layerCount, rec.format,

                    rec.producerUsage, rec.consumerUsage,

                    rec.requestorName.c_str());

                    rec.usage, rec.requestorName.c_str());

        }

        result.append(buffer);

        total += rec.size;
@@ -95,8 +93,8 @@ void GraphicBufferAllocator::dumpToSystemLog() 
}



status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height,

        PixelFormat format, uint32_t layerCount, uint64_t producerUsage,

        uint64_t consumerUsage, buffer_handle_t* handle, uint32_t* stride,

        PixelFormat format, uint32_t layerCount, uint64_t usage,

        buffer_handle_t* handle, uint32_t* stride,

        uint64_t /*graphicBufferId*/, std::string requestorName)

{

    ATRACE_CALL();
@@ -115,8 +113,7 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, 
    info.height = height;

    info.layerCount = layerCount;

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

    info.usage = static_cast<uint64_t>(android_convertGralloc1To0Usage(

                producerUsage, consumerUsage));

    info.usage = usage;



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

    if (error == Gralloc2::Error::NONE) {
@@ -129,8 +126,7 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, 
        rec.stride = *stride;

        rec.format = format;

        rec.layerCount = layerCount;

        rec.producerUsage = producerUsage;

        rec.consumerUsage = consumerUsage;

        rec.usage = usage;

        rec.size = static_cast<size_t>(height * (*stride) * bpp);

        rec.requestorName = std::move(requestorName);

        list.add(*handle, rec);
@@ -138,9 +134,9 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, 
        return NO_ERROR;

    } else {

        ALOGE("Failed to allocate (%u x %u) layerCount %u format %d "

                "producerUsage %" PRIx64 " consumerUsage %" PRIx64 ": %d",

                width, height, layerCount, format, producerUsage,

                consumerUsage, error);

                "usage %" PRIx64 ": %d",

                width, height, layerCount, format, usage,

                error);

        return NO_MEMORY;

    }

}