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

Commit 92c696dd authored by Mathias Agopian's avatar Mathias Agopian Committed by android-build-merger
Browse files

Plumb gralloc producer/consumer bits correctly 

am: 2c38b56d

Change-Id: If11a52165cf5012b66b07ae4a81bd55a8bc5249b
parents 2b463dda 2c38b56d

libs/nativewindow/AHardwareBuffer.cpp

+44 −133
Original line number Diff line number Diff line
@@ -27,10 +27,9 @@ 
#include <utils/StrongPointer.h>

#include <ui/GraphicBuffer.h>

#include <system/graphics.h>

#include <hardware/gralloc1.h>

#include <grallocusage/GrallocUsageConversion.h>



#include <private/android/AHardwareBufferHelpers.h>

#include <android/hardware/graphics/common/1.0/types.h>





static constexpr int kFdBufferSize = 128 * sizeof(int);  // 128 ints
@@ -51,17 +50,17 @@ int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, AHardwareBuffer** 
        return BAD_VALUE;

    }



    if (desc->reserved != 0) {

        ALOGE("AHardwareBuffer_Desc::reserved field must be 0");

        return BAD_VALUE;

    }



    if (desc->format == AHARDWAREBUFFER_FORMAT_BLOB && desc->height != 1) {

        ALOGE("Height must be 1 when using the AHARDWAREBUFFER_FORMAT_BLOB format");

        return BAD_VALUE;

    }



    uint64_t producerUsage = 0;

    uint64_t consumerUsage = 0;

    AHardwareBuffer_convertToGrallocUsageBits(&producerUsage, &consumerUsage, desc->usage0,

            desc->usage1);

    uint32_t usage = android_convertGralloc1To0Usage(producerUsage, consumerUsage);



    uint64_t usage =  AHardwareBuffer_convertToGrallocUsageBits(desc->usage);

    sp<GraphicBuffer> gbuffer(new GraphicBuffer(

            desc->width, desc->height, format, desc->layers, usage,

            std::string("AHardwareBuffer pid [") + std::to_string(getpid()) + "]"));
@@ -102,30 +101,24 @@ void AHardwareBuffer_describe(const AHardwareBuffer* buffer, 
    outDesc->width = gbuffer->getWidth();

    outDesc->height = gbuffer->getHeight();

    outDesc->layers = gbuffer->getLayerCount();



    uint64_t producerUsage = 0;

    uint64_t consumerUsage = 0;

    android_convertGralloc0To1Usage(gbuffer->getUsage(), &producerUsage, &consumerUsage);

    AHardwareBuffer_convertFromGrallocUsageBits(&outDesc->usage0, &outDesc->usage1,

            producerUsage, consumerUsage);

    outDesc->format = AHardwareBuffer_convertFromPixelFormat(

            static_cast<uint32_t>(gbuffer->getPixelFormat()));

    outDesc->usage = AHardwareBuffer_convertFromGrallocUsageBits(gbuffer->getUsage());

    outDesc->reserved = 0;

}



int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage0,

int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage,

        int32_t fence, const ARect* rect, void** outVirtualAddress) {

    if (!buffer) return BAD_VALUE;



    if (usage0 & ~(AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN |

                   AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN)) {

    if (usage & ~(AHARDWAREBUFFER_USAGE_CPU_READ_MASK |

                  AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) {

        ALOGE("Invalid usage flags passed to AHardwareBuffer_lock; only "

                " AHARDWAREBUFFER_USAGE0_CPU_* flags are allowed");

                " AHARDWAREBUFFER_USAGE_CPU_* flags are allowed");

        return BAD_VALUE;

    }



    uint64_t producerUsage = 0;

    uint64_t consumerUsage = 0;

    AHardwareBuffer_convertToGrallocUsageBits(&producerUsage, &consumerUsage, usage0, 0);

    usage = AHardwareBuffer_convertToGrallocUsageBits(usage);

    GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);

    Rect bounds;

    if (!rect) {
@@ -133,8 +126,7 @@ int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage0, 
    } else {

        bounds.set(Rect(rect->left, rect->top, rect->right, rect->bottom));

    }

    return gBuffer->lockAsync(producerUsage, consumerUsage, bounds,

            outVirtualAddress, fence);

    return gBuffer->lockAsync(usage, usage, bounds, outVirtualAddress, fence);

}



