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

Commit 4e36f6e2 authored by Dan Stoza's avatar Dan Stoza Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'gralloc1' into nyc-mr1-dev 

* changes:
  libui: Convert Allocator and Mapper to gralloc1
  libui: Adds C++ shim for gralloc1
  libui: Add Gralloc1On0Adapter
parents 4931fb29 8deb4da6

include/ui/Gralloc1.h

0 → 100644
+238 −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.

 */



#ifndef ANDROID_UI_GRALLOC1_H

#define ANDROID_UI_GRALLOC1_H



#define GRALLOC1_LOG_TAG "Gralloc1"



#include <ui/Gralloc1On0Adapter.h>



#include <unordered_set>



namespace std {

    template <>

    struct hash<gralloc1_capability_t> {

        size_t operator()(gralloc1_capability_t capability) const {

            return std::hash<int32_t>()(static_cast<int32_t>(capability));

        }

    };

}



namespace android {



class Fence;

class GraphicBuffer;



namespace Gralloc1 {



class Device;



class Descriptor {

public:

    Descriptor(Device& device, gralloc1_buffer_descriptor_t deviceId)

      : mShimDevice(device),

        mDeviceId(deviceId),

        mWidth(0),

        mHeight(0),

        mFormat(static_cast<android_pixel_format_t>(0)),

        mProducerUsage(GRALLOC1_PRODUCER_USAGE_NONE),

        mConsumerUsage(GRALLOC1_CONSUMER_USAGE_NONE) {}



    ~Descriptor();



    gralloc1_buffer_descriptor_t getDeviceId() const { return mDeviceId; }



    gralloc1_error_t setDimensions(uint32_t width, uint32_t height);

    gralloc1_error_t setFormat(android_pixel_format_t format);

    gralloc1_error_t setProducerUsage(gralloc1_producer_usage_t usage);

    gralloc1_error_t setConsumerUsage(gralloc1_consumer_usage_t usage);



private:

    Device& mShimDevice;

    const gralloc1_buffer_descriptor_t mDeviceId;



    uint32_t mWidth;

    uint32_t mHeight;

    android_pixel_format_t mFormat;

    gralloc1_producer_usage_t mProducerUsage;

    gralloc1_consumer_usage_t mConsumerUsage;



}; // Descriptor



class Device {

    friend class Gralloc1::Descriptor;



public:

    Device(gralloc1_device_t* device);



    bool hasCapability(gralloc1_capability_t capability) const;



    std::string dump();



    std::shared_ptr<Descriptor> createDescriptor();



    gralloc1_error_t getStride(buffer_handle_t buffer, uint32_t* outStride);



    gralloc1_error_t allocate(

            const std::vector<std::shared_ptr<const Descriptor>>& descriptors,

            std::vector<buffer_handle_t>* outBuffers);

    gralloc1_error_t allocate(

            const std::shared_ptr<const Descriptor>& descriptor,

            gralloc1_backing_store_t id, buffer_handle_t* outBuffer);



    gralloc1_error_t retain(buffer_handle_t buffer);

    gralloc1_error_t retain(const GraphicBuffer* buffer);



    gralloc1_error_t release(buffer_handle_t buffer);



    gralloc1_error_t getNumFlexPlanes(buffer_handle_t buffer,

            uint32_t* outNumPlanes);



    gralloc1_error_t lock(buffer_handle_t buffer,

            gralloc1_producer_usage_t producerUsage,

            gralloc1_consumer_usage_t consumerUsage,

            const gralloc1_rect_t* accessRegion, void** outData,

            const sp<Fence>& acquireFence);

    gralloc1_error_t lockFlex(buffer_handle_t buffer,

            gralloc1_producer_usage_t producerUsage,

            gralloc1_consumer_usage_t consumerUsage,

            const gralloc1_rect_t* accessRegion,

            struct android_flex_layout* outData, const sp<Fence>& acquireFence);

