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

Commit 99015fe4 authored by Craig Donner's avatar Craig Donner Committed by Android (Google) Code Review
Browse files

Merge "Use gralloc1 flags to allocate AHardwareBuffers"

parents 0c4f715a 90051064

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) {