int AHardwareBuffer_unlock(AHardwareBuffer* buffer, int32_t* fence) {
@@ -287,68 +279,6 @@ struct UsageMaskMapping { 
    uint64_t grallocMask;

};



static constexpr UsageMaskMapping kUsage0ProducerMapping[] = {

    { AHARDWAREBUFFER_USAGE0_CPU_WRITE, GRALLOC1_PRODUCER_USAGE_CPU_WRITE },

    { AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN, GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN },

    { AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT, GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET },

    { AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT, GRALLOC1_PRODUCER_USAGE_PROTECTED },

    { AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA, GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA },

};



static constexpr UsageMaskMapping kUsage1ProducerMapping[] = {

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_0, GRALLOC1_PRODUCER_USAGE_PRIVATE_0 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_1, GRALLOC1_PRODUCER_USAGE_PRIVATE_1 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_2, GRALLOC1_PRODUCER_USAGE_PRIVATE_2 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_3, GRALLOC1_PRODUCER_USAGE_PRIVATE_3 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_4, GRALLOC1_PRODUCER_USAGE_PRIVATE_4 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_5, GRALLOC1_PRODUCER_USAGE_PRIVATE_5 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_6, GRALLOC1_PRODUCER_USAGE_PRIVATE_6 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_7, GRALLOC1_PRODUCER_USAGE_PRIVATE_7 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_8, GRALLOC1_PRODUCER_USAGE_PRIVATE_8 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_9, GRALLOC1_PRODUCER_USAGE_PRIVATE_9 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_10, GRALLOC1_PRODUCER_USAGE_PRIVATE_10 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_11, GRALLOC1_PRODUCER_USAGE_PRIVATE_11 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_12, GRALLOC1_PRODUCER_USAGE_PRIVATE_12 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_13, GRALLOC1_PRODUCER_USAGE_PRIVATE_13 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_14, GRALLOC1_PRODUCER_USAGE_PRIVATE_14 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_15, GRALLOC1_PRODUCER_USAGE_PRIVATE_15 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_16, GRALLOC1_PRODUCER_USAGE_PRIVATE_16 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_17, GRALLOC1_PRODUCER_USAGE_PRIVATE_17 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_18, GRALLOC1_PRODUCER_USAGE_PRIVATE_18 },

    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_19, GRALLOC1_PRODUCER_USAGE_PRIVATE_19 },

};



static constexpr UsageMaskMapping kUsage0ConsumerMapping[] = {

    { AHARDWAREBUFFER_USAGE0_CPU_READ, GRALLOC1_CONSUMER_USAGE_CPU_READ },

    { AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN, GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN },

    { AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE, GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE },

    { AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER, GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER },

    { AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE, GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER },

};



static constexpr UsageMaskMapping kUsage1ConsumerMapping[] = {

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_0, GRALLOC1_CONSUMER_USAGE_PRIVATE_0 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_1, GRALLOC1_CONSUMER_USAGE_PRIVATE_1 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_2, GRALLOC1_CONSUMER_USAGE_PRIVATE_2 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_3, GRALLOC1_CONSUMER_USAGE_PRIVATE_3 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_4, GRALLOC1_CONSUMER_USAGE_PRIVATE_4 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_5, GRALLOC1_CONSUMER_USAGE_PRIVATE_5 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_6, GRALLOC1_CONSUMER_USAGE_PRIVATE_6 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_7, GRALLOC1_CONSUMER_USAGE_PRIVATE_7 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_8, GRALLOC1_CONSUMER_USAGE_PRIVATE_8 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_9, GRALLOC1_CONSUMER_USAGE_PRIVATE_9 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_10, GRALLOC1_CONSUMER_USAGE_PRIVATE_10 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_11, GRALLOC1_CONSUMER_USAGE_PRIVATE_11 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_12, GRALLOC1_CONSUMER_USAGE_PRIVATE_12 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_13, GRALLOC1_CONSUMER_USAGE_PRIVATE_13 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_14, GRALLOC1_CONSUMER_USAGE_PRIVATE_14 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_15, GRALLOC1_CONSUMER_USAGE_PRIVATE_15 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_16, GRALLOC1_CONSUMER_USAGE_PRIVATE_16 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17, GRALLOC1_CONSUMER_USAGE_PRIVATE_17 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_18, GRALLOC1_CONSUMER_USAGE_PRIVATE_18 },

    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_19, GRALLOC1_CONSUMER_USAGE_PRIVATE_19 },

};



static inline bool containsBits(uint64_t mask, uint64_t bitsToCheck) {

    return (mask & bitsToCheck) == bitsToCheck && bitsToCheck;

}
@@ -381,56 +311,37 @@ uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t format) { 
    }

}



