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

Commit bf974abe authored by Andy McFadden's avatar Andy McFadden
Browse files

Refactor SurfaceTexture a bit. 

Rearranges updateTexImage() so that the SurfaceFlinger-specific
behavior is in a new SurfaceFlingerConsumer subclass.

SurfaceTexture behavior should not be altered.  Instead of
acquire-bind-release we now do acquire-release-bind, but since
it's all done with the lock held there shouldn't be any
externally-visible change.

Change-Id: Ia566e4727945e2cfb9359fc6d2a8f8af64d7b7b7
parent 0e1e53e3

include/gui/BufferQueue.h

+3 −2
Original line number Diff line number Diff line
@@ -182,8 +182,9 @@ public: 
           mBuf(INVALID_BUFFER_SLOT) {

             mCrop.makeInvalid();

         }

        // mGraphicBuffer points to the buffer allocated for this slot or is NULL

        // if no buffer has been allocated.

        // mGraphicBuffer points to the buffer allocated for this slot, or is NULL

        // if the buffer in this slot has been acquired in the past (see

        // BufferSlot.mAcquireCalled).

        sp<GraphicBuffer> mGraphicBuffer;



        // mCrop is the current crop rectangle for this buffer slot.

include/gui/SurfaceTexture.h

+38 −30
Original line number Diff line number Diff line
@@ -74,14 +74,13 @@ public: 
            GLenum texTarget = GL_TEXTURE_EXTERNAL_OES, bool useFenceSync = true,

            const sp<BufferQueue> &bufferQueue = 0);



    // updateTexImage sets the image contents of the target texture to that of

    // the most recently queued buffer.

    // updateTexImage acquires the most recently queued buffer, and sets the

    // image contents of the target texture to it.

    //

    // This call may only be made while the OpenGL ES context to which the

    // target texture belongs is bound to the calling thread.

    //

    // After calling this method the doGLFenceWait method must be called

    // before issuing OpenGL ES commands that access the texture contents.

    // This calls doGLFenceWait to ensure proper synchronization.

    status_t updateTexImage();



    // setReleaseFence stores a fence file descriptor that will signal when the
@@ -161,8 +160,7 @@ public: 


    // doGLFenceWait inserts a wait command into the OpenGL ES command stream

    // to ensure that it is safe for future OpenGL ES commands to access the

    // current texture buffer.  This must be called each time updateTexImage

    // is called before issuing OpenGL ES commands that access the texture.

    // current texture buffer.

    status_t doGLFenceWait() const;



    // isSynchronousMode returns whether the SurfaceTexture is currently in
@@ -233,23 +231,33 @@ protected: 
    virtual status_t releaseBufferLocked(int buf, EGLDisplay display,

           EGLSyncKHR eglFence);



    status_t releaseBufferLocked(int buf, EGLSyncKHR eglFence) {

        return releaseBufferLocked(buf, mEglDisplay, eglFence);

    }



    static bool isExternalFormat(uint32_t format);



private:

    // this version of updateTexImage() takes a functor used to reject or not

    // the newly acquired buffer.

    // this API is TEMPORARY and intended to be used by SurfaceFlinger only,

    // which is why class Layer is made a friend of SurfaceTexture below.

    class BufferRejecter {

        friend class SurfaceTexture;

        virtual bool reject(const sp<GraphicBuffer>& buf,

                const BufferQueue::BufferItem& item) = 0;

    protected:

        virtual ~BufferRejecter() { }

    };

    friend class Layer;

    status_t updateTexImage(BufferRejecter* rejecter, bool skipSync);

    // This releases the buffer in the slot referenced by mCurrentTexture,

    // then updates state to refer to the BufferItem, which must be a

    // newly-acquired buffer.

    status_t releaseAndUpdateLocked(const BufferQueue::BufferItem& item);



    // Binds mTexName and the current buffer to mTexTarget.  Uses

    // mCurrentTexture if it's set, mCurrentTextureBuf if not.

    status_t bindTextureImage();



    // doGLFenceWaitLocked inserts a wait command into the OpenGL ES command

    // stream to ensure that it is safe for future OpenGL ES commands to

    // access the current texture buffer.

    status_t doGLFenceWaitLocked() const;



    // Gets the current EGLDisplay and EGLContext values, and compares them

    // to mEglDisplay and mEglContext.  If the fields have been previously

    // set, the values must match; if not, the fields are set to the current

    // values.

    status_t checkAndUpdateEglStateLocked();



