libs/gui/SurfaceTextureClient.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 "SurfaceTextureClient"
 //#define LOG_NDEBUG 0

 #include <gui/SurfaceTextureClient.h>

 #include <utils/Log.h>

 namespace android {

 SurfaceTextureClient::SurfaceTextureClient(
         const sp<ISurfaceTexture>& surfaceTexture)
 {
     SurfaceTextureClient::init();
     SurfaceTextureClient::setISurfaceTexture(surfaceTexture);
 }

 SurfaceTextureClient::SurfaceTextureClient() {
     SurfaceTextureClient::init();
 }

 void SurfaceTextureClient::init() {
     // Initialize the ANativeWindow function pointers.
     ANativeWindow::setSwapInterval  = hook_setSwapInterval;
     ANativeWindow::dequeueBuffer    = hook_dequeueBuffer;
     ANativeWindow::cancelBuffer     = hook_cancelBuffer;
     ANativeWindow::lockBuffer       = hook_lockBuffer;
     ANativeWindow::queueBuffer      = hook_queueBuffer;
     ANativeWindow::query            = hook_query;
     ANativeWindow::perform          = hook_perform;

     const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
     const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;

     mReqWidth = 0;
     mReqHeight = 0;
     mReqFormat = 0;
     mReqUsage = 0;
     mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
     mQueryWidth = 0;
     mQueryHeight = 0;
     mQueryFormat = 0;
     mDefaultWidth = 0;
     mDefaultHeight = 0;
     mTransformHint = 0;
     mConnectedToCpu = false;
 }

 void SurfaceTextureClient::setISurfaceTexture(
         const sp<ISurfaceTexture>& surfaceTexture)
 {
     mSurfaceTexture = surfaceTexture;
 }

 sp<ISurfaceTexture> SurfaceTextureClient::getISurfaceTexture() const {
     return mSurfaceTexture;
 }

 int SurfaceTextureClient::hook_setSwapInterval(ANativeWindow* window, int interval) {
     SurfaceTextureClient* c = getSelf(window);
     return c->setSwapInterval(interval);
 }

 int SurfaceTextureClient::hook_dequeueBuffer(ANativeWindow* window,
         ANativeWindowBuffer** buffer) {
     SurfaceTextureClient* c = getSelf(window);
     return c->dequeueBuffer(buffer);
 }

 int SurfaceTextureClient::hook_cancelBuffer(ANativeWindow* window,
         ANativeWindowBuffer* buffer) {
     SurfaceTextureClient* c = getSelf(window);
     return c->cancelBuffer(buffer);
 }

 int SurfaceTextureClient::hook_lockBuffer(ANativeWindow* window,
         ANativeWindowBuffer* buffer) {
     SurfaceTextureClient* c = getSelf(window);
     return c->lockBuffer(buffer);
 }

 int SurfaceTextureClient::hook_queueBuffer(ANativeWindow* window,
         ANativeWindowBuffer* buffer) {
     SurfaceTextureClient* c = getSelf(window);
     return c->queueBuffer(buffer);
 }

 int SurfaceTextureClient::hook_query(const ANativeWindow* window,
                                 int what, int* value) {
     const SurfaceTextureClient* c = getSelf(window);
     return c->query(what, value);
 }

 int SurfaceTextureClient::hook_perform(ANativeWindow* window, int operation, ...) {
     va_list args;
     va_start(args, operation);
     SurfaceTextureClient* c = getSelf(window);
     return c->perform(operation, args);
 }

 int SurfaceTextureClient::setSwapInterval(int interval) {
     // EGL specification states:
     //  interval is silently clamped to minimum and maximum implementation
     //  dependent values before being stored.
     // Although we don't have to, we apply the same logic here.

     if (interval < minSwapInterval)
         interval = minSwapInterval;

     if (interval > maxSwapInterval)
         interval = maxSwapInterval;

     status_t res = mSurfaceTexture->setSynchronousMode(interval ? true : false);

     return res;
 }

 int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {
     LOGV("SurfaceTextureClient::dequeueBuffer");
     Mutex::Autolock lock(mMutex);
     int buf = -1;
     status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,
             mReqFormat, mReqUsage);
     if (result < 0) {
         LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
              "failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
              result);
         return result;
     }
     sp<GraphicBuffer>& gbuf(mSlots[buf]);
     if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
         freeAllBuffers();
     }

     if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
         gbuf = mSurfaceTexture->requestBuffer(buf);
         if (gbuf == 0) {
             LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed");
             return NO_MEMORY;
         }
         mQueryWidth  = gbuf->width;
         mQueryHeight = gbuf->height;
         mQueryFormat = gbuf->format;
     }
     *buffer = gbuf.get();
     return OK;
 }

 int SurfaceTextureClient::cancelBuffer(android_native_buffer_t* buffer) {
     LOGV("SurfaceTextureClient::cancelBuffer");
     Mutex::Autolock lock(mMutex);
     int i = getSlotFromBufferLocked(buffer);
     if (i < 0) {
         return i;
     }
     mSurfaceTexture->cancelBuffer(i);
     return OK;
 }

 int SurfaceTextureClient::getSlotFromBufferLocked(
         android_native_buffer_t* buffer) const {
     bool dumpedState = false;
     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
         // XXX: Dump the slots whenever we hit a NULL entry while searching for
         // a buffer.
         if (mSlots[i] == NULL) {
             if (!dumpedState) {
                 LOGD("getSlotFromBufferLocked: encountered NULL buffer in slot %d "
                         "looking for buffer %p", i, buffer->handle);
                 for (int j = 0; j < NUM_BUFFER_SLOTS; j++) {
                     if (mSlots[j] == NULL) {
                         LOGD("getSlotFromBufferLocked:   %02d: NULL", j);
                     } else {
                         LOGD("getSlotFromBufferLocked:   %02d: %p", j, mSlots[j]->handle);
                     }
                 }
                 dumpedState = true;
             }
         }

         if (mSlots[i] != NULL && mSlots[i]->handle == buffer->handle) {
             return i;
         }
     }
     LOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle);
     return BAD_VALUE;
 }

 int SurfaceTextureClient::lockBuffer(android_native_buffer_t* buffer) {
     LOGV("SurfaceTextureClient::lockBuffer");
     Mutex::Autolock lock(mMutex);
     return OK;
 }

 int SurfaceTextureClient::queueBuffer(android_native_buffer_t* buffer) {
     LOGV("SurfaceTextureClient::queueBuffer");
     Mutex::Autolock lock(mMutex);
     int64_t timestamp;
     if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
         timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
         LOGV("SurfaceTextureClient::queueBuffer making up timestamp: %.2f ms",
              timestamp / 1000000.f);
     } else {
         timestamp = mTimestamp;
     }
     int i = getSlotFromBufferLocked(buffer);
     if (i < 0) {
         return i;
     }
     mSurfaceTexture->queueBuffer(i, timestamp,
             &mDefaultWidth, &mDefaultHeight, &mTransformHint);
     return OK;
 }

 int SurfaceTextureClient::query(int what, int* value) const {
     LOGV("SurfaceTextureClient::query");
     { // scope for the lock
         Mutex::Autolock lock(mMutex);
         switch (what) {
             case NATIVE_WINDOW_FORMAT:
                 if (mReqFormat) {
                     *value = mReqFormat;
                     return NO_ERROR;
                 }
                 break;
             case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER:
                 *value = 0;
                 return NO_ERROR;
             case NATIVE_WINDOW_CONCRETE_TYPE:
                 *value = NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT;
                 return NO_ERROR;
             case NATIVE_WINDOW_DEFAULT_WIDTH:
                 *value = mDefaultWidth;
                 return NO_ERROR;
             case NATIVE_WINDOW_DEFAULT_HEIGHT:
                 *value = mDefaultHeight;
                 return NO_ERROR;
             case NATIVE_WINDOW_TRANSFORM_HINT:
                 *value = mTransformHint;
                 return NO_ERROR;
         }
     }
     return mSurfaceTexture->query(what, value);
 }

 int SurfaceTextureClient::perform(int operation, va_list args)
 {
     int res = NO_ERROR;
     switch (operation) {
     case NATIVE_WINDOW_CONNECT:
         res = dispatchConnect(args);
         break;
     case NATIVE_WINDOW_DISCONNECT:
         res = dispatchDisconnect(args);
         break;
     case NATIVE_WINDOW_SET_USAGE:
         res = dispatchSetUsage(args);
         break;
     case NATIVE_WINDOW_SET_CROP:
         res = dispatchSetCrop(args);
         break;
     case NATIVE_WINDOW_SET_BUFFER_COUNT:
         res = dispatchSetBufferCount(args);
         break;
     case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
         res = dispatchSetBuffersGeometry(args);
         break;
     case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
         res = dispatchSetBuffersTransform(args);
         break;
     case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
         res = dispatchSetBuffersTimestamp(args);
         break;
     case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
         res = dispatchSetBuffersDimensions(args);
         break;
     case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
         res = dispatchSetBuffersFormat(args);
         break;
     case NATIVE_WINDOW_LOCK:
         res = dispatchLock(args);
         break;
     case NATIVE_WINDOW_UNLOCK_AND_POST:
         res = dispatchUnlockAndPost(args);
         break;
     case NATIVE_WINDOW_SET_SCALING_MODE:
         res = dispatchSetScalingMode(args);
         break;
     default:
         res = NAME_NOT_FOUND;
         break;
     }
     return res;
 }

 int SurfaceTextureClient::dispatchConnect(va_list args) {
     int api = va_arg(args, int);
     return connect(api);
 }

 int SurfaceTextureClient::dispatchDisconnect(va_list args) {
     int api = va_arg(args, int);
     return disconnect(api);
 }

 int SurfaceTextureClient::dispatchSetUsage(va_list args) {
     int usage = va_arg(args, int);
     return setUsage(usage);
 }

 int SurfaceTextureClient::dispatchSetCrop(va_list args) {
     android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
     return setCrop(reinterpret_cast<Rect const*>(rect));
 }

 int SurfaceTextureClient::dispatchSetBufferCount(va_list args) {
     size_t bufferCount = va_arg(args, size_t);
     return setBufferCount(bufferCount);
 }

 int SurfaceTextureClient::dispatchSetBuffersGeometry(va_list args) {
     int w = va_arg(args, int);
     int h = va_arg(args, int);
     int f = va_arg(args, int);
     int err = setBuffersDimensions(w, h);
     if (err != 0) {
         return err;
     }
     return setBuffersFormat(f);
 }

 int SurfaceTextureClient::dispatchSetBuffersDimensions(va_list args) {
     int w = va_arg(args, int);
     int h = va_arg(args, int);
     return setBuffersDimensions(w, h);
 }

 int SurfaceTextureClient::dispatchSetBuffersFormat(va_list args) {
     int f = va_arg(args, int);
     return setBuffersFormat(f);
 }

 int SurfaceTextureClient::dispatchSetScalingMode(va_list args) {
     int m = va_arg(args, int);
     return setScalingMode(m);
 }

 int SurfaceTextureClient::dispatchSetBuffersTransform(va_list args) {
     int transform = va_arg(args, int);
     return setBuffersTransform(transform);
 }

 int SurfaceTextureClient::dispatchSetBuffersTimestamp(va_list args) {
     int64_t timestamp = va_arg(args, int64_t);
     return setBuffersTimestamp(timestamp);
 }

 int SurfaceTextureClient::dispatchLock(va_list args) {
     ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*);
     ARect* inOutDirtyBounds = va_arg(args, ARect*);
     return lock(outBuffer, inOutDirtyBounds);
 }

 int SurfaceTextureClient::dispatchUnlockAndPost(va_list args) {
     return unlockAndPost();
 }


 int SurfaceTextureClient::connect(int api) {
     LOGV("SurfaceTextureClient::connect");
     Mutex::Autolock lock(mMutex);
     int err = mSurfaceTexture->connect(api);
     if (!err && api == NATIVE_WINDOW_API_CPU) {
         mConnectedToCpu = true;
     }
     return err;
 }

 int SurfaceTextureClient::disconnect(int api) {
     LOGV("SurfaceTextureClient::disconnect");
     Mutex::Autolock lock(mMutex);
     int err = mSurfaceTexture->disconnect(api);
     if (!err && api == NATIVE_WINDOW_API_CPU) {
         mConnectedToCpu = false;
     }
     return err;
 }

 int SurfaceTextureClient::setUsage(uint32_t reqUsage)
 {
     LOGV("SurfaceTextureClient::setUsage");
     Mutex::Autolock lock(mMutex);
     mReqUsage = reqUsage;
     return OK;
 }

 int SurfaceTextureClient::setCrop(Rect const* rect)
 {
     LOGV("SurfaceTextureClient::setCrop");
     Mutex::Autolock lock(mMutex);

     Rect realRect;
     if (rect == NULL || rect->isEmpty()) {
         realRect = Rect(0, 0);
     } else {
         realRect = *rect;
     }

     status_t err = mSurfaceTexture->setCrop(*rect);
     LOGE_IF(err, "ISurfaceTexture::setCrop(...) returned %s", strerror(-err));

     return err;
 }

 int SurfaceTextureClient::setBufferCount(int bufferCount)
 {
     LOGV("SurfaceTextureClient::setBufferCount");
     Mutex::Autolock lock(mMutex);

     status_t err = mSurfaceTexture->setBufferCount(bufferCount);
     LOGE_IF(err, "ISurfaceTexture::setBufferCount(%d) returned %s",
             bufferCount, strerror(-err));

     if (err == NO_ERROR) {
         freeAllBuffers();
     }

     return err;
 }

 int SurfaceTextureClient::setBuffersDimensions(int w, int h)
 {
     LOGV("SurfaceTextureClient::setBuffersDimensions");
     Mutex::Autolock lock(mMutex);

     if (w<0 || h<0)
         return BAD_VALUE;

     if ((w && !h) || (!w && h))
         return BAD_VALUE;

     mReqWidth = w;
     mReqHeight = h;

     status_t err = mSurfaceTexture->setCrop(Rect(0, 0));
     LOGE_IF(err, "ISurfaceTexture::setCrop(...) returned %s", strerror(-err));

     return err;
 }

 int SurfaceTextureClient::setBuffersFormat(int format)
 {
     LOGV("SurfaceTextureClient::setBuffersFormat");
     Mutex::Autolock lock(mMutex);

     if (format<0)
         return BAD_VALUE;

     mReqFormat = format;

     return NO_ERROR;
 }

 int SurfaceTextureClient::setScalingMode(int mode)
 {
     LOGV("SurfaceTextureClient::setScalingMode(%d)", mode);
     Mutex::Autolock lock(mMutex);
     // mode is validated on the server
     status_t err = mSurfaceTexture->setScalingMode(mode);
     LOGE_IF(err, "ISurfaceTexture::setScalingMode(%d) returned %s",
             mode, strerror(-err));

     return err;
 }

 int SurfaceTextureClient::setBuffersTransform(int transform)
 {
     LOGV("SurfaceTextureClient::setBuffersTransform");
     Mutex::Autolock lock(mMutex);
     status_t err = mSurfaceTexture->setTransform(transform);
     return err;
 }

 int SurfaceTextureClient::setBuffersTimestamp(int64_t timestamp)
 {
     LOGV("SurfaceTextureClient::setBuffersTimestamp");
     Mutex::Autolock lock(mMutex);
     mTimestamp = timestamp;
     return NO_ERROR;
 }

 void SurfaceTextureClient::freeAllBuffers() {
     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
         mSlots[i] = 0;
     }
 }

 // ----------------------------------------------------------------------
 // the lock/unlock APIs must be used from the same thread

 static status_t copyBlt(
         const sp<GraphicBuffer>& dst,
         const sp<GraphicBuffer>& src,
         const Region& reg)
 {
     // src and dst with, height and format must be identical. no verification
     // is done here.
     status_t err;
     uint8_t const * src_bits = NULL;
     err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits);
     LOGE_IF(err, "error locking src buffer %s", strerror(-err));

     uint8_t* dst_bits = NULL;
     err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits);
     LOGE_IF(err, "error locking dst buffer %s", strerror(-err));

     Region::const_iterator head(reg.begin());
     Region::const_iterator tail(reg.end());
     if (head != tail && src_bits && dst_bits) {
         const size_t bpp = bytesPerPixel(src->format);
         const size_t dbpr = dst->stride * bpp;
         const size_t sbpr = src->stride * bpp;

         while (head != tail) {
             const Rect& r(*head++);
             ssize_t h = r.height();
             if (h <= 0) continue;
             size_t size = r.width() * bpp;
             uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
             uint8_t       * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
             if (dbpr==sbpr && size==sbpr) {
                 size *= h;
                 h = 1;
             }
             do {
                 memcpy(d, s, size);
                 d += dbpr;
                 s += sbpr;
             } while (--h > 0);
         }
     }

     if (src_bits)
         src->unlock();

     if (dst_bits)
         dst->unlock();

     return err;
 }

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

 status_t SurfaceTextureClient::lock(
         ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
 {
     if (mLockedBuffer != 0) {
         LOGE("Surface::lock failed, already locked");
         return INVALID_OPERATION;
     }

     if (!mConnectedToCpu) {
         int err = SurfaceTextureClient::connect(NATIVE_WINDOW_API_CPU);
         if (err) {
             return err;
         }
         // we're intending to do software rendering from this point
         setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
     }

     ANativeWindowBuffer* out;
     status_t err = dequeueBuffer(&out);
     LOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
     if (err == NO_ERROR) {
         sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
         err = lockBuffer(backBuffer.get());
         LOGE_IF(err, "lockBuffer (handle=%p) failed (%s)",
                 backBuffer->handle, strerror(-err));
         if (err == NO_ERROR) {
             const Rect bounds(backBuffer->width, backBuffer->height);

             Region newDirtyRegion;
             if (inOutDirtyBounds) {
                 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));
                 newDirtyRegion.andSelf(bounds);
             } else {
                 newDirtyRegion.set(bounds);
             }

             // figure out if we can copy the frontbuffer back
             const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
             const bool canCopyBack = (frontBuffer != 0 &&
                     backBuffer->width  == frontBuffer->width &&
                     backBuffer->height == frontBuffer->height &&
                     backBuffer->format == frontBuffer->format);

             if (canCopyBack) {
                 // copy the area that is invalid and not repainted this round
                 const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));
                 if (!copyback.isEmpty())
                     copyBlt(backBuffer, frontBuffer, copyback);
             } else {
                 // if we can't copy-back anything, modify the user's dirty
                 // region to make sure they redraw the whole buffer
                 newDirtyRegion.set(bounds);
             }

             // keep track of the are of the buffer that is "clean"
             // (ie: that will be redrawn)
             mOldDirtyRegion = newDirtyRegion;

             if (inOutDirtyBounds) {
                 *inOutDirtyBounds = newDirtyRegion.getBounds();
             }

             void* vaddr;
             status_t res = backBuffer->lock(
                     GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
                     newDirtyRegion.bounds(), &vaddr);

             LOGW_IF(res, "failed locking buffer (handle = %p)",
                     backBuffer->handle);

             mLockedBuffer = backBuffer;
             outBuffer->width  = backBuffer->width;
             outBuffer->height = backBuffer->height;
             outBuffer->stride = backBuffer->stride;
             outBuffer->format = backBuffer->format;
             outBuffer->bits   = vaddr;
         }
     }
     return err;
 }

 status_t SurfaceTextureClient::unlockAndPost()
 {
     if (mLockedBuffer == 0) {
         LOGE("Surface::unlockAndPost failed, no locked buffer");
         return INVALID_OPERATION;
     }

     status_t err = mLockedBuffer->unlock();
     LOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);

     err = queueBuffer(mLockedBuffer.get());
     LOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
             mLockedBuffer->handle, strerror(-err));

     mPostedBuffer = mLockedBuffer;
     mLockedBuffer = 0;
     return err;
 }

 }; // 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 "SurfaceTextureClient"
	//#define LOG_NDEBUG 0

	#include <gui/SurfaceTextureClient.h>

	#include <utils/Log.h>

	namespace android {

	SurfaceTextureClient::SurfaceTextureClient(
	const sp<ISurfaceTexture>& surfaceTexture)
	{
	SurfaceTextureClient::init();
	SurfaceTextureClient::setISurfaceTexture(surfaceTexture);
	}

	SurfaceTextureClient::SurfaceTextureClient() {
	SurfaceTextureClient::init();
	}

	void SurfaceTextureClient::init() {
	// Initialize the ANativeWindow function pointers.
	ANativeWindow::setSwapInterval = hook_setSwapInterval;
	ANativeWindow::dequeueBuffer = hook_dequeueBuffer;
	ANativeWindow::cancelBuffer = hook_cancelBuffer;
	ANativeWindow::lockBuffer = hook_lockBuffer;
	ANativeWindow::queueBuffer = hook_queueBuffer;
	ANativeWindow::query = hook_query;
	ANativeWindow::perform = hook_perform;

	const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
	const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;

	mReqWidth = 0;
	mReqHeight = 0;
	mReqFormat = 0;
	mReqUsage = 0;
	mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
	mQueryWidth = 0;
	mQueryHeight = 0;
	mQueryFormat = 0;
	mDefaultWidth = 0;
	mDefaultHeight = 0;
	mTransformHint = 0;
	mConnectedToCpu = false;
	}

	void SurfaceTextureClient::setISurfaceTexture(
	const sp<ISurfaceTexture>& surfaceTexture)
	{
	mSurfaceTexture = surfaceTexture;
	}

	sp<ISurfaceTexture> SurfaceTextureClient::getISurfaceTexture() const {
	return mSurfaceTexture;
	}

	int SurfaceTextureClient::hook_setSwapInterval(ANativeWindow* window, int interval) {
	SurfaceTextureClient* c = getSelf(window);
	return c->setSwapInterval(interval);
	}

	int SurfaceTextureClient::hook_dequeueBuffer(ANativeWindow* window,
	ANativeWindowBuffer** buffer) {
	SurfaceTextureClient* c = getSelf(window);
	return c->dequeueBuffer(buffer);
	}

	int SurfaceTextureClient::hook_cancelBuffer(ANativeWindow* window,
	ANativeWindowBuffer* buffer) {
	SurfaceTextureClient* c = getSelf(window);
	return c->cancelBuffer(buffer);
	}

	int SurfaceTextureClient::hook_lockBuffer(ANativeWindow* window,
	ANativeWindowBuffer* buffer) {
	SurfaceTextureClient* c = getSelf(window);
	return c->lockBuffer(buffer);
	}

	int SurfaceTextureClient::hook_queueBuffer(ANativeWindow* window,
	ANativeWindowBuffer* buffer) {
	SurfaceTextureClient* c = getSelf(window);
	return c->queueBuffer(buffer);
	}

	int SurfaceTextureClient::hook_query(const ANativeWindow* window,
	int what, int* value) {
	const SurfaceTextureClient* c = getSelf(window);
	return c->query(what, value);
	}

	int SurfaceTextureClient::hook_perform(ANativeWindow* window, int operation, ...) {
	va_list args;
	va_start(args, operation);
	SurfaceTextureClient* c = getSelf(window);
	return c->perform(operation, args);
	}

	int SurfaceTextureClient::setSwapInterval(int interval) {
	// EGL specification states:
	// interval is silently clamped to minimum and maximum implementation
	// dependent values before being stored.
	// Although we don't have to, we apply the same logic here.

	if (interval < minSwapInterval)
	interval = minSwapInterval;

	if (interval > maxSwapInterval)
	interval = maxSwapInterval;

	status_t res = mSurfaceTexture->setSynchronousMode(interval ? true : false);

	return res;
	}

	int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {
	LOGV("SurfaceTextureClient::dequeueBuffer");
	Mutex::Autolock lock(mMutex);
	int buf = -1;
	status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,
	mReqFormat, mReqUsage);
	if (result < 0) {
	LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
	"failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
	result);
	return result;
	}
	sp<GraphicBuffer>& gbuf(mSlots[buf]);
	if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
	freeAllBuffers();
	}

	if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) \|\| gbuf == 0) {
	gbuf = mSurfaceTexture->requestBuffer(buf);
	if (gbuf == 0) {
	LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed");
	return NO_MEMORY;
	}
	mQueryWidth = gbuf->width;
	mQueryHeight = gbuf->height;
	mQueryFormat = gbuf->format;
	}
	*buffer = gbuf.get();
	return OK;
	}

	int SurfaceTextureClient::cancelBuffer(android_native_buffer_t* buffer) {
	LOGV("SurfaceTextureClient::cancelBuffer");
	Mutex::Autolock lock(mMutex);
	int i = getSlotFromBufferLocked(buffer);
	if (i < 0) {
	return i;
	}
	mSurfaceTexture->cancelBuffer(i);
	return OK;
	}

	int SurfaceTextureClient::getSlotFromBufferLocked(
	android_native_buffer_t* buffer) const {
	bool dumpedState = false;
	for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
	// XXX: Dump the slots whenever we hit a NULL entry while searching for
	// a buffer.
	if (mSlots[i] == NULL) {
	if (!dumpedState) {
	LOGD("getSlotFromBufferLocked: encountered NULL buffer in slot %d "
	"looking for buffer %p", i, buffer->handle);
	for (int j = 0; j < NUM_BUFFER_SLOTS; j++) {
	if (mSlots[j] == NULL) {
	LOGD("getSlotFromBufferLocked: %02d: NULL", j);
	} else {
	LOGD("getSlotFromBufferLocked: %02d: %p", j, mSlots[j]->handle);
	}
	}
	dumpedState = true;
	}
	}

	if (mSlots[i] != NULL && mSlots[i]->handle == buffer->handle) {
	return i;
	}
	}
	LOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle);
	return BAD_VALUE;
	}

	int SurfaceTextureClient::lockBuffer(android_native_buffer_t* buffer) {
	LOGV("SurfaceTextureClient::lockBuffer");
	Mutex::Autolock lock(mMutex);
	return OK;
	}

	int SurfaceTextureClient::queueBuffer(android_native_buffer_t* buffer) {
	LOGV("SurfaceTextureClient::queueBuffer");
	Mutex::Autolock lock(mMutex);
	int64_t timestamp;
	if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
	timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
	LOGV("SurfaceTextureClient::queueBuffer making up timestamp: %.2f ms",
	timestamp / 1000000.f);
	} else {
	timestamp = mTimestamp;
	}
	int i = getSlotFromBufferLocked(buffer);
	if (i < 0) {
	return i;
	}
	mSurfaceTexture->queueBuffer(i, timestamp,
	&mDefaultWidth, &mDefaultHeight, &mTransformHint);
	return OK;
	}

	int SurfaceTextureClient::query(int what, int* value) const {
	LOGV("SurfaceTextureClient::query");
	{ // scope for the lock
	Mutex::Autolock lock(mMutex);
	switch (what) {
	case NATIVE_WINDOW_FORMAT:
	if (mReqFormat) {
	*value = mReqFormat;
	return NO_ERROR;
	}
	break;
	case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER:
	*value = 0;
	return NO_ERROR;
	case NATIVE_WINDOW_CONCRETE_TYPE:
	*value = NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT;
	return NO_ERROR;
	case NATIVE_WINDOW_DEFAULT_WIDTH:
	*value = mDefaultWidth;
	return NO_ERROR;
	case NATIVE_WINDOW_DEFAULT_HEIGHT:
	*value = mDefaultHeight;
	return NO_ERROR;
	case NATIVE_WINDOW_TRANSFORM_HINT:
	*value = mTransformHint;
	return NO_ERROR;
	}
	}
	return mSurfaceTexture->query(what, value);
	}

	int SurfaceTextureClient::perform(int operation, va_list args)
	{
	int res = NO_ERROR;
	switch (operation) {
	case NATIVE_WINDOW_CONNECT:
	res = dispatchConnect(args);
	break;
	case NATIVE_WINDOW_DISCONNECT:
	res = dispatchDisconnect(args);
	break;
	case NATIVE_WINDOW_SET_USAGE:
	res = dispatchSetUsage(args);
	break;
	case NATIVE_WINDOW_SET_CROP:
	res = dispatchSetCrop(args);
	break;
	case NATIVE_WINDOW_SET_BUFFER_COUNT:
	res = dispatchSetBufferCount(args);
	break;
	case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
	res = dispatchSetBuffersGeometry(args);
	break;
	case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
	res = dispatchSetBuffersTransform(args);
	break;
	case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
	res = dispatchSetBuffersTimestamp(args);
	break;
	case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
	res = dispatchSetBuffersDimensions(args);
	break;
	case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
	res = dispatchSetBuffersFormat(args);
	break;
	case NATIVE_WINDOW_LOCK:
	res = dispatchLock(args);
	break;
	case NATIVE_WINDOW_UNLOCK_AND_POST:
	res = dispatchUnlockAndPost(args);
	break;
	case NATIVE_WINDOW_SET_SCALING_MODE:
	res = dispatchSetScalingMode(args);
	break;
	default:
	res = NAME_NOT_FOUND;
	break;
	}
	return res;
	}

	int SurfaceTextureClient::dispatchConnect(va_list args) {
	int api = va_arg(args, int);
	return connect(api);
	}

	int SurfaceTextureClient::dispatchDisconnect(va_list args) {
	int api = va_arg(args, int);
	return disconnect(api);
	}

	int SurfaceTextureClient::dispatchSetUsage(va_list args) {
	int usage = va_arg(args, int);
	return setUsage(usage);
	}

	int SurfaceTextureClient::dispatchSetCrop(va_list args) {
	android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
	return setCrop(reinterpret_cast<Rect const*>(rect));
	}

	int SurfaceTextureClient::dispatchSetBufferCount(va_list args) {
	size_t bufferCount = va_arg(args, size_t);
	return setBufferCount(bufferCount);
	}

	int SurfaceTextureClient::dispatchSetBuffersGeometry(va_list args) {
	int w = va_arg(args, int);
	int h = va_arg(args, int);
	int f = va_arg(args, int);
	int err = setBuffersDimensions(w, h);
	if (err != 0) {
	return err;
	}
	return setBuffersFormat(f);
	}

	int SurfaceTextureClient::dispatchSetBuffersDimensions(va_list args) {
	int w = va_arg(args, int);
	int h = va_arg(args, int);
	return setBuffersDimensions(w, h);
	}

	int SurfaceTextureClient::dispatchSetBuffersFormat(va_list args) {
	int f = va_arg(args, int);
	return setBuffersFormat(f);
	}

	int SurfaceTextureClient::dispatchSetScalingMode(va_list args) {
	int m = va_arg(args, int);
	return setScalingMode(m);
	}

	int SurfaceTextureClient::dispatchSetBuffersTransform(va_list args) {
	int transform = va_arg(args, int);
	return setBuffersTransform(transform);
	}

	int SurfaceTextureClient::dispatchSetBuffersTimestamp(va_list args) {
	int64_t timestamp = va_arg(args, int64_t);
	return setBuffersTimestamp(timestamp);
	}

	int SurfaceTextureClient::dispatchLock(va_list args) {
	ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*);
	ARect* inOutDirtyBounds = va_arg(args, ARect*);
	return lock(outBuffer, inOutDirtyBounds);
	}

	int SurfaceTextureClient::dispatchUnlockAndPost(va_list args) {
	return unlockAndPost();
	}


	int SurfaceTextureClient::connect(int api) {
	LOGV("SurfaceTextureClient::connect");
	Mutex::Autolock lock(mMutex);
	int err = mSurfaceTexture->connect(api);
	if (!err && api == NATIVE_WINDOW_API_CPU) {
	mConnectedToCpu = true;
	}
	return err;
	}

	int SurfaceTextureClient::disconnect(int api) {
	LOGV("SurfaceTextureClient::disconnect");
	Mutex::Autolock lock(mMutex);
	int err = mSurfaceTexture->disconnect(api);
	if (!err && api == NATIVE_WINDOW_API_CPU) {
	mConnectedToCpu = false;
	}
	return err;
	}

	int SurfaceTextureClient::setUsage(uint32_t reqUsage)
	{
	LOGV("SurfaceTextureClient::setUsage");
	Mutex::Autolock lock(mMutex);
	mReqUsage = reqUsage;
	return OK;
	}

	int SurfaceTextureClient::setCrop(Rect const* rect)
	{
	LOGV("SurfaceTextureClient::setCrop");
	Mutex::Autolock lock(mMutex);

	Rect realRect;
	if (rect == NULL \|\| rect->isEmpty()) {
	realRect = Rect(0, 0);
	} else {
	realRect = *rect;
	}

	status_t err = mSurfaceTexture->setCrop(*rect);
	LOGE_IF(err, "ISurfaceTexture::setCrop(...) returned %s", strerror(-err));

	return err;
	}

	int SurfaceTextureClient::setBufferCount(int bufferCount)
	{
	LOGV("SurfaceTextureClient::setBufferCount");
	Mutex::Autolock lock(mMutex);

	status_t err = mSurfaceTexture->setBufferCount(bufferCount);
	LOGE_IF(err, "ISurfaceTexture::setBufferCount(%d) returned %s",
	bufferCount, strerror(-err));

	if (err == NO_ERROR) {
	freeAllBuffers();
	}

	return err;
	}

	int SurfaceTextureClient::setBuffersDimensions(int w, int h)
	{
	LOGV("SurfaceTextureClient::setBuffersDimensions");
	Mutex::Autolock lock(mMutex);

	if (w<0 \|\| h<0)
	return BAD_VALUE;

	if ((w && !h) \|\| (!w && h))
	return BAD_VALUE;

	mReqWidth = w;
	mReqHeight = h;

	status_t err = mSurfaceTexture->setCrop(Rect(0, 0));
	LOGE_IF(err, "ISurfaceTexture::setCrop(...) returned %s", strerror(-err));

	return err;
	}

	int SurfaceTextureClient::setBuffersFormat(int format)
	{
	LOGV("SurfaceTextureClient::setBuffersFormat");
	Mutex::Autolock lock(mMutex);

	if (format<0)
	return BAD_VALUE;

	mReqFormat = format;

	return NO_ERROR;
	}

	int SurfaceTextureClient::setScalingMode(int mode)
	{
	LOGV("SurfaceTextureClient::setScalingMode(%d)", mode);
	Mutex::Autolock lock(mMutex);
	// mode is validated on the server
	status_t err = mSurfaceTexture->setScalingMode(mode);
	LOGE_IF(err, "ISurfaceTexture::setScalingMode(%d) returned %s",
	mode, strerror(-err));

	return err;
	}

	int SurfaceTextureClient::setBuffersTransform(int transform)
	{
	LOGV("SurfaceTextureClient::setBuffersTransform");
	Mutex::Autolock lock(mMutex);
	status_t err = mSurfaceTexture->setTransform(transform);
	return err;
	}

	int SurfaceTextureClient::setBuffersTimestamp(int64_t timestamp)
	{
	LOGV("SurfaceTextureClient::setBuffersTimestamp");
	Mutex::Autolock lock(mMutex);
	mTimestamp = timestamp;
	return NO_ERROR;
	}

	void SurfaceTextureClient::freeAllBuffers() {
	for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
	mSlots[i] = 0;
	}
	}

	// ----------------------------------------------------------------------
	// the lock/unlock APIs must be used from the same thread

	static status_t copyBlt(
	const sp<GraphicBuffer>& dst,
	const sp<GraphicBuffer>& src,
	const Region& reg)
	{
	// src and dst with, height and format must be identical. no verification
	// is done here.
	status_t err;
	uint8_t const * src_bits = NULL;
	err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits);
	LOGE_IF(err, "error locking src buffer %s", strerror(-err));

	uint8_t* dst_bits = NULL;
	err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits);
	LOGE_IF(err, "error locking dst buffer %s", strerror(-err));

	Region::const_iterator head(reg.begin());
	Region::const_iterator tail(reg.end());
	if (head != tail && src_bits && dst_bits) {
	const size_t bpp = bytesPerPixel(src->format);
	const size_t dbpr = dst->stride * bpp;
	const size_t sbpr = src->stride * bpp;

	while (head != tail) {
	const Rect& r(*head++);
	ssize_t h = r.height();
	if (h <= 0) continue;
	size_t size = r.width() * bpp;
	uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
	uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
	if (dbpr==sbpr && size==sbpr) {
	size *= h;
	h = 1;
	}
	do {
	memcpy(d, s, size);
	d += dbpr;
	s += sbpr;
	} while (--h > 0);
	}
	}

	if (src_bits)
	src->unlock();

	if (dst_bits)
	dst->unlock();

	return err;
	}

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

	status_t SurfaceTextureClient::lock(
	ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
	{
	if (mLockedBuffer != 0) {
	LOGE("Surface::lock failed, already locked");
	return INVALID_OPERATION;
	}

	if (!mConnectedToCpu) {
	int err = SurfaceTextureClient::connect(NATIVE_WINDOW_API_CPU);
	if (err) {
	return err;
	}
	// we're intending to do software rendering from this point
	setUsage(GRALLOC_USAGE_SW_READ_OFTEN \| GRALLOC_USAGE_SW_WRITE_OFTEN);
	}

	ANativeWindowBuffer* out;
	status_t err = dequeueBuffer(&out);
	LOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
	if (err == NO_ERROR) {
	sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
	err = lockBuffer(backBuffer.get());
	LOGE_IF(err, "lockBuffer (handle=%p) failed (%s)",
	backBuffer->handle, strerror(-err));
	if (err == NO_ERROR) {
	const Rect bounds(backBuffer->width, backBuffer->height);

	Region newDirtyRegion;
	if (inOutDirtyBounds) {
	newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));
	newDirtyRegion.andSelf(bounds);
	} else {
	newDirtyRegion.set(bounds);
	}

	// figure out if we can copy the frontbuffer back
	const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
	const bool canCopyBack = (frontBuffer != 0 &&
	backBuffer->width == frontBuffer->width &&
	backBuffer->height == frontBuffer->height &&
	backBuffer->format == frontBuffer->format);

	if (canCopyBack) {
	// copy the area that is invalid and not repainted this round
	const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));
	if (!copyback.isEmpty())
	copyBlt(backBuffer, frontBuffer, copyback);
	} else {
	// if we can't copy-back anything, modify the user's dirty
	// region to make sure they redraw the whole buffer
	newDirtyRegion.set(bounds);
	}

	// keep track of the are of the buffer that is "clean"
	// (ie: that will be redrawn)
	mOldDirtyRegion = newDirtyRegion;

	if (inOutDirtyBounds) {
	*inOutDirtyBounds = newDirtyRegion.getBounds();
	}

	void* vaddr;
	status_t res = backBuffer->lock(
	GRALLOC_USAGE_SW_READ_OFTEN \| GRALLOC_USAGE_SW_WRITE_OFTEN,
	newDirtyRegion.bounds(), &vaddr);

	LOGW_IF(res, "failed locking buffer (handle = %p)",
	backBuffer->handle);

	mLockedBuffer = backBuffer;
	outBuffer->width = backBuffer->width;
	outBuffer->height = backBuffer->height;
	outBuffer->stride = backBuffer->stride;
	outBuffer->format = backBuffer->format;
	outBuffer->bits = vaddr;
	}
	}
	return err;
	}

	status_t SurfaceTextureClient::unlockAndPost()
	{
	if (mLockedBuffer == 0) {
	LOGE("Surface::unlockAndPost failed, no locked buffer");
	return INVALID_OPERATION;
	}

	status_t err = mLockedBuffer->unlock();
	LOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);

	err = queueBuffer(mLockedBuffer.get());
	LOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
	mLockedBuffer->handle, strerror(-err));

	mPostedBuffer = mLockedBuffer;
	mLockedBuffer = 0;
	return err;
	}

	}; // namespace android