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

Commit 90051064 authored by Craig Donner's avatar Craig Donner
Browse files

Use gralloc1 flags to allocate AHardwareBuffers 

Bug: 34939453
Test: cts-tradefed run cts -m CtsNativeHardwareTestCases
Change-Id: I48add1b78c4e1409c0e787d6197f0582f0c3fb4c
parent a59b4912

core/jni/android_hardware_HardwareBuffer.cpp

+41 −29
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include <binder/Parcel.h>

#include <gui/IGraphicBufferAlloc.h>

#include <gui/ISurfaceComposer.h>

#include <hardware/gralloc1.h>

#include <ui/GraphicBuffer.h>



#include <private/gui/ComposerService.h>
@@ -96,10 +97,15 @@ static jlong android_hardware_HardwareBuffer_create(JNIEnv* env, jobject clazz, 
        }

        return NULL;

    }

    uint32_t grallocUsage = android_hardware_HardwareBuffer_convertToGrallocUsageBits(usage, 0);

    uint64_t producerUsage = 0;

    uint64_t consumerUsage = 0;

    android_hardware_HardwareBuffer_convertToGrallocUsageBits(usage, 0, &producerUsage,

            &consumerUsage);

    status_t error;

    sp<GraphicBuffer> buffer(alloc->createGraphicBuffer(width, height, pixelFormat,

            layers, grallocUsage, &error));

            layers, producerUsage, consumerUsage,

            std::string("HardwareBuffer pid [") + std::to_string(getpid()) +"]",

            &error));

    if (buffer == NULL) {

        if (kDebugGraphicBuffer) {

            ALOGW("createGraphicBuffer() failed in HardwareBuffer.create()");
@@ -158,7 +164,7 @@ static jlong android_hardware_HardwareBuffer_getUsage(JNIEnv* env, 
    jobject clazz, jlong nativeObject) {

    GraphicBuffer* buffer = GraphicBufferWrapper_to_GraphicBuffer(nativeObject);

    return android_hardware_HardwareBuffer_convertFromGrallocUsageBits(

            buffer->getUsage());

            buffer->getUsage(), buffer->getUsage());

}



// ----------------------------------------------------------------------------
@@ -261,52 +267,58 @@ uint32_t android_hardware_HardwareBuffer_convertToPixelFormat(uint32_t format) { 
    }

}



uint32_t android_hardware_HardwareBuffer_convertToGrallocUsageBits(uint64_t usage0,

        uint64_t usage1) {

    uint32_t bits = 0;

void android_hardware_HardwareBuffer_convertToGrallocUsageBits(uint64_t usage0,

        uint64_t usage1, uint64_t* outProducerUsage,

        uint64_t* outConsumerUsage) {

    *outProducerUsage = 0;

    *outConsumerUsage = 0;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_CPU_READ))

        bits |= GRALLOC_USAGE_SW_READ_RARELY;

        *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CPU_READ;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN))

        bits |= GRALLOC_USAGE_SW_READ_OFTEN;

        *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_CPU_WRITE))

        bits |= GRALLOC_USAGE_SW_WRITE_RARELY;

        *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_WRITE;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN))

        bits |= GRALLOC_USAGE_SW_WRITE_OFTEN;

        *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE))

        bits |= GRALLOC_USAGE_HW_TEXTURE;

        *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT))

        bits |= GRALLOC_USAGE_HW_RENDER;

        *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET;

    // Not sure what this should be.

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_CUBEMAP)) bits |= 0;

    //if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER) bits |= 0;

    //if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_CUBEMAP)) bits |= 0;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER))

        *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE))

        bits |= GRALLOC_USAGE_HW_VIDEO_ENCODER;

        *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT))

        bits |= GRALLOC_USAGE_PROTECTED;



    (void)usage1;



    return bits;

        *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_PROTECTED;

    if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA))

        *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA;

}