private:

    // createImage creates a new EGLImage from a GraphicBuffer.

    EGLImageKHR createImage(EGLDisplay dpy,

            const sp<GraphicBuffer>& graphicBuffer);
@@ -267,19 +275,19 @@ private: 
    // mCurrentTextureBuf must not be NULL.

    void computeCurrentTransformMatrixLocked();



    // doGLFenceWaitLocked inserts a wait command into the OpenGL ES command

    // stream to ensure that it is safe for future OpenGL ES commands to

    // access the current texture buffer.  This must be called each time

    // updateTexImage is called before issuing OpenGL ES commands that access

    // the texture.

    status_t doGLFenceWaitLocked() const;



    // syncForReleaseLocked performs the synchronization needed to release the

    // current slot from an OpenGL ES context.  If needed it will set the

    // current slot's fence to guard against a producer accessing the buffer

    // before the outstanding accesses have completed.

    status_t syncForReleaseLocked(EGLDisplay dpy);



    // Normally, when we bind a buffer to a texture target, we bind a buffer

    // that is referenced by an entry in mEglSlots.  In some situations we

    // have a buffer in mCurrentTextureBuf, but no corresponding entry for

    // it in our slot array.  bindUnslottedBuffer handles that situation by

    // binding the buffer without touching the EglSlots.

    status_t bindUnslottedBufferLocked(EGLDisplay dpy);



    // The default consumer usage flags that SurfaceTexture always sets on its

    // BufferQueue instance; these will be OR:d with any additional flags passed

    // from the SurfaceTexture user. In particular, SurfaceTexture will always
