You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
675 lines
25 KiB
675 lines
25 KiB
/*
|
|
* Copyright (C) 2018 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define GL_GLEXT_PROTOTYPES
|
|
#define EGL_EGLEXT_PROTOTYPES
|
|
|
|
#include <EGL/egl.h>
|
|
#include <EGL/eglext.h>
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
#include <cutils/compiler.h>
|
|
#include <gui/BufferItem.h>
|
|
#include <gui/BufferQueue.h>
|
|
#include <surfacetexture/EGLConsumer.h>
|
|
#include <surfacetexture/SurfaceTexture.h>
|
|
#include <inttypes.h>
|
|
#include <private/gui/SyncFeatures.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/String8.h>
|
|
#include <utils/Trace.h>
|
|
|
|
#define PROT_CONTENT_EXT_STR "EGL_EXT_protected_content"
|
|
#define EGL_PROTECTED_CONTENT_EXT 0x32C0
|
|
|
|
namespace android {
|
|
|
|
// Macros for including the SurfaceTexture name in log messages
|
|
#define EGC_LOGV(x, ...) ALOGV("[%s] " x, st.mName.string(), ##__VA_ARGS__)
|
|
#define EGC_LOGD(x, ...) ALOGD("[%s] " x, st.mName.string(), ##__VA_ARGS__)
|
|
#define EGC_LOGW(x, ...) ALOGW("[%s] " x, st.mName.string(), ##__VA_ARGS__)
|
|
#define EGC_LOGE(x, ...) ALOGE("[%s] " x, st.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____"
|
|
"_______________"
|
|
"_______________"};
|
|
|
|
Mutex EGLConsumer::sStaticInitLock;
|
|
sp<GraphicBuffer> EGLConsumer::sReleasedTexImageBuffer;
|
|
|
|
static bool hasEglProtectedContentImpl() {
|
|
EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
const char* exts = eglQueryString(dpy, EGL_EXTENSIONS);
|
|
size_t cropExtLen = strlen(PROT_CONTENT_EXT_STR);
|
|
size_t extsLen = strlen(exts);
|
|
bool equal = !strcmp(PROT_CONTENT_EXT_STR, exts);
|
|
bool atStart = !strncmp(PROT_CONTENT_EXT_STR " ", exts, cropExtLen + 1);
|
|
bool atEnd = (cropExtLen + 1) < extsLen &&
|
|
!strcmp(" " PROT_CONTENT_EXT_STR, exts + extsLen - (cropExtLen + 1));
|
|
bool inMiddle = strstr(exts, " " PROT_CONTENT_EXT_STR " ");
|
|
return equal || atStart || atEnd || inMiddle;
|
|
}
|
|
|
|
static bool hasEglProtectedContent() {
|
|
// Only compute whether the extension is present once the first time this
|
|
// function is called.
|
|
static bool hasIt = hasEglProtectedContentImpl();
|
|
return hasIt;
|
|
}
|
|
|
|
EGLConsumer::EGLConsumer() : mEglDisplay(EGL_NO_DISPLAY), mEglContext(EGL_NO_CONTEXT) {}
|
|
|
|
status_t EGLConsumer::updateTexImage(SurfaceTexture& st) {
|
|
// Make sure the EGL state is the same as in previous calls.
|
|
status_t err = checkAndUpdateEglStateLocked(st);
|
|
if (err != NO_ERROR) {
|
|
return err;
|
|
}
|
|
|
|
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 = st.acquireBufferLocked(&item, 0);
|
|
if (err != NO_ERROR) {
|
|
if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
|
|
// We always bind the texture even if we don't update its contents.
|
|
EGC_LOGV("updateTexImage: no buffers were available");
|
|
glBindTexture(st.mTexTarget, st.mTexName);
|
|
err = NO_ERROR;
|
|
} else {
|
|
EGC_LOGE("updateTexImage: acquire failed: %s (%d)", strerror(-err), err);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
// Release the previous buffer.
|
|
err = updateAndReleaseLocked(item, nullptr, st);
|
|
if (err != NO_ERROR) {
|
|
// We always bind the texture.
|
|
glBindTexture(st.mTexTarget, st.mTexName);
|
|
return err;
|
|
}
|
|
|
|
// Bind the new buffer to the GL texture, and wait until it's ready.
|
|
return bindTextureImageLocked(st);
|
|
}
|
|
|
|
status_t EGLConsumer::releaseTexImage(SurfaceTexture& st) {
|
|
// Make sure the EGL state is the same as in previous calls.
|
|
status_t err = NO_ERROR;
|
|
|
|
// if we're detached, no need to validate EGL's state -- we won't use it.
|
|
if (st.mOpMode == SurfaceTexture::OpMode::attachedToGL) {
|
|
err = checkAndUpdateEglStateLocked(st, true);
|
|
if (err != NO_ERROR) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
// Update the EGLConsumer state.
|
|
int buf = st.mCurrentTexture;
|
|
if (buf != BufferQueue::INVALID_BUFFER_SLOT) {
|
|
EGC_LOGV("releaseTexImage: (slot=%d, mOpMode=%d)", buf, (int)st.mOpMode);
|
|
|
|
// if we're detached, we just use the fence that was created in
|
|
// detachFromContext() so... basically, nothing more to do here.
|
|
if (st.mOpMode == SurfaceTexture::OpMode::attachedToGL) {
|
|
// Do whatever sync ops we need to do before releasing the slot.
|
|
err = syncForReleaseLocked(mEglDisplay, st);
|
|
if (err != NO_ERROR) {
|
|
EGC_LOGE("syncForReleaseLocked failed (slot=%d), err=%d", buf, err);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
err = st.releaseBufferLocked(buf, st.mSlots[buf].mGraphicBuffer, mEglDisplay,
|
|
EGL_NO_SYNC_KHR);
|
|
if (err < NO_ERROR) {
|
|
EGC_LOGE("releaseTexImage: failed to release buffer: %s (%d)", strerror(-err), err);
|
|
return err;
|
|
}
|
|
|
|
if (mReleasedTexImage == nullptr) {
|
|
mReleasedTexImage = new EglImage(getDebugTexImageBuffer());
|
|
}
|
|
|
|
st.mCurrentTexture = BufferQueue::INVALID_BUFFER_SLOT;
|
|
mCurrentTextureImage = mReleasedTexImage;
|
|
st.mCurrentCrop.makeInvalid();
|
|
st.mCurrentTransform = 0;
|
|
st.mCurrentTimestamp = 0;
|
|
st.mCurrentDataSpace = HAL_DATASPACE_UNKNOWN;
|
|
st.mCurrentFence = Fence::NO_FENCE;
|
|
st.mCurrentFenceTime = FenceTime::NO_FENCE;
|
|
|
|
// detached, don't touch the texture (and we may not even have an
|
|
// EGLDisplay here.
|
|
if (st.mOpMode == SurfaceTexture::OpMode::attachedToGL) {
|
|
// This binds a dummy buffer (mReleasedTexImage).
|
|
status_t result = bindTextureImageLocked(st);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
sp<GraphicBuffer> EGLConsumer::getDebugTexImageBuffer() {
|
|
Mutex::Autolock _l(sStaticInitLock);
|
|
if (CC_UNLIKELY(sReleasedTexImageBuffer == nullptr)) {
|
|
// 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,
|
|
"[EGLConsumer 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;
|
|
}
|
|
|
|
void EGLConsumer::onAcquireBufferLocked(BufferItem* item, SurfaceTexture& st) {
|
|
// If item->mGraphicBuffer is not null, this buffer has not been acquired
|
|
// before, so any prior EglImage created is using a stale buffer. This
|
|
// replaces any old EglImage with a new one (using the new buffer).
|
|
int slot = item->mSlot;
|
|
if (item->mGraphicBuffer != nullptr || mEglSlots[slot].mEglImage.get() == nullptr) {
|
|
mEglSlots[slot].mEglImage = new EglImage(st.mSlots[slot].mGraphicBuffer);
|
|
}
|
|
}
|
|
|
|
void EGLConsumer::onReleaseBufferLocked(int buf) {
|
|
mEglSlots[buf].mEglFence = EGL_NO_SYNC_KHR;
|
|
}
|
|
|
|
status_t EGLConsumer::updateAndReleaseLocked(const BufferItem& item, PendingRelease* pendingRelease,
|
|
SurfaceTexture& st) {
|
|
status_t err = NO_ERROR;
|
|
|
|
int slot = item.mSlot;
|
|
|
|
if (st.mOpMode != SurfaceTexture::OpMode::attachedToGL) {
|
|
EGC_LOGE("updateAndRelease: EGLConsumer is not attached to an OpenGL "
|
|
"ES context");
|
|
st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
// Confirm state.
|
|
err = checkAndUpdateEglStateLocked(st);
|
|
if (err != NO_ERROR) {
|
|
st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);
|
|
return err;
|
|
}
|
|
|
|
// Ensure we have a valid EglImageKHR for the slot, creating an EglImage
|
|
// if nessessary, 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).
|
|
err = mEglSlots[slot].mEglImage->createIfNeeded(mEglDisplay);
|
|
if (err != NO_ERROR) {
|
|
EGC_LOGW("updateAndRelease: unable to createImage on display=%p slot=%d", mEglDisplay,
|
|
slot);
|
|
st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
// Do whatever sync ops we need to do before releasing the old slot.
|
|
if (slot != st.mCurrentTexture) {
|
|
err = syncForReleaseLocked(mEglDisplay, st);
|
|
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.
|
|
// As we are still under lock since acquireBuffer, it is safe to
|
|
// release by slot.
|
|
st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay,
|
|
EGL_NO_SYNC_KHR);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
EGC_LOGV("updateAndRelease: (slot=%d buf=%p) -> (slot=%d buf=%p)", st.mCurrentTexture,
|
|
mCurrentTextureImage != nullptr ? mCurrentTextureImage->graphicBufferHandle()
|
|
: nullptr,
|
|
slot, st.mSlots[slot].mGraphicBuffer->handle);
|
|
|
|
// Hang onto the pointer so that it isn't freed in the call to
|
|
// releaseBufferLocked() if we're in shared buffer mode and both buffers are
|
|
// the same.
|
|
sp<EglImage> nextTextureImage = mEglSlots[slot].mEglImage;
|
|
|
|
// release old buffer
|
|
if (st.mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
|
|
if (pendingRelease == nullptr) {
|
|
status_t status =
|
|
st.releaseBufferLocked(st.mCurrentTexture,
|
|
mCurrentTextureImage->graphicBuffer(), mEglDisplay,
|
|
mEglSlots[st.mCurrentTexture].mEglFence);
|
|
if (status < NO_ERROR) {
|
|
EGC_LOGE("updateAndRelease: failed to release buffer: %s (%d)", strerror(-status),
|
|
status);
|
|
err = status;
|
|
// keep going, with error raised [?]
|
|
}
|
|
} else {
|
|
pendingRelease->currentTexture = st.mCurrentTexture;
|
|
pendingRelease->graphicBuffer = mCurrentTextureImage->graphicBuffer();
|
|
pendingRelease->display = mEglDisplay;
|
|
pendingRelease->fence = mEglSlots[st.mCurrentTexture].mEglFence;
|
|
pendingRelease->isPending = true;
|
|
}
|
|
}
|
|
|
|
// Update the EGLConsumer state.
|
|
st.mCurrentTexture = slot;
|
|
mCurrentTextureImage = nextTextureImage;
|
|
st.mCurrentCrop = item.mCrop;
|
|
st.mCurrentTransform = item.mTransform;
|
|
st.mCurrentScalingMode = item.mScalingMode;
|
|
st.mCurrentTimestamp = item.mTimestamp;
|
|
st.mCurrentDataSpace = item.mDataSpace;
|
|
st.mCurrentFence = item.mFence;
|
|
st.mCurrentFenceTime = item.mFenceTime;
|
|
st.mCurrentFrameNumber = item.mFrameNumber;
|
|
|
|
st.computeCurrentTransformMatrixLocked();
|
|
|
|
return err;
|
|
}
|
|
|
|
status_t EGLConsumer::bindTextureImageLocked(SurfaceTexture& st) {
|
|
if (mEglDisplay == EGL_NO_DISPLAY) {
|
|
ALOGE("bindTextureImage: invalid display");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
GLenum error;
|
|
while ((error = glGetError()) != GL_NO_ERROR) {
|
|
EGC_LOGW("bindTextureImage: clearing GL error: %#04x", error);
|
|
}
|
|
|
|
glBindTexture(st.mTexTarget, st.mTexName);
|
|
if (st.mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT && mCurrentTextureImage == nullptr) {
|
|
EGC_LOGE("bindTextureImage: no currently-bound texture");
|
|
return NO_INIT;
|
|
}
|
|
|
|
status_t err = mCurrentTextureImage->createIfNeeded(mEglDisplay);
|
|
if (err != NO_ERROR) {
|
|
EGC_LOGW("bindTextureImage: can't create image on display=%p slot=%d", mEglDisplay,
|
|
st.mCurrentTexture);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
mCurrentTextureImage->bindToTextureTarget(st.mTexTarget);
|
|
|
|
// In the rare case that the display is terminated and then initialized
|
|
// again, we can't detect that the display changed (it didn't), but the
|
|
// image is invalid. In this case, repeat the exact same steps while
|
|
// forcing the creation of a new image.
|
|
if ((error = glGetError()) != GL_NO_ERROR) {
|
|
glBindTexture(st.mTexTarget, st.mTexName);
|
|
status_t result = mCurrentTextureImage->createIfNeeded(mEglDisplay, true);
|
|
if (result != NO_ERROR) {
|
|
EGC_LOGW("bindTextureImage: can't create image on display=%p slot=%d", mEglDisplay,
|
|
st.mCurrentTexture);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
mCurrentTextureImage->bindToTextureTarget(st.mTexTarget);
|
|
if ((error = glGetError()) != GL_NO_ERROR) {
|
|
EGC_LOGE("bindTextureImage: error binding external image: %#04x", error);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
}
|
|
|
|
// Wait for the new buffer to be ready.
|
|
return doGLFenceWaitLocked(st);
|
|
}
|
|
|
|
status_t EGLConsumer::checkAndUpdateEglStateLocked(SurfaceTexture& st, bool contextCheck) {
|
|
EGLDisplay dpy = eglGetCurrentDisplay();
|
|
EGLContext ctx = eglGetCurrentContext();
|
|
|
|
if (!contextCheck) {
|
|
// if this is the first time we're called, mEglDisplay/mEglContext have
|
|
// never been set, so don't error out (below).
|
|
if (mEglDisplay == EGL_NO_DISPLAY) {
|
|
mEglDisplay = dpy;
|
|
}
|
|
if (mEglContext == EGL_NO_CONTEXT) {
|
|
mEglContext = ctx;
|
|
}
|
|
}
|
|
|
|
if (mEglDisplay != dpy || dpy == EGL_NO_DISPLAY) {
|
|
EGC_LOGE("checkAndUpdateEglState: invalid current EGLDisplay");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (mEglContext != ctx || ctx == EGL_NO_CONTEXT) {
|
|
EGC_LOGE("checkAndUpdateEglState: invalid current EGLContext");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
mEglDisplay = dpy;
|
|
mEglContext = ctx;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t EGLConsumer::detachFromContext(SurfaceTexture& st) {
|
|
EGLDisplay dpy = eglGetCurrentDisplay();
|
|
EGLContext ctx = eglGetCurrentContext();
|
|
|
|
if (mEglDisplay != dpy && mEglDisplay != EGL_NO_DISPLAY) {
|
|
EGC_LOGE("detachFromContext: invalid current EGLDisplay");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (mEglContext != ctx && mEglContext != EGL_NO_CONTEXT) {
|
|
EGC_LOGE("detachFromContext: invalid current EGLContext");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (dpy != EGL_NO_DISPLAY && ctx != EGL_NO_CONTEXT) {
|
|
status_t err = syncForReleaseLocked(dpy, st);
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
glDeleteTextures(1, &st.mTexName);
|
|
}
|
|
|
|
mEglDisplay = EGL_NO_DISPLAY;
|
|
mEglContext = EGL_NO_CONTEXT;
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t EGLConsumer::attachToContext(uint32_t tex, SurfaceTexture& st) {
|
|
// Initialize mCurrentTextureImage if there is a current buffer from past
|
|
// attached state.
|
|
int slot = st.mCurrentTexture;
|
|
if (slot != BufferItem::INVALID_BUFFER_SLOT) {
|
|
if (!mEglSlots[slot].mEglImage.get()) {
|
|
mEglSlots[slot].mEglImage = new EglImage(st.mSlots[slot].mGraphicBuffer);
|
|
}
|
|
mCurrentTextureImage = mEglSlots[slot].mEglImage;
|
|
}
|
|
|
|
EGLDisplay dpy = eglGetCurrentDisplay();
|
|
EGLContext ctx = eglGetCurrentContext();
|
|
|
|
if (dpy == EGL_NO_DISPLAY) {
|
|
EGC_LOGE("attachToContext: invalid current EGLDisplay");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (ctx == EGL_NO_CONTEXT) {
|
|
EGC_LOGE("attachToContext: invalid current EGLContext");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
// We need to bind the texture regardless of whether there's a current
|
|
// buffer.
|
|
glBindTexture(st.mTexTarget, GLuint(tex));
|
|
|
|
mEglDisplay = dpy;
|
|
mEglContext = ctx;
|
|
st.mTexName = tex;
|
|
st.mOpMode = SurfaceTexture::OpMode::attachedToGL;
|
|
|
|
if (mCurrentTextureImage != nullptr) {
|
|
// This may wait for a buffer a second time. This is likely required if
|
|
// this is a different context, since otherwise the wait could be skipped
|
|
// by bouncing through another context. For the same context the extra
|
|
// wait is redundant.
|
|
status_t err = bindTextureImageLocked(st);
|
|
if (err != NO_ERROR) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t EGLConsumer::syncForReleaseLocked(EGLDisplay dpy, SurfaceTexture& st) {
|
|
EGC_LOGV("syncForReleaseLocked");
|
|
|
|
if (st.mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
|
|
if (SyncFeatures::getInstance().useNativeFenceSync()) {
|
|
EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
|
|
if (sync == EGL_NO_SYNC_KHR) {
|
|
EGC_LOGE("syncForReleaseLocked: error creating EGL fence: %#x", eglGetError());
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
glFlush();
|
|
int fenceFd = eglDupNativeFenceFDANDROID(dpy, sync);
|
|
eglDestroySyncKHR(dpy, sync);
|
|
if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
|
|
EGC_LOGE("syncForReleaseLocked: error dup'ing native fence "
|
|
"fd: %#x",
|
|
eglGetError());
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
sp<Fence> fence(new Fence(fenceFd));
|
|
status_t err = st.addReleaseFenceLocked(st.mCurrentTexture,
|
|
mCurrentTextureImage->graphicBuffer(), fence);
|
|
if (err != OK) {
|
|
EGC_LOGE("syncForReleaseLocked: error adding release fence: "
|
|
"%s (%d)",
|
|
strerror(-err), err);
|
|
return err;
|
|
}
|
|
} else if (st.mUseFenceSync && SyncFeatures::getInstance().useFenceSync()) {
|
|
EGLSyncKHR fence = mEglSlots[st.mCurrentTexture].mEglFence;
|
|
if (fence != EGL_NO_SYNC_KHR) {
|
|
// There is already a fence for the current slot. We need to
|
|
// wait on that before replacing it with another fence to
|
|
// ensure that all outstanding buffer accesses have completed
|
|
// before the producer accesses it.
|
|
EGLint result = eglClientWaitSyncKHR(dpy, fence, 0, 1000000000);
|
|
if (result == EGL_FALSE) {
|
|
EGC_LOGE("syncForReleaseLocked: error waiting for previous "
|
|
"fence: %#x",
|
|
eglGetError());
|
|
return UNKNOWN_ERROR;
|
|
} else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
|
|
EGC_LOGE("syncForReleaseLocked: timeout waiting for previous "
|
|
"fence");
|
|
return TIMED_OUT;
|
|
}
|
|
eglDestroySyncKHR(dpy, fence);
|
|
}
|
|
|
|
// Create a fence for the outstanding accesses in the current
|
|
// OpenGL ES context.
|
|
fence = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, nullptr);
|
|
if (fence == EGL_NO_SYNC_KHR) {
|
|
EGC_LOGE("syncForReleaseLocked: error creating fence: %#x", eglGetError());
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
glFlush();
|
|
mEglSlots[st.mCurrentTexture].mEglFence = fence;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t EGLConsumer::doGLFenceWaitLocked(SurfaceTexture& st) const {
|
|
EGLDisplay dpy = eglGetCurrentDisplay();
|
|
EGLContext ctx = eglGetCurrentContext();
|
|
|
|
if (mEglDisplay != dpy || mEglDisplay == EGL_NO_DISPLAY) {
|
|
EGC_LOGE("doGLFenceWait: invalid current EGLDisplay");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (mEglContext != ctx || mEglContext == EGL_NO_CONTEXT) {
|
|
EGC_LOGE("doGLFenceWait: invalid current EGLContext");
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (st.mCurrentFence->isValid()) {
|
|
if (SyncFeatures::getInstance().useWaitSync() &&
|
|
SyncFeatures::getInstance().useNativeFenceSync()) {
|
|
// Create an EGLSyncKHR from the current fence.
|
|
int fenceFd = st.mCurrentFence->dup();
|
|
if (fenceFd == -1) {
|
|
EGC_LOGE("doGLFenceWait: error dup'ing fence fd: %d", errno);
|
|
return -errno;
|
|
}
|
|
EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd, EGL_NONE};
|
|
EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
|
|
if (sync == EGL_NO_SYNC_KHR) {
|
|
close(fenceFd);
|
|
EGC_LOGE("doGLFenceWait: error creating EGL fence: %#x", eglGetError());
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
// XXX: The spec draft is inconsistent as to whether this should
|
|
// return an EGLint or void. Ignore the return value for now, as
|
|
// it's not strictly needed.
|
|
eglWaitSyncKHR(dpy, sync, 0);
|
|
EGLint eglErr = eglGetError();
|
|
eglDestroySyncKHR(dpy, sync);
|
|
if (eglErr != EGL_SUCCESS) {
|
|
EGC_LOGE("doGLFenceWait: error waiting for EGL fence: %#x", eglErr);
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
} else {
|
|
status_t err = st.mCurrentFence->waitForever("EGLConsumer::doGLFenceWaitLocked");
|
|
if (err != NO_ERROR) {
|
|
EGC_LOGE("doGLFenceWait: error waiting for fence: %d", err);
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void EGLConsumer::onFreeBufferLocked(int slotIndex) {
|
|
mEglSlots[slotIndex].mEglImage.clear();
|
|
}
|
|
|
|
void EGLConsumer::onAbandonLocked() {
|
|
mCurrentTextureImage.clear();
|
|
}
|
|
|
|
EGLConsumer::EglImage::EglImage(sp<GraphicBuffer> graphicBuffer)
|
|
: mGraphicBuffer(graphicBuffer), mEglImage(EGL_NO_IMAGE_KHR), mEglDisplay(EGL_NO_DISPLAY) {}
|
|
|
|
EGLConsumer::EglImage::~EglImage() {
|
|
if (mEglImage != EGL_NO_IMAGE_KHR) {
|
|
if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) {
|
|
ALOGE("~EglImage: eglDestroyImageKHR failed");
|
|
}
|
|
eglTerminate(mEglDisplay);
|
|
}
|
|
}
|
|
|
|
status_t EGLConsumer::EglImage::createIfNeeded(EGLDisplay eglDisplay, bool forceCreation) {
|
|
// If there's an image and it's no longer valid, destroy it.
|
|
bool haveImage = mEglImage != EGL_NO_IMAGE_KHR;
|
|
bool displayInvalid = mEglDisplay != eglDisplay;
|
|
if (haveImage && (displayInvalid || forceCreation)) {
|
|
if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) {
|
|
ALOGE("createIfNeeded: eglDestroyImageKHR failed");
|
|
}
|
|
eglTerminate(mEglDisplay);
|
|
mEglImage = EGL_NO_IMAGE_KHR;
|
|
mEglDisplay = EGL_NO_DISPLAY;
|
|
}
|
|
|
|
// If there's no image, create one.
|
|
if (mEglImage == EGL_NO_IMAGE_KHR) {
|
|
mEglDisplay = eglDisplay;
|
|
mEglImage = createImage(mEglDisplay, mGraphicBuffer);
|
|
}
|
|
|
|
// Fail if we can't create a valid image.
|
|
if (mEglImage == EGL_NO_IMAGE_KHR) {
|
|
mEglDisplay = EGL_NO_DISPLAY;
|
|
const sp<GraphicBuffer>& buffer = mGraphicBuffer;
|
|
ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
|
|
buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(),
|
|
buffer->getPixelFormat());
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
void EGLConsumer::EglImage::bindToTextureTarget(uint32_t texTarget) {
|
|
glEGLImageTargetTexture2DOES(texTarget, static_cast<GLeglImageOES>(mEglImage));
|
|
}
|
|
|
|
EGLImageKHR EGLConsumer::EglImage::createImage(EGLDisplay dpy,
|
|
const sp<GraphicBuffer>& graphicBuffer) {
|
|
EGLClientBuffer cbuf = static_cast<EGLClientBuffer>(graphicBuffer->getNativeBuffer());
|
|
const bool createProtectedImage =
|
|
(graphicBuffer->getUsage() & GRALLOC_USAGE_PROTECTED) && hasEglProtectedContent();
|
|
EGLint attrs[] = {
|
|
EGL_IMAGE_PRESERVED_KHR,
|
|
EGL_TRUE,
|
|
createProtectedImage ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
|
|
createProtectedImage ? EGL_TRUE : EGL_NONE,
|
|
EGL_NONE,
|
|
};
|
|
eglInitialize(dpy, nullptr, nullptr);
|
|
EGLImageKHR image =
|
|
eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, cbuf, attrs);
|
|
if (image == EGL_NO_IMAGE_KHR) {
|
|
EGLint error = eglGetError();
|
|
ALOGE("error creating EGLImage: %#x", error);
|
|
eglTerminate(dpy);
|
|
}
|
|
return image;
|
|
}
|
|
|
|
} // namespace android
|