    gralloc1_error_t lockYCbCr(buffer_handle_t buffer,

            gralloc1_producer_usage_t producerUsage,

            gralloc1_consumer_usage_t consumerUsage,

            const gralloc1_rect_t* accessRegion, struct android_ycbcr* outData,

            const sp<Fence>& acquireFence);



    gralloc1_error_t unlock(buffer_handle_t buffer, sp<Fence>* outFence);



private:

    std::unordered_set<gralloc1_capability_t> loadCapabilities();



    bool loadFunctions();



    template <typename LockType, typename OutType>

    gralloc1_error_t lockHelper(LockType pfn, buffer_handle_t buffer,

            gralloc1_producer_usage_t producerUsage,

            gralloc1_consumer_usage_t consumerUsage,

            const gralloc1_rect_t* accessRegion, OutType* outData,

            const sp<Fence>& acquireFence) {

        int32_t intError = pfn(mDevice, buffer,

                static_cast<uint64_t>(producerUsage),

                static_cast<uint64_t>(consumerUsage), accessRegion, outData,

                acquireFence->dup());

        return static_cast<gralloc1_error_t>(intError);

    }



    gralloc1_device_t* const mDevice;



    const std::unordered_set<gralloc1_capability_t> mCapabilities;



    template <typename PFN, gralloc1_function_descriptor_t descriptor>

    struct FunctionLoader {

        FunctionLoader() : pfn(nullptr) {}



        bool load(gralloc1_device_t* device, bool errorIfNull) {

            gralloc1_function_pointer_t rawPointer =

                    device->getFunction(device, descriptor);

            pfn = reinterpret_cast<PFN>(rawPointer);

            if (errorIfNull && !rawPointer) {

                ALOG(LOG_ERROR, GRALLOC1_LOG_TAG,

                        "Failed to load function pointer %d", descriptor);

            }

            return rawPointer != nullptr;

        }



        template <typename ...Args>

        typename std::result_of<PFN(Args...)>::type operator()(Args... args) {

            return pfn(args...);

        }



        PFN pfn;

    };



    // Function pointers

    struct Functions {

        FunctionLoader<GRALLOC1_PFN_DUMP, GRALLOC1_FUNCTION_DUMP> dump;

        FunctionLoader<GRALLOC1_PFN_CREATE_DESCRIPTOR,

                GRALLOC1_FUNCTION_CREATE_DESCRIPTOR> createDescriptor;

        FunctionLoader<GRALLOC1_PFN_DESTROY_DESCRIPTOR,

                GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR> destroyDescriptor;

        FunctionLoader<GRALLOC1_PFN_SET_CONSUMER_USAGE,

                GRALLOC1_FUNCTION_SET_CONSUMER_USAGE> setConsumerUsage;

        FunctionLoader<GRALLOC1_PFN_SET_DIMENSIONS,

                GRALLOC1_FUNCTION_SET_DIMENSIONS> setDimensions;

        FunctionLoader<GRALLOC1_PFN_SET_FORMAT,

                GRALLOC1_FUNCTION_SET_FORMAT> setFormat;

        FunctionLoader<GRALLOC1_PFN_SET_PRODUCER_USAGE,

                GRALLOC1_FUNCTION_SET_PRODUCER_USAGE> setProducerUsage;

        FunctionLoader<GRALLOC1_PFN_GET_BACKING_STORE,

                GRALLOC1_FUNCTION_GET_BACKING_STORE> getBackingStore;

        FunctionLoader<GRALLOC1_PFN_GET_CONSUMER_USAGE,

                GRALLOC1_FUNCTION_GET_CONSUMER_USAGE> getConsumerUsage;

        FunctionLoader<GRALLOC1_PFN_GET_DIMENSIONS,

                GRALLOC1_FUNCTION_GET_DIMENSIONS> getDimensions;

        FunctionLoader<GRALLOC1_PFN_GET_FORMAT,

                GRALLOC1_FUNCTION_GET_FORMAT> getFormat;

        FunctionLoader<GRALLOC1_PFN_GET_PRODUCER_USAGE,

