libs/gui/SurfaceTexture.cpp - platform_frameworks_base - Gitiles

 /*
  * Copyright (C) 2010 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 LOG_TAG "SurfaceTexture"
 //#define LOG_NDEBUG 0

 #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 <hardware/hardware.h>

 #include <gui/IGraphicBufferAlloc.h>
 #include <gui/ISurfaceComposer.h>
 #include <gui/SurfaceComposerClient.h>
 #include <gui/SurfaceTexture.h>

 #include <private/gui/ComposerService.h>

 #include <utils/Log.h>
 #include <utils/String8.h>

 // This compile option makes SurfaceTexture use the EGL_KHR_fence_sync extension
 // to synchronize access to the buffers.  It will cause dequeueBuffer to stall,
 // waiting for the GL reads for the buffer being dequeued to complete before
 // allowing the buffer to be dequeued.
 #ifdef USE_FENCE_SYNC
 #ifdef ALLOW_DEQUEUE_CURRENT_BUFFER
 #error "USE_FENCE_SYNC and ALLOW_DEQUEUE_CURRENT_BUFFER are incompatible"
 #endif
 #endif

 // Macros for including the SurfaceTexture name in log messages
 #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__)

 namespace android {

 // Transform matrices
 static float mtxIdentity[16] = {
     1, 0, 0, 0,
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
 };
 static float mtxFlipH[16] = {
     -1, 0, 0, 0,
     0, 1, 0, 0,
     0, 0, 1, 0,
     1, 0, 0, 1,
 };
 static float mtxFlipV[16] = {
     1, 0, 0, 0,
     0, -1, 0, 0,
     0, 0, 1, 0,
     0, 1, 0, 1,
 };
 static float mtxRot90[16] = {
     0, 1, 0, 0,
     -1, 0, 0, 0,
     0, 0, 1, 0,
     1, 0, 0, 1,
 };
 static float mtxRot180[16] = {
     -1, 0, 0, 0,
     0, -1, 0, 0,
     0, 0, 1, 0,
     1, 1, 0, 1,
 };
 static float mtxRot270[16] = {
     0, -1, 0, 0,
     1, 0, 0, 0,
     0, 0, 1, 0,
     0, 1, 0, 1,
 };

 static void mtxMul(float out[16], const float a[16], const float b[16]);

 // Get an ID that's unique within this process.
 static int32_t createProcessUniqueId() {
     static volatile int32_t globalCounter = 0;
     return android_atomic_inc(&globalCounter);
 }

 SurfaceTexture::SurfaceTexture(GLuint tex, bool allowSynchronousMode,
         GLenum texTarget, bool useFenceSync) :
     BufferQueue(allowSynchronousMode),
     mCurrentTransform(0),
     mCurrentTimestamp(0),
     mTexName(tex),
 #ifdef USE_FENCE_SYNC
     mUseFenceSync(useFenceSync),
 #else
     mUseFenceSync(false),
 #endif
     mTexTarget(texTarget),
     mAbandoned(false),
     mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT)
 {
     // Choose a name using the PID and a process-unique ID.
     mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
     BufferQueue::setConsumerName(mName);

     ST_LOGV("SurfaceTexture");
     memcpy(mCurrentTransformMatrix, mtxIdentity,
             sizeof(mCurrentTransformMatrix));
 }

 SurfaceTexture::~SurfaceTexture() {
     ST_LOGV("~SurfaceTexture");
     abandon();
 }

 status_t SurfaceTexture::setBufferCountServer(int bufferCount) {
     Mutex::Autolock lock(mMutex);
     return BufferQueue::setBufferCountServer(bufferCount);
 }


 status_t SurfaceTexture::setDefaultBufferSize(uint32_t w, uint32_t h)
 {
     return BufferQueue::setDefaultBufferSize(w, h);
 }

 status_t SurfaceTexture::updateTexImage() {
     ST_LOGV("updateTexImage");
     Mutex::Autolock lock(mMutex);

     if (mAbandoned) {
         ST_LOGE("calling updateTexImage() on an abandoned SurfaceTexture");
         return NO_INIT;
     }

     BufferItem item;

     // In asynchronous mode the list is guaranteed to be one buffer
     // deep, while in synchronous mode we use the oldest buffer.
     if (acquire(&item) == NO_ERROR) {
         int buf = item.mBuf;
         // This buffer was newly allocated, so we need to clean up on our side
         if (item.mGraphicBuffer != NULL) {
             mEGLSlots[buf].mGraphicBuffer = 0;
             if (mEGLSlots[buf].mEglImage != EGL_NO_IMAGE_KHR) {
                 eglDestroyImageKHR(mEGLSlots[buf].mEglDisplay,
                         mEGLSlots[buf].mEglImage);
                 mEGLSlots[buf].mEglImage = EGL_NO_IMAGE_KHR;
                 mEGLSlots[buf].mEglDisplay = EGL_NO_DISPLAY;
             }
             mEGLSlots[buf].mGraphicBuffer = item.mGraphicBuffer;
         }

         // Update the GL texture object.
         EGLImageKHR image = mEGLSlots[buf].mEglImage;
         EGLDisplay dpy = eglGetCurrentDisplay();
         if (image == EGL_NO_IMAGE_KHR) {
             if (item.mGraphicBuffer == 0) {
                 ST_LOGE("buffer at slot %d is null", buf);
                 return BAD_VALUE;
             }
             image = createImage(dpy, item.mGraphicBuffer);
             mEGLSlots[buf].mEglImage = image;
             mEGLSlots[buf].mEglDisplay = dpy;
             if (image == EGL_NO_IMAGE_KHR) {
                 // NOTE: if dpy was invalid, createImage() is guaranteed to
                 // fail. so we'd end up here.
                 return -EINVAL;
             }
         }

         GLint error;
         while ((error = glGetError()) != GL_NO_ERROR) {
             ST_LOGW("updateTexImage: clearing GL error: %#04x", error);
         }

         glBindTexture(mTexTarget, mTexName);
         glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)image);

         bool failed = false;
         while ((error = glGetError()) != GL_NO_ERROR) {
             ST_LOGE("error binding external texture image %p (slot %d): %#04x",
                     image, buf, error);
             failed = true;
         }
         if (failed) {
             releaseBuffer(buf, mEGLSlots[buf].mEglDisplay,
                     mEGLSlots[buf].mFence);
             return -EINVAL;
         }

         if (mCurrentTexture != INVALID_BUFFER_SLOT) {
             if (mUseFenceSync) {
                 EGLSyncKHR fence = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR,
                         NULL);
                 if (fence == EGL_NO_SYNC_KHR) {
                     ALOGE("updateTexImage: error creating fence: %#x",
                             eglGetError());
                     releaseBuffer(buf, mEGLSlots[buf].mEglDisplay,
                             mEGLSlots[buf].mFence);
                     return -EINVAL;
                 }
                 glFlush();
                 mEGLSlots[mCurrentTexture].mFence = fence;
             }
         }

         ST_LOGV("updateTexImage: (slot=%d buf=%p) -> (slot=%d buf=%p)",
                 mCurrentTexture,
                 mCurrentTextureBuf != NULL ? mCurrentTextureBuf->handle : 0,
                 buf, item.mGraphicBuffer->handle);

         // release old buffer
         releaseBuffer(mCurrentTexture,
                 mEGLSlots[mCurrentTexture].mEglDisplay,
                 mEGLSlots[mCurrentTexture].mFence);

         // Update the SurfaceTexture state.
         mCurrentTexture = buf;
         mCurrentTextureBuf = mEGLSlots[buf].mGraphicBuffer;
         mCurrentCrop = item.mCrop;
         mCurrentTransform = item.mTransform;
         mCurrentScalingMode = item.mScalingMode;
         mCurrentTimestamp = item.mTimestamp;
         computeCurrentTransformMatrix();

         // Now that we've passed the point at which failures can happen,
         // it's safe to remove the buffer from the front of the queue.

     } else {
         // We always bind the texture even if we don't update its contents.
         glBindTexture(mTexTarget, mTexName);
     }

     return OK;
 }

 bool SurfaceTexture::isExternalFormat(uint32_t format)
 {
     switch (format) {
     // supported YUV formats
     case HAL_PIXEL_FORMAT_YV12:
     // Legacy/deprecated YUV formats
     case HAL_PIXEL_FORMAT_YCbCr_422_SP:
     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
     case HAL_PIXEL_FORMAT_YCbCr_422_I:
         return true;
     }

     // Any OEM format needs to be considered
     if (format>=0x100 && format<=0x1FF)
         return true;

     return false;
 }

 GLenum SurfaceTexture::getCurrentTextureTarget() const {
     return mTexTarget;
 }

 void SurfaceTexture::getTransformMatrix(float mtx[16]) {
     Mutex::Autolock lock(mMutex);
     memcpy(mtx, mCurrentTransformMatrix, sizeof(mCurrentTransformMatrix));
 }

 void SurfaceTexture::computeCurrentTransformMatrix() {
     ST_LOGV("computeCurrentTransformMatrix");

     float xform[16];
     for (int i = 0; i < 16; i++) {
         xform[i] = mtxIdentity[i];
     }
     if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {
         float result[16];
         mtxMul(result, xform, mtxFlipH);
         for (int i = 0; i < 16; i++) {
             xform[i] = result[i];
         }
     }
     if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {
         float result[16];
         mtxMul(result, xform, mtxFlipV);
         for (int i = 0; i < 16; i++) {
             xform[i] = result[i];
         }
     }
     if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
         float result[16];
         mtxMul(result, xform, mtxRot90);
         for (int i = 0; i < 16; i++) {
             xform[i] = result[i];
         }
     }

     sp<GraphicBuffer>& buf(mCurrentTextureBuf);
     float tx, ty, sx, sy;
     if (!mCurrentCrop.isEmpty()) {
         // In order to prevent bilinear sampling at the of the crop rectangle we
         // may need to shrink it by 2 texels in each direction.  Normally this
         // would just need to take 1/2 a texel off each end, but because the
         // chroma channels will likely be subsampled we need to chop off a whole
         // texel.  This will cause artifacts if someone does nearest sampling
         // with 1:1 pixel:texel ratio, but it's impossible to simultaneously
         // accomodate the bilinear and nearest sampling uses.
         //
         // If nearest sampling turns out to be a desirable usage of these
         // textures then we could add the ability to switch a SurfaceTexture to
         // nearest-mode.  Preferably, however, the image producers (video
         // decoder, camera, etc.) would simply not use a crop rectangle (or at
         // least not tell the framework about it) so that the GPU can do the
         // correct edge behavior.
         int xshrink = 0, yshrink = 0;
         if (mCurrentCrop.left > 0) {
             tx = float(mCurrentCrop.left + 1) / float(buf->getWidth());
             xshrink++;
         } else {
             tx = 0.0f;
         }
         if (mCurrentCrop.right < int32_t(buf->getWidth())) {
             xshrink++;
         }
         if (mCurrentCrop.bottom < int32_t(buf->getHeight())) {
             ty = (float(buf->getHeight() - mCurrentCrop.bottom) + 1.0f) /
                     float(buf->getHeight());
             yshrink++;
         } else {
             ty = 0.0f;
         }
         if (mCurrentCrop.top > 0) {
             yshrink++;
         }
         sx = float(mCurrentCrop.width() - xshrink) / float(buf->getWidth());
         sy = float(mCurrentCrop.height() - yshrink) / float(buf->getHeight());
     } else {
         tx = 0.0f;
         ty = 0.0f;
         sx = 1.0f;
         sy = 1.0f;
     }
     float crop[16] = {
         sx, 0, 0, 0,
         0, sy, 0, 0,
         0, 0, 1, 0,
         tx, ty, 0, 1,
     };

     float mtxBeforeFlipV[16];
     mtxMul(mtxBeforeFlipV, crop, xform);

     // SurfaceFlinger expects the top of its window textures to be at a Y
     // coordinate of 0, so SurfaceTexture must behave the same way.  We don't
     // want to expose this to applications, however, so we must add an
     // additional vertical flip to the transform after all the other transforms.
     mtxMul(mCurrentTransformMatrix, mtxFlipV, mtxBeforeFlipV);
 }

 nsecs_t SurfaceTexture::getTimestamp() {
     ST_LOGV("getTimestamp");
     Mutex::Autolock lock(mMutex);
     return mCurrentTimestamp;
 }

 void SurfaceTexture::setFrameAvailableListener(
         const sp<FrameAvailableListener>& listener) {
     ST_LOGV("setFrameAvailableListener");
     Mutex::Autolock lock(mMutex);
     BufferQueue::setFrameAvailableListener(listener);
 }

 EGLImageKHR SurfaceTexture::createImage(EGLDisplay dpy,
         const sp<GraphicBuffer>& graphicBuffer) {
     EGLClientBuffer cbuf = (EGLClientBuffer)graphicBuffer->getNativeBuffer();
     EGLint attrs[] = {
         EGL_IMAGE_PRESERVED_KHR,    EGL_TRUE,
         EGL_NONE,
     };
     EGLImageKHR image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT,
             EGL_NATIVE_BUFFER_ANDROID, cbuf, attrs);
     if (image == EGL_NO_IMAGE_KHR) {
         EGLint error = eglGetError();
         ST_LOGE("error creating EGLImage: %#x", error);
     }
     return image;
 }

 sp<GraphicBuffer> SurfaceTexture::getCurrentBuffer() const {
     Mutex::Autolock lock(mMutex);
     return mCurrentTextureBuf;
 }

 Rect SurfaceTexture::getCurrentCrop() const {
     Mutex::Autolock lock(mMutex);
     return mCurrentCrop;
 }

 uint32_t SurfaceTexture::getCurrentTransform() const {
     Mutex::Autolock lock(mMutex);
     return mCurrentTransform;
 }

 uint32_t SurfaceTexture::getCurrentScalingMode() const {
     Mutex::Autolock lock(mMutex);
     return mCurrentScalingMode;
 }

 bool SurfaceTexture::isSynchronousMode() const {
     Mutex::Autolock lock(mMutex);
     return BufferQueue::isSynchronousMode();
 }

 void SurfaceTexture::abandon() {
     Mutex::Autolock lock(mMutex);
     mAbandoned = true;
     mCurrentTextureBuf.clear();

     // destroy all egl buffers
     for (int i =0; i < NUM_BUFFER_SLOTS; i++) {
         mEGLSlots[i].mGraphicBuffer = 0;
         if (mEGLSlots[i].mEglImage != EGL_NO_IMAGE_KHR) {
             eglDestroyImageKHR(mEGLSlots[i].mEglDisplay,
                     mEGLSlots[i].mEglImage);
             mEGLSlots[i].mEglImage = EGL_NO_IMAGE_KHR;
             mEGLSlots[i].mEglDisplay = EGL_NO_DISPLAY;
         }
     }

     // disconnect from the BufferQueue
     BufferQueue::consumerDisconnect();
 }

 void SurfaceTexture::setName(const String8& name) {
     Mutex::Autolock _l(mMutex);
     mName = name;
     BufferQueue::setConsumerName(name);
 }

 void SurfaceTexture::dump(String8& result) const
 {
     char buffer[1024];
     dump(result, "", buffer, 1024);
 }

 void SurfaceTexture::dump(String8& result, const char* prefix,
         char* buffer, size_t SIZE) const
 {
     Mutex::Autolock _l(mMutex);
     snprintf(buffer, SIZE, "%smTexName=%d\n", prefix, mTexName);
     result.append(buffer);

     snprintf(buffer, SIZE,
             "%snext   : {crop=[%d,%d,%d,%d], transform=0x%02x, current=%d}\n"
             ,prefix, mCurrentCrop.left,
             mCurrentCrop.top, mCurrentCrop.right, mCurrentCrop.bottom,
             mCurrentTransform, mCurrentTexture
     );
     result.append(buffer);


     BufferQueue::dump(result, prefix, buffer, SIZE);
 }

 static void mtxMul(float out[16], const float a[16], const float b[16]) {
     out[0] = a[0]*b[0] + a[4]*b[1] + a[8]*b[2] + a[12]*b[3];
     out[1] = a[1]*b[0] + a[5]*b[1] + a[9]*b[2] + a[13]*b[3];
     out[2] = a[2]*b[0] + a[6]*b[1] + a[10]*b[2] + a[14]*b[3];
     out[3] = a[3]*b[0] + a[7]*b[1] + a[11]*b[2] + a[15]*b[3];

     out[4] = a[0]*b[4] + a[4]*b[5] + a[8]*b[6] + a[12]*b[7];
     out[5] = a[1]*b[4] + a[5]*b[5] + a[9]*b[6] + a[13]*b[7];
     out[6] = a[2]*b[4] + a[6]*b[5] + a[10]*b[6] + a[14]*b[7];
     out[7] = a[3]*b[4] + a[7]*b[5] + a[11]*b[6] + a[15]*b[7];

     out[8] = a[0]*b[8] + a[4]*b[9] + a[8]*b[10] + a[12]*b[11];
     out[9] = a[1]*b[8] + a[5]*b[9] + a[9]*b[10] + a[13]*b[11];
     out[10] = a[2]*b[8] + a[6]*b[9] + a[10]*b[10] + a[14]*b[11];
     out[11] = a[3]*b[8] + a[7]*b[9] + a[11]*b[10] + a[15]*b[11];

     out[12] = a[0]*b[12] + a[4]*b[13] + a[8]*b[14] + a[12]*b[15];
     out[13] = a[1]*b[12] + a[5]*b[13] + a[9]*b[14] + a[13]*b[15];
     out[14] = a[2]*b[12] + a[6]*b[13] + a[10]*b[14] + a[14]*b[15];
     out[15] = a[3]*b[12] + a[7]*b[13] + a[11]*b[14] + a[15]*b[15];
 }

 }; // namespace android
	/*
	* Copyright (C) 2010 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 LOG_TAG "SurfaceTexture"
	//#define LOG_NDEBUG 0

	#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 <hardware/hardware.h>

	#include <gui/IGraphicBufferAlloc.h>
	#include <gui/ISurfaceComposer.h>
	#include <gui/SurfaceComposerClient.h>
	#include <gui/SurfaceTexture.h>

	#include <private/gui/ComposerService.h>

	#include <utils/Log.h>
	#include <utils/String8.h>

	// This compile option makes SurfaceTexture use the EGL_KHR_fence_sync extension
	// to synchronize access to the buffers. It will cause dequeueBuffer to stall,
	// waiting for the GL reads for the buffer being dequeued to complete before
	// allowing the buffer to be dequeued.
	#ifdef USE_FENCE_SYNC
	#ifdef ALLOW_DEQUEUE_CURRENT_BUFFER
	#error "USE_FENCE_SYNC and ALLOW_DEQUEUE_CURRENT_BUFFER are incompatible"
	#endif
	#endif

	// Macros for including the SurfaceTexture name in log messages
	#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__)

	namespace android {

	// Transform matrices
	static float mtxIdentity[16] = {
	1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1,
	};
	static float mtxFlipH[16] = {
	-1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	1, 0, 0, 1,
	};
	static float mtxFlipV[16] = {
	1, 0, 0, 0,
	0, -1, 0, 0,
	0, 0, 1, 0,
	0, 1, 0, 1,
	};
	static float mtxRot90[16] = {
	0, 1, 0, 0,
	-1, 0, 0, 0,
	0, 0, 1, 0,
	1, 0, 0, 1,
	};
	static float mtxRot180[16] = {
	-1, 0, 0, 0,
	0, -1, 0, 0,
	0, 0, 1, 0,
	1, 1, 0, 1,
	};
	static float mtxRot270[16] = {
	0, -1, 0, 0,
	1, 0, 0, 0,
	0, 0, 1, 0,
	0, 1, 0, 1,
	};

	static void mtxMul(float out[16], const float a[16], const float b[16]);

	// Get an ID that's unique within this process.
	static int32_t createProcessUniqueId() {
	static volatile int32_t globalCounter = 0;
	return android_atomic_inc(&globalCounter);
	}

	SurfaceTexture::SurfaceTexture(GLuint tex, bool allowSynchronousMode,
	GLenum texTarget, bool useFenceSync) :
	BufferQueue(allowSynchronousMode),
	mCurrentTransform(0),
	mCurrentTimestamp(0),
	mTexName(tex),
	#ifdef USE_FENCE_SYNC
	mUseFenceSync(useFenceSync),
	#else
	mUseFenceSync(false),
	#endif
	mTexTarget(texTarget),
	mAbandoned(false),
	mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT)
	{
	// Choose a name using the PID and a process-unique ID.
	mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
	BufferQueue::setConsumerName(mName);

	ST_LOGV("SurfaceTexture");
	memcpy(mCurrentTransformMatrix, mtxIdentity,
	sizeof(mCurrentTransformMatrix));
	}

	SurfaceTexture::~SurfaceTexture() {
	ST_LOGV("~SurfaceTexture");
	abandon();
	}

	status_t SurfaceTexture::setBufferCountServer(int bufferCount) {
	Mutex::Autolock lock(mMutex);
	return BufferQueue::setBufferCountServer(bufferCount);
	}


	status_t SurfaceTexture::setDefaultBufferSize(uint32_t w, uint32_t h)
	{
	return BufferQueue::setDefaultBufferSize(w, h);
	}

	status_t SurfaceTexture::updateTexImage() {
	ST_LOGV("updateTexImage");
	Mutex::Autolock lock(mMutex);

	if (mAbandoned) {
	ST_LOGE("calling updateTexImage() on an abandoned SurfaceTexture");
	return NO_INIT;
	}

	BufferItem item;

	// In asynchronous mode the list is guaranteed to be one buffer
	// deep, while in synchronous mode we use the oldest buffer.
	if (acquire(&item) == NO_ERROR) {
	int buf = item.mBuf;
	// This buffer was newly allocated, so we need to clean up on our side
	if (item.mGraphicBuffer != NULL) {
	mEGLSlots[buf].mGraphicBuffer = 0;
	if (mEGLSlots[buf].mEglImage != EGL_NO_IMAGE_KHR) {
	eglDestroyImageKHR(mEGLSlots[buf].mEglDisplay,
	mEGLSlots[buf].mEglImage);
	mEGLSlots[buf].mEglImage = EGL_NO_IMAGE_KHR;
	mEGLSlots[buf].mEglDisplay = EGL_NO_DISPLAY;
	}
	mEGLSlots[buf].mGraphicBuffer = item.mGraphicBuffer;
	}

	// Update the GL texture object.
	EGLImageKHR image = mEGLSlots[buf].mEglImage;
	EGLDisplay dpy = eglGetCurrentDisplay();
	if (image == EGL_NO_IMAGE_KHR) {
	if (item.mGraphicBuffer == 0) {
	ST_LOGE("buffer at slot %d is null", buf);
	return BAD_VALUE;
	}
	image = createImage(dpy, item.mGraphicBuffer);
	mEGLSlots[buf].mEglImage = image;
	mEGLSlots[buf].mEglDisplay = dpy;
	if (image == EGL_NO_IMAGE_KHR) {
	// NOTE: if dpy was invalid, createImage() is guaranteed to
	// fail. so we'd end up here.
	return -EINVAL;
	}
	}

	GLint error;
	while ((error = glGetError()) != GL_NO_ERROR) {
	ST_LOGW("updateTexImage: clearing GL error: %#04x", error);
	}

	glBindTexture(mTexTarget, mTexName);
	glEGLImageTargetTexture2DOES(mTexTarget, (GLeglImageOES)image);

	bool failed = false;
	while ((error = glGetError()) != GL_NO_ERROR) {
	ST_LOGE("error binding external texture image %p (slot %d): %#04x",
	image, buf, error);
	failed = true;
	}
	if (failed) {
	releaseBuffer(buf, mEGLSlots[buf].mEglDisplay,
	mEGLSlots[buf].mFence);
	return -EINVAL;
	}

	if (mCurrentTexture != INVALID_BUFFER_SLOT) {
	if (mUseFenceSync) {
	EGLSyncKHR fence = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR,
	NULL);
	if (fence == EGL_NO_SYNC_KHR) {
	ALOGE("updateTexImage: error creating fence: %#x",
	eglGetError());
	releaseBuffer(buf, mEGLSlots[buf].mEglDisplay,
	mEGLSlots[buf].mFence);
	return -EINVAL;
	}
	glFlush();
	mEGLSlots[mCurrentTexture].mFence = fence;
	}
	}

	ST_LOGV("updateTexImage: (slot=%d buf=%p) -> (slot=%d buf=%p)",
	mCurrentTexture,
	mCurrentTextureBuf != NULL ? mCurrentTextureBuf->handle : 0,
	buf, item.mGraphicBuffer->handle);

	// release old buffer
	releaseBuffer(mCurrentTexture,
	mEGLSlots[mCurrentTexture].mEglDisplay,
	mEGLSlots[mCurrentTexture].mFence);

	// Update the SurfaceTexture state.
	mCurrentTexture = buf;
	mCurrentTextureBuf = mEGLSlots[buf].mGraphicBuffer;
	mCurrentCrop = item.mCrop;
	mCurrentTransform = item.mTransform;
	mCurrentScalingMode = item.mScalingMode;
	mCurrentTimestamp = item.mTimestamp;
	computeCurrentTransformMatrix();

	// Now that we've passed the point at which failures can happen,
	// it's safe to remove the buffer from the front of the queue.

	} else {
	// We always bind the texture even if we don't update its contents.
	glBindTexture(mTexTarget, mTexName);
	}

	return OK;
	}

	bool SurfaceTexture::isExternalFormat(uint32_t format)
	{
	switch (format) {
	// supported YUV formats
	case HAL_PIXEL_FORMAT_YV12:
	// Legacy/deprecated YUV formats
	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
	case HAL_PIXEL_FORMAT_YCrCb_420_SP:
	case HAL_PIXEL_FORMAT_YCbCr_422_I:
	return true;
	}

	// Any OEM format needs to be considered
	if (format>=0x100 && format<=0x1FF)
	return true;

	return false;
	}

	GLenum SurfaceTexture::getCurrentTextureTarget() const {
	return mTexTarget;
	}

	void SurfaceTexture::getTransformMatrix(float mtx[16]) {
	Mutex::Autolock lock(mMutex);
	memcpy(mtx, mCurrentTransformMatrix, sizeof(mCurrentTransformMatrix));
	}

	void SurfaceTexture::computeCurrentTransformMatrix() {
	ST_LOGV("computeCurrentTransformMatrix");

	float xform[16];
	for (int i = 0; i < 16; i++) {
	xform[i] = mtxIdentity[i];
	}
	if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {
	float result[16];
	mtxMul(result, xform, mtxFlipH);
	for (int i = 0; i < 16; i++) {
	xform[i] = result[i];
	}
	}
	if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {
	float result[16];
	mtxMul(result, xform, mtxFlipV);
	for (int i = 0; i < 16; i++) {
	xform[i] = result[i];
	}
	}
	if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
	float result[16];
	mtxMul(result, xform, mtxRot90);
	for (int i = 0; i < 16; i++) {
	xform[i] = result[i];
	}
	}

	sp<GraphicBuffer>& buf(mCurrentTextureBuf);
	float tx, ty, sx, sy;
	if (!mCurrentCrop.isEmpty()) {
	// In order to prevent bilinear sampling at the of the crop rectangle we
	// may need to shrink it by 2 texels in each direction. Normally this
	// would just need to take 1/2 a texel off each end, but because the
	// chroma channels will likely be subsampled we need to chop off a whole
	// texel. This will cause artifacts if someone does nearest sampling
	// with 1:1 pixel:texel ratio, but it's impossible to simultaneously
	// accomodate the bilinear and nearest sampling uses.
	//
	// If nearest sampling turns out to be a desirable usage of these
	// textures then we could add the ability to switch a SurfaceTexture to
	// nearest-mode. Preferably, however, the image producers (video
	// decoder, camera, etc.) would simply not use a crop rectangle (or at
	// least not tell the framework about it) so that the GPU can do the
	// correct edge behavior.
	int xshrink = 0, yshrink = 0;
	if (mCurrentCrop.left > 0) {
	tx = float(mCurrentCrop.left + 1) / float(buf->getWidth());
	xshrink++;
	} else {
	tx = 0.0f;
	}
	if (mCurrentCrop.right < int32_t(buf->getWidth())) {
	xshrink++;
	}
	if (mCurrentCrop.bottom < int32_t(buf->getHeight())) {
	ty = (float(buf->getHeight() - mCurrentCrop.bottom) + 1.0f) /
	float(buf->getHeight());
	yshrink++;
	} else {
	ty = 0.0f;
	}
	if (mCurrentCrop.top > 0) {
	yshrink++;
	}
	sx = float(mCurrentCrop.width() - xshrink) / float(buf->getWidth());
	sy = float(mCurrentCrop.height() - yshrink) / float(buf->getHeight());
	} else {
	tx = 0.0f;
	ty = 0.0f;
	sx = 1.0f;
	sy = 1.0f;
	}
	float crop[16] = {
	sx, 0, 0, 0,
	0, sy, 0, 0,
	0, 0, 1, 0,
	tx, ty, 0, 1,
	};

	float mtxBeforeFlipV[16];
	mtxMul(mtxBeforeFlipV, crop, xform);

	// SurfaceFlinger expects the top of its window textures to be at a Y
	// coordinate of 0, so SurfaceTexture must behave the same way. We don't
	// want to expose this to applications, however, so we must add an
	// additional vertical flip to the transform after all the other transforms.
	mtxMul(mCurrentTransformMatrix, mtxFlipV, mtxBeforeFlipV);
	}

	nsecs_t SurfaceTexture::getTimestamp() {
	ST_LOGV("getTimestamp");
	Mutex::Autolock lock(mMutex);
	return mCurrentTimestamp;
	}

	void SurfaceTexture::setFrameAvailableListener(
	const sp<FrameAvailableListener>& listener) {
	ST_LOGV("setFrameAvailableListener");
	Mutex::Autolock lock(mMutex);
	BufferQueue::setFrameAvailableListener(listener);
	}

	EGLImageKHR SurfaceTexture::createImage(EGLDisplay dpy,
	const sp<GraphicBuffer>& graphicBuffer) {
	EGLClientBuffer cbuf = (EGLClientBuffer)graphicBuffer->getNativeBuffer();
	EGLint attrs[] = {
	EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
	EGL_NONE,
	};
	EGLImageKHR image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT,
	EGL_NATIVE_BUFFER_ANDROID, cbuf, attrs);
	if (image == EGL_NO_IMAGE_KHR) {
	EGLint error = eglGetError();
	ST_LOGE("error creating EGLImage: %#x", error);
	}
	return image;
	}

	sp<GraphicBuffer> SurfaceTexture::getCurrentBuffer() const {
	Mutex::Autolock lock(mMutex);
	return mCurrentTextureBuf;
	}

	Rect SurfaceTexture::getCurrentCrop() const {
	Mutex::Autolock lock(mMutex);
	return mCurrentCrop;
	}

	uint32_t SurfaceTexture::getCurrentTransform() const {
	Mutex::Autolock lock(mMutex);
	return mCurrentTransform;
	}

	uint32_t SurfaceTexture::getCurrentScalingMode() const {
	Mutex::Autolock lock(mMutex);
	return mCurrentScalingMode;
	}

	bool SurfaceTexture::isSynchronousMode() const {
	Mutex::Autolock lock(mMutex);
	return BufferQueue::isSynchronousMode();
	}

	void SurfaceTexture::abandon() {
	Mutex::Autolock lock(mMutex);
	mAbandoned = true;
	mCurrentTextureBuf.clear();

	// destroy all egl buffers
	for (int i =0; i < NUM_BUFFER_SLOTS; i++) {
	mEGLSlots[i].mGraphicBuffer = 0;
	if (mEGLSlots[i].mEglImage != EGL_NO_IMAGE_KHR) {
	eglDestroyImageKHR(mEGLSlots[i].mEglDisplay,
	mEGLSlots[i].mEglImage);
	mEGLSlots[i].mEglImage = EGL_NO_IMAGE_KHR;
	mEGLSlots[i].mEglDisplay = EGL_NO_DISPLAY;
	}
	}

	// disconnect from the BufferQueue
	BufferQueue::consumerDisconnect();
	}

	void SurfaceTexture::setName(const String8& name) {
	Mutex::Autolock _l(mMutex);
	mName = name;
	BufferQueue::setConsumerName(name);
	}

	void SurfaceTexture::dump(String8& result) const
	{
	char buffer[1024];
	dump(result, "", buffer, 1024);
	}

	void SurfaceTexture::dump(String8& result, const char* prefix,
	char* buffer, size_t SIZE) const
	{
	Mutex::Autolock _l(mMutex);
	snprintf(buffer, SIZE, "%smTexName=%d\n", prefix, mTexName);
	result.append(buffer);

	snprintf(buffer, SIZE,
	"%snext : {crop=[%d,%d,%d,%d], transform=0x%02x, current=%d}\n"
	,prefix, mCurrentCrop.left,
	mCurrentCrop.top, mCurrentCrop.right, mCurrentCrop.bottom,
	mCurrentTransform, mCurrentTexture
	);
	result.append(buffer);


	BufferQueue::dump(result, prefix, buffer, SIZE);
	}

	static void mtxMul(float out[16], const float a[16], const float b[16]) {
	out[0] = a[0]b[0] + a[4]b[1] + a[8]b[2] + a[12]b[3];
	out[1] = a[1]b[0] + a[5]b[1] + a[9]b[2] + a[13]b[3];
	out[2] = a[2]b[0] + a[6]b[1] + a[10]b[2] + a[14]b[3];
	out[3] = a[3]b[0] + a[7]b[1] + a[11]b[2] + a[15]b[3];

	out[4] = a[0]b[4] + a[4]b[5] + a[8]b[6] + a[12]b[7];
	out[5] = a[1]b[4] + a[5]b[5] + a[9]b[6] + a[13]b[7];
	out[6] = a[2]b[4] + a[6]b[5] + a[10]b[6] + a[14]b[7];
	out[7] = a[3]b[4] + a[7]b[5] + a[11]b[6] + a[15]b[7];

	out[8] = a[0]b[8] + a[4]b[9] + a[8]b[10] + a[12]b[11];
	out[9] = a[1]b[8] + a[5]b[9] + a[9]b[10] + a[13]b[11];
	out[10] = a[2]b[8] + a[6]b[9] + a[10]b[10] + a[14]b[11];
	out[11] = a[3]b[8] + a[7]b[9] + a[11]b[10] + a[15]b[11];

	out[12] = a[0]b[12] + a[4]b[13] + a[8]b[14] + a[12]b[15];
	out[13] = a[1]b[12] + a[5]b[13] + a[9]b[14] + a[13]b[15];
	out[14] = a[2]b[12] + a[6]b[13] + a[10]b[14] + a[14]b[15];
	out[15] = a[3]b[12] + a[7]b[13] + a[11]b[14] + a[15]b[15];
	}

	}; // namespace android