uint64_t android_hardware_HardwareBuffer_convertFromGrallocUsageBits(uint64_t usage0) {

uint64_t android_hardware_HardwareBuffer_convertFromGrallocUsageBits(

        uint64_t producerUsage, uint64_t consumerUsage) {

    uint64_t bits = 0;

    if (containsBits(usage0, GRALLOC_USAGE_SW_READ_RARELY))

    if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_CPU_READ))

        bits |= AHARDWAREBUFFER_USAGE0_CPU_READ;

    if (containsBits(usage0, GRALLOC_USAGE_SW_READ_OFTEN))

    if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN))

        bits |= AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN;

    if (containsBits(usage0, GRALLOC_USAGE_SW_WRITE_RARELY))

    if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_CPU_WRITE))

        bits |= AHARDWAREBUFFER_USAGE0_CPU_WRITE;

    if (containsBits(usage0, GRALLOC_USAGE_SW_WRITE_OFTEN))

    if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN))

        bits |= AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN;

    if (containsBits(usage0, GRALLOC_USAGE_HW_TEXTURE))

    if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE))

        bits |= AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE;

    if (containsBits(usage0, GRALLOC_USAGE_HW_RENDER))

    if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET))

        bits |= AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT;

    if (containsBits(usage0, GRALLOC_USAGE_HW_VIDEO_ENCODER))

    if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER))

        bits |= AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER;

    if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER))

        bits |= AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE;

    if (containsBits(usage0, GRALLOC_USAGE_PROTECTED))

    if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_PROTECTED))

        bits |= AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT;

    if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA))

        bits |= AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA;



    return bits;

}

core/jni/include/android_runtime/android_hardware_HardwareBuffer.h

+4 −3
Original line number Diff line number Diff line
@@ -40,12 +40,13 @@ extern uint32_t android_hardware_HardwareBuffer_convertToPixelFormat( 
      uint32_t format);



/* Convert from AHARDWAREBUFFER_USAGE* flags to to gralloc usage flags. */

extern uint32_t android_hardware_HardwareBuffer_convertToGrallocUsageBits(

      uint64_t usage0, uint64_t usage1);

extern void android_hardware_HardwareBuffer_convertToGrallocUsageBits(

      uint64_t usage0, uint64_t usage1, uint64_t* outProducerUsage,

      uint64_t* outConsumerUsage);



/* Convert from gralloc usage flags to to AHARDWAREBUFFER_USAGE0* flags. */

extern uint64_t android_hardware_HardwareBuffer_convertFromGrallocUsageBits(

      uint64_t usage0);

      uint64_t producerUsage, uint64_t consumerUsage);



} // namespace android

native/android/hardware_buffer.cpp

+19 −10
Original line number Diff line number Diff line
@@ -26,10 +26,11 @@ 
#include <android_runtime/android_hardware_HardwareBuffer.h>

#include <binder/Binder.h>

#include <binder/Parcel.h>

#include <cutils/native_handle.h>

#include <binder/IServiceManager.h>

#include <cutils/native_handle.h>

#include <gui/ISurfaceComposer.h>

#include <gui/IGraphicBufferAlloc.h>

#include <hardware/gralloc1.h>

#include <ui/GraphicBuffer.h>

#include <utils/Flattenable.h>

#include <utils/Log.h>
@@ -96,10 +97,14 @@ int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, 
    }



    status_t err;

    uint32_t usage = android_hardware_HardwareBuffer_convertToGrallocUsageBits(

            desc->usage0, desc->usage1);

    uint64_t producerUsage = 0;

    uint64_t consumerUsage = 0;

    android_hardware_HardwareBuffer_convertToGrallocUsageBits(desc->usage0,

            desc->usage1, &producerUsage, &consumerUsage);

    sp<GraphicBuffer> gbuffer = allocator->createGraphicBuffer(desc->width,

            desc->height, format, desc->layers, usage, &err);

            desc->height, format, desc->layers, producerUsage, consumerUsage,

            std::string("AHardwareBuffer pid [") + std::to_string(getpid()) +

            "]", &err);

    if (err != NO_ERROR) {

        return err;

    }
@@ -131,7 +136,7 @@ void AHardwareBuffer_describe(const AHardwareBuffer* buffer, 
    outDesc->layers = gbuffer->getLayerCount();

    outDesc->usage0 =

            android_hardware_HardwareBuffer_convertFromGrallocUsageBits(

                    gbuffer->getUsage());

                    gbuffer->getUsage(), gbuffer->getUsage());

    outDesc->usage1 = 0;

    outDesc->format = android_hardware_HardwareBuffer_convertFromPixelFormat(

            static_cast<uint32_t>(gbuffer->getPixelFormat()));
@@ -148,15 +153,19 @@ int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage0, 
        return BAD_VALUE;

    }



    uint32_t usage = android_hardware_HardwareBuffer_convertToGrallocUsageBits(

            usage0, 0);

    uint64_t producerUsage = 0;

    uint64_t consumerUsage = 0;

    android_hardware_HardwareBuffer_convertToGrallocUsageBits(usage0, 0,

            &producerUsage, &consumerUsage);

    GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);

    Rect bounds;

    if (!rect) {

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

        bounds.set(Rect(gBuffer->getWidth(), gBuffer->getHeight()));

    } else {

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

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

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

    }

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

            outVirtualAddress, fence);

}



int AHardwareBuffer_unlock(AHardwareBuffer* buffer, int32_t* fence) {