surfaceflinger: remove BufferLayerConsumer::releaseTexImage

#define BLC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)

#define BLC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)

static const struct {

    uint32_t width, height;

    char const* bits;

} kDebugData = {15, 12,

                "_______________"

                "_______________"

                "_____XX_XX_____"

                "__X_X_____X_X__"

                "__X_XXXXXXX_X__"

                "__XXXXXXXXXXX__"

                "___XX_XXX_XX___"

                "____XXXXXXX____"

                "_____X___X_____"

                "____X_____X____"

                "_______________"

                "_______________"};

static const mat4 mtxIdentity;

Mutex BufferLayerConsumer::sStaticInitLock;

sp<GraphicBuffer> BufferLayerConsumer::sReleasedTexImageBuffer;

static bool hasEglAndroidImageCropImpl() {

    EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    const char* exts = eglQueryStringImplementationANDROID(dpy, EGL_EXTENSIONS);

    return bindTextureImageLocked();

}

status_t BufferLayerConsumer::releaseTexImage() {

    ATRACE_CALL();

    BLC_LOGV("releaseTexImage");

    Mutex::Autolock lock(mMutex);

    if (mAbandoned) {

        BLC_LOGE("releaseTexImage: BufferLayerConsumer is abandoned!");

        return NO_INIT;

    }

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

    status_t err = NO_ERROR;

    if (mAttached) {

        err = checkAndUpdateEglStateLocked(true);

        if (err != NO_ERROR) {

            return err;

        }

    } else {

        // if we're detached, no need to validate EGL's state -- we won't use it.

    }

    // Update the BufferLayerConsumer state.

    int buf = mCurrentTexture;

    if (buf != BufferQueue::INVALID_BUFFER_SLOT) {

        BLC_LOGV("releaseTexImage: (slot=%d, mAttached=%d)", buf, mAttached);

        if (mAttached) {

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

            err = syncForReleaseLocked(mEglDisplay);

            if (err != NO_ERROR) {

                BLC_LOGE("syncForReleaseLocked failed (slot=%d), err=%d", buf, err);

                return err;

            }

        } else {

            // if we're detached, we just use the fence that was created in detachFromContext()

            // so... basically, nothing more to do here.

        }

        err = releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);

        if (err < NO_ERROR) {

            BLC_LOGE("releaseTexImage: failed to release buffer: %s (%d)", strerror(-err), err);

            return err;

        }

        if (mReleasedTexImage == NULL) {

            mReleasedTexImage = new EglImage(getDebugTexImageBuffer());

        }

        mCurrentTexture = BufferQueue::INVALID_BUFFER_SLOT;

        mCurrentTextureImage = mReleasedTexImage;

        mCurrentCrop.makeInvalid();

        mCurrentTransform = 0;

        mCurrentTimestamp = 0;

        mCurrentDataSpace = HAL_DATASPACE_UNKNOWN;

        mCurrentFence = Fence::NO_FENCE;

        mCurrentFenceTime = FenceTime::NO_FENCE;

        if (mAttached) {

            // This binds a dummy buffer (mReleasedTexImage).

            status_t result = bindTextureImageLocked();

            if (result != NO_ERROR) {

                return result;

            }

        } else {

            // detached, don't touch the texture (and we may not even have an

            // EGLDisplay here.

        }

    }

    return NO_ERROR;

}

sp<GraphicBuffer> BufferLayerConsumer::getDebugTexImageBuffer() {

    Mutex::Autolock _l(sStaticInitLock);

    if (CC_UNLIKELY(sReleasedTexImageBuffer == NULL)) {

        // The first time, create the debug texture in case the application

        // continues to use it.

        sp<GraphicBuffer> buffer =

                new GraphicBuffer(kDebugData.width, kDebugData.height, PIXEL_FORMAT_RGBA_8888,

                                  GraphicBuffer::USAGE_SW_WRITE_RARELY,

                                  "[BufferLayerConsumer debug texture]");

        uint32_t* bits;

        buffer->lock(GraphicBuffer::USAGE_SW_WRITE_RARELY, reinterpret_cast<void**>(&bits));

        uint32_t stride = buffer->getStride();

        uint32_t height = buffer->getHeight();

        memset(bits, 0, stride * height * 4);

        for (uint32_t y = 0; y < kDebugData.height; y++) {

            for (uint32_t x = 0; x < kDebugData.width; x++) {

                bits[x] = (kDebugData.bits[y + kDebugData.width + x] == 'X') ? 0xFF000000

                                                                             : 0xFFFFFFFF;

            }

            bits += stride;

        }

        buffer->unlock();

        sReleasedTexImageBuffer = buffer;

    }

    return sReleasedTexImageBuffer;

}

status_t BufferLayerConsumer::acquireBufferLocked(BufferItem* item, nsecs_t presentWhen,

                                                  uint64_t maxFrameNumber) {

    status_t err = ConsumerBase::acquireBufferLocked(item, presentWhen, maxFrameNumber);

    // This calls doGLFenceWait to ensure proper synchronization.

    status_t updateTexImage();

    // releaseTexImage releases the texture acquired in updateTexImage().

    // This is intended to be used in single buffer mode.

    //

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

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

    status_t releaseTexImage();

    // setReleaseFence stores a fence that will signal when the current buffer

    // is no longer being read. This fence will be returned to the producer

    // when the current buffer is released by updateTexImage(). Multiple

private:

    // EglImage is a utility class for tracking and creating EGLImageKHRs. There

    // is primarily just one image per slot, but there is also special cases:

    //  - For releaseTexImage, we use a debug image (mReleasedTexImage)

    //  - After freeBuffer, we must still keep the current image/buffer

    // Reference counting EGLImages lets us handle all these cases easily while

    // also only creating new EGLImages from buffers when required.

    // before the outstanding accesses have completed.

    status_t syncForReleaseLocked(EGLDisplay dpy);

    // returns a graphic buffer used when the texture image has been released

    static sp<GraphicBuffer> getDebugTexImageBuffer();

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

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

    // from the BufferLayerConsumer user. In particular, BufferLayerConsumer will always

    // It is set to false by detachFromContext, and then set to true again by

    // attachToContext.

    bool mAttached;

    // protects static initialization

    static Mutex sStaticInitLock;

    // mReleasedTexImageBuffer is a dummy buffer used when in single buffer

    // mode and releaseTexImage() has been called

    static sp<GraphicBuffer> sReleasedTexImageBuffer;

    sp<EglImage> mReleasedTexImage;

};

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