diff options
Diffstat (limited to 'libs/gui/GLConsumer.cpp')
| -rw-r--r-- | libs/gui/GLConsumer.cpp | 206 |
1 files changed, 97 insertions, 109 deletions
diff --git a/libs/gui/GLConsumer.cpp b/libs/gui/GLConsumer.cpp index 936ad53..b886c5b 100644 --- a/libs/gui/GLConsumer.cpp +++ b/libs/gui/GLConsumer.cpp @@ -47,28 +47,18 @@ EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint na namespace android { // Macros for including the GLConsumer name in log messages -#define GLC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) -#define GLC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define GLC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) -#define GLC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) -#define GLC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__) +#define ST_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) +#define ST_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) +#define ST_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) +#define ST_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) +#define ST_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__) static const struct { - uint32_t width, height; + size_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____" - "_______________" - "_______________" + "___________________________________XX_XX_______X_X_____X_X____X_XXXXXXX_X____XXXXXXXXXXX__" + "___XX_XXX_XX_______XXXXXXX_________X___X_________X_____X__________________________________" }; // Transform matrices @@ -145,7 +135,7 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t tex, mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT), mAttached(true) { - GLC_LOGV("GLConsumer"); + ST_LOGV("GLConsumer"); memcpy(mCurrentTransformMatrix, mtxIdentity, sizeof(mCurrentTransformMatrix)); @@ -164,7 +154,7 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget, mDefaultWidth(1), mDefaultHeight(1), mFilteringEnabled(true), - mTexName(0), + mTexName(-1), mUseFenceSync(useFenceSync), mTexTarget(texTarget), mEglDisplay(EGL_NO_DISPLAY), @@ -172,7 +162,7 @@ GLConsumer::GLConsumer(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget, mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT), mAttached(false) { - GLC_LOGV("GLConsumer"); + ST_LOGV("GLConsumer"); memcpy(mCurrentTransformMatrix, mtxIdentity, sizeof(mCurrentTransformMatrix)); @@ -196,11 +186,11 @@ status_t GLConsumer::setDefaultBufferSize(uint32_t w, uint32_t h) status_t GLConsumer::updateTexImage() { ATRACE_CALL(); - GLC_LOGV("updateTexImage"); + ST_LOGV("updateTexImage"); Mutex::Autolock lock(mMutex); if (mAbandoned) { - GLC_LOGE("updateTexImage: GLConsumer is abandoned!"); + ST_LOGE("updateTexImage: GLConsumer is abandoned!"); return NO_INIT; } @@ -219,11 +209,11 @@ status_t GLConsumer::updateTexImage() { if (err != NO_ERROR) { if (err == BufferQueue::NO_BUFFER_AVAILABLE) { // We always bind the texture even if we don't update its contents. - GLC_LOGV("updateTexImage: no buffers were available"); + ST_LOGV("updateTexImage: no buffers were available"); glBindTexture(mTexTarget, mTexName); err = NO_ERROR; } else { - GLC_LOGE("updateTexImage: acquire failed: %s (%d)", + ST_LOGE("updateTexImage: acquire failed: %s (%d)", strerror(-err), err); } return err; @@ -244,11 +234,11 @@ status_t GLConsumer::updateTexImage() { status_t GLConsumer::releaseTexImage() { ATRACE_CALL(); - GLC_LOGV("releaseTexImage"); + ST_LOGV("releaseTexImage"); Mutex::Autolock lock(mMutex); if (mAbandoned) { - GLC_LOGE("releaseTexImage: GLConsumer is abandoned!"); + ST_LOGE("releaseTexImage: GLConsumer is abandoned!"); return NO_INIT; } @@ -268,13 +258,13 @@ status_t GLConsumer::releaseTexImage() { int buf = mCurrentTexture; if (buf != BufferQueue::INVALID_BUFFER_SLOT) { - GLC_LOGV("releaseTexImage: (slot=%d, mAttached=%d)", buf, mAttached); + ST_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) { - GLC_LOGE("syncForReleaseLocked failed (slot=%d), err=%d", buf, err); + ST_LOGE("syncForReleaseLocked failed (slot=%d), err=%d", buf, err); return err; } } else { @@ -284,7 +274,7 @@ status_t GLConsumer::releaseTexImage() { err = releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR); if (err < NO_ERROR) { - GLC_LOGE("releaseTexImage: failed to release buffer: %s (%d)", + ST_LOGE("releaseTexImage: failed to release buffer: %s (%d)", strerror(-err), err); return err; } @@ -303,9 +293,9 @@ status_t GLConsumer::releaseTexImage() { if (mAttached) { // This binds a dummy buffer (mReleasedTexImage). - status_t result = bindTextureImageLocked(); - if (result != NO_ERROR) { - return result; + status_t err = bindTextureImageLocked(); + if (err != NO_ERROR) { + return err; } } else { // detached, don't touch the texture (and we may not even have an @@ -326,15 +316,14 @@ sp<GraphicBuffer> GLConsumer::getDebugTexImageBuffer() { GraphicBuffer::USAGE_SW_WRITE_RARELY); 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; + size_t w = buffer->getStride(); + size_t h = buffer->getHeight(); + memset(bits, 0, w*h*4); + for (size_t y=0 ; y<kDebugData.height ; y++) { + for (size_t x=0 ; x<kDebugData.width ; x++) { + bits[x] = (kDebugData.bits[y*kDebugData.width+x] == 'X') ? 0xFF000000 : 0xFFFFFFFF; } - bits += stride; + bits += w; } buffer->unlock(); sReleasedTexImageBuffer = buffer; @@ -380,7 +369,7 @@ status_t GLConsumer::updateAndReleaseLocked(const BufferQueue::BufferItem& item) int buf = item.mBuf; if (!mAttached) { - GLC_LOGE("updateAndRelease: GLConsumer is not attached to an OpenGL " + ST_LOGE("updateAndRelease: GLConsumer is not attached to an OpenGL " "ES context"); releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR); @@ -402,7 +391,7 @@ status_t GLConsumer::updateAndReleaseLocked(const BufferQueue::BufferItem& item) // means the buffer was previously acquired). err = mEglSlots[buf].mEglImage->createIfNeeded(mEglDisplay, item.mCrop); if (err != NO_ERROR) { - GLC_LOGW("updateAndRelease: unable to createImage on display=%p slot=%d", + ST_LOGW("updateAndRelease: unable to createImage on display=%p slot=%d", mEglDisplay, buf); releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR); @@ -421,7 +410,7 @@ status_t GLConsumer::updateAndReleaseLocked(const BufferQueue::BufferItem& item) return err; } - GLC_LOGV("updateAndRelease: (slot=%d buf=%p) -> (slot=%d buf=%p)", + ST_LOGV("updateAndRelease: (slot=%d buf=%p) -> (slot=%d buf=%p)", mCurrentTexture, mCurrentTextureImage != NULL ? mCurrentTextureImage->graphicBufferHandle() : 0, buf, mSlots[buf].mGraphicBuffer->handle); @@ -432,7 +421,7 @@ status_t GLConsumer::updateAndReleaseLocked(const BufferQueue::BufferItem& item) mCurrentTexture, mCurrentTextureImage->graphicBuffer(), mEglDisplay, mEglSlots[mCurrentTexture].mEglFence); if (status < NO_ERROR) { - GLC_LOGE("updateAndRelease: failed to release buffer: %s (%d)", + ST_LOGE("updateAndRelease: failed to release buffer: %s (%d)", strerror(-status), status); err = status; // keep going, with error raised [?] @@ -460,22 +449,22 @@ status_t GLConsumer::bindTextureImageLocked() { return INVALID_OPERATION; } - GLenum error; + GLint error; while ((error = glGetError()) != GL_NO_ERROR) { - GLC_LOGW("bindTextureImage: clearing GL error: %#04x", error); + ST_LOGW("bindTextureImage: clearing GL error: %#04x", error); } glBindTexture(mTexTarget, mTexName); if (mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT && mCurrentTextureImage == NULL) { - GLC_LOGE("bindTextureImage: no currently-bound texture"); + ST_LOGE("bindTextureImage: no currently-bound texture"); return NO_INIT; } status_t err = mCurrentTextureImage->createIfNeeded(mEglDisplay, mCurrentCrop); if (err != NO_ERROR) { - GLC_LOGW("bindTextureImage: can't create image on display=%p slot=%d", + ST_LOGW("bindTextureImage: can't create image on display=%p slot=%d", mEglDisplay, mCurrentTexture); return UNKNOWN_ERROR; } @@ -487,17 +476,17 @@ status_t GLConsumer::bindTextureImageLocked() { // forcing the creation of a new image. if ((error = glGetError()) != GL_NO_ERROR) { glBindTexture(mTexTarget, mTexName); - status_t result = mCurrentTextureImage->createIfNeeded(mEglDisplay, - mCurrentCrop, - true); - if (result != NO_ERROR) { - GLC_LOGW("bindTextureImage: can't create image on display=%p slot=%d", + status_t err = mCurrentTextureImage->createIfNeeded(mEglDisplay, + mCurrentCrop, + true); + if (err != NO_ERROR) { + ST_LOGW("bindTextureImage: can't create image on display=%p slot=%d", mEglDisplay, mCurrentTexture); return UNKNOWN_ERROR; } mCurrentTextureImage->bindToTextureTarget(mTexTarget); if ((error = glGetError()) != GL_NO_ERROR) { - GLC_LOGE("bindTextureImage: error binding external image: %#04x", error); + ST_LOGE("bindTextureImage: error binding external image: %#04x", error); return UNKNOWN_ERROR; } } @@ -516,18 +505,18 @@ status_t GLConsumer::checkAndUpdateEglStateLocked(bool contextCheck) { if (mEglDisplay == EGL_NO_DISPLAY) { mEglDisplay = dpy; } - if (mEglContext == EGL_NO_DISPLAY) { + if (mEglContext == EGL_NO_CONTEXT) { mEglContext = ctx; } } if (mEglDisplay != dpy || dpy == EGL_NO_DISPLAY) { - GLC_LOGE("checkAndUpdateEglState: invalid current EGLDisplay"); + ST_LOGE("checkAndUpdateEglState: invalid current EGLDisplay"); return INVALID_OPERATION; } if (mEglContext != ctx || ctx == EGL_NO_CONTEXT) { - GLC_LOGE("checkAndUpdateEglState: invalid current EGLContext"); + ST_LOGE("checkAndUpdateEglState: invalid current EGLContext"); return INVALID_OPERATION; } @@ -542,7 +531,7 @@ void GLConsumer::setReleaseFence(const sp<Fence>& fence) { status_t err = addReleaseFence(mCurrentTexture, mCurrentTextureImage->graphicBuffer(), fence); if (err != OK) { - GLC_LOGE("setReleaseFence: failed to add the fence: %s (%d)", + ST_LOGE("setReleaseFence: failed to add the fence: %s (%d)", strerror(-err), err); } } @@ -550,16 +539,16 @@ void GLConsumer::setReleaseFence(const sp<Fence>& fence) { status_t GLConsumer::detachFromContext() { ATRACE_CALL(); - GLC_LOGV("detachFromContext"); + ST_LOGV("detachFromContext"); Mutex::Autolock lock(mMutex); if (mAbandoned) { - GLC_LOGE("detachFromContext: abandoned GLConsumer"); + ST_LOGE("detachFromContext: abandoned GLConsumer"); return NO_INIT; } if (!mAttached) { - GLC_LOGE("detachFromContext: GLConsumer is not attached to a " + ST_LOGE("detachFromContext: GLConsumer is not attached to a " "context"); return INVALID_OPERATION; } @@ -568,12 +557,12 @@ status_t GLConsumer::detachFromContext() { EGLContext ctx = eglGetCurrentContext(); if (mEglDisplay != dpy && mEglDisplay != EGL_NO_DISPLAY) { - GLC_LOGE("detachFromContext: invalid current EGLDisplay"); + ST_LOGE("detachFromContext: invalid current EGLDisplay"); return INVALID_OPERATION; } if (mEglContext != ctx && mEglContext != EGL_NO_CONTEXT) { - GLC_LOGE("detachFromContext: invalid current EGLContext"); + ST_LOGE("detachFromContext: invalid current EGLContext"); return INVALID_OPERATION; } @@ -595,16 +584,16 @@ status_t GLConsumer::detachFromContext() { status_t GLConsumer::attachToContext(uint32_t tex) { ATRACE_CALL(); - GLC_LOGV("attachToContext"); + ST_LOGV("attachToContext"); Mutex::Autolock lock(mMutex); if (mAbandoned) { - GLC_LOGE("attachToContext: abandoned GLConsumer"); + ST_LOGE("attachToContext: abandoned GLConsumer"); return NO_INIT; } if (mAttached) { - GLC_LOGE("attachToContext: GLConsumer is already attached to a " + ST_LOGE("attachToContext: GLConsumer is already attached to a " "context"); return INVALID_OPERATION; } @@ -613,12 +602,12 @@ status_t GLConsumer::attachToContext(uint32_t tex) { EGLContext ctx = eglGetCurrentContext(); if (dpy == EGL_NO_DISPLAY) { - GLC_LOGE("attachToContext: invalid current EGLDisplay"); + ST_LOGE("attachToContext: invalid current EGLDisplay"); return INVALID_OPERATION; } if (ctx == EGL_NO_CONTEXT) { - GLC_LOGE("attachToContext: invalid current EGLContext"); + ST_LOGE("attachToContext: invalid current EGLContext"); return INVALID_OPERATION; } @@ -647,14 +636,14 @@ status_t GLConsumer::attachToContext(uint32_t tex) { status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) { - GLC_LOGV("syncForReleaseLocked"); + ST_LOGV("syncForReleaseLocked"); if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) { if (SyncFeatures::getInstance().useNativeFenceSync()) { EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL); if (sync == EGL_NO_SYNC_KHR) { - GLC_LOGE("syncForReleaseLocked: error creating EGL fence: %#x", + ST_LOGE("syncForReleaseLocked: error creating EGL fence: %#x", eglGetError()); return UNKNOWN_ERROR; } @@ -662,7 +651,7 @@ status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) { int fenceFd = eglDupNativeFenceFDANDROID(dpy, sync); eglDestroySyncKHR(dpy, sync); if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) { - GLC_LOGE("syncForReleaseLocked: error dup'ing native fence " + ST_LOGE("syncForReleaseLocked: error dup'ing native fence " "fd: %#x", eglGetError()); return UNKNOWN_ERROR; } @@ -670,7 +659,7 @@ status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) { status_t err = addReleaseFenceLocked(mCurrentTexture, mCurrentTextureImage->graphicBuffer(), fence); if (err != OK) { - GLC_LOGE("syncForReleaseLocked: error adding release fence: " + ST_LOGE("syncForReleaseLocked: error adding release fence: " "%s (%d)", strerror(-err), err); return err; } @@ -683,11 +672,11 @@ status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) { // before the producer accesses it. EGLint result = eglClientWaitSyncKHR(dpy, fence, 0, 1000000000); if (result == EGL_FALSE) { - GLC_LOGE("syncForReleaseLocked: error waiting for previous " + ST_LOGE("syncForReleaseLocked: error waiting for previous " "fence: %#x", eglGetError()); return UNKNOWN_ERROR; } else if (result == EGL_TIMEOUT_EXPIRED_KHR) { - GLC_LOGE("syncForReleaseLocked: timeout waiting for previous " + ST_LOGE("syncForReleaseLocked: timeout waiting for previous " "fence"); return TIMED_OUT; } @@ -698,7 +687,7 @@ status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) { // OpenGL ES context. fence = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL); if (fence == EGL_NO_SYNC_KHR) { - GLC_LOGE("syncForReleaseLocked: error creating fence: %#x", + ST_LOGE("syncForReleaseLocked: error creating fence: %#x", eglGetError()); return UNKNOWN_ERROR; } @@ -710,7 +699,7 @@ status_t GLConsumer::syncForReleaseLocked(EGLDisplay dpy) { return OK; } -bool GLConsumer::isExternalFormat(PixelFormat format) +bool GLConsumer::isExternalFormat(uint32_t format) { switch (format) { // supported YUV formats @@ -741,14 +730,14 @@ void GLConsumer::getTransformMatrix(float mtx[16]) { void GLConsumer::setFilteringEnabled(bool enabled) { Mutex::Autolock lock(mMutex); if (mAbandoned) { - GLC_LOGE("setFilteringEnabled: GLConsumer is abandoned!"); + ST_LOGE("setFilteringEnabled: GLConsumer is abandoned!"); return; } bool needsRecompute = mFilteringEnabled != enabled; mFilteringEnabled = enabled; if (needsRecompute && mCurrentTextureImage==NULL) { - GLC_LOGD("setFilteringEnabled called with mCurrentTextureImage == NULL"); + ST_LOGD("setFilteringEnabled called with mCurrentTextureImage == NULL"); } if (needsRecompute && mCurrentTextureImage != NULL) { @@ -757,7 +746,7 @@ void GLConsumer::setFilteringEnabled(bool enabled) { } void GLConsumer::computeCurrentTransformMatrixLocked() { - GLC_LOGV("computeCurrentTransformMatrixLocked"); + ST_LOGV("computeCurrentTransformMatrixLocked"); float xform[16]; for (int i = 0; i < 16; i++) { @@ -789,7 +778,7 @@ void GLConsumer::computeCurrentTransformMatrixLocked() { NULL : mCurrentTextureImage->graphicBuffer(); if (buf == NULL) { - GLC_LOGD("computeCurrentTransformMatrixLocked: mCurrentTextureImage is NULL"); + ST_LOGD("computeCurrentTransformMatrixLocked: mCurrentTextureImage is NULL"); } float mtxBeforeFlipV[16]; @@ -861,13 +850,13 @@ void GLConsumer::computeCurrentTransformMatrixLocked() { } nsecs_t GLConsumer::getTimestamp() { - GLC_LOGV("getTimestamp"); + ST_LOGV("getTimestamp"); Mutex::Autolock lock(mMutex); return mCurrentTimestamp; } -uint64_t GLConsumer::getFrameNumber() { - GLC_LOGV("getFrameNumber"); +nsecs_t GLConsumer::getFrameNumber() { + ST_LOGV("getFrameNumber"); Mutex::Autolock lock(mMutex); return mCurrentFrameNumber; } @@ -883,33 +872,30 @@ Rect GLConsumer::getCurrentCrop() const { Rect outCrop = mCurrentCrop; if (mCurrentScalingMode == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP) { - uint32_t newWidth = static_cast<uint32_t>(mCurrentCrop.width()); - uint32_t newHeight = static_cast<uint32_t>(mCurrentCrop.height()); + int32_t newWidth = mCurrentCrop.width(); + int32_t newHeight = mCurrentCrop.height(); if (newWidth * mDefaultHeight > newHeight * mDefaultWidth) { newWidth = newHeight * mDefaultWidth / mDefaultHeight; - GLC_LOGV("too wide: newWidth = %d", newWidth); + ST_LOGV("too wide: newWidth = %d", newWidth); } else if (newWidth * mDefaultHeight < newHeight * mDefaultWidth) { newHeight = newWidth * mDefaultHeight / mDefaultWidth; - GLC_LOGV("too tall: newHeight = %d", newHeight); + ST_LOGV("too tall: newHeight = %d", newHeight); } - uint32_t currentWidth = static_cast<uint32_t>(mCurrentCrop.width()); - uint32_t currentHeight = static_cast<uint32_t>(mCurrentCrop.height()); - // The crop is too wide - if (newWidth < currentWidth) { - uint32_t dw = (newWidth - currentWidth) / 2; + if (newWidth < mCurrentCrop.width()) { + int32_t dw = (newWidth - mCurrentCrop.width())/2; outCrop.left -=dw; outCrop.right += dw; // The crop is too tall - } else if (newHeight < currentHeight) { - uint32_t dh = (newHeight - currentHeight) / 2; + } else if (newHeight < mCurrentCrop.height()) { + int32_t dh = (newHeight - mCurrentCrop.height())/2; outCrop.top -= dh; outCrop.bottom += dh; } - GLC_LOGV("getCurrentCrop final crop [%d,%d,%d,%d]", + ST_LOGV("getCurrentCrop final crop [%d,%d,%d,%d]", outCrop.left, outCrop.top, outCrop.right,outCrop.bottom); } @@ -943,12 +929,12 @@ status_t GLConsumer::doGLFenceWaitLocked() const { EGLContext ctx = eglGetCurrentContext(); if (mEglDisplay != dpy || mEglDisplay == EGL_NO_DISPLAY) { - GLC_LOGE("doGLFenceWait: invalid current EGLDisplay"); + ST_LOGE("doGLFenceWait: invalid current EGLDisplay"); return INVALID_OPERATION; } if (mEglContext != ctx || mEglContext == EGL_NO_CONTEXT) { - GLC_LOGE("doGLFenceWait: invalid current EGLContext"); + ST_LOGE("doGLFenceWait: invalid current EGLContext"); return INVALID_OPERATION; } @@ -957,7 +943,7 @@ status_t GLConsumer::doGLFenceWaitLocked() const { // Create an EGLSyncKHR from the current fence. int fenceFd = mCurrentFence->dup(); if (fenceFd == -1) { - GLC_LOGE("doGLFenceWait: error dup'ing fence fd: %d", errno); + ST_LOGE("doGLFenceWait: error dup'ing fence fd: %d", errno); return -errno; } EGLint attribs[] = { @@ -968,7 +954,7 @@ status_t GLConsumer::doGLFenceWaitLocked() const { EGL_SYNC_NATIVE_FENCE_ANDROID, attribs); if (sync == EGL_NO_SYNC_KHR) { close(fenceFd); - GLC_LOGE("doGLFenceWait: error creating EGL fence: %#x", + ST_LOGE("doGLFenceWait: error creating EGL fence: %#x", eglGetError()); return UNKNOWN_ERROR; } @@ -980,7 +966,7 @@ status_t GLConsumer::doGLFenceWaitLocked() const { EGLint eglErr = eglGetError(); eglDestroySyncKHR(dpy, sync); if (eglErr != EGL_SUCCESS) { - GLC_LOGE("doGLFenceWait: error waiting for EGL fence: %#x", + ST_LOGE("doGLFenceWait: error waiting for EGL fence: %#x", eglErr); return UNKNOWN_ERROR; } @@ -988,7 +974,7 @@ status_t GLConsumer::doGLFenceWaitLocked() const { status_t err = mCurrentFence->waitForever( "GLConsumer::doGLFenceWaitLocked"); if (err != NO_ERROR) { - GLC_LOGE("doGLFenceWait: error waiting for fence: %d", err); + ST_LOGE("doGLFenceWait: error waiting for fence: %d", err); return err; } } @@ -998,7 +984,7 @@ status_t GLConsumer::doGLFenceWaitLocked() const { } void GLConsumer::freeBufferLocked(int slotIndex) { - GLC_LOGV("freeBufferLocked: slotIndex=%d", slotIndex); + ST_LOGV("freeBufferLocked: slotIndex=%d", slotIndex); if (slotIndex == mCurrentTexture) { mCurrentTexture = BufferQueue::INVALID_BUFFER_SLOT; } @@ -1007,7 +993,7 @@ void GLConsumer::freeBufferLocked(int slotIndex) { } void GLConsumer::abandonLocked() { - GLC_LOGV("abandonLocked"); + ST_LOGV("abandonLocked"); mCurrentTextureImage.clear(); ConsumerBase::abandonLocked(); } @@ -1018,7 +1004,7 @@ void GLConsumer::setName(const String8& name) { mConsumer->setConsumerName(name); } -status_t GLConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) { +status_t GLConsumer::setDefaultBufferFormat(uint32_t defaultFormat) { Mutex::Autolock lock(mMutex); return mConsumer->setDefaultBufferFormat(defaultFormat); } @@ -1079,6 +1065,7 @@ GLConsumer::EglImage::~EglImage() { if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) { ALOGE("~EglImage: eglDestroyImageKHR failed"); } + eglTerminate(mEglDisplay); } } @@ -1093,6 +1080,7 @@ status_t GLConsumer::EglImage::createIfNeeded(EGLDisplay eglDisplay, if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) { ALOGE("createIfNeeded: eglDestroyImageKHR failed"); } + eglTerminate(mEglDisplay); mEglImage = EGL_NO_IMAGE_KHR; mEglDisplay = EGL_NO_DISPLAY; } @@ -1119,14 +1107,12 @@ status_t GLConsumer::EglImage::createIfNeeded(EGLDisplay eglDisplay, } void GLConsumer::EglImage::bindToTextureTarget(uint32_t texTarget) { - glEGLImageTargetTexture2DOES(texTarget, - static_cast<GLeglImageOES>(mEglImage)); + glEGLImageTargetTexture2DOES(texTarget, (GLeglImageOES)mEglImage); } EGLImageKHR GLConsumer::EglImage::createImage(EGLDisplay dpy, const sp<GraphicBuffer>& graphicBuffer, const Rect& crop) { - EGLClientBuffer cbuf = - static_cast<EGLClientBuffer>(graphicBuffer->getNativeBuffer()); + EGLClientBuffer cbuf = (EGLClientBuffer)graphicBuffer->getNativeBuffer(); EGLint attrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_IMAGE_CROP_LEFT_ANDROID, crop.left, @@ -1145,11 +1131,13 @@ EGLImageKHR GLConsumer::EglImage::createImage(EGLDisplay dpy, // removes this restriction if there is hardware that can support it. attrs[2] = EGL_NONE; } + eglInitialize(dpy, 0, 0); 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; } |