@@ -344,8 +352,8 @@ private: 


    // EGLSlot contains the information and object references that

    // SurfaceTexture maintains about a BufferQueue buffer slot.

    struct EGLSlot {

        EGLSlot()

    struct EglSlot {

        EglSlot()

        : mEglImage(EGL_NO_IMAGE_KHR),

          mEglFence(EGL_NO_SYNC_KHR) {

        }
@@ -379,7 +387,7 @@ private: 
    // slot that has not yet been used. The buffer allocated to a slot will also

    // be replaced if the requested buffer usage or geometry differs from that

    // of the buffer allocated to a slot.

    EGLSlot mEglSlots[BufferQueue::NUM_BUFFER_SLOTS];

    EglSlot mEglSlots[BufferQueue::NUM_BUFFER_SLOTS];



    // mCurrentTexture is the buffer slot index of the buffer that is currently

    // bound to the OpenGL texture. It is initialized to INVALID_BUFFER_SLOT,

libs/gui/BufferQueue.cpp

+0 −1
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ 
#include <private/gui/ComposerService.h>



#include <utils/Log.h>

#include <gui/SurfaceTexture.h>

#include <utils/Trace.h>



// Macros for including the BufferQueue name in log messages

libs/gui/SurfaceTexture.cpp

+192 −138
Original line number Diff line number Diff line
@@ -154,7 +154,56 @@ status_t SurfaceTexture::setDefaultBufferSize(uint32_t w, uint32_t h) 
}



status_t SurfaceTexture::updateTexImage() {

    return SurfaceTexture::updateTexImage(NULL, false);

    ATRACE_CALL();

    ST_LOGV("updateTexImage");

    Mutex::Autolock lock(mMutex);



    if (mAbandoned) {

        ST_LOGE("updateTexImage: SurfaceTexture is abandoned!");

        return NO_INIT;

    }



    // Make sure the EGL state is the same as in previous calls.

    status_t err = checkAndUpdateEglStateLocked();

    if (err != NO_ERROR) {

        return err;

    }



    BufferQueue::BufferItem item;



    // Acquire the next buffer.

    // In asynchronous mode the list is guaranteed to be one buffer

    // deep, while in synchronous mode we use the oldest buffer.

    err = acquireBufferLocked(&item);

    if (err != NO_ERROR) {

        if (err == BufferQueue::NO_BUFFER_AVAILABLE) {

            // We always bind the texture even if we don't update its contents.

            ST_LOGV("updateTexImage: no buffers were available");

            glBindTexture(mTexTarget, mTexName);

            err = NO_ERROR;

        } else {

            ST_LOGE("updateTexImage: acquire failed: %s (%d)",

                strerror(-err), err);

        }

        return err;

    }



    // Release the previous buffer.

    err = releaseAndUpdateLocked(item);

    if (err != NO_ERROR) {

        // We always bind the texture.

        glBindTexture(mTexTarget, mTexName);

        return err;

    }



    // Bind the new buffer to the GL texture.

    err = bindTextureImage();

    if (err != NO_ERROR) {

        return err;

    }



    // Wait for the new buffer to be ready.

    return doGLFenceWaitLocked();

}



status_t SurfaceTexture::acquireBufferLocked(BufferQueue::BufferItem *item) {
@@ -165,21 +214,16 @@ status_t SurfaceTexture::acquireBufferLocked(BufferQueue::BufferItem *item) { 


    int slot = item->mBuf;

    if (item->mGraphicBuffer != NULL) {

        // This buffer has not been acquired before, so we must assume

        // that any EGLImage in mEglSlots is stale.

        if (mEglSlots[slot].mEglImage != EGL_NO_IMAGE_KHR) {

            eglDestroyImageKHR(mEglDisplay, mEglSlots[slot].mEglImage);

            mEglSlots[slot].mEglImage = EGL_NO_IMAGE_KHR;

        }

            if (!eglDestroyImageKHR(mEglDisplay, mEglSlots[slot].mEglImage)) {

                ST_LOGW("acquireBufferLocked: eglDestroyImageKHR failed for slot=%d",

                      slot);

                // keep going

            }



    // Update the GL texture object. We may have to do this even when

    // item.mGraphicBuffer == NULL, if we destroyed the EGLImage when

    // detaching from a context but the buffer has not been re-allocated.

    if (mEglSlots[slot].mEglImage == EGL_NO_IMAGE_KHR) {

        EGLImageKHR image = createImage(mEglDisplay, mSlots[slot].mGraphicBuffer);

        if (image == EGL_NO_IMAGE_KHR) {

            return UNKNOWN_ERROR;

            mEglSlots[slot].mEglImage = EGL_NO_IMAGE_KHR;

        }

        mEglSlots[slot].mEglImage = image;

    }



    return NO_ERROR;
@@ -187,106 +231,71 @@ status_t SurfaceTexture::acquireBufferLocked(BufferQueue::BufferItem *item) { 


status_t SurfaceTexture::releaseBufferLocked(int buf, EGLDisplay display,

       EGLSyncKHR eglFence) {

    status_t err = ConsumerBase::releaseBufferLocked(buf, mEglDisplay,

           eglFence);

    status_t err = ConsumerBase::releaseBufferLocked(buf, display, eglFence);



    mEglSlots[buf].mEglFence = EGL_NO_SYNC_KHR;



    return err;

}



status_t SurfaceTexture::updateTexImage(BufferRejecter* rejecter, bool skipSync) {

    ATRACE_CALL();

    ST_LOGV("updateTexImage");

    Mutex::Autolock lock(mMutex);



status_t SurfaceTexture::releaseAndUpdateLocked(const BufferQueue::BufferItem& item)

{

    status_t err = NO_ERROR;



    if (mAbandoned) {

        ST_LOGE("updateTexImage: SurfaceTexture is abandoned!");

        return NO_INIT;

    }



    if (!mAttached) {

        ST_LOGE("updateTexImage: SurfaceTexture is not attached to an OpenGL "

        ST_LOGE("releaseAndUpdate: SurfaceTexture is not attached to an OpenGL "

                "ES context");

        return INVALID_OPERATION;

    }



    EGLDisplay dpy = eglGetCurrentDisplay();

    EGLContext ctx = eglGetCurrentContext();



    if ((mEglDisplay != dpy && mEglDisplay != EGL_NO_DISPLAY) ||

            dpy == EGL_NO_DISPLAY) {

        ST_LOGE("updateTexImage: invalid current EGLDisplay");

        return INVALID_OPERATION;

    }



    if ((mEglContext != ctx && mEglContext != EGL_NO_CONTEXT) ||

            ctx == EGL_NO_CONTEXT) {

        ST_LOGE("updateTexImage: invalid current EGLContext");

        return INVALID_OPERATION;

    // Confirm state.

    err = checkAndUpdateEglStateLocked();

    if (err != NO_ERROR) {

        return err;

    }



    mEglDisplay = dpy;

    mEglContext = ctx;



    BufferQueue::BufferItem item;



    // In asynchronous mode the list is guaranteed to be one buffer

    // deep, while in synchronous mode we use the oldest buffer.

    err = acquireBufferLocked(&item);

    if (err == NO_ERROR) {

    int buf = item.mBuf;



        // we call the rejecter here, in case the caller has a reason to

        // not accept this buffer. this is used by SurfaceFlinger to

        // reject buffers which have the wrong size

        if (rejecter && rejecter->reject(mSlots[buf].mGraphicBuffer, item)) {

            releaseBufferLocked(buf, dpy, EGL_NO_SYNC_KHR);

            glBindTexture(mTexTarget, mTexName);

            return NO_ERROR;

        }



        GLint error;

        while ((error = glGetError()) != GL_NO_ERROR) {

            ST_LOGW("updateTexImage: clearing GL error: %#04x", error);

        }



        EGLImageKHR image = mEglSlots[buf].mEglImage;

        glBindTexture(mTexTarget, mTexName);

        glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)image);



        while ((error = glGetError()) != GL_NO_ERROR) {

            ST_LOGE("updateTexImage: error binding external texture image %p "

                    "(slot %d): %#04x", image, buf, error);

            err = UNKNOWN_ERROR;

    // If the mEglSlot entry is empty, create an EGLImage for the gralloc

    // buffer currently in the slot in ConsumerBase.

    //

    // We may have to do this even when item.mGraphicBuffer == NULL (which

    // means the buffer was previously acquired), if we destroyed the

    // EGLImage when detaching from a context but the buffer has not been

    // re-allocated.

    if (mEglSlots[buf].mEglImage == EGL_NO_IMAGE_KHR) {

        EGLImageKHR image = createImage(mEglDisplay, mSlots[buf].mGraphicBuffer);

        if (image == EGL_NO_IMAGE_KHR) {

            ST_LOGW("releaseAndUpdate: unable to createImage on display=%p slot=%d",

                  mEglDisplay, buf);

            return UNKNOWN_ERROR;

        }



        if (err == NO_ERROR) {

            err = syncForReleaseLocked(dpy);

        mEglSlots[buf].mEglImage = image;

    }



    // Do whatever sync ops we need to do before releasing the old slot.

    err = syncForReleaseLocked(mEglDisplay);

    if (err != NO_ERROR) {

        // Release the buffer we just acquired.  It's not safe to

        // release the old buffer, so instead we just drop the new frame.

            releaseBufferLocked(buf, dpy, EGL_NO_SYNC_KHR);

        releaseBufferLocked(buf, mEglDisplay, EGL_NO_SYNC_KHR);

        return err;

    }



        ST_LOGV("updateTexImage: (slot=%d buf=%p) -> (slot=%d buf=%p)",

    ST_LOGV("releaseAndUpdate: (slot=%d buf=%p) -> (slot=%d buf=%p)",

            mCurrentTexture,

            mCurrentTextureBuf != NULL ? mCurrentTextureBuf->handle : 0,

            buf, mSlots[buf].mGraphicBuffer->handle);



    // release old buffer

    if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {

            status_t status = releaseBufferLocked(mCurrentTexture, dpy,

        status_t status = releaseBufferLocked(mCurrentTexture, mEglDisplay,

                mEglSlots[mCurrentTexture].mEglFence);

        if (status != NO_ERROR && status != BufferQueue::STALE_BUFFER_SLOT) {

                ST_LOGE("updateTexImage: failed to release buffer: %s (%d)",

            ST_LOGE("releaseAndUpdate: failed to release buffer: %s (%d)",

                   strerror(-status), status);

            err = status;

            // keep going, with error raised [?]

        }

    }
@@ -298,28 +307,63 @@ status_t SurfaceTexture::updateTexImage(BufferRejecter* rejecter, bool skipSync) 
    mCurrentScalingMode = item.mScalingMode;

    mCurrentTimestamp = item.mTimestamp;

    mCurrentFence = item.mFence;

        if (!skipSync) {

            // SurfaceFlinger needs to lazily perform GLES synchronization

            // only when it's actually going to use GLES for compositing.

            // Eventually SurfaceFlinger should have its own consumer class,

            // but for now we'll just hack it in to SurfaceTexture.

            // SurfaceFlinger is responsible for calling doGLFenceWait before

            // texturing from this SurfaceTexture.

            doGLFenceWaitLocked();

        }



    computeCurrentTransformMatrixLocked();

    } else  {

        if (err < 0) {

            ST_LOGE("updateTexImage: acquire failed: %s (%d)",

                strerror(-err), err);



    return err;

}

        // We always bind the texture even if we don't update its contents.



status_t SurfaceTexture::bindTextureImage() {

    if (mEglDisplay == EGL_NO_DISPLAY) {

        ALOGE("bindTextureImage: invalid display");

        return INVALID_OPERATION;

    }



    GLint error;

    while ((error = glGetError()) != GL_NO_ERROR) {

        ST_LOGW("bindTextureImage: clearing GL error: %#04x", error);

    }



    glBindTexture(mTexTarget, mTexName);

        return OK;

    if (mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT) {

        if (mCurrentTextureBuf == NULL) {

            ST_LOGE("bindTextureImage: no currently-bound texture");

            return NO_INIT;

        }

        return bindUnslottedBufferLocked(mEglDisplay);

    } else {

        EGLImageKHR image = mEglSlots[mCurrentTexture].mEglImage;



    return err;

        glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)image);



        while ((error = glGetError()) != GL_NO_ERROR) {

            ST_LOGE("bindTextureImage: error binding external texture image %p"

                    ": %#04x", image, error);

            return UNKNOWN_ERROR;

        }

        return NO_ERROR;

    }

}



status_t SurfaceTexture::checkAndUpdateEglStateLocked() {

    EGLDisplay dpy = eglGetCurrentDisplay();

    EGLContext ctx = eglGetCurrentContext();



    if ((mEglDisplay != dpy && mEglDisplay != EGL_NO_DISPLAY) ||

            dpy == EGL_NO_DISPLAY) {

        ST_LOGE("checkAndUpdateEglState: invalid current EGLDisplay");

        return INVALID_OPERATION;

    }



    if ((mEglContext != ctx && mEglContext != EGL_NO_CONTEXT) ||

            ctx == EGL_NO_CONTEXT) {

        ST_LOGE("checkAndUpdateEglState: invalid current EGLContext");

        return INVALID_OPERATION;

    }



    mEglDisplay = dpy;

    mEglContext = ctx;

    return NO_ERROR;

}



void SurfaceTexture::setReleaseFence(int fenceFd) {
@@ -427,6 +471,25 @@ status_t SurfaceTexture::attachToContext(GLuint tex) { 
        // The EGLImageKHR that was associated with the slot was destroyed when

        // the SurfaceTexture was detached from the old context, so we need to

        // recreate it here.

        status_t err = bindUnslottedBufferLocked(dpy);

        if (err != NO_ERROR) {

            return err;

        }

    }



    mEglDisplay = dpy;

    mEglContext = ctx;

    mTexName = tex;

    mAttached = true;



    return OK;

}



status_t SurfaceTexture::bindUnslottedBufferLocked(EGLDisplay dpy) {

    ST_LOGV("bindUnslottedBuffer ct=%d ctb=%p",

            mCurrentTexture, mCurrentTextureBuf.get());



    // Create a temporary EGLImageKHR.

    EGLImageKHR image = createImage(dpy, mCurrentTextureBuf);

    if (image == EGL_NO_IMAGE_KHR) {

        return UNKNOWN_ERROR;
@@ -438,7 +501,7 @@ status_t SurfaceTexture::attachToContext(GLuint tex) { 
    GLint error;

    status_t err = OK;

    while ((error = glGetError()) != GL_NO_ERROR) {

            ST_LOGE("attachToContext: error binding external texture image %p "

        ST_LOGE("bindUnslottedBuffer: error binding external texture image %p "

                "(slot %d): %#04x", image, mCurrentTexture, error);

        err = UNKNOWN_ERROR;

    }
@@ -450,18 +513,9 @@ status_t SurfaceTexture::attachToContext(GLuint tex) { 
    // gets acquired in updateTexImage.

    eglDestroyImageKHR(dpy, image);



        if (err != OK) {

    return err;

}

    }



    mEglDisplay = dpy;

    mEglContext = ctx;

    mTexName = tex;

    mAttached = true;



    return OK;

}



status_t SurfaceTexture::syncForReleaseLocked(EGLDisplay dpy) {

    ST_LOGV("syncForReleaseLocked");

services/surfaceflinger/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ LOCAL_SRC_FILES:= \ 
    GLExtensions.cpp                        \

    MessageQueue.cpp                        \

    SurfaceFlinger.cpp                      \

    SurfaceFlingerConsumer.cpp              \

    SurfaceTextureLayer.cpp                 \

    Transform.cpp                           \