void AHardwareBuffer_convertToGrallocUsageBits(uint64_t* outProducerUsage,

    uint64_t* outConsumerUsage, uint64_t usage0, uint64_t usage1) {

    *outProducerUsage = 0;

    *outConsumerUsage = 0;

    for (const UsageMaskMapping& mapping : kUsage0ProducerMapping) {

        if (containsBits(usage0, mapping.hardwareBufferMask)) {

            *outProducerUsage |= mapping.grallocMask;

        }

    }

    for (const UsageMaskMapping& mapping : kUsage1ProducerMapping) {

        if (containsBits(usage1, mapping.hardwareBufferMask)) {

            *outProducerUsage |= mapping.grallocMask;

        }

    }

    for (const UsageMaskMapping& mapping : kUsage0ConsumerMapping) {

        if (containsBits(usage0, mapping.hardwareBufferMask)) {

            *outConsumerUsage |= mapping.grallocMask;

        }

    }

    for (const UsageMaskMapping& mapping : kUsage1ConsumerMapping) {

        if (containsBits(usage1, mapping.hardwareBufferMask)) {

            *outConsumerUsage |= mapping.grallocMask;

        }

    }

}



void AHardwareBuffer_convertFromGrallocUsageBits(uint64_t* outUsage0, uint64_t* outUsage1,

        uint64_t producerUsage, uint64_t consumerUsage) {

    *outUsage0 = 0;

    *outUsage1 = 0;

    for (const UsageMaskMapping& mapping : kUsage0ProducerMapping) {

        if (containsBits(producerUsage, mapping.grallocMask)) {

            *outUsage0 |= mapping.hardwareBufferMask;

        }

    }

    for (const UsageMaskMapping& mapping : kUsage1ProducerMapping) {

        if (containsBits(producerUsage, mapping.grallocMask)) {

            *outUsage1 |= mapping.hardwareBufferMask;

        }

    }

    for (const UsageMaskMapping& mapping : kUsage0ConsumerMapping) {

        if (containsBits(consumerUsage, mapping.grallocMask)) {

            *outUsage0 |= mapping.hardwareBufferMask;

        }

    }

    for (const UsageMaskMapping& mapping : kUsage1ConsumerMapping) {

        if (containsBits(consumerUsage, mapping.grallocMask)) {

            *outUsage1 |= mapping.hardwareBufferMask;

        }

    }

uint64_t AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage) {

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

    static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER == (uint64_t)BufferUsage::CPU_READ_NEVER,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_RARELY == (uint64_t)BufferUsage::CPU_READ_RARELY,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN == (uint64_t)BufferUsage::CPU_READ_OFTEN,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER == (uint64_t)BufferUsage::CPU_WRITE_NEVER,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY == (uint64_t)BufferUsage::CPU_WRITE_RARELY,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN == (uint64_t)BufferUsage::CPU_WRITE_OFTEN,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE == (uint64_t)BufferUsage::GPU_TEXTURE,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT == (uint64_t)BufferUsage::GPU_RENDER_TARGET,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT == (uint64_t)BufferUsage::PROTECTED,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_VIDEO_ENCODE == (uint64_t)BufferUsage::VIDEO_ENCODER,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER == (uint64_t)BufferUsage::GPU_DATA_BUFFER,

            "gralloc and AHardwareBuffer flags don't match");

    static_assert(AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA == (uint64_t)BufferUsage::SENSOR_DIRECT_DATA,

            "gralloc and AHardwareBuffer flags don't match");

    return usage;

}



uint64_t AHardwareBuffer_convertFromGrallocUsageBits(uint64_t usage) {

    return usage;

}



const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer) {

libs/nativewindow/ANativeWindow.cpp

+3 −4
Original line number Diff line number Diff line
@@ -191,10 +191,9 @@ int ANativeWindow_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffe 
    return window->cancelBuffer(window, buffer, fenceFd);

}



