diff options
Diffstat (limited to 'libs')
41 files changed, 622 insertions, 636 deletions
diff --git a/libs/binder/Parcel.cpp b/libs/binder/Parcel.cpp index 80c5d7e..2c566f9 100644 --- a/libs/binder/Parcel.cpp +++ b/libs/binder/Parcel.cpp @@ -26,7 +26,6 @@ #include <binder/TextOutput.h> #include <errno.h> -#include <utils/CallStack.h> #include <utils/Debug.h> #include <utils/Log.h> #include <utils/String8.h> @@ -36,8 +35,8 @@ #include <cutils/ashmem.h> #include <private/binder/binder_module.h> +#include <private/binder/Static.h> -#include <fcntl.h> #include <inttypes.h> #include <stdio.h> #include <stdlib.h> @@ -50,6 +49,8 @@ #define LOG_REFS(...) //#define LOG_REFS(...) ALOG(LOG_DEBUG, "Parcel", __VA_ARGS__) +#define LOG_ALLOC(...) +//#define LOG_ALLOC(...) ALOG(LOG_DEBUG, "Parcel", __VA_ARGS__) // --------------------------------------------------------------------------- @@ -74,6 +75,10 @@ struct small_flat_data namespace android { +static pthread_mutex_t gParcelGlobalAllocSizeLock = PTHREAD_MUTEX_INITIALIZER; +static size_t gParcelGlobalAllocSize = 0; +static size_t gParcelGlobalAllocCount = 0; + void acquire_object(const sp<ProcessState>& proc, const flat_binder_object& obj, const void* who) { @@ -293,12 +298,28 @@ status_t unflatten_binder(const sp<ProcessState>& proc, Parcel::Parcel() { + LOG_ALLOC("Parcel %p: constructing", this); initState(); } Parcel::~Parcel() { freeDataNoInit(); + LOG_ALLOC("Parcel %p: destroyed", this); +} + +size_t Parcel::getGlobalAllocSize() { + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + size_t size = gParcelGlobalAllocSize; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); + return size; +} + +size_t Parcel::getGlobalAllocCount() { + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + size_t count = gParcelGlobalAllocCount; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); + return count; } const uint8_t* Parcel::data() const @@ -774,29 +795,6 @@ status_t Parcel::writeFileDescriptor(int fd, bool takeOwnership) status_t Parcel::writeDupFileDescriptor(int fd) { int dupFd = dup(fd); - - { // Temporary extra debug validation for b/17477219: a Parcel recipient is - // getting a positive but invalid fd unexpectedly. Trying to track down - // where it's coming from. - int dupErrno = dupFd < 0 ? errno : 0; - int fdFlags = fcntl(fd, F_GETFD); - int fdFlagsErrno = fdFlags == -1 ? errno : 0; - int dupFlags = fcntl(dupFd, F_GETFD); - int dupFlagsErrno = dupFlags == -1 ? errno : 0; - if (dupFd < 0 || fdFlags == -1 || dupFlags == -1) { - ALOGE("Parcel::writeDupFileDescriptor failed:\n" - " fd=%d flags=%d err=%d(%s)\n" - " dupFd=%d dupErr=%d(%s) flags=%d err=%d(%s)", - fd, fdFlags, fdFlagsErrno, strerror(fdFlagsErrno), - dupFd, dupErrno, strerror(dupErrno), - dupFlags, dupFlagsErrno, strerror(dupFlagsErrno)); - if (fd < 0 || fdFlags == -1) { - CallStack(LOG_TAG); - } - return -errno; - } - } - if (dupFd < 0) { return -errno; } @@ -1320,23 +1318,11 @@ status_t Parcel::read(FlattenableHelperInterface& val) const status_t err = NO_ERROR; for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) { - int oldfd = this->readFileDescriptor(); - fds[i] = dup(oldfd); + fds[i] = dup(this->readFileDescriptor()); if (fds[i] < 0) { - int dupErrno = errno; err = BAD_VALUE; - int flags = fcntl(oldfd, F_GETFD); - int fcntlErrno = errno; - const flat_binder_object* flat = readObject(true); - ALOGE("dup failed in Parcel::read, fd %zu of %zu\n" - " dup(%d) = %d [errno: %d (%s)]\n" - " fcntl(%d, F_GETFD) = %d [errno: %d (%s)]\n" - " flat %p type %d", - i, fd_count, - oldfd, fds[i], dupErrno, strerror(dupErrno), - oldfd, flags, fcntlErrno, strerror(fcntlErrno), - flat, flat ? flat->type : 0); - CallStack(LOG_TAG); + ALOGE("dup() failed in Parcel::read, i is %zu, fds[i] is %d, fd_count is %zu, error: %s", + i, fds[i], fd_count, strerror(errno)); } } @@ -1540,11 +1526,20 @@ void Parcel::freeData() void Parcel::freeDataNoInit() { if (mOwner) { + LOG_ALLOC("Parcel %p: freeing other owner data", this); //ALOGI("Freeing data ref of %p (pid=%d)", this, getpid()); mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie); } else { + LOG_ALLOC("Parcel %p: freeing allocated data", this); releaseObjects(); - if (mData) free(mData); + if (mData) { + LOG_ALLOC("Parcel %p: freeing with %zu capacity", this, mDataCapacity); + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + gParcelGlobalAllocSize -= mDataCapacity; + gParcelGlobalAllocCount--; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); + free(mData); + } if (mObjects) free(mObjects); } } @@ -1573,6 +1568,11 @@ status_t Parcel::restartWrite(size_t desired) releaseObjects(); if (data) { + LOG_ALLOC("Parcel %p: restart from %zu to %zu capacity", this, mDataCapacity, desired); + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + gParcelGlobalAllocSize += desired; + gParcelGlobalAllocSize -= mDataCapacity; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); mData = data; mDataCapacity = desired; } @@ -1652,6 +1652,12 @@ status_t Parcel::continueWrite(size_t desired) mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie); mOwner = NULL; + LOG_ALLOC("Parcel %p: taking ownership of %zu capacity", this, desired); + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + gParcelGlobalAllocSize += desired; + gParcelGlobalAllocCount++; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); + mData = data; mObjects = objects; mDataSize = (mDataSize < desired) ? mDataSize : desired; @@ -1686,6 +1692,12 @@ status_t Parcel::continueWrite(size_t desired) if (desired > mDataCapacity) { uint8_t* data = (uint8_t*)realloc(mData, desired); if (data) { + LOG_ALLOC("Parcel %p: continue from %zu to %zu capacity", this, mDataCapacity, + desired); + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + gParcelGlobalAllocSize += desired; + gParcelGlobalAllocSize -= mDataCapacity; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); mData = data; mDataCapacity = desired; } else if (desired > mDataCapacity) { @@ -1716,6 +1728,12 @@ status_t Parcel::continueWrite(size_t desired) ALOGE("continueWrite: %zu/%p/%zu/%zu", mDataCapacity, mObjects, mObjectsCapacity, desired); } + LOG_ALLOC("Parcel %p: allocating with %zu capacity", this, desired); + pthread_mutex_lock(&gParcelGlobalAllocSizeLock); + gParcelGlobalAllocSize += desired; + gParcelGlobalAllocCount++; + pthread_mutex_unlock(&gParcelGlobalAllocSizeLock); + mData = data; mDataSize = mDataPos = 0; ALOGV("continueWrite Setting data size of %p to %zu", this, mDataSize); @@ -1728,6 +1746,7 @@ status_t Parcel::continueWrite(size_t desired) void Parcel::initState() { + LOG_ALLOC("Parcel %p: initState", this); mError = NO_ERROR; mData = 0; mDataSize = 0; diff --git a/libs/binder/Static.cpp b/libs/binder/Static.cpp index 2062692..cd9509f 100644 --- a/libs/binder/Static.cpp +++ b/libs/binder/Static.cpp @@ -90,7 +90,7 @@ public: static LibBinderIPCtStatics gIPCStatics; -// ------------ ServiceManager.cpp +// ------------ IServiceManager.cpp Mutex gDefaultServiceManagerLock; sp<IServiceManager> gDefaultServiceManager; diff --git a/libs/binder/TextOutput.cpp b/libs/binder/TextOutput.cpp index db3e858..2ed5188 100644 --- a/libs/binder/TextOutput.cpp +++ b/libs/binder/TextOutput.cpp @@ -116,8 +116,8 @@ TextOutput& operator<<(TextOutput& to, double val) TextOutput& operator<<(TextOutput& to, const void* val) { - char buf[16]; - sprintf(buf, "%p", val); + char buf[32]; + snprintf(buf, sizeof(buf), "%p", val); to.print(buf, strlen(buf)); return to; } diff --git a/libs/gui/Android.mk b/libs/gui/Android.mk index 8a965dd..fffe28a 100644 --- a/libs/gui/Android.mk +++ b/libs/gui/Android.mk @@ -1,40 +1,8 @@ -# Copyright 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. - LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_CLANG := true -LOCAL_CPPFLAGS := -std=c++1y -Weverything -Werror - -# The static constructors and destructors in this library have not been noted to -# introduce significant overheads -LOCAL_CPPFLAGS += -Wno-exit-time-destructors -LOCAL_CPPFLAGS += -Wno-global-constructors - -# We only care about compiling as C++14 -LOCAL_CPPFLAGS += -Wno-c++98-compat-pedantic - -# We don't need to enumerate every case in a switch as long as a default case -# is present -LOCAL_CPPFLAGS += -Wno-switch-enum - -# Allow calling variadic macros without a __VA_ARGS__ list -LOCAL_CPPFLAGS += -Wno-gnu-zero-variadic-macro-arguments - -# Don't warn about struct padding -LOCAL_CPPFLAGS += -Wno-padded +LOCAL_CPPFLAGS := -std=c++11 LOCAL_SRC_FILES := \ IGraphicBufferConsumer.cpp \ diff --git a/libs/gui/BitTube.cpp b/libs/gui/BitTube.cpp index b653c5b..3ed1f37 100644 --- a/libs/gui/BitTube.cpp +++ b/libs/gui/BitTube.cpp @@ -149,12 +149,12 @@ ssize_t BitTube::sendObjects(const sp<BitTube>& tube, ssize_t size = tube->write(vaddr, count*objSize); // should never happen because of SOCK_SEQPACKET - LOG_ALWAYS_FATAL_IF((size >= 0) && (size % static_cast<ssize_t>(objSize)), + LOG_ALWAYS_FATAL_IF((size >= 0) && (size % objSize), "BitTube::sendObjects(count=%zu, size=%zu), res=%zd (partial events were sent!)", count, objSize, size); //ALOGE_IF(size<0, "error %d sending %d events", size, count); - return size < 0 ? size : size / static_cast<ssize_t>(objSize); + return size < 0 ? size : size / objSize; } ssize_t BitTube::recvObjects(const sp<BitTube>& tube, @@ -164,12 +164,12 @@ ssize_t BitTube::recvObjects(const sp<BitTube>& tube, ssize_t size = tube->read(vaddr, count*objSize); // should never happen because of SOCK_SEQPACKET - LOG_ALWAYS_FATAL_IF((size >= 0) && (size % static_cast<ssize_t>(objSize)), + LOG_ALWAYS_FATAL_IF((size >= 0) && (size % objSize), "BitTube::recvObjects(count=%zu, size=%zu), res=%zd (partial events were received!)", count, objSize, size); //ALOGE_IF(size<0, "error %d receiving %d events", size, count); - return size < 0 ? size : size / static_cast<ssize_t>(objSize); + return size < 0 ? size : size / objSize; } // ---------------------------------------------------------------------------- diff --git a/libs/gui/BufferItem.cpp b/libs/gui/BufferItem.cpp index d3fa43e..e6fc791 100644 --- a/libs/gui/BufferItem.cpp +++ b/libs/gui/BufferItem.cpp @@ -36,6 +36,8 @@ BufferItem::BufferItem() : mCrop.makeInvalid(); } +BufferItem::~BufferItem() {} + BufferItem::operator IGraphicBufferConsumer::BufferItem() const { IGraphicBufferConsumer::BufferItem bufferItem; bufferItem.mGraphicBuffer = mGraphicBuffer; diff --git a/libs/gui/BufferItemConsumer.cpp b/libs/gui/BufferItemConsumer.cpp index 61de69a..2d976e5 100644 --- a/libs/gui/BufferItemConsumer.cpp +++ b/libs/gui/BufferItemConsumer.cpp @@ -16,15 +16,15 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "BufferItemConsumer" -//#define ATRACE_TAG ATRACE_TAG_GRAPHICS +#define ATRACE_TAG ATRACE_TAG_GRAPHICS #include <utils/Log.h> #include <gui/BufferItemConsumer.h> -//#define BI_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define BI_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define BI_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define BI_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) +#define BI_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) +#define BI_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) +#define BI_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) +#define BI_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) #define BI_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__) namespace android { @@ -44,7 +44,8 @@ BufferItemConsumer::BufferItemConsumer( } } -BufferItemConsumer::~BufferItemConsumer() {} +BufferItemConsumer::~BufferItemConsumer() { +} void BufferItemConsumer::setName(const String8& name) { Mutex::Autolock _l(mMutex); @@ -104,7 +105,7 @@ status_t BufferItemConsumer::setDefaultBufferSize(uint32_t w, uint32_t h) { return mConsumer->setDefaultBufferSize(w, h); } -status_t BufferItemConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) { +status_t BufferItemConsumer::setDefaultBufferFormat(uint32_t defaultFormat) { Mutex::Autolock _l(mMutex); return mConsumer->setDefaultBufferFormat(defaultFormat); } diff --git a/libs/gui/BufferQueue.cpp b/libs/gui/BufferQueue.cpp index c49a886..61fd8c4 100644 --- a/libs/gui/BufferQueue.cpp +++ b/libs/gui/BufferQueue.cpp @@ -31,10 +31,11 @@ BufferQueue::ProxyConsumerListener::ProxyConsumerListener( BufferQueue::ProxyConsumerListener::~ProxyConsumerListener() {} -void BufferQueue::ProxyConsumerListener::onFrameAvailable() { +void BufferQueue::ProxyConsumerListener::onFrameAvailable( + const android::BufferItem& item) { sp<ConsumerListener> listener(mConsumerListener.promote()); if (listener != NULL) { - listener->onFrameAvailable(); + listener->onFrameAvailable(item); } } diff --git a/libs/gui/BufferQueueConsumer.cpp b/libs/gui/BufferQueueConsumer.cpp index a798b18..36e3c06 100644 --- a/libs/gui/BufferQueueConsumer.cpp +++ b/libs/gui/BufferQueueConsumer.cpp @@ -488,7 +488,7 @@ void BufferQueueConsumer::setConsumerName(const String8& name) { mConsumerName = name; } -status_t BufferQueueConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) { +status_t BufferQueueConsumer::setDefaultBufferFormat(uint32_t defaultFormat) { ATRACE_CALL(); BQ_LOGV("setDefaultBufferFormat: %u", defaultFormat); Mutex::Autolock lock(mCore->mMutex); diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp index ef2a7e8..bf9c84d 100644 --- a/libs/gui/BufferQueueProducer.cpp +++ b/libs/gui/BufferQueueProducer.cpp @@ -38,7 +38,12 @@ BufferQueueProducer::BufferQueueProducer(const sp<BufferQueueCore>& core) : mCore(core), mSlots(core->mSlots), mConsumerName(), - mStickyTransform(0) {} + mStickyTransform(0), + mLastQueueBufferFence(Fence::NO_FENCE), + mCallbackMutex(), + mNextCallbackTicket(0), + mCurrentCallbackTicket(0), + mCallbackCondition() {} BufferQueueProducer::~BufferQueueProducer() {} @@ -245,7 +250,7 @@ status_t BufferQueueProducer::waitForFreeSlotThenRelock(const char* caller, status_t BufferQueueProducer::dequeueBuffer(int *outSlot, sp<android::Fence> *outFence, bool async, - uint32_t width, uint32_t height, PixelFormat format, uint32_t usage) { + uint32_t width, uint32_t height, uint32_t format, uint32_t usage) { ATRACE_CALL(); { // Autolock scope Mutex::Autolock lock(mCore->mMutex); @@ -306,7 +311,7 @@ status_t BufferQueueProducer::dequeueBuffer(int *outSlot, if ((buffer == NULL) || (static_cast<uint32_t>(buffer->width) != width) || (static_cast<uint32_t>(buffer->height) != height) || - (buffer->format != format) || + (static_cast<uint32_t>(buffer->format) != format) || ((static_cast<uint32_t>(buffer->usage) & usage) != usage)) { mSlots[found].mAcquireCalled = false; @@ -336,7 +341,7 @@ status_t BufferQueueProducer::dequeueBuffer(int *outSlot, status_t error; BQ_LOGV("dequeueBuffer: allocating a new buffer for slot %d", *outSlot); sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer( - width, height, format, usage, &error)); + width, height, format, usage, &error)); if (graphicBuffer == NULL) { BQ_LOGE("dequeueBuffer: createGraphicBuffer failed"); return error; @@ -522,12 +527,7 @@ status_t BufferQueueProducer::queueBuffer(int slot, if (fence == NULL) { BQ_LOGE("queueBuffer: fence is NULL"); - // Temporary workaround for b/17946343: soldier-on instead of returning an error. This - // prevents the client from dying, at the risk of visible corruption due to hwcomposer - // reading the buffer before the producer is done rendering it. Unless the buffer is the - // last frame of an animation, the corruption will be transient. - fence = Fence::NO_FENCE; - // return BAD_VALUE; + return BAD_VALUE; } switch (scalingMode) { @@ -541,7 +541,10 @@ status_t BufferQueueProducer::queueBuffer(int slot, return BAD_VALUE; } - sp<IConsumerListener> listener; + sp<IConsumerListener> frameAvailableListener; + sp<IConsumerListener> frameReplacedListener; + int callbackTicket = 0; + BufferItem item; { // Autolock scope Mutex::Autolock lock(mCore->mMutex); @@ -579,8 +582,8 @@ status_t BufferQueueProducer::queueBuffer(int slot, BQ_LOGV("queueBuffer: slot=%d/%" PRIu64 " time=%" PRIu64 " crop=[%d,%d,%d,%d] transform=%#x scale=%s", slot, mCore->mFrameCounter + 1, timestamp, - crop.left, crop.top, crop.right, crop.bottom, transform, - BufferItem::scalingModeName(static_cast<uint32_t>(scalingMode))); + crop.left, crop.top, crop.right, crop.bottom, + transform, BufferItem::scalingModeName(scalingMode)); const sp<GraphicBuffer>& graphicBuffer(mSlots[slot].mGraphicBuffer); Rect bufferRect(graphicBuffer->getWidth(), graphicBuffer->getHeight()); @@ -597,15 +600,13 @@ status_t BufferQueueProducer::queueBuffer(int slot, ++mCore->mFrameCounter; mSlots[slot].mFrameNumber = mCore->mFrameCounter; - BufferItem item; item.mAcquireCalled = mSlots[slot].mAcquireCalled; item.mGraphicBuffer = mSlots[slot].mGraphicBuffer; item.mCrop = crop; - item.mTransform = transform & - ~static_cast<uint32_t>(NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY); + item.mTransform = transform & ~NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY; item.mTransformToDisplayInverse = - (transform & NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) != 0; - item.mScalingMode = static_cast<uint32_t>(scalingMode); + bool(transform & NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY); + item.mScalingMode = scalingMode; item.mTimestamp = timestamp; item.mIsAutoTimestamp = isAutoTimestamp; item.mFrameNumber = mCore->mFrameCounter; @@ -619,7 +620,7 @@ status_t BufferQueueProducer::queueBuffer(int slot, // When the queue is empty, we can ignore mDequeueBufferCannotBlock // and simply queue this buffer mCore->mQueue.push_back(item); - listener = mCore->mConsumerListener; + frameAvailableListener = mCore->mConsumerListener; } else { // When the queue is not empty, we need to look at the front buffer // state to see if we need to replace it @@ -635,9 +636,10 @@ status_t BufferQueueProducer::queueBuffer(int slot, } // Overwrite the droppable buffer with the incoming one *front = item; + frameReplacedListener = mCore->mConsumerListener; } else { mCore->mQueue.push_back(item); - listener = mCore->mConsumerListener; + frameAvailableListener = mCore->mConsumerListener; } } @@ -645,15 +647,44 @@ status_t BufferQueueProducer::queueBuffer(int slot, mCore->mDequeueCondition.broadcast(); output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight, - mCore->mTransformHint, - static_cast<uint32_t>(mCore->mQueue.size())); + mCore->mTransformHint, mCore->mQueue.size()); ATRACE_INT(mCore->mConsumerName.string(), mCore->mQueue.size()); + + // Take a ticket for the callback functions + callbackTicket = mNextCallbackTicket++; } // Autolock scope - // Call back without lock held - if (listener != NULL) { - listener->onFrameAvailable(); + // Wait without lock held + if (mCore->mConnectedApi == NATIVE_WINDOW_API_EGL) { + // Waiting here allows for two full buffers to be queued but not a + // third. In the event that frames take varying time, this makes a + // small trade-off in favor of latency rather than throughput. + mLastQueueBufferFence->waitForever("Throttling EGL Production"); + mLastQueueBufferFence = fence; + } + + // Don't send the GraphicBuffer through the callback, and don't send + // the slot number, since the consumer shouldn't need it + item.mGraphicBuffer.clear(); + item.mSlot = BufferItem::INVALID_BUFFER_SLOT; + + // Call back without the main BufferQueue lock held, but with the callback + // lock held so we can ensure that callbacks occur in order + { + Mutex::Autolock lock(mCallbackMutex); + while (callbackTicket != mCurrentCallbackTicket) { + mCallbackCondition.wait(mCallbackMutex); + } + + if (frameAvailableListener != NULL) { + frameAvailableListener->onFrameAvailable(item); + } else if (frameReplacedListener != NULL) { + frameReplacedListener->onFrameReplaced(item); + } + + ++mCurrentCallbackTicket; + mCallbackCondition.broadcast(); } return NO_ERROR; @@ -705,25 +736,25 @@ int BufferQueueProducer::query(int what, int *outValue) { int value; switch (what) { case NATIVE_WINDOW_WIDTH: - value = static_cast<int32_t>(mCore->mDefaultWidth); + value = mCore->mDefaultWidth; break; case NATIVE_WINDOW_HEIGHT: - value = static_cast<int32_t>(mCore->mDefaultHeight); + value = mCore->mDefaultHeight; break; case NATIVE_WINDOW_FORMAT: - value = static_cast<int32_t>(mCore->mDefaultBufferFormat); + value = mCore->mDefaultBufferFormat; break; case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS: value = mCore->getMinUndequeuedBufferCountLocked(false); break; case NATIVE_WINDOW_STICKY_TRANSFORM: - value = static_cast<int32_t>(mStickyTransform); + value = static_cast<int>(mStickyTransform); break; case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: value = (mCore->mQueue.size() > 1); break; case NATIVE_WINDOW_CONSUMER_USAGE_BITS: - value = static_cast<int32_t>(mCore->mConsumerUsageBits); + value = mCore->mConsumerUsageBits; break; default: return BAD_VALUE; @@ -771,8 +802,7 @@ status_t BufferQueueProducer::connect(const sp<IProducerListener>& listener, case NATIVE_WINDOW_API_CAMERA: mCore->mConnectedApi = api; output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight, - mCore->mTransformHint, - static_cast<uint32_t>(mCore->mQueue.size())); + mCore->mTransformHint, mCore->mQueue.size()); // Set up a death notification so that we can disconnect // automatically if the remote producer dies @@ -874,14 +904,14 @@ status_t BufferQueueProducer::setSidebandStream(const sp<NativeHandle>& stream) } void BufferQueueProducer::allocateBuffers(bool async, uint32_t width, - uint32_t height, PixelFormat format, uint32_t usage) { + uint32_t height, uint32_t format, uint32_t usage) { ATRACE_CALL(); while (true) { Vector<int> freeSlots; size_t newBufferCount = 0; uint32_t allocWidth = 0; uint32_t allocHeight = 0; - PixelFormat allocFormat = PIXEL_FORMAT_UNKNOWN; + uint32_t allocFormat = 0; uint32_t allocUsage = 0; { // Autolock scope Mutex::Autolock lock(mCore->mMutex); @@ -907,8 +937,7 @@ void BufferQueueProducer::allocateBuffers(bool async, uint32_t width, currentBufferCount, maxBufferCount); if (maxBufferCount <= currentBufferCount) return; - newBufferCount = - static_cast<size_t>(maxBufferCount - currentBufferCount); + newBufferCount = maxBufferCount - currentBufferCount; if (freeSlots.size() < newBufferCount) { BQ_LOGE("allocateBuffers: ran out of free slots"); return; @@ -921,7 +950,7 @@ void BufferQueueProducer::allocateBuffers(bool async, uint32_t width, mCore->mIsAllocating = true; } // Autolock scope - Vector<sp<GraphicBuffer>> buffers; + Vector<sp<GraphicBuffer> > buffers; for (size_t i = 0; i < newBufferCount; ++i) { status_t result = NO_ERROR; sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer( @@ -941,8 +970,7 @@ void BufferQueueProducer::allocateBuffers(bool async, uint32_t width, Mutex::Autolock lock(mCore->mMutex); uint32_t checkWidth = width > 0 ? width : mCore->mDefaultWidth; uint32_t checkHeight = height > 0 ? height : mCore->mDefaultHeight; - PixelFormat checkFormat = format != 0 ? - format : mCore->mDefaultBufferFormat; + uint32_t checkFormat = format != 0 ? format : mCore->mDefaultBufferFormat; uint32_t checkUsage = usage | mCore->mConsumerUsageBits; if (checkWidth != allocWidth || checkHeight != allocHeight || checkFormat != allocFormat || checkUsage != allocUsage) { diff --git a/libs/gui/BufferSlot.cpp b/libs/gui/BufferSlot.cpp index 01595de..b8877fe 100644 --- a/libs/gui/BufferSlot.cpp +++ b/libs/gui/BufferSlot.cpp @@ -24,8 +24,8 @@ const char* BufferSlot::bufferStateName(BufferState state) { case BufferSlot::QUEUED: return "QUEUED"; case BufferSlot::FREE: return "FREE"; case BufferSlot::ACQUIRED: return "ACQUIRED"; + default: return "Unknown"; } - return "Unknown"; } } // namespace android diff --git a/libs/gui/ConsumerBase.cpp b/libs/gui/ConsumerBase.cpp index 580e0e7..95f5507 100644 --- a/libs/gui/ConsumerBase.cpp +++ b/libs/gui/ConsumerBase.cpp @@ -40,9 +40,9 @@ // Macros for including the ConsumerBase name in log messages #define CB_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define CB_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define CB_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define CB_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) +#define CB_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) +#define CB_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) +#define CB_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) #define CB_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__) namespace android { @@ -98,7 +98,7 @@ void ConsumerBase::freeBufferLocked(int slotIndex) { mSlots[slotIndex].mFrameNumber = 0; } -void ConsumerBase::onFrameAvailable() { +void ConsumerBase::onFrameAvailable(const BufferItem& item) { CB_LOGV("onFrameAvailable"); sp<FrameAvailableListener> listener; @@ -109,7 +109,7 @@ void ConsumerBase::onFrameAvailable() { if (listener != NULL) { CB_LOGV("actually calling onFrameAvailable"); - listener->onFrameAvailable(); + listener->onFrameAvailable(item); } } diff --git a/libs/gui/CpuConsumer.cpp b/libs/gui/CpuConsumer.cpp index d74d06c..c5b6dfe 100644 --- a/libs/gui/CpuConsumer.cpp +++ b/libs/gui/CpuConsumer.cpp @@ -16,22 +16,22 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "CpuConsumer" -//#define ATRACE_TAG ATRACE_TAG_GRAPHICS +#define ATRACE_TAG ATRACE_TAG_GRAPHICS #include <cutils/compiler.h> #include <utils/Log.h> #include <gui/CpuConsumer.h> -//#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) -//#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) +#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) +#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) +#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) #define CC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) #define CC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__) namespace android { CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq, - size_t maxLockedBuffers, bool controlledByApp) : + uint32_t maxLockedBuffers, bool controlledByApp) : ConsumerBase(bq, controlledByApp), mMaxLockedBuffers(maxLockedBuffers), mCurrentLockedBuffers(0) @@ -40,7 +40,7 @@ CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq, mAcquiredBuffers.insertAt(0, maxLockedBuffers); mConsumer->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN); - mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers)); + mConsumer->setMaxAcquiredBufferCount(maxLockedBuffers); } CpuConsumer::~CpuConsumer() { @@ -61,18 +61,46 @@ status_t CpuConsumer::setDefaultBufferSize(uint32_t width, uint32_t height) return mConsumer->setDefaultBufferSize(width, height); } -status_t CpuConsumer::setDefaultBufferFormat(PixelFormat defaultFormat) +status_t CpuConsumer::setDefaultBufferFormat(uint32_t defaultFormat) { Mutex::Autolock _l(mMutex); return mConsumer->setDefaultBufferFormat(defaultFormat); } +static bool isPossiblyYUV(PixelFormat format) { + switch ((int)format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + case HAL_PIXEL_FORMAT_RGBX_8888: + case HAL_PIXEL_FORMAT_RGB_888: + case HAL_PIXEL_FORMAT_RGB_565: + case HAL_PIXEL_FORMAT_BGRA_8888: + case HAL_PIXEL_FORMAT_sRGB_A_8888: + case HAL_PIXEL_FORMAT_sRGB_X_8888: + case HAL_PIXEL_FORMAT_Y8: + case HAL_PIXEL_FORMAT_Y16: + case HAL_PIXEL_FORMAT_RAW16: // same as HAL_PIXEL_FORMAT_RAW_SENSOR + case HAL_PIXEL_FORMAT_RAW10: + case HAL_PIXEL_FORMAT_RAW_OPAQUE: + case HAL_PIXEL_FORMAT_BLOB: + case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: + return false; + + case HAL_PIXEL_FORMAT_YV12: + case HAL_PIXEL_FORMAT_YCbCr_420_888: + case HAL_PIXEL_FORMAT_YCbCr_422_SP: + case HAL_PIXEL_FORMAT_YCrCb_420_SP: + case HAL_PIXEL_FORMAT_YCbCr_422_I: + default: + return true; + } +} + status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) { status_t err; if (!nativeBuffer) return BAD_VALUE; if (mCurrentLockedBuffers == mMaxLockedBuffers) { - CC_LOGW("Max buffers have been locked (%zd), cannot lock anymore.", + CC_LOGW("Max buffers have been locked (%d), cannot lock anymore.", mMaxLockedBuffers); return NOT_ENOUGH_DATA; } @@ -96,64 +124,56 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) { void *bufferPointer = NULL; android_ycbcr ycbcr = android_ycbcr(); - if (b.mFence.get()) { - if (mSlots[buf].mGraphicBuffer->getPixelFormat() == - HAL_PIXEL_FORMAT_YCbCr_420_888) { + PixelFormat format = mSlots[buf].mGraphicBuffer->getPixelFormat(); + PixelFormat flexFormat = format; + if (isPossiblyYUV(format)) { + if (b.mFence.get()) { err = mSlots[buf].mGraphicBuffer->lockAsyncYCbCr( GraphicBuffer::USAGE_SW_READ_OFTEN, b.mCrop, &ycbcr, b.mFence->dup()); - - if (err != OK) { - CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)", - strerror(-err), err); - return err; - } - bufferPointer = ycbcr.y; } else { - err = mSlots[buf].mGraphicBuffer->lockAsync( + err = mSlots[buf].mGraphicBuffer->lockYCbCr( GraphicBuffer::USAGE_SW_READ_OFTEN, b.mCrop, - &bufferPointer, - b.mFence->dup()); - - if (err != OK) { - CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)", - strerror(-err), err); - return err; + &ycbcr); + } + if (err == OK) { + bufferPointer = ycbcr.y; + flexFormat = HAL_PIXEL_FORMAT_YCbCr_420_888; + if (format != HAL_PIXEL_FORMAT_YCbCr_420_888) { + CC_LOGV("locking buffer of format %#x as flex YUV", format); } + } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) { + CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)", + strerror(-err), err); + return err; } - } else { - if (mSlots[buf].mGraphicBuffer->getPixelFormat() == - HAL_PIXEL_FORMAT_YCbCr_420_888) { - err = mSlots[buf].mGraphicBuffer->lockYCbCr( + } + + if (bufferPointer == NULL) { // not flexible YUV + if (b.mFence.get()) { + err = mSlots[buf].mGraphicBuffer->lockAsync( GraphicBuffer::USAGE_SW_READ_OFTEN, b.mCrop, - &ycbcr); - - if (err != OK) { - CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)", - strerror(-err), err); - return err; - } - bufferPointer = ycbcr.y; + &bufferPointer, + b.mFence->dup()); } else { err = mSlots[buf].mGraphicBuffer->lock( GraphicBuffer::USAGE_SW_READ_OFTEN, b.mCrop, &bufferPointer); - - if (err != OK) { - CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)", - strerror(-err), err); - return err; - } + } + if (err != OK) { + CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)", + strerror(-err), err); + return err; } } size_t lockedIdx = 0; - for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) { + for (; lockedIdx < mMaxLockedBuffers; lockedIdx++) { if (mAcquiredBuffers[lockedIdx].mSlot == BufferQueue::INVALID_BUFFER_SLOT) { break; @@ -170,9 +190,10 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) { reinterpret_cast<uint8_t*>(bufferPointer); nativeBuffer->width = mSlots[buf].mGraphicBuffer->getWidth(); nativeBuffer->height = mSlots[buf].mGraphicBuffer->getHeight(); - nativeBuffer->format = mSlots[buf].mGraphicBuffer->getPixelFormat(); + nativeBuffer->format = format; + nativeBuffer->flexFormat = flexFormat; nativeBuffer->stride = (ycbcr.y != NULL) ? - static_cast<uint32_t>(ycbcr.ystride) : + ycbcr.ystride : mSlots[buf].mGraphicBuffer->getStride(); nativeBuffer->crop = b.mCrop; @@ -183,8 +204,8 @@ status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) { nativeBuffer->dataCb = reinterpret_cast<uint8_t*>(ycbcr.cb); nativeBuffer->dataCr = reinterpret_cast<uint8_t*>(ycbcr.cr); - nativeBuffer->chromaStride = static_cast<uint32_t>(ycbcr.cstride); - nativeBuffer->chromaStep = static_cast<uint32_t>(ycbcr.chroma_step); + nativeBuffer->chromaStride = ycbcr.cstride; + nativeBuffer->chromaStep = ycbcr.chroma_step; mCurrentLockedBuffers++; @@ -196,7 +217,7 @@ status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) { size_t lockedIdx = 0; void *bufPtr = reinterpret_cast<void *>(nativeBuffer.data); - for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) { + for (; lockedIdx < mMaxLockedBuffers; lockedIdx++) { if (bufPtr == mAcquiredBuffers[lockedIdx].mBufferPointer) break; } if (lockedIdx == mMaxLockedBuffers) { @@ -207,13 +228,13 @@ status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) { return releaseAcquiredBufferLocked(lockedIdx); } -status_t CpuConsumer::releaseAcquiredBufferLocked(size_t lockedIdx) { +status_t CpuConsumer::releaseAcquiredBufferLocked(int lockedIdx) { status_t err; int fd = -1; err = mAcquiredBuffers[lockedIdx].mGraphicBuffer->unlockAsync(&fd); if (err != OK) { - CC_LOGE("%s: Unable to unlock graphic buffer %zd", __FUNCTION__, + CC_LOGE("%s: Unable to unlock graphic buffer %d", __FUNCTION__, lockedIdx); return err; } 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; } diff --git a/libs/gui/GraphicBufferAlloc.cpp b/libs/gui/GraphicBufferAlloc.cpp index 9643402..b360e81 100644 --- a/libs/gui/GraphicBufferAlloc.cpp +++ b/libs/gui/GraphicBufferAlloc.cpp @@ -31,10 +31,9 @@ GraphicBufferAlloc::GraphicBufferAlloc() { GraphicBufferAlloc::~GraphicBufferAlloc() { } -sp<GraphicBuffer> GraphicBufferAlloc::createGraphicBuffer(uint32_t width, - uint32_t height, PixelFormat format, uint32_t usage, status_t* error) { - sp<GraphicBuffer> graphicBuffer( - new GraphicBuffer(width, height, format, usage)); +sp<GraphicBuffer> GraphicBufferAlloc::createGraphicBuffer(uint32_t w, uint32_t h, + PixelFormat format, uint32_t usage, status_t* error) { + sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(w, h, format, usage)); status_t err = graphicBuffer->initCheck(); *error = err; if (err != 0 || graphicBuffer->handle == 0) { @@ -43,7 +42,7 @@ sp<GraphicBuffer> GraphicBufferAlloc::createGraphicBuffer(uint32_t width, } ALOGE("GraphicBufferAlloc::createGraphicBuffer(w=%d, h=%d) " "failed (%s), handle=%p", - width, height, strerror(-err), graphicBuffer->handle); + w, h, strerror(-err), graphicBuffer->handle); return 0; } return graphicBuffer; diff --git a/libs/gui/IConsumerListener.cpp b/libs/gui/IConsumerListener.cpp index 32d7920..409dfe4 100644 --- a/libs/gui/IConsumerListener.cpp +++ b/libs/gui/IConsumerListener.cpp @@ -21,6 +21,7 @@ #include <binder/Parcel.h> #include <gui/IConsumerListener.h> +#include <gui/BufferItem.h> // --------------------------------------------------------------------------- namespace android { @@ -39,11 +40,10 @@ public: : BpInterface<IConsumerListener>(impl) { } - virtual ~BpConsumerListener(); - - virtual void onFrameAvailable() { + virtual void onFrameAvailable(const BufferItem& item) { Parcel data, reply; data.writeInterfaceToken(IConsumerListener::getInterfaceDescriptor()); + data.write(item); remote()->transact(ON_FRAME_AVAILABLE, data, &reply, IBinder::FLAG_ONEWAY); } @@ -60,10 +60,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpConsumerListener::~BpConsumerListener() {} - IMPLEMENT_META_INTERFACE(ConsumerListener, "android.gui.IConsumerListener"); // ---------------------------------------------------------------------- @@ -72,18 +68,20 @@ status_t BnConsumerListener::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { - case ON_FRAME_AVAILABLE: + case ON_FRAME_AVAILABLE: { CHECK_INTERFACE(IConsumerListener, data, reply); - onFrameAvailable(); - return NO_ERROR; - case ON_BUFFER_RELEASED: + BufferItem item; + data.read(item); + onFrameAvailable(item); + return NO_ERROR; } + case ON_BUFFER_RELEASED: { CHECK_INTERFACE(IConsumerListener, data, reply); onBuffersReleased(); - return NO_ERROR; - case ON_SIDEBAND_STREAM_CHANGED: + return NO_ERROR; } + case ON_SIDEBAND_STREAM_CHANGED: { CHECK_INTERFACE(IConsumerListener, data, reply); onSidebandStreamChanged(); - return NO_ERROR; + return NO_ERROR; } } return BBinder::onTransact(code, data, reply, flags); } diff --git a/libs/gui/IDisplayEventConnection.cpp b/libs/gui/IDisplayEventConnection.cpp index 9890f44..887d176 100644 --- a/libs/gui/IDisplayEventConnection.cpp +++ b/libs/gui/IDisplayEventConnection.cpp @@ -44,8 +44,6 @@ public: { } - virtual ~BpDisplayEventConnection(); - virtual sp<BitTube> getDataChannel() const { Parcel data, reply; @@ -57,7 +55,7 @@ public: virtual void setVsyncRate(uint32_t count) { Parcel data, reply; data.writeInterfaceToken(IDisplayEventConnection::getInterfaceDescriptor()); - data.writeUint32(count); + data.writeInt32(count); remote()->transact(SET_VSYNC_RATE, data, &reply); } @@ -68,10 +66,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpDisplayEventConnection::~BpDisplayEventConnection() {} - IMPLEMENT_META_INTERFACE(DisplayEventConnection, "android.gui.DisplayEventConnection"); // ---------------------------------------------------------------------------- @@ -85,17 +79,17 @@ status_t BnDisplayEventConnection::onTransact( sp<BitTube> channel(getDataChannel()); channel->writeToParcel(reply); return NO_ERROR; - } + } break; case SET_VSYNC_RATE: { CHECK_INTERFACE(IDisplayEventConnection, data, reply); - setVsyncRate(data.readUint32()); + setVsyncRate(data.readInt32()); return NO_ERROR; - } + } break; case REQUEST_NEXT_VSYNC: { CHECK_INTERFACE(IDisplayEventConnection, data, reply); requestNextVsync(); return NO_ERROR; - } + } break; } return BBinder::onTransact(code, data, reply, flags); } diff --git a/libs/gui/IGraphicBufferAlloc.cpp b/libs/gui/IGraphicBufferAlloc.cpp index 09b63a1..139f219 100644 --- a/libs/gui/IGraphicBufferAlloc.cpp +++ b/libs/gui/IGraphicBufferAlloc.cpp @@ -42,17 +42,14 @@ public: { } - virtual ~BpGraphicBufferAlloc(); - - virtual sp<GraphicBuffer> createGraphicBuffer(uint32_t width, - uint32_t height, PixelFormat format, uint32_t usage, - status_t* error) { + virtual sp<GraphicBuffer> createGraphicBuffer(uint32_t w, uint32_t h, + PixelFormat format, uint32_t usage, status_t* error) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferAlloc::getInterfaceDescriptor()); - data.writeUint32(width); - data.writeUint32(height); - data.writeInt32(static_cast<int32_t>(format)); - data.writeUint32(usage); + data.writeInt32(w); + data.writeInt32(h); + data.writeInt32(format); + data.writeInt32(usage); remote()->transact(CREATE_GRAPHIC_BUFFER, data, &reply); sp<GraphicBuffer> graphicBuffer; status_t result = reply.readInt32(); @@ -68,10 +65,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpGraphicBufferAlloc::~BpGraphicBufferAlloc() {} - IMPLEMENT_META_INTERFACE(GraphicBufferAlloc, "android.ui.IGraphicBufferAlloc"); // ---------------------------------------------------------------------- @@ -81,26 +74,27 @@ status_t BnGraphicBufferAlloc::onTransact( { // codes that don't require permission check - // BufferReference just keeps a strong reference to a GraphicBuffer until it - // is destroyed (that is, until no local or remote process have a reference - // to it). + /* BufferReference just keeps a strong reference to a + * GraphicBuffer until it is destroyed (that is, until + * no local or remote process have a reference to it). + */ class BufferReference : public BBinder { - sp<GraphicBuffer> mBuffer; + sp<GraphicBuffer> buffer; public: - BufferReference(const sp<GraphicBuffer>& buffer) : mBuffer(buffer) {} + BufferReference(const sp<GraphicBuffer>& buffer) : buffer(buffer) { } }; - switch (code) { + switch(code) { case CREATE_GRAPHIC_BUFFER: { CHECK_INTERFACE(IGraphicBufferAlloc, data, reply); - uint32_t width = data.readUint32(); - uint32_t height = data.readUint32(); - PixelFormat format = static_cast<PixelFormat>(data.readInt32()); - uint32_t usage = data.readUint32(); + uint32_t w = data.readInt32(); + uint32_t h = data.readInt32(); + PixelFormat format = data.readInt32(); + uint32_t usage = data.readInt32(); status_t error; sp<GraphicBuffer> result = - createGraphicBuffer(width, height, format, usage, &error); + createGraphicBuffer(w, h, format, usage, &error); reply->writeInt32(error); if (result != 0) { reply->write(*result); @@ -113,7 +107,7 @@ status_t BnGraphicBufferAlloc::onTransact( reply->writeStrongBinder( new BufferReference(result) ); } return NO_ERROR; - } + } break; default: return BBinder::onTransact(code, data, reply, flags); } diff --git a/libs/gui/IGraphicBufferConsumer.cpp b/libs/gui/IGraphicBufferConsumer.cpp index 2602884..cc581a3 100644 --- a/libs/gui/IGraphicBufferConsumer.cpp +++ b/libs/gui/IGraphicBufferConsumer.cpp @@ -215,8 +215,6 @@ public: { } - virtual ~BpGraphicBufferConsumer(); - virtual status_t acquireBuffer(BufferItem *buffer, nsecs_t presentWhen) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); @@ -263,7 +261,7 @@ public: Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); data.writeInt32(buf); - data.writeInt64(static_cast<int64_t>(frameNumber)); + data.writeInt64(frameNumber); data.write(*releaseFence); status_t result = remote()->transact(RELEASE_BUFFER, data, &reply); if (result != NO_ERROR) { @@ -305,15 +303,15 @@ public: if (result != NO_ERROR) { return result; } - *slotMask = static_cast<uint64_t>(reply.readInt64()); + *slotMask = reply.readInt64(); return reply.readInt32(); } - virtual status_t setDefaultBufferSize(uint32_t width, uint32_t height) { + virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); - data.writeUint32(width); - data.writeUint32(height); + data.writeInt32(w); + data.writeInt32(h); status_t result = remote()->transact(SET_DEFAULT_BUFFER_SIZE, data, &reply); if (result != NO_ERROR) { return result; @@ -360,10 +358,10 @@ public: remote()->transact(SET_CONSUMER_NAME, data, &reply); } - virtual status_t setDefaultBufferFormat(PixelFormat defaultFormat) { + virtual status_t setDefaultBufferFormat(uint32_t defaultFormat) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); - data.writeInt32(static_cast<int32_t>(defaultFormat)); + data.writeInt32(defaultFormat); status_t result = remote()->transact(SET_DEFAULT_BUFFER_FORMAT, data, &reply); if (result != NO_ERROR) { return result; @@ -374,7 +372,7 @@ public: virtual status_t setConsumerUsageBits(uint32_t usage) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); - data.writeUint32(usage); + data.writeInt32(usage); status_t result = remote()->transact(SET_CONSUMER_USAGE_BITS, data, &reply); if (result != NO_ERROR) { return result; @@ -385,7 +383,7 @@ public: virtual status_t setTransformHint(uint32_t hint) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); - data.writeUint32(hint); + data.writeInt32(hint); status_t result = remote()->transact(SET_TRANSFORM_HINT, data, &reply); if (result != NO_ERROR) { return result; @@ -417,10 +415,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpGraphicBufferConsumer::~BpGraphicBufferConsumer() {} - IMPLEMENT_META_INTERFACE(GraphicBufferConsumer, "android.gui.IGraphicBufferConsumer"); // ---------------------------------------------------------------------- @@ -438,14 +432,14 @@ status_t BnGraphicBufferConsumer::onTransact( if (err) return err; reply->writeInt32(result); return NO_ERROR; - } + } break; case DETACH_BUFFER: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); int slot = data.readInt32(); int result = detachBuffer(slot); reply->writeInt32(result); return NO_ERROR; - } + } break; case ATTACH_BUFFER: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); sp<GraphicBuffer> buffer = new GraphicBuffer(); @@ -455,11 +449,11 @@ status_t BnGraphicBufferConsumer::onTransact( reply->writeInt32(slot); reply->writeInt32(result); return NO_ERROR; - } + } break; case RELEASE_BUFFER: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); int buf = data.readInt32(); - uint64_t frameNumber = static_cast<uint64_t>(data.readInt64()); + uint64_t frameNumber = data.readInt64(); sp<Fence> releaseFence = new Fence(); status_t err = data.read(*releaseFence); if (err) return err; @@ -467,7 +461,7 @@ status_t BnGraphicBufferConsumer::onTransact( EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, releaseFence); reply->writeInt32(result); return NO_ERROR; - } + } break; case CONSUMER_CONNECT: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); sp<IConsumerListener> consumer = IConsumerListener::asInterface( data.readStrongBinder() ); @@ -475,75 +469,75 @@ status_t BnGraphicBufferConsumer::onTransact( status_t result = consumerConnect(consumer, controlledByApp); reply->writeInt32(result); return NO_ERROR; - } + } break; case CONSUMER_DISCONNECT: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); status_t result = consumerDisconnect(); reply->writeInt32(result); return NO_ERROR; - } + } break; case GET_RELEASED_BUFFERS: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); uint64_t slotMask; status_t result = getReleasedBuffers(&slotMask); - reply->writeInt64(static_cast<int64_t>(slotMask)); + reply->writeInt64(slotMask); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_DEFAULT_BUFFER_SIZE: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); - uint32_t width = data.readUint32(); - uint32_t height = data.readUint32(); - status_t result = setDefaultBufferSize(width, height); + uint32_t w = data.readInt32(); + uint32_t h = data.readInt32(); + status_t result = setDefaultBufferSize(w, h); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_DEFAULT_MAX_BUFFER_COUNT: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); - int bufferCount = data.readInt32(); + uint32_t bufferCount = data.readInt32(); status_t result = setDefaultMaxBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; - } + } break; case DISABLE_ASYNC_BUFFER: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); status_t result = disableAsyncBuffer(); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_MAX_ACQUIRED_BUFFER_COUNT: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); - int maxAcquiredBuffers = data.readInt32(); + uint32_t maxAcquiredBuffers = data.readInt32(); status_t result = setMaxAcquiredBufferCount(maxAcquiredBuffers); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_CONSUMER_NAME: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); setConsumerName( data.readString8() ); return NO_ERROR; - } + } break; case SET_DEFAULT_BUFFER_FORMAT: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); - PixelFormat defaultFormat = static_cast<PixelFormat>(data.readInt32()); + uint32_t defaultFormat = data.readInt32(); status_t result = setDefaultBufferFormat(defaultFormat); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_CONSUMER_USAGE_BITS: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); - uint32_t usage = data.readUint32(); + uint32_t usage = data.readInt32(); status_t result = setConsumerUsageBits(usage); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_TRANSFORM_HINT: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); - uint32_t hint = data.readUint32(); + uint32_t hint = data.readInt32(); status_t result = setTransformHint(hint); reply->writeInt32(result); return NO_ERROR; - } + } break; case DUMP: { CHECK_INTERFACE(IGraphicBufferConsumer, data, reply); String8 result = data.readString8(); diff --git a/libs/gui/IGraphicBufferProducer.cpp b/libs/gui/IGraphicBufferProducer.cpp index 63d881e..bcdf368 100644 --- a/libs/gui/IGraphicBufferProducer.cpp +++ b/libs/gui/IGraphicBufferProducer.cpp @@ -56,8 +56,6 @@ public: { } - virtual ~BpGraphicBufferProducer(); - virtual status_t requestBuffer(int bufferIdx, sp<GraphicBuffer>* buf) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor()); @@ -93,15 +91,14 @@ public: } virtual status_t dequeueBuffer(int *buf, sp<Fence>* fence, bool async, - uint32_t width, uint32_t height, PixelFormat format, - uint32_t usage) { + uint32_t w, uint32_t h, uint32_t format, uint32_t usage) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor()); - data.writeInt32(static_cast<int32_t>(async)); - data.writeUint32(width); - data.writeUint32(height); - data.writeInt32(static_cast<int32_t>(format)); - data.writeUint32(usage); + data.writeInt32(async); + data.writeInt32(w); + data.writeInt32(h); + data.writeInt32(format); + data.writeInt32(usage); status_t result = remote()->transact(DEQUEUE_BUFFER, data, &reply); if (result != NO_ERROR) { return result; @@ -258,14 +255,14 @@ public: } virtual void allocateBuffers(bool async, uint32_t width, uint32_t height, - PixelFormat format, uint32_t usage) { + uint32_t format, uint32_t usage) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor()); data.writeInt32(static_cast<int32_t>(async)); - data.writeUint32(width); - data.writeUint32(height); + data.writeInt32(static_cast<int32_t>(width)); + data.writeInt32(static_cast<int32_t>(height)); data.writeInt32(static_cast<int32_t>(format)); - data.writeUint32(usage); + data.writeInt32(static_cast<int32_t>(usage)); status_t result = remote()->transact(ALLOCATE_BUFFERS, data, &reply); if (result != NO_ERROR) { ALOGE("allocateBuffers failed to transact: %d", result); @@ -273,10 +270,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpGraphicBufferProducer::~BpGraphicBufferProducer() {} - IMPLEMENT_META_INTERFACE(GraphicBufferProducer, "android.gui.IGraphicBufferProducer"); // ---------------------------------------------------------------------- @@ -296,25 +289,24 @@ status_t BnGraphicBufferProducer::onTransact( } reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; - } + } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); - bool async = static_cast<bool>(data.readInt32()); - uint32_t width = data.readUint32(); - uint32_t height = data.readUint32(); - PixelFormat format = static_cast<PixelFormat>(data.readInt32()); - uint32_t usage = data.readUint32(); + bool async = data.readInt32(); + uint32_t w = data.readInt32(); + uint32_t h = data.readInt32(); + uint32_t format = data.readInt32(); + uint32_t usage = data.readInt32(); int buf; sp<Fence> fence; - int result = dequeueBuffer(&buf, &fence, async, width, height, - format, usage); + int result = dequeueBuffer(&buf, &fence, async, w, h, format, usage); reply->writeInt32(buf); reply->writeInt32(fence != NULL); if (fence != NULL) { @@ -322,14 +314,14 @@ status_t BnGraphicBufferProducer::onTransact( } reply->writeInt32(result); return NO_ERROR; - } + } break; case DETACH_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int slot = data.readInt32(); int result = detachBuffer(slot); reply->writeInt32(result); return NO_ERROR; - } + } break; case DETACH_NEXT_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); sp<GraphicBuffer> buffer; @@ -347,7 +339,7 @@ status_t BnGraphicBufferProducer::onTransact( } } return NO_ERROR; - } + } break; case ATTACH_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); sp<GraphicBuffer> buffer = new GraphicBuffer(); @@ -357,7 +349,7 @@ status_t BnGraphicBufferProducer::onTransact( reply->writeInt32(slot); reply->writeInt32(result); return NO_ERROR; - } + } break; case QUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); @@ -368,7 +360,7 @@ status_t BnGraphicBufferProducer::onTransact( status_t result = queueBuffer(buf, input, output); reply->writeInt32(result); return NO_ERROR; - } + } break; case CANCEL_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); @@ -376,7 +368,7 @@ status_t BnGraphicBufferProducer::onTransact( data.read(*fence.get()); cancelBuffer(buf, fence); return NO_ERROR; - } + } break; case QUERY: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int value; @@ -385,7 +377,7 @@ status_t BnGraphicBufferProducer::onTransact( reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; - } + } break; case CONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); sp<IProducerListener> listener; @@ -400,14 +392,14 @@ status_t BnGraphicBufferProducer::onTransact( status_t res = connect(listener, api, producerControlledByApp, output); reply->writeInt32(res); return NO_ERROR; - } + } break; case DISCONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; - } + } break; case SET_SIDEBAND_STREAM: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); sp<NativeHandle> stream; @@ -417,14 +409,14 @@ status_t BnGraphicBufferProducer::onTransact( status_t result = setSidebandStream(stream); reply->writeInt32(result); return NO_ERROR; - } + } break; case ALLOCATE_BUFFERS: CHECK_INTERFACE(IGraphicBufferProducer, data, reply); bool async = static_cast<bool>(data.readInt32()); - uint32_t width = data.readUint32(); - uint32_t height = data.readUint32(); - PixelFormat format = static_cast<PixelFormat>(data.readInt32()); - uint32_t usage = data.readUint32(); + uint32_t width = static_cast<uint32_t>(data.readInt32()); + uint32_t height = static_cast<uint32_t>(data.readInt32()); + uint32_t format = static_cast<uint32_t>(data.readInt32()); + uint32_t usage = static_cast<uint32_t>(data.readInt32()); allocateBuffers(async, width, height, format, usage); return NO_ERROR; } diff --git a/libs/gui/IProducerListener.cpp b/libs/gui/IProducerListener.cpp index 81adc95..efe4069 100644 --- a/libs/gui/IProducerListener.cpp +++ b/libs/gui/IProducerListener.cpp @@ -30,8 +30,6 @@ public: BpProducerListener(const sp<IBinder>& impl) : BpInterface<IProducerListener>(impl) {} - virtual ~BpProducerListener(); - virtual void onBufferReleased() { Parcel data, reply; data.writeInterfaceToken(IProducerListener::getInterfaceDescriptor()); @@ -39,10 +37,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpProducerListener::~BpProducerListener() {} - IMPLEMENT_META_INTERFACE(ProducerListener, "android.gui.IProducerListener") status_t BnProducerListener::onTransact(uint32_t code, const Parcel& data, diff --git a/libs/gui/ISensorEventConnection.cpp b/libs/gui/ISensorEventConnection.cpp index dc7a35c..28fcb53 100644 --- a/libs/gui/ISensorEventConnection.cpp +++ b/libs/gui/ISensorEventConnection.cpp @@ -45,8 +45,6 @@ public: { } - virtual ~BpSensorEventConnection(); - virtual sp<BitTube> getSensorChannel() const { Parcel data, reply; @@ -87,10 +85,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpSensorEventConnection::~BpSensorEventConnection() {} - IMPLEMENT_META_INTERFACE(SensorEventConnection, "android.gui.SensorEventConnection"); // ---------------------------------------------------------------------------- @@ -104,7 +98,7 @@ status_t BnSensorEventConnection::onTransact( sp<BitTube> channel(getSensorChannel()); channel->writeToParcel(reply); return NO_ERROR; - } + } break; case ENABLE_DISABLE: { CHECK_INTERFACE(ISensorEventConnection, data, reply); int handle = data.readInt32(); @@ -116,21 +110,21 @@ status_t BnSensorEventConnection::onTransact( maxBatchReportLatencyNs, reservedFlags); reply->writeInt32(result); return NO_ERROR; - } + } break; case SET_EVENT_RATE: { CHECK_INTERFACE(ISensorEventConnection, data, reply); int handle = data.readInt32(); - nsecs_t ns = data.readInt64(); + int ns = data.readInt64(); status_t result = setEventRate(handle, ns); reply->writeInt32(result); return NO_ERROR; - } + } break; case FLUSH_SENSOR: { CHECK_INTERFACE(ISensorEventConnection, data, reply); status_t result = flush(); reply->writeInt32(result); return NO_ERROR; - } + } break; } return BBinder::onTransact(code, data, reply, flags); } diff --git a/libs/gui/ISensorServer.cpp b/libs/gui/ISensorServer.cpp index 8e09e7c..a8464a2 100644 --- a/libs/gui/ISensorServer.cpp +++ b/libs/gui/ISensorServer.cpp @@ -45,8 +45,6 @@ public: { } - virtual ~BpSensorServer(); - virtual Vector<Sensor> getSensorList() { Parcel data, reply; @@ -54,7 +52,7 @@ public: remote()->transact(GET_SENSOR_LIST, data, &reply); Sensor s; Vector<Sensor> v; - uint32_t n = reply.readUint32(); + int32_t n = reply.readInt32(); v.setCapacity(n); while (n--) { reply.read(s); @@ -72,10 +70,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpSensorServer::~BpSensorServer() {} - IMPLEMENT_META_INTERFACE(SensorServer, "android.gui.SensorServer"); // ---------------------------------------------------------------------- @@ -88,18 +82,18 @@ status_t BnSensorServer::onTransact( CHECK_INTERFACE(ISensorServer, data, reply); Vector<Sensor> v(getSensorList()); size_t n = v.size(); - reply->writeUint32(static_cast<uint32_t>(n)); - for (size_t i = 0; i < n; i++) { + reply->writeInt32(n); + for (size_t i=0 ; i<n ; i++) { reply->write(v[i]); } return NO_ERROR; - } + } break; case CREATE_SENSOR_EVENT_CONNECTION: { CHECK_INTERFACE(ISensorServer, data, reply); sp<ISensorEventConnection> connection(createSensorEventConnection()); reply->writeStrongBinder(IInterface::asBinder(connection)); return NO_ERROR; - } + } break; } return BBinder::onTransact(code, data, reply, flags); } diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp index 78886d5..00173c7 100644 --- a/libs/gui/ISurfaceComposer.cpp +++ b/libs/gui/ISurfaceComposer.cpp @@ -51,8 +51,6 @@ public: { } - virtual ~BpSurfaceComposer(); - virtual sp<ISurfaceComposerClient> createConnection() { Parcel data, reply; @@ -76,18 +74,23 @@ public: { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - - data.writeUint32(static_cast<uint32_t>(state.size())); - for (const auto& s : state) { - s.write(data); + { + Vector<ComposerState>::const_iterator b(state.begin()); + Vector<ComposerState>::const_iterator e(state.end()); + data.writeInt32(state.size()); + for ( ; b != e ; ++b ) { + b->write(data); + } } - - data.writeUint32(static_cast<uint32_t>(displays.size())); - for (const auto& d : displays) { - d.write(data); + { + Vector<DisplayState>::const_iterator b(displays.begin()); + Vector<DisplayState>::const_iterator e(displays.end()); + data.writeInt32(displays.size()); + for ( ; b != e ; ++b ) { + b->write(data); + } } - - data.writeUint32(flags); + data.writeInt32(flags); remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply); } @@ -110,10 +113,10 @@ public: data.writeStrongBinder(display); data.writeStrongBinder(IInterface::asBinder(producer)); data.write(sourceCrop); - data.writeUint32(reqWidth); - data.writeUint32(reqHeight); - data.writeUint32(minLayerZ); - data.writeUint32(maxLayerZ); + data.writeInt32(reqWidth); + data.writeInt32(reqHeight); + data.writeInt32(minLayerZ); + data.writeInt32(maxLayerZ); data.writeInt32(static_cast<int32_t>(useIdentityTransform)); data.writeInt32(static_cast<int32_t>(rotation)); remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply); @@ -221,7 +224,7 @@ public: remote()->transact(BnSurfaceComposer::GET_DISPLAY_CONFIGS, data, &reply); status_t result = reply.readInt32(); if (result == NO_ERROR) { - size_t numConfigs = reply.readUint32(); + size_t numConfigs = static_cast<size_t>(reply.readInt32()); configs->clear(); configs->resize(numConfigs); for (size_t c = 0; c < numConfigs; ++c) { @@ -284,10 +287,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpSurfaceComposer::~BpSurfaceComposer() {} - IMPLEMENT_META_INTERFACE(SurfaceComposer, "android.ui.ISurfaceComposer"); // ---------------------------------------------------------------------- @@ -310,37 +309,34 @@ status_t BnSurfaceComposer::onTransact( } case SET_TRANSACTION_STATE: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - - size_t count = data.readUint32(); + size_t count = data.readInt32(); if (count > data.dataSize()) { return BAD_VALUE; } ComposerState s; Vector<ComposerState> state; state.setCapacity(count); - for (size_t i = 0; i < count; i++) { + for (size_t i=0 ; i<count ; i++) { if (s.read(data) == BAD_VALUE) { return BAD_VALUE; } state.add(s); } - - count = data.readUint32(); + count = data.readInt32(); if (count > data.dataSize()) { return BAD_VALUE; } DisplayState d; Vector<DisplayState> displays; displays.setCapacity(count); - for (size_t i = 0; i < count; i++) { + for (size_t i=0 ; i<count ; i++) { if (d.read(data) == BAD_VALUE) { return BAD_VALUE; } displays.add(d); } - - uint32_t stateFlags = data.readUint32(); - setTransactionState(state, displays, stateFlags); + uint32_t flags = data.readInt32(); + setTransactionState(state, displays, flags); return NO_ERROR; } case BOOT_FINISHED: { @@ -355,12 +351,12 @@ status_t BnSurfaceComposer::onTransact( interface_cast<IGraphicBufferProducer>(data.readStrongBinder()); Rect sourceCrop; data.read(sourceCrop); - uint32_t reqWidth = data.readUint32(); - uint32_t reqHeight = data.readUint32(); - uint32_t minLayerZ = data.readUint32(); - uint32_t maxLayerZ = data.readUint32(); + uint32_t reqWidth = data.readInt32(); + uint32_t reqHeight = data.readInt32(); + uint32_t minLayerZ = data.readInt32(); + uint32_t maxLayerZ = data.readInt32(); bool useIdentityTransform = static_cast<bool>(data.readInt32()); - int32_t rotation = data.readInt32(); + uint32_t rotation = data.readInt32(); status_t res = captureScreen(display, producer, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, @@ -411,7 +407,7 @@ status_t BnSurfaceComposer::onTransact( status_t result = getDisplayConfigs(display, &configs); reply->writeInt32(result); if (result == NO_ERROR) { - reply->writeUint32(static_cast<uint32_t>(configs.size())); + reply->writeInt32(static_cast<int32_t>(configs.size())); for (size_t c = 0; c < configs.size(); ++c) { memcpy(reply->writeInplace(sizeof(DisplayInfo)), &configs[c], sizeof(DisplayInfo)); @@ -471,6 +467,8 @@ status_t BnSurfaceComposer::onTransact( return BBinder::onTransact(code, data, reply, flags); } } + // should be unreachable + return NO_ERROR; } // ---------------------------------------------------------------------------- diff --git a/libs/gui/ISurfaceComposerClient.cpp b/libs/gui/ISurfaceComposerClient.cpp index 2ecb908..de4d8c1 100644 --- a/libs/gui/ISurfaceComposerClient.cpp +++ b/libs/gui/ISurfaceComposerClient.cpp @@ -51,19 +51,17 @@ public: : BpInterface<ISurfaceComposerClient>(impl) { } - virtual ~BpSurfaceComposerClient(); - - virtual status_t createSurface(const String8& name, uint32_t width, - uint32_t height, PixelFormat format, uint32_t flags, + virtual status_t createSurface(const String8& name, uint32_t w, + uint32_t h, PixelFormat format, uint32_t flags, sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp) { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor()); data.writeString8(name); - data.writeUint32(width); - data.writeUint32(height); - data.writeInt32(static_cast<int32_t>(format)); - data.writeUint32(flags); + data.writeInt32(w); + data.writeInt32(h); + data.writeInt32(format); + data.writeInt32(flags); remote()->transact(CREATE_SURFACE, data, &reply); *handle = reply.readStrongBinder(); *gbp = interface_cast<IGraphicBufferProducer>(reply.readStrongBinder()); @@ -96,10 +94,6 @@ public: } }; -// Out-of-line virtual method definition to trigger vtable emission in this -// translation unit (see clang warning -Wweak-vtables) -BpSurfaceComposerClient::~BpSurfaceComposerClient() {} - IMPLEMENT_META_INTERFACE(SurfaceComposerClient, "android.ui.ISurfaceComposerClient"); // ---------------------------------------------------------------------- @@ -111,31 +105,31 @@ status_t BnSurfaceComposerClient::onTransact( case CREATE_SURFACE: { CHECK_INTERFACE(ISurfaceComposerClient, data, reply); String8 name = data.readString8(); - uint32_t width = data.readUint32(); - uint32_t height = data.readUint32(); - PixelFormat format = static_cast<PixelFormat>(data.readInt32()); - uint32_t createFlags = data.readUint32(); + uint32_t w = data.readInt32(); + uint32_t h = data.readInt32(); + PixelFormat format = data.readInt32(); + uint32_t flags = data.readInt32(); sp<IBinder> handle; sp<IGraphicBufferProducer> gbp; - status_t result = createSurface(name, width, height, format, - createFlags, &handle, &gbp); + status_t result = createSurface(name, w, h, format, flags, + &handle, &gbp); reply->writeStrongBinder(handle); reply->writeStrongBinder(IInterface::asBinder(gbp)); reply->writeInt32(result); return NO_ERROR; - } + } break; case DESTROY_SURFACE: { CHECK_INTERFACE(ISurfaceComposerClient, data, reply); reply->writeInt32(destroySurface( data.readStrongBinder() ) ); return NO_ERROR; - } + } break; case CLEAR_LAYER_FRAME_STATS: { CHECK_INTERFACE(ISurfaceComposerClient, data, reply); sp<IBinder> handle = data.readStrongBinder(); status_t result = clearLayerFrameStats(handle); reply->writeInt32(result); return NO_ERROR; - } + } break; case GET_LAYER_FRAME_STATS: { CHECK_INTERFACE(ISurfaceComposerClient, data, reply); sp<IBinder> handle = data.readStrongBinder(); @@ -144,7 +138,7 @@ status_t BnSurfaceComposerClient::onTransact( reply->write(stats); reply->writeInt32(result); return NO_ERROR; - } + } break; default: return BBinder::onTransact(code, data, reply, flags); } diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp index 00323dc..ccf8b78 100644 --- a/libs/gui/LayerState.cpp +++ b/libs/gui/LayerState.cpp @@ -25,16 +25,16 @@ namespace android { status_t layer_state_t::write(Parcel& output) const { output.writeStrongBinder(surface); - output.writeUint32(what); + output.writeInt32(what); output.writeFloat(x); output.writeFloat(y); - output.writeUint32(z); - output.writeUint32(w); - output.writeUint32(h); - output.writeUint32(layerStack); + output.writeInt32(z); + output.writeInt32(w); + output.writeInt32(h); + output.writeInt32(layerStack); output.writeFloat(alpha); - output.writeUint32(flags); - output.writeUint32(mask); + output.writeInt32(flags); + output.writeInt32(mask); *reinterpret_cast<layer_state_t::matrix22_t *>( output.writeInplace(sizeof(layer_state_t::matrix22_t))) = matrix; output.write(crop); @@ -45,16 +45,16 @@ status_t layer_state_t::write(Parcel& output) const status_t layer_state_t::read(const Parcel& input) { surface = input.readStrongBinder(); - what = input.readUint32(); + what = input.readInt32(); x = input.readFloat(); y = input.readFloat(); - z = input.readUint32(); - w = input.readUint32(); - h = input.readUint32(); - layerStack = input.readUint32(); + z = input.readInt32(); + w = input.readInt32(); + h = input.readInt32(); + layerStack = input.readInt32(); alpha = input.readFloat(); - flags = static_cast<uint8_t>(input.readUint32()); - mask = static_cast<uint8_t>(input.readUint32()); + flags = input.readInt32(); + mask = input.readInt32(); const void* matrix_data = input.readInplace(sizeof(layer_state_t::matrix22_t)); if (matrix_data) { matrix = *reinterpret_cast<layer_state_t::matrix22_t const *>(matrix_data); @@ -80,26 +80,26 @@ status_t ComposerState::read(const Parcel& input) { status_t DisplayState::write(Parcel& output) const { output.writeStrongBinder(token); output.writeStrongBinder(IInterface::asBinder(surface)); - output.writeUint32(what); - output.writeUint32(layerStack); - output.writeUint32(orientation); + output.writeInt32(what); + output.writeInt32(layerStack); + output.writeInt32(orientation); output.write(viewport); output.write(frame); - output.writeUint32(width); - output.writeUint32(height); + output.writeInt32(width); + output.writeInt32(height); return NO_ERROR; } status_t DisplayState::read(const Parcel& input) { token = input.readStrongBinder(); surface = interface_cast<IGraphicBufferProducer>(input.readStrongBinder()); - what = input.readUint32(); - layerStack = input.readUint32(); - orientation = input.readUint32(); + what = input.readInt32(); + layerStack = input.readInt32(); + orientation = input.readInt32(); input.read(viewport); input.read(frame); - width = input.readUint32(); - height = input.readUint32(); + width = input.readInt32(); + height = input.readInt32(); return NO_ERROR; } diff --git a/libs/gui/Sensor.cpp b/libs/gui/Sensor.cpp index 8d38eef..41a45fc 100644 --- a/libs/gui/Sensor.cpp +++ b/libs/gui/Sensor.cpp @@ -72,7 +72,7 @@ Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion) static_cast<int64_t>(hwSensor->maxDelay)); mMaxDelay = INT_MAX; } else { - mMaxDelay = static_cast<int32_t>(hwSensor->maxDelay); + mMaxDelay = (int32_t) hwSensor->maxDelay; } } else { // For older hals set maxDelay to 0. @@ -204,6 +204,13 @@ Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion) mFlags |= SENSOR_FLAG_WAKE_UP; } break; + case SENSOR_TYPE_WRIST_TILT_GESTURE: + mStringType = SENSOR_STRING_TYPE_WRIST_TILT_GESTURE; + mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE; + if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) { + mFlags |= SENSOR_FLAG_WAKE_UP; + } + break; default: // Only pipe the stringType, requiredPermission and flags for custom sensors. if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor->stringType) { @@ -214,7 +221,7 @@ Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion) } if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) { - mFlags = static_cast<uint32_t>(hwSensor->flags); + mFlags = (int32_t) hwSensor->flags; } else { // This is an OEM defined sensor on an older HAL. Use minDelay to determine the // reporting mode of the sensor. @@ -295,11 +302,11 @@ int32_t Sensor::getVersion() const { return mVersion; } -uint32_t Sensor::getFifoReservedEventCount() const { +int32_t Sensor::getFifoReservedEventCount() const { return mFifoReservedEventCount; } -uint32_t Sensor::getFifoMaxEventCount() const { +int32_t Sensor::getFifoMaxEventCount() const { return mFifoMaxEventCount; } @@ -315,7 +322,7 @@ int32_t Sensor::getMaxDelay() const { return mMaxDelay; } -uint32_t Sensor::getFlags() const { +int32_t Sensor::getFlags() const { return mFlags; } @@ -407,7 +414,7 @@ status_t Sensor::unflatten(void const* buffer, size_t size) { void Sensor::flattenString8(void*& buffer, size_t& size, const String8& string8) { - uint32_t len = static_cast<uint32_t>(string8.length()); + uint32_t len = string8.length(); FlattenableUtils::write(buffer, size, len); memcpy(static_cast<char*>(buffer), string8.string(), len); FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len)); diff --git a/libs/gui/SensorEventQueue.cpp b/libs/gui/SensorEventQueue.cpp index 76ae470..6f5f204 100644 --- a/libs/gui/SensorEventQueue.cpp +++ b/libs/gui/SensorEventQueue.cpp @@ -16,7 +16,6 @@ #define LOG_TAG "Sensors" -#include <algorithm> #include <stdint.h> #include <sys/types.h> #include <sys/socket.h> @@ -32,8 +31,6 @@ #include <android/sensor.h> -using std::min; - // ---------------------------------------------------------------------------- namespace android { // ---------------------------------------------------------------------------- @@ -71,14 +68,14 @@ ssize_t SensorEventQueue::read(ASensorEvent* events, size_t numEvents) { if (err < 0) { return err; } - mAvailable = static_cast<size_t>(err); + mAvailable = err; mConsumed = 0; } - size_t count = min(numEvents, mAvailable); - memcpy(events, mRecBuffer + mConsumed, count * sizeof(ASensorEvent)); + size_t count = numEvents < mAvailable ? numEvents : mAvailable; + memcpy(events, mRecBuffer + mConsumed, count*sizeof(ASensorEvent)); mAvailable -= count; mConsumed += count; - return static_cast<ssize_t>(count); + return count; } sp<Looper> SensorEventQueue::getLooper() const diff --git a/libs/gui/SensorManager.cpp b/libs/gui/SensorManager.cpp index d6df404..17960ff 100644 --- a/libs/gui/SensorManager.cpp +++ b/libs/gui/SensorManager.cpp @@ -90,8 +90,7 @@ status_t SensorManager::assertStateLocked() const { mSensors = mSensorServer->getSensorList(); size_t count = mSensors.size(); - mSensorList = - static_cast<Sensor const**>(malloc(count * sizeof(Sensor*))); + mSensorList = (Sensor const**)malloc(count * sizeof(Sensor*)); for (size_t i=0 ; i<count ; i++) { mSensorList[i] = mSensors.array() + i; } @@ -107,10 +106,10 @@ ssize_t SensorManager::getSensorList(Sensor const* const** list) const Mutex::Autolock _l(mLock); status_t err = assertStateLocked(); if (err < 0) { - return static_cast<ssize_t>(err); + return ssize_t(err); } *list = mSensorList; - return static_cast<ssize_t>(mSensors.size()); + return mSensors.size(); } Sensor const* SensorManager::getDefaultSensor(int type) diff --git a/libs/gui/StreamSplitter.cpp b/libs/gui/StreamSplitter.cpp index 4a1f9e0..25e6cab 100644 --- a/libs/gui/StreamSplitter.cpp +++ b/libs/gui/StreamSplitter.cpp @@ -98,7 +98,7 @@ void StreamSplitter::setName(const String8 &name) { mInput->setConsumerName(name); } -void StreamSplitter::onFrameAvailable() { +void StreamSplitter::onFrameAvailable(const BufferItem& /* item */) { ATRACE_CALL(); Mutex::Autolock lock(mMutex); @@ -141,7 +141,7 @@ void StreamSplitter::onFrameAvailable() { IGraphicBufferProducer::QueueBufferInput queueInput( bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp, - bufferItem.mCrop, static_cast<int32_t>(bufferItem.mScalingMode), + bufferItem.mCrop, bufferItem.mScalingMode, bufferItem.mTransform, bufferItem.mIsDroppable, bufferItem.mFence); diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp index aa4aee4..ab984de 100644 --- a/libs/gui/Surface.cpp +++ b/libs/gui/Surface.cpp @@ -193,17 +193,17 @@ int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) { ATRACE_CALL(); ALOGV("Surface::dequeueBuffer"); - uint32_t reqWidth; - uint32_t reqHeight; + int reqW; + int reqH; bool swapIntervalZero; - PixelFormat reqFormat; + uint32_t reqFormat; uint32_t reqUsage; { Mutex::Autolock lock(mMutex); - reqWidth = mReqWidth ? mReqWidth : mUserWidth; - reqHeight = mReqHeight ? mReqHeight : mUserHeight; + reqW = mReqWidth ? mReqWidth : mUserWidth; + reqH = mReqHeight ? mReqHeight : mUserHeight; swapIntervalZero = mSwapIntervalZero; reqFormat = mReqFormat; @@ -213,12 +213,12 @@ int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) { int buf = -1; sp<Fence> fence; status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, swapIntervalZero, - reqWidth, reqHeight, reqFormat, reqUsage); + reqW, reqH, reqFormat, reqUsage); if (result < 0) { ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d, %d)" - "failed: %d", swapIntervalZero, reqWidth, reqHeight, reqFormat, - reqUsage, result); + "failed: %d", swapIntervalZero, reqW, reqH, reqFormat, reqUsage, + result); return result; } @@ -346,7 +346,7 @@ int Surface::query(int what, int* value) const { switch (what) { case NATIVE_WINDOW_FORMAT: if (mReqFormat) { - *value = static_cast<int>(mReqFormat); + *value = mReqFormat; return NO_ERROR; } break; @@ -364,15 +364,13 @@ int Surface::query(int what, int* value) const { *value = NATIVE_WINDOW_SURFACE; return NO_ERROR; case NATIVE_WINDOW_DEFAULT_WIDTH: - *value = static_cast<int>( - mUserWidth ? mUserWidth : mDefaultWidth); + *value = mUserWidth ? mUserWidth : mDefaultWidth; return NO_ERROR; case NATIVE_WINDOW_DEFAULT_HEIGHT: - *value = static_cast<int>( - mUserHeight ? mUserHeight : mDefaultHeight); + *value = mUserHeight ? mUserHeight : mDefaultHeight; return NO_ERROR; case NATIVE_WINDOW_TRANSFORM_HINT: - *value = static_cast<int>(mTransformHint); + *value = mTransformHint; return NO_ERROR; case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: { status_t err = NO_ERROR; @@ -468,7 +466,7 @@ int Surface::dispatchDisconnect(va_list args) { int Surface::dispatchSetUsage(va_list args) { int usage = va_arg(args, int); - return setUsage(static_cast<uint32_t>(usage)); + return setUsage(usage); } int Surface::dispatchSetCrop(va_list args) { @@ -478,49 +476,49 @@ int Surface::dispatchSetCrop(va_list args) { int Surface::dispatchSetBufferCount(va_list args) { size_t bufferCount = va_arg(args, size_t); - return setBufferCount(static_cast<int32_t>(bufferCount)); + return setBufferCount(bufferCount); } int Surface::dispatchSetBuffersGeometry(va_list args) { - uint32_t width = va_arg(args, uint32_t); - uint32_t height = va_arg(args, uint32_t); - PixelFormat format = va_arg(args, PixelFormat); - int err = setBuffersDimensions(width, height); + 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(format); + return setBuffersFormat(f); } int Surface::dispatchSetBuffersDimensions(va_list args) { - uint32_t width = va_arg(args, uint32_t); - uint32_t height = va_arg(args, uint32_t); - return setBuffersDimensions(width, height); + int w = va_arg(args, int); + int h = va_arg(args, int); + return setBuffersDimensions(w, h); } int Surface::dispatchSetBuffersUserDimensions(va_list args) { - uint32_t width = va_arg(args, uint32_t); - uint32_t height = va_arg(args, uint32_t); - return setBuffersUserDimensions(width, height); + int w = va_arg(args, int); + int h = va_arg(args, int); + return setBuffersUserDimensions(w, h); } int Surface::dispatchSetBuffersFormat(va_list args) { - PixelFormat format = va_arg(args, PixelFormat); - return setBuffersFormat(format); + int f = va_arg(args, int); + return setBuffersFormat(f); } int Surface::dispatchSetScalingMode(va_list args) { - int mode = va_arg(args, int); - return setScalingMode(mode); + int m = va_arg(args, int); + return setScalingMode(m); } int Surface::dispatchSetBuffersTransform(va_list args) { - uint32_t transform = va_arg(args, uint32_t); + int transform = va_arg(args, int); return setBuffersTransform(transform); } int Surface::dispatchSetBuffersStickyTransform(va_list args) { - uint32_t transform = va_arg(args, uint32_t); + int transform = va_arg(args, int); return setBuffersStickyTransform(transform); } @@ -640,38 +638,47 @@ int Surface::setBufferCount(int bufferCount) return err; } -int Surface::setBuffersDimensions(uint32_t width, uint32_t height) +int Surface::setBuffersDimensions(int w, int h) { ATRACE_CALL(); ALOGV("Surface::setBuffersDimensions"); - if ((width && !height) || (!width && height)) + if (w<0 || h<0) + return BAD_VALUE; + + if ((w && !h) || (!w && h)) return BAD_VALUE; Mutex::Autolock lock(mMutex); - mReqWidth = width; - mReqHeight = height; + mReqWidth = w; + mReqHeight = h; return NO_ERROR; } -int Surface::setBuffersUserDimensions(uint32_t width, uint32_t height) +int Surface::setBuffersUserDimensions(int w, int h) { ATRACE_CALL(); ALOGV("Surface::setBuffersUserDimensions"); - if ((width && !height) || (!width && height)) + if (w<0 || h<0) + return BAD_VALUE; + + if ((w && !h) || (!w && h)) return BAD_VALUE; Mutex::Autolock lock(mMutex); - mUserWidth = width; - mUserHeight = height; + mUserWidth = w; + mUserHeight = h; return NO_ERROR; } -int Surface::setBuffersFormat(PixelFormat format) +int Surface::setBuffersFormat(int format) { ALOGV("Surface::setBuffersFormat"); + if (format<0) + return BAD_VALUE; + Mutex::Autolock lock(mMutex); mReqFormat = format; return NO_ERROR; @@ -697,7 +704,7 @@ int Surface::setScalingMode(int mode) return NO_ERROR; } -int Surface::setBuffersTransform(uint32_t transform) +int Surface::setBuffersTransform(int transform) { ATRACE_CALL(); ALOGV("Surface::setBuffersTransform"); @@ -706,7 +713,7 @@ int Surface::setBuffersTransform(uint32_t transform) return NO_ERROR; } -int Surface::setBuffersStickyTransform(uint32_t transform) +int Surface::setBuffersStickyTransform(int transform) { ATRACE_CALL(); ALOGV("Surface::setBuffersStickyTransform"); @@ -740,34 +747,30 @@ static status_t copyBlt( // src and dst with, height and format must be identical. no verification // is done here. status_t err; - uint8_t* src_bits = NULL; - err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), - reinterpret_cast<void**>(&src_bits)); + uint8_t const * src_bits = NULL; + err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits); ALOGE_IF(err, "error locking src buffer %s", strerror(-err)); uint8_t* dst_bits = NULL; - err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), - reinterpret_cast<void**>(&dst_bits)); + err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits); ALOGE_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 = static_cast<uint32_t>(dst->stride) * bpp; - const size_t sbpr = static_cast<uint32_t>(src->stride) * bpp; + const size_t dbpr = dst->stride * bpp; + const size_t sbpr = src->stride * bpp; while (head != tail) { const Rect& r(*head++); - int32_t h = r.height(); + ssize_t h = r.height(); if (h <= 0) continue; - size_t size = static_cast<uint32_t>(r.width()) * bpp; - uint8_t const * s = src_bits + - static_cast<uint32_t>(r.left + src->stride * r.top) * bpp; - uint8_t * d = dst_bits + - static_cast<uint32_t>(r.left + dst->stride * r.top) * bpp; + 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 *= static_cast<size_t>(h); + size *= h; h = 1; } do { diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp index 707a321..1be7895 100644 --- a/libs/gui/SurfaceComposerClient.cpp +++ b/libs/gui/SurfaceComposerClient.cpp @@ -143,7 +143,7 @@ public: status_t setSize(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, uint32_t w, uint32_t h); status_t setLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - uint32_t z); + int32_t z); status_t setFlags(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, uint32_t flags, uint32_t mask); status_t setTransparentRegionHint( @@ -293,7 +293,7 @@ status_t Composer::setSize(const sp<SurfaceComposerClient>& client, } status_t Composer::setLayer(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, uint32_t z) { + const sp<IBinder>& id, int32_t z) { Mutex::Autolock _l(mLock); layer_state_t* s = getLayerStateLocked(client, id); if (!s) @@ -395,7 +395,7 @@ DisplayState& Composer::getDisplayStateLocked(const sp<IBinder>& token) { s.what = 0; index = mDisplayStates.add(s); } - return mDisplayStates.editItemAt(static_cast<size_t>(index)); + return mDisplayStates.editItemAt(index); } void Composer::setDisplaySurface(const sp<IBinder>& token, @@ -571,7 +571,7 @@ status_t SurfaceComposerClient::setSize(const sp<IBinder>& id, uint32_t w, uint3 return getComposer().setSize(this, id, w, h); } -status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, uint32_t z) { +status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) { return getComposer().setLayer(this, id, z); } @@ -657,7 +657,7 @@ status_t SurfaceComposerClient::getDisplayInfo(const sp<IBinder>& display, return NAME_NOT_FOUND; } - *info = configs[static_cast<size_t>(activeId)]; + *info = configs[activeId]; return NO_ERROR; } diff --git a/libs/gui/SurfaceControl.cpp b/libs/gui/SurfaceControl.cpp index 1983027..61011b9 100644 --- a/libs/gui/SurfaceControl.cpp +++ b/libs/gui/SurfaceControl.cpp @@ -89,12 +89,12 @@ bool SurfaceControl::isSameSurface( return lhs->mHandle == rhs->mHandle; } -status_t SurfaceControl::setLayerStack(uint32_t layerStack) { +status_t SurfaceControl::setLayerStack(int32_t layerStack) { status_t err = validate(); if (err < 0) return err; return mClient->setLayerStack(mHandle, layerStack); } -status_t SurfaceControl::setLayer(uint32_t layer) { +status_t SurfaceControl::setLayer(int32_t layer) { status_t err = validate(); if (err < 0) return err; return mClient->setLayer(mHandle, layer); diff --git a/libs/gui/SyncFeatures.cpp b/libs/gui/SyncFeatures.cpp index 187b211..e5804a7 100644 --- a/libs/gui/SyncFeatures.cpp +++ b/libs/gui/SyncFeatures.cpp @@ -16,6 +16,7 @@ #define LOG_TAG "GLConsumer" +#define GL_GLEXT_PROTOTYPES #define EGL_EGLEXT_PROTOTYPES #include <EGL/egl.h> @@ -77,11 +78,10 @@ bool SyncFeatures::useFenceSync() const { // on some devices it's better to not use EGL_KHR_fence_sync // even if they have it return false; -#else +#endif // currently we shall only attempt to use EGL_KHR_fence_sync if // USE_FENCE_SYNC is set in our makefile return !mHasNativeFenceSync && mHasFenceSync; -#endif } bool SyncFeatures::useWaitSync() const { return (useNativeFenceSync() || useFenceSync()) && mHasWaitSync; diff --git a/libs/gui/tests/BufferQueue_test.cpp b/libs/gui/tests/BufferQueue_test.cpp index 5cccc9b..838ad90 100644 --- a/libs/gui/tests/BufferQueue_test.cpp +++ b/libs/gui/tests/BufferQueue_test.cpp @@ -67,7 +67,7 @@ protected: }; struct DummyConsumer : public BnConsumerListener { - virtual void onFrameAvailable() {} + virtual void onFrameAvailable(const BufferItem& /* item */) {} virtual void onBuffersReleased() {} virtual void onSidebandStreamChanged() {} }; diff --git a/libs/gui/tests/DisconnectWaiter.h b/libs/gui/tests/DisconnectWaiter.h index 56e96c2..6e6915b 100644 --- a/libs/gui/tests/DisconnectWaiter.h +++ b/libs/gui/tests/DisconnectWaiter.h @@ -44,7 +44,7 @@ public: mPendingFrames--; } - virtual void onFrameAvailable() { + virtual void onFrameAvailable(const BufferItem& /* item */) { Mutex::Autolock lock(mMutex); mPendingFrames++; mFrameCondition.signal(); diff --git a/libs/gui/tests/FrameWaiter.h b/libs/gui/tests/FrameWaiter.h index bdedba6..f78fa00 100644 --- a/libs/gui/tests/FrameWaiter.h +++ b/libs/gui/tests/FrameWaiter.h @@ -35,7 +35,7 @@ public: mPendingFrames--; } - virtual void onFrameAvailable() { + virtual void onFrameAvailable(const BufferItem& /* item */) { Mutex::Autolock lock(mMutex); mPendingFrames++; mCondition.signal(); diff --git a/libs/gui/tests/IGraphicBufferProducer_test.cpp b/libs/gui/tests/IGraphicBufferProducer_test.cpp index aadfe61..8d5fd8f 100644 --- a/libs/gui/tests/IGraphicBufferProducer_test.cpp +++ b/libs/gui/tests/IGraphicBufferProducer_test.cpp @@ -65,7 +65,7 @@ const sp<Fence> QUEUE_BUFFER_INPUT_FENCE = Fence::NO_FENCE; }; // namespace anonymous struct DummyConsumer : public BnConsumerListener { - virtual void onFrameAvailable() {} + virtual void onFrameAvailable(const BufferItem& /* item */) {} virtual void onBuffersReleased() {} virtual void onSidebandStreamChanged() {} }; diff --git a/libs/gui/tests/StreamSplitter_test.cpp b/libs/gui/tests/StreamSplitter_test.cpp index 32ec90d..4e63a6f 100644 --- a/libs/gui/tests/StreamSplitter_test.cpp +++ b/libs/gui/tests/StreamSplitter_test.cpp @@ -46,7 +46,7 @@ protected: }; struct DummyListener : public BnConsumerListener { - virtual void onFrameAvailable() {} + virtual void onFrameAvailable(const BufferItem& /* item */) {} virtual void onBuffersReleased() {} virtual void onSidebandStreamChanged() {} }; diff --git a/libs/gui/tests/SurfaceTextureGLThreadToGL.h b/libs/gui/tests/SurfaceTextureGLThreadToGL.h index 6410516..14e42ac 100644 --- a/libs/gui/tests/SurfaceTextureGLThreadToGL.h +++ b/libs/gui/tests/SurfaceTextureGLThreadToGL.h @@ -130,7 +130,7 @@ protected: } // This should be called by GLConsumer on the producer thread. - virtual void onFrameAvailable() { + virtual void onFrameAvailable(const BufferItem& /* item */) { Mutex::Autolock lock(mMutex); ALOGV("+onFrameAvailable"); mFrameAvailable = true; diff --git a/libs/ui/GraphicBufferMapper.cpp b/libs/ui/GraphicBufferMapper.cpp index 01acdc8..31bfb2d 100644 --- a/libs/ui/GraphicBufferMapper.cpp +++ b/libs/ui/GraphicBufferMapper.cpp @@ -97,6 +97,10 @@ status_t GraphicBufferMapper::lockYCbCr(buffer_handle_t handle, ATRACE_CALL(); status_t err; + if (mAllocMod->lock_ycbcr == NULL) { + return -EINVAL; // do not log failure + } + err = mAllocMod->lock_ycbcr(mAllocMod, handle, static_cast<int>(usage), bounds.left, bounds.top, bounds.width(), bounds.height(), ycbcr); @@ -144,16 +148,19 @@ status_t GraphicBufferMapper::lockAsyncYCbCr(buffer_handle_t handle, ATRACE_CALL(); status_t err; - if (mAllocMod->common.module_api_version >= GRALLOC_MODULE_API_VERSION_0_3) { + if (mAllocMod->common.module_api_version >= GRALLOC_MODULE_API_VERSION_0_3 + && mAllocMod->lockAsync_ycbcr != NULL) { err = mAllocMod->lockAsync_ycbcr(mAllocMod, handle, static_cast<int>(usage), bounds.left, bounds.top, bounds.width(), bounds.height(), ycbcr, fenceFd); - } else { + } else if (mAllocMod->lock_ycbcr != NULL) { sync_wait(fenceFd, -1); close(fenceFd); err = mAllocMod->lock_ycbcr(mAllocMod, handle, static_cast<int>(usage), bounds.left, bounds.top, bounds.width(), bounds.height(), ycbcr); + } else { + return -EINVAL; // do not log failure } ALOGW_IF(err, "lock(...) failed %d (%s)", err, strerror(-err)); |