                GRALLOC1_FUNCTION_GET_PRODUCER_USAGE> getProducerUsage;

        FunctionLoader<GRALLOC1_PFN_GET_STRIDE,

                GRALLOC1_FUNCTION_GET_STRIDE> getStride;

        FunctionLoader<GRALLOC1_PFN_ALLOCATE,

                GRALLOC1_FUNCTION_ALLOCATE> allocate;

        FunctionLoader<GRALLOC1_PFN_RETAIN,

                GRALLOC1_FUNCTION_RETAIN> retain;

        FunctionLoader<GRALLOC1_PFN_RELEASE,

                GRALLOC1_FUNCTION_RELEASE> release;

        FunctionLoader<GRALLOC1_PFN_GET_NUM_FLEX_PLANES,

                GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES> getNumFlexPlanes;

        FunctionLoader<GRALLOC1_PFN_LOCK,

                GRALLOC1_FUNCTION_LOCK> lock;

        FunctionLoader<GRALLOC1_PFN_LOCK_FLEX,

                GRALLOC1_FUNCTION_LOCK_FLEX> lockFlex;

        FunctionLoader<GRALLOC1_PFN_LOCK_YCBCR,

                GRALLOC1_FUNCTION_LOCK_YCBCR> lockYCbCr;

        FunctionLoader<GRALLOC1_PFN_UNLOCK,

                GRALLOC1_FUNCTION_UNLOCK> unlock;



        // Adapter-only functions

        FunctionLoader<GRALLOC1_PFN_RETAIN_GRAPHIC_BUFFER,

                GRALLOC1_FUNCTION_RETAIN_GRAPHIC_BUFFER> retainGraphicBuffer;

        FunctionLoader<GRALLOC1_PFN_ALLOCATE_WITH_ID,

                GRALLOC1_FUNCTION_ALLOCATE_WITH_ID> allocateWithId;

    } mFunctions;



}; // class android::Gralloc1::Device



class Loader

{

public:

    Loader();

    ~Loader();



    std::unique_ptr<Device> getDevice();



private:

    static std::unique_ptr<Gralloc1On0Adapter> mAdapter;

    std::unique_ptr<Device> mDevice;

};



} // namespace android::Gralloc1



} // namespace android



#endif

include/ui/Gralloc1On0Adapter.h

0 → 100644
+478 −0

File added.

Preview size limit exceeded, changes collapsed.

include/ui/GraphicBufferAllocator.h

+19 −19
Original line number Diff line number Diff line
@@ -27,42 +27,41 @@ 
#include <utils/threads.h>

#include <utils/Singleton.h>



#include <ui/Gralloc1.h>

#include <ui/PixelFormat.h>



#include <hardware/gralloc.h>





namespace android {

// ---------------------------------------------------------------------------



class Gralloc1Loader;

class String8;



class GraphicBufferAllocator : public Singleton<GraphicBufferAllocator>

{

public:

    enum {

        USAGE_SW_READ_NEVER     = GRALLOC_USAGE_SW_READ_NEVER,

        USAGE_SW_READ_RARELY    = GRALLOC_USAGE_SW_READ_RARELY,

        USAGE_SW_READ_OFTEN     = GRALLOC_USAGE_SW_READ_OFTEN,

        USAGE_SW_READ_MASK      = GRALLOC_USAGE_SW_READ_MASK,

        USAGE_SW_READ_NEVER     = GRALLOC1_CONSUMER_USAGE_CPU_READ_NEVER,

        USAGE_SW_READ_RARELY    = GRALLOC1_CONSUMER_USAGE_CPU_READ,

        USAGE_SW_READ_OFTEN     = GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN,

        USAGE_SW_READ_MASK      = GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN,



        USAGE_SW_WRITE_NEVER    = GRALLOC_USAGE_SW_WRITE_NEVER,

        USAGE_SW_WRITE_RARELY   = GRALLOC_USAGE_SW_WRITE_RARELY,