int ANativeWindow_setUsage(ANativeWindow* window, uint64_t usage0, uint64_t usage1) {

    uint64_t pUsage, cUsage;

    AHardwareBuffer_convertToGrallocUsageBits(&pUsage, &cUsage, usage0, usage1);

    return native_window_set_usage(window, android_convertGralloc1To0Usage(pUsage, cUsage));

int ANativeWindow_setUsage(ANativeWindow* window, uint64_t usage) {

    usage = AHardwareBuffer_convertToGrallocUsageBits(usage);

    return native_window_set_usage(window, (uint32_t)usage); // FIXME: we need a 64-bits version

}



int ANativeWindow_setBufferCount(ANativeWindow* window, size_t bufferCount) {

libs/nativewindow/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -49,6 +49,7 @@ cc_library { 
        "liblog",

        "libutils",

        "libui",

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

    ],



    static_libs: [

libs/nativewindow/include/android/hardware_buffer.h

+50 −63
Original line number Diff line number Diff line
@@ -83,70 +83,57 @@ enum { 
};



enum {

    /* The buffer will never be read by the CPU */

    AHARDWAREBUFFER_USAGE_CPU_READ_NEVER        = 0UL,

    /* The buffer will sometimes be read by the CPU */

    AHARDWAREBUFFER_USAGE0_CPU_READ               = 1ULL << 1,

    AHARDWAREBUFFER_USAGE_CPU_READ_RARELY       = 2UL,

    /* The buffer will often be read by the CPU */

    AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN         = 1ULL << 2 | AHARDWAREBUFFER_USAGE0_CPU_READ,

    AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN        = 3UL,

    /* CPU read value mask */

    AHARDWAREBUFFER_USAGE_CPU_READ_MASK         = 0xFUL,



    /* The buffer will never be written by the CPU */

    AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER       = 0UL << 4,

    /* The buffer will sometimes be written to by the CPU */

    AHARDWAREBUFFER_USAGE0_CPU_WRITE              = 1ULL << 5,

    AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY      = 2UL << 4,

    /* The buffer will often be written to by the CPU */

    AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN        = 1ULL << 6 | AHARDWAREBUFFER_USAGE0_CPU_WRITE,

    AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN       = 3UL << 4,

    /* CPU write value mask */

    AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK        = 0xFUL << 4,



    /* The buffer will be read from by the GPU */

    AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE      = 1ULL << 10,

    AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE      = 1UL << 8,

    /* The buffer will be written to by the GPU */

    AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT       = 1ULL << 11,

    /* The buffer will be used as a shader storage or uniform buffer object*/

    AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER        = 1ULL << 14,

    AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT       = 1UL << 9,

    /* The buffer must not be used outside of a protected hardware path */

    AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT      = 1ULL << 18,

    /** The buffer will be used for sensor direct data */

    AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA     = 1ULL << 29,

    AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT      = 1UL << 14,

    /* The buffer will be read by a hardware video encoder */

    AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE           = 1ULL << 21,

};



/* These flags are intended only for use by device-specific graphics drivers. */

enum {

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_19 = 1ULL << 24,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_19 = 1ULL << 25,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_18 = 1ULL << 26,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_18 = 1ULL << 27,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17 = 1ULL << 28,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_17 = 1ULL << 29,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_16 = 1ULL << 30,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_16 = 1ULL << 31,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_15 = 1ULL << 32,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_15 = 1ULL << 33,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_14 = 1ULL << 34,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_14 = 1ULL << 35,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_13 = 1ULL << 36,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_13 = 1ULL << 37,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_12 = 1ULL << 38,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_12 = 1ULL << 39,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_11 = 1ULL << 40,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_11 = 1ULL << 41,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_10 = 1ULL << 42,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_10 = 1ULL << 43,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_9 = 1ULL << 44,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_9 = 1ULL << 45,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_8 = 1ULL << 46,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_8 = 1ULL << 47,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_7 = 1ULL << 48,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_7 = 1ULL << 49,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_6 = 1ULL << 50,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_6 = 1ULL << 51,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_5 = 1ULL << 52,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_5 = 1ULL << 53,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_4 = 1ULL << 54,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_4 = 1ULL << 55,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_3 = 1ULL << 56,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_3 = 1ULL << 57,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_2 = 1ULL << 58,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_2 = 1ULL << 59,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_1 = 1ULL << 60,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_1 = 1ULL << 61,

    AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_0 = 1ULL << 62,

    AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_0 = 1ULL << 63,

    AHARDWAREBUFFER_USAGE_VIDEO_ENCODE           = 1UL << 16,

    /** The buffer will be used for sensor direct data */

    AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA     = 1UL << 23,

    /* The buffer will be used as a shader storage or uniform buffer object*/

    AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER        = 1UL << 24,



    AHARDWAREBUFFER_USAGE_VENDOR_0  = 1ULL << 28,

    AHARDWAREBUFFER_USAGE_VENDOR_1  = 1ULL << 29,

    AHARDWAREBUFFER_USAGE_VENDOR_2  = 1ULL << 30,

    AHARDWAREBUFFER_USAGE_VENDOR_3  = 1ULL << 31,

    AHARDWAREBUFFER_USAGE_VENDOR_4  = 1ULL << 48,

    AHARDWAREBUFFER_USAGE_VENDOR_5  = 1ULL << 49,

    AHARDWAREBUFFER_USAGE_VENDOR_6  = 1ULL << 50,

    AHARDWAREBUFFER_USAGE_VENDOR_7  = 1ULL << 51,

    AHARDWAREBUFFER_USAGE_VENDOR_8  = 1ULL << 52,

    AHARDWAREBUFFER_USAGE_VENDOR_9  = 1ULL << 53,

    AHARDWAREBUFFER_USAGE_VENDOR_10 = 1ULL << 54,

    AHARDWAREBUFFER_USAGE_VENDOR_11 = 1ULL << 55,

    AHARDWAREBUFFER_USAGE_VENDOR_12 = 1ULL << 56,

    AHARDWAREBUFFER_USAGE_VENDOR_13 = 1ULL << 57,

    AHARDWAREBUFFER_USAGE_VENDOR_14 = 1ULL << 58,

    AHARDWAREBUFFER_USAGE_VENDOR_15 = 1ULL << 59,

    AHARDWAREBUFFER_USAGE_VENDOR_16 = 1ULL << 60,

    AHARDWAREBUFFER_USAGE_VENDOR_17 = 1ULL << 61,

    AHARDWAREBUFFER_USAGE_VENDOR_18 = 1ULL << 62,

    AHARDWAREBUFFER_USAGE_VENDOR_19 = 1ULL << 63,

};



typedef struct AHardwareBuffer_Desc {
@@ -154,8 +141,8 @@ typedef struct AHardwareBuffer_Desc { 
    uint32_t    height;

    uint32_t    layers;

    uint32_t    format;     // One of AHARDWAREBUFFER_FORMAT_*

    uint64_t    usage0;     // Combination of AHARDWAREBUFFER_USAGE0_*

    uint64_t    usage1;     // Initialize to zero, reserved for future use

    uint64_t    usage;      // Combination of AHARDWAREBUFFER_USAGE_*

    uint64_t    reserved;   // Initialize to zero, reserved for future use

} AHardwareBuffer_Desc;



typedef struct AHardwareBuffer AHardwareBuffer;
@@ -203,7 +190,7 @@ void AHardwareBuffer_describe(const AHardwareBuffer* buffer, 
 * The content of the buffer outside of the specified rect is NOT modified

 * by this call.

 *

 * The buffer usage may only specify AHARDWAREBUFFER_USAGE0_CPU_*. If set, then

 * The buffer usage may only specify AHARDWAREBUFFER_USAGE_CPU_*. If set, then

 * outVirtualAddress is filled with the address of the buffer in virtual memory,

 * otherwise this function will fail.

 *
@@ -217,11 +204,11 @@ void AHardwareBuffer_describe(const AHardwareBuffer* buffer, 
 * may return an error or leave the buffer's content into an indeterminate

 * state.

 *

 * Returns NO_ERROR on success, BAD_VALUE if the buffer is NULL or if the usage0

 * flags are not a combination of AHARDWAREBUFFER_USAGE0_CPU_*, or an error

 * Returns NO_ERROR on success, BAD_VALUE if the buffer is NULL or if the usage

 * flags are not a combination of AHARDWAREBUFFER_USAGE_CPU_*, or an error

 * number of the lock fails for any reason.

 */

int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage0,

int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage,

        int32_t fence, const ARect* rect, void** outVirtualAddress);



/*

libs/nativewindow/include/private/android/AHardwareBufferHelpers.h

+2 −7
Original line number Diff line number Diff line
@@ -33,14 +33,9 @@ struct ANativeWindowBuffer; 
namespace android {



uint32_t AHardwareBuffer_convertFromPixelFormat(uint32_t format);



uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t format);



void AHardwareBuffer_convertToGrallocUsageBits(uint64_t* outProducerUsage,

    uint64_t* outConsumerUsage, uint64_t usage0, uint64_t usage1);



void AHardwareBuffer_convertFromGrallocUsageBits(uint64_t* outUsage0, uint64_t* outUsage1,

    uint64_t producerUsage, uint64_t consumerUsage);

uint64_t AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage);

uint64_t AHardwareBuffer_convertFromGrallocUsageBits(uint64_t usage);



class GraphicBuffer;

const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer);