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

Commit 378ef077 authored by Francis Hart's avatar Francis Hart Committed by Greg Hackmann
Browse files

Use asynchronous lock/unlock API 

The gralloc API now provides a way for using lock/unlock with the Android
explicit synchronisation concept. This changes updates the GraphicBuffer class
to also expose this functionality, and updates the Surface class to make use of
in line with the dequeueBuffer/queueBuffer mechanism.

This new behaviour is dependent on GRALLOC_MODULE_API_VERSION_0_3. If the local
gralloc module does not support this then the existing synchronous lock/unlock
mechanism will be used.

Change-Id: I77daa1beb197b63b1c2f281b8414ac4ae4b5b03c
parent cb079c89

include/ui/GraphicBuffer.h

+5 −0
Original line number Original line Diff line number Diff line
@@ -97,6 +97,11 @@ public: 
    status_t lockYCbCr(uint32_t usage, android_ycbcr *ycbcr);

    status_t lockYCbCr(uint32_t usage, android_ycbcr *ycbcr);

    status_t lockYCbCr(uint32_t usage, const Rect& rect, android_ycbcr *ycbcr);

    status_t lockYCbCr(uint32_t usage, const Rect& rect, android_ycbcr *ycbcr);

    status_t unlock();

    status_t unlock();

    status_t lockAsync(uint32_t usage, void** vaddr, int fenceFd);

    status_t lockAsync(uint32_t usage, const Rect& rect, void** vaddr, int fenceFd);

    status_t lockAsyncYCbCr(uint32_t usage, android_ycbcr *ycbcr, int fenceFd);

    status_t lockAsyncYCbCr(uint32_t usage, const Rect& rect, android_ycbcr *ycbcr, int fenceFd);

    status_t unlockAsync(int *fenceFd);





    ANativeWindowBuffer* getNativeBuffer() const;

    ANativeWindowBuffer* getNativeBuffer() const;

include/ui/GraphicBufferMapper.h

+8 −0
Original line number Original line Diff line number Diff line
@@ -50,6 +50,14 @@ public: 




    status_t unlock(buffer_handle_t handle);

    status_t unlock(buffer_handle_t handle);





    status_t lockAsync(buffer_handle_t handle,

            int usage, const Rect& bounds, void** vaddr, int fenceFd);



    status_t lockAsyncYCbCr(buffer_handle_t handle,

            int usage, const Rect& bounds, android_ycbcr *ycbcr, int fenceFd);



    status_t unlockAsync(buffer_handle_t handle, int *fenceFd);

    

    // dumps information about the mapping of this handle

    // dumps information about the mapping of this handle

    void dump(buffer_handle_t handle);

    void dump(buffer_handle_t handle);

libs/gui/Surface.cpp

+5 −13
Original line number Original line Diff line number Diff line
@@ -740,15 +740,6 @@ status_t Surface::lock( 
    ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));

    ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));

    if (err == NO_ERROR) {

    if (err == NO_ERROR) {

        sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));

        sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));

        sp<Fence> fence(new Fence(fenceFd));



        err = fence->waitForever("Surface::lock");

        if (err != OK) {

            ALOGE("Fence::wait failed (%s)", strerror(-err));

            cancelBuffer(out, fenceFd);

            return err;

        }



        const Rect bounds(backBuffer->width, backBuffer->height);

        const Rect bounds(backBuffer->width, backBuffer->height);





        Region newDirtyRegion;

        Region newDirtyRegion;
@@ -799,9 +790,9 @@ status_t Surface::lock( 
        }

        }





        void* vaddr;

        void* vaddr;

        status_t res = backBuffer->lock(

        status_t res = backBuffer->lockAsync(

                GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,

                GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,

                newDirtyRegion.bounds(), &vaddr);

                newDirtyRegion.bounds(), &vaddr, fenceFd);





        ALOGW_IF(res, "failed locking buffer (handle = %p)",

        ALOGW_IF(res, "failed locking buffer (handle = %p)",

                backBuffer->handle);

                backBuffer->handle);
@@ -827,10 +818,11 @@ status_t Surface::unlockAndPost() 
        return INVALID_OPERATION;

        return INVALID_OPERATION;

    }

    }





    status_t err = mLockedBuffer->unlock();

    int fd = -1;

    status_t err = mLockedBuffer->unlockAsync(&fd);

    ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);

    ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);





    err = queueBuffer(mLockedBuffer.get(), -1);

    err = queueBuffer(mLockedBuffer.get(), fd);

    ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",

    ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",

            mLockedBuffer->handle, strerror(-err));

            mLockedBuffer->handle, strerror(-err));

libs/ui/GraphicBuffer.cpp

+46 −0
Original line number Original line Diff line number Diff line
@@ -200,6 +200,52 @@ status_t GraphicBuffer::unlock() 
    return res;

    return res;

}

}





status_t GraphicBuffer::lockAsync(uint32_t usage, void** vaddr, int fenceFd)

{

    const Rect lockBounds(width, height);

    status_t res = lockAsync(usage, lockBounds, vaddr, fenceFd);

    return res;

}



status_t GraphicBuffer::lockAsync(uint32_t usage, const Rect& rect, void** vaddr, int fenceFd)

{

    if (rect.left < 0 || rect.right  > this->width ||

        rect.top  < 0 || rect.bottom > this->height) {

        ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",

                rect.left, rect.top, rect.right, rect.bottom,

                this->width, this->height);

        return BAD_VALUE;

    }

    status_t res = getBufferMapper().lockAsync(handle, usage, rect, vaddr, fenceFd);

    return res;

}



status_t GraphicBuffer::lockAsyncYCbCr(uint32_t usage, android_ycbcr *ycbcr, int fenceFd)

{

    const Rect lockBounds(width, height);

    status_t res = lockAsyncYCbCr(usage, lockBounds, ycbcr, fenceFd);

    return res;

}



status_t GraphicBuffer::lockAsyncYCbCr(uint32_t usage, const Rect& rect, android_ycbcr *ycbcr, int fenceFd)

{

    if (rect.left < 0 || rect.right  > this->width ||

        rect.top  < 0 || rect.bottom > this->height) {

        ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",

                rect.left, rect.top, rect.right, rect.bottom,

                this->width, this->height);

        return BAD_VALUE;

    }

    status_t res = getBufferMapper().lockAsyncYCbCr(handle, usage, rect, ycbcr, fenceFd);

    return res;

}



status_t GraphicBuffer::unlockAsync(int *fenceFd)

{

    status_t res = getBufferMapper().unlockAsync(handle, fenceFd);

    return res;

}



size_t GraphicBuffer::getFlattenedSize() const {

size_t GraphicBuffer::getFlattenedSize() const {

    return (8 + (handle ? handle->numInts : 0))*sizeof(int);

    return (8 + (handle ? handle->numInts : 0))*sizeof(int);

}

}

libs/ui/GraphicBufferMapper.cpp

+62 −0
Original line number Original line Diff line number Diff line
@@ -20,6 +20,8 @@ 
#include <stdint.h>

#include <stdint.h>

#include <errno.h>

#include <errno.h>





#include <sync/sync.h>



#include <utils/Errors.h>

#include <utils/Errors.h>

#include <utils/Log.h>

#include <utils/Log.h>

#include <utils/Trace.h>

#include <utils/Trace.h>
@@ -109,5 +111,65 @@ status_t GraphicBufferMapper::unlock(buffer_handle_t handle) 
    return err;

    return err;

}

}





status_t GraphicBufferMapper::lockAsync(buffer_handle_t handle,

        int usage, const Rect& bounds, void** vaddr, int fenceFd)

{

    ATRACE_CALL();

    status_t err;



    if (mAllocMod->common.module_api_version >= GRALLOC_MODULE_API_VERSION_0_3) {

        err = mAllocMod->lockAsync(mAllocMod, handle, usage,

                bounds.left, bounds.top, bounds.width(), bounds.height(),

                vaddr, fenceFd);

    } else {

        sync_wait(fenceFd, -1);

        close(fenceFd);

        err = mAllocMod->lock(mAllocMod, handle, usage,

                bounds.left, bounds.top, bounds.width(), bounds.height(),

                vaddr);

    }



    ALOGW_IF(err, "lockAsync(...) failed %d (%s)", err, strerror(-err));

    return err;

}



status_t GraphicBufferMapper::lockAsyncYCbCr(buffer_handle_t handle,

        int usage, const Rect& bounds, android_ycbcr *ycbcr, int fenceFd)

{

    ATRACE_CALL();

    status_t err;



    if (mAllocMod->common.module_api_version >= GRALLOC_MODULE_API_VERSION_0_3) {

        err = mAllocMod->lockAsync_ycbcr(mAllocMod, handle, usage,

                bounds.left, bounds.top, bounds.width(), bounds.height(),

                ycbcr, fenceFd);

    } else {

        sync_wait(fenceFd, -1);

        close(fenceFd);

        err = mAllocMod->lock_ycbcr(mAllocMod, handle, usage,

                bounds.left, bounds.top, bounds.width(), bounds.height(),

                ycbcr);

    }



    ALOGW_IF(err, "lock(...) failed %d (%s)", err, strerror(-err));

    return err;

}



status_t GraphicBufferMapper::unlockAsync(buffer_handle_t handle, int *fenceFd)

{

    ATRACE_CALL();

    status_t err;



    if (mAllocMod->common.module_api_version >= GRALLOC_MODULE_API_VERSION_0_3) {

        err = mAllocMod->unlockAsync(mAllocMod, handle, fenceFd);

    } else {

        *fenceFd = -1;

        err = mAllocMod->unlock(mAllocMod, handle);

    }



    ALOGW_IF(err, "unlockAsync(...) failed %d (%s)", err, strerror(-err));

    return err;

}



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

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

}; // namespace android
 
}; // namespace android