        USAGE_SW_WRITE_OFTEN    = GRALLOC_USAGE_SW_WRITE_OFTEN,

        USAGE_SW_WRITE_MASK     = GRALLOC_USAGE_SW_WRITE_MASK,

        USAGE_SW_WRITE_NEVER    = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_NEVER,

        USAGE_SW_WRITE_RARELY   = GRALLOC1_PRODUCER_USAGE_CPU_WRITE,

        USAGE_SW_WRITE_OFTEN    = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN,

        USAGE_SW_WRITE_MASK     = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN,



        USAGE_SOFTWARE_MASK     = USAGE_SW_READ_MASK|USAGE_SW_WRITE_MASK,



        USAGE_HW_TEXTURE        = GRALLOC_USAGE_HW_TEXTURE,

        USAGE_HW_RENDER         = GRALLOC_USAGE_HW_RENDER,

        USAGE_HW_2D             = GRALLOC_USAGE_HW_2D,

        USAGE_HW_MASK           = GRALLOC_USAGE_HW_MASK

        USAGE_HW_TEXTURE        = GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE,

        USAGE_HW_RENDER         = GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET,

        USAGE_HW_2D             = 0x00000400, // Deprecated

        USAGE_HW_MASK           = 0x00071F00, // Deprecated

    };



    static inline GraphicBufferAllocator& get() { return getInstance(); }



    status_t alloc(uint32_t w, uint32_t h, PixelFormat format, uint32_t usage,

            buffer_handle_t* handle, uint32_t* stride);

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

            uint32_t usage, buffer_handle_t* handle, uint32_t* stride,

            uint64_t graphicBufferId);



    status_t free(buffer_handle_t handle);
@@ -86,7 +85,8 @@ private: 
    GraphicBufferAllocator();

    ~GraphicBufferAllocator();



    alloc_device_t  *mAllocDev;

    std::unique_ptr<Gralloc1::Loader> mLoader;

    std::unique_ptr<Gralloc1::Device> mDevice;

};



// ---------------------------------------------------------------------------

include/ui/GraphicBufferMapper.h

+7 −9
Original line number Diff line number Diff line
@@ -20,12 +20,9 @@ 
#include <stdint.h>

#include <sys/types.h>



#include <utils/Singleton.h>



#include <hardware/gralloc.h>

#include <ui/Gralloc1.h>





struct gralloc_module_t;

#include <utils/Singleton.h>



namespace android {
@@ -39,6 +36,7 @@ public: 
    static inline GraphicBufferMapper& get() { return getInstance(); }



    status_t registerBuffer(buffer_handle_t handle);

    status_t registerBuffer(const GraphicBuffer* buffer);



    status_t unregisterBuffer(buffer_handle_t handle);
@@ -59,13 +57,13 @@ public: 


    status_t unlockAsync(buffer_handle_t handle, int *fenceFd);



    // dumps information about the mapping of this handle

    void dump(buffer_handle_t handle);



private:

    friend class Singleton<GraphicBufferMapper>;



    GraphicBufferMapper();

    gralloc_module_t const *mAllocMod;



    std::unique_ptr<Gralloc1::Loader> mLoader;

    std::unique_ptr<Gralloc1::Device> mDevice;

};



// ---------------------------------------------------------------------------

libs/ui/Android.mk

+3 −1
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ include $(CLEAR_VARS) 


LOCAL_CLANG := true

LOCAL_CPPFLAGS := -std=c++1y -Weverything -Werror

LOCAL_SANITIZE := integer

# LOCAL_SANITIZE := integer



# The static constructors and destructors in this library have not been noted to

# introduce significant overheads
@@ -37,6 +37,8 @@ LOCAL_CPPFLAGS += -Wno-padded 
LOCAL_SRC_FILES := \

	Fence.cpp \

	FrameStats.cpp \

	Gralloc1.cpp \

	Gralloc1On0Adapter.cpp \

	GraphicBuffer.cpp \

	GraphicBufferAllocator.cpp \

	GraphicBufferMapper.cpp \