ed8a50c9c5
Generally we never want to lock a buffer for write access if it is at the "head" on the surfaceflinger side. The only exception (1) is when the buffer is not currently in use AND there is at least one queued buffer -- in which case, SurfaceFlinger will never use said buffer anymore, because on the next composition around, it will be able to retire the first queued buffer. The logic above relies on SurfaceFlinger always retiring and locking a buffer before composition -- unfortunately this didn't happen during a screenshot. This could leave us in a situation where a buffer is locked by the application for write, and used by SurfaceFlinger for texturing, causing a hang. Here, we fix this issue by never assuming the exception (1), it was intended as an optimization allowing ANativeWindow::lockBuffer() to return sooner and was justified when most of SF composition was done in software. The actual buffer locking is now ensured by gralloc. We could have handled screenshots in a similar way to a regular composition, but it could have caused glitches on screen, essentially, taking a screenshot could cause to skip a frame. Change-Id: I1f226b1ebdf6918439b687c2723955d55b842c55
749 lines
21 KiB
C++
749 lines
21 KiB
C++
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "SharedBufferStack"
|
|
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <utils/Debug.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/threads.h>
|
|
|
|
#include <private/surfaceflinger/SharedBufferStack.h>
|
|
|
|
#include <ui/Rect.h>
|
|
#include <ui/Region.h>
|
|
|
|
#define DEBUG_ATOMICS 0
|
|
|
|
namespace android {
|
|
// ----------------------------------------------------------------------------
|
|
|
|
SharedClient::SharedClient()
|
|
: lock(Mutex::SHARED), cv(Condition::SHARED)
|
|
{
|
|
}
|
|
|
|
SharedClient::~SharedClient() {
|
|
}
|
|
|
|
|
|
// these functions are used by the clients
|
|
status_t SharedClient::validate(size_t i) const {
|
|
if (uint32_t(i) >= uint32_t(SharedBufferStack::NUM_LAYERS_MAX))
|
|
return BAD_INDEX;
|
|
return surfaces[i].status;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
|
SharedBufferStack::SharedBufferStack()
|
|
{
|
|
}
|
|
|
|
void SharedBufferStack::init(int32_t i)
|
|
{
|
|
inUse = -2;
|
|
status = NO_ERROR;
|
|
identity = i;
|
|
}
|
|
|
|
status_t SharedBufferStack::setCrop(int buffer, const Rect& crop)
|
|
{
|
|
if (uint32_t(buffer) >= NUM_BUFFER_MAX)
|
|
return BAD_INDEX;
|
|
|
|
buffers[buffer].crop.l = uint16_t(crop.left);
|
|
buffers[buffer].crop.t = uint16_t(crop.top);
|
|
buffers[buffer].crop.r = uint16_t(crop.right);
|
|
buffers[buffer].crop.b = uint16_t(crop.bottom);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t SharedBufferStack::setTransform(int buffer, uint8_t transform)
|
|
{
|
|
if (uint32_t(buffer) >= NUM_BUFFER_MAX)
|
|
return BAD_INDEX;
|
|
buffers[buffer].transform = transform;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t SharedBufferStack::setDirtyRegion(int buffer, const Region& dirty)
|
|
{
|
|
if (uint32_t(buffer) >= NUM_BUFFER_MAX)
|
|
return BAD_INDEX;
|
|
|
|
FlatRegion& reg(buffers[buffer].dirtyRegion);
|
|
if (dirty.isEmpty()) {
|
|
reg.count = 0;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
size_t count;
|
|
Rect const* r = dirty.getArray(&count);
|
|
if (count > FlatRegion::NUM_RECT_MAX) {
|
|
const Rect bounds(dirty.getBounds());
|
|
reg.count = 1;
|
|
reg.rects[0].l = uint16_t(bounds.left);
|
|
reg.rects[0].t = uint16_t(bounds.top);
|
|
reg.rects[0].r = uint16_t(bounds.right);
|
|
reg.rects[0].b = uint16_t(bounds.bottom);
|
|
} else {
|
|
reg.count = count;
|
|
for (size_t i=0 ; i<count ; i++) {
|
|
reg.rects[i].l = uint16_t(r[i].left);
|
|
reg.rects[i].t = uint16_t(r[i].top);
|
|
reg.rects[i].r = uint16_t(r[i].right);
|
|
reg.rects[i].b = uint16_t(r[i].bottom);
|
|
}
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
Region SharedBufferStack::getDirtyRegion(int buffer) const
|
|
{
|
|
Region res;
|
|
if (uint32_t(buffer) >= NUM_BUFFER_MAX)
|
|
return res;
|
|
|
|
const FlatRegion& reg(buffers[buffer].dirtyRegion);
|
|
if (reg.count > FlatRegion::NUM_RECT_MAX)
|
|
return res;
|
|
|
|
if (reg.count == 1) {
|
|
const Rect r(
|
|
reg.rects[0].l,
|
|
reg.rects[0].t,
|
|
reg.rects[0].r,
|
|
reg.rects[0].b);
|
|
res.set(r);
|
|
} else {
|
|
for (size_t i=0 ; i<reg.count ; i++) {
|
|
const Rect r(
|
|
reg.rects[i].l,
|
|
reg.rects[i].t,
|
|
reg.rects[i].r,
|
|
reg.rects[i].b);
|
|
res.orSelf(r);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
Rect SharedBufferStack::getCrop(int buffer) const
|
|
{
|
|
Rect res(-1, -1);
|
|
if (uint32_t(buffer) >= NUM_BUFFER_MAX)
|
|
return res;
|
|
res.left = buffers[buffer].crop.l;
|
|
res.top = buffers[buffer].crop.t;
|
|
res.right = buffers[buffer].crop.r;
|
|
res.bottom = buffers[buffer].crop.b;
|
|
return res;
|
|
}
|
|
|
|
uint32_t SharedBufferStack::getTransform(int buffer) const
|
|
{
|
|
if (uint32_t(buffer) >= NUM_BUFFER_MAX)
|
|
return 0;
|
|
return buffers[buffer].transform;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
SharedBufferBase::SharedBufferBase(SharedClient* sharedClient,
|
|
int surface, int32_t identity)
|
|
: mSharedClient(sharedClient),
|
|
mSharedStack(sharedClient->surfaces + surface),
|
|
mIdentity(identity)
|
|
{
|
|
}
|
|
|
|
SharedBufferBase::~SharedBufferBase()
|
|
{
|
|
}
|
|
|
|
status_t SharedBufferBase::getStatus() const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.status;
|
|
}
|
|
|
|
int32_t SharedBufferBase::getIdentity() const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.identity;
|
|
}
|
|
|
|
String8 SharedBufferBase::dump(char const* prefix) const
|
|
{
|
|
const size_t SIZE = 1024;
|
|
char buffer[SIZE];
|
|
String8 result;
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
snprintf(buffer, SIZE,
|
|
"%s[ head=%2d, available=%2d, queued=%2d ] "
|
|
"reallocMask=%08x, inUse=%2d, identity=%d, status=%d",
|
|
prefix, stack.head, stack.available, stack.queued,
|
|
stack.reallocMask, stack.inUse, stack.identity, stack.status);
|
|
result.append(buffer);
|
|
result.append("\n");
|
|
return result;
|
|
}
|
|
|
|
status_t SharedBufferBase::waitForCondition(const ConditionBase& condition)
|
|
{
|
|
const SharedBufferStack& stack( *mSharedStack );
|
|
SharedClient& client( *mSharedClient );
|
|
const nsecs_t TIMEOUT = s2ns(1);
|
|
const int identity = mIdentity;
|
|
|
|
Mutex::Autolock _l(client.lock);
|
|
while ((condition()==false) &&
|
|
(stack.identity == identity) &&
|
|
(stack.status == NO_ERROR))
|
|
{
|
|
status_t err = client.cv.waitRelative(client.lock, TIMEOUT);
|
|
// handle errors and timeouts
|
|
if (CC_UNLIKELY(err != NO_ERROR)) {
|
|
if (err == TIMED_OUT) {
|
|
if (condition()) {
|
|
LOGE("waitForCondition(%s) timed out (identity=%d), "
|
|
"but condition is true! We recovered but it "
|
|
"shouldn't happen." , condition.name(), stack.identity);
|
|
break;
|
|
} else {
|
|
LOGW("waitForCondition(%s) timed out "
|
|
"(identity=%d, status=%d). "
|
|
"CPU may be pegged. trying again.", condition.name(),
|
|
stack.identity, stack.status);
|
|
}
|
|
} else {
|
|
LOGE("waitForCondition(%s) error (%s) ",
|
|
condition.name(), strerror(-err));
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
return (stack.identity != mIdentity) ? status_t(BAD_INDEX) : stack.status;
|
|
}
|
|
// ============================================================================
|
|
// conditions and updates
|
|
// ============================================================================
|
|
|
|
SharedBufferClient::DequeueCondition::DequeueCondition(
|
|
SharedBufferClient* sbc) : ConditionBase(sbc) {
|
|
}
|
|
bool SharedBufferClient::DequeueCondition::operator()() const {
|
|
return stack.available > 0;
|
|
}
|
|
|
|
SharedBufferClient::LockCondition::LockCondition(
|
|
SharedBufferClient* sbc, int buf) : ConditionBase(sbc), buf(buf) {
|
|
}
|
|
bool SharedBufferClient::LockCondition::operator()() const {
|
|
// NOTE: if stack.head is messed up, we could crash the client
|
|
// or cause some drawing artifacts. This is okay, as long as it is
|
|
// limited to the client.
|
|
return (buf != stack.index[stack.head]);
|
|
}
|
|
|
|
SharedBufferServer::BuffersAvailableCondition::BuffersAvailableCondition(
|
|
SharedBufferServer* sbs, int numBuffers) : ConditionBase(sbs),
|
|
mNumBuffers(numBuffers) {
|
|
}
|
|
bool SharedBufferServer::BuffersAvailableCondition::operator()() const {
|
|
return stack.available == mNumBuffers;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
SharedBufferClient::QueueUpdate::QueueUpdate(SharedBufferBase* sbb)
|
|
: UpdateBase(sbb) {
|
|
}
|
|
ssize_t SharedBufferClient::QueueUpdate::operator()() {
|
|
android_atomic_inc(&stack.queued);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
SharedBufferClient::DequeueUpdate::DequeueUpdate(SharedBufferBase* sbb)
|
|
: UpdateBase(sbb) {
|
|
}
|
|
ssize_t SharedBufferClient::DequeueUpdate::operator()() {
|
|
if (android_atomic_dec(&stack.available) == 0) {
|
|
LOGW("dequeue probably called from multiple threads!");
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
SharedBufferClient::CancelUpdate::CancelUpdate(SharedBufferBase* sbb,
|
|
int tail, int buf)
|
|
: UpdateBase(sbb), tail(tail), buf(buf) {
|
|
}
|
|
ssize_t SharedBufferClient::CancelUpdate::operator()() {
|
|
stack.index[tail] = buf;
|
|
android_atomic_inc(&stack.available);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
SharedBufferServer::UnlockUpdate::UnlockUpdate(
|
|
SharedBufferBase* sbb, int lockedBuffer)
|
|
: UpdateBase(sbb), lockedBuffer(lockedBuffer) {
|
|
}
|
|
ssize_t SharedBufferServer::UnlockUpdate::operator()() {
|
|
if (stack.inUse != lockedBuffer) {
|
|
LOGE("unlocking %d, but currently locked buffer is %d "
|
|
"(identity=%d, token=%d)",
|
|
lockedBuffer, stack.inUse,
|
|
stack.identity, stack.token);
|
|
return BAD_VALUE;
|
|
}
|
|
android_atomic_write(-1, &stack.inUse);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
SharedBufferServer::RetireUpdate::RetireUpdate(
|
|
SharedBufferBase* sbb, int numBuffers)
|
|
: UpdateBase(sbb), numBuffers(numBuffers) {
|
|
}
|
|
ssize_t SharedBufferServer::RetireUpdate::operator()() {
|
|
int32_t head = stack.head;
|
|
if (uint32_t(head) >= SharedBufferStack::NUM_BUFFER_MAX)
|
|
return BAD_VALUE;
|
|
|
|
// Preventively lock the current buffer before updating queued.
|
|
android_atomic_write(stack.headBuf, &stack.inUse);
|
|
|
|
// Decrement the number of queued buffers
|
|
int32_t queued;
|
|
do {
|
|
queued = stack.queued;
|
|
if (queued == 0) {
|
|
return NOT_ENOUGH_DATA;
|
|
}
|
|
} while (android_atomic_cmpxchg(queued, queued-1, &stack.queued));
|
|
|
|
// lock the buffer before advancing head, which automatically unlocks
|
|
// the buffer we preventively locked upon entering this function
|
|
|
|
head = (head + 1) % numBuffers;
|
|
const int8_t headBuf = stack.index[head];
|
|
stack.headBuf = headBuf;
|
|
android_atomic_write(headBuf, &stack.inUse);
|
|
|
|
// head is only modified here, so we don't need to use cmpxchg
|
|
android_atomic_write(head, &stack.head);
|
|
|
|
// now that head has moved, we can increment the number of available buffers
|
|
android_atomic_inc(&stack.available);
|
|
return head;
|
|
}
|
|
|
|
SharedBufferServer::StatusUpdate::StatusUpdate(
|
|
SharedBufferBase* sbb, status_t status)
|
|
: UpdateBase(sbb), status(status) {
|
|
}
|
|
|
|
ssize_t SharedBufferServer::StatusUpdate::operator()() {
|
|
android_atomic_write(status, &stack.status);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// ============================================================================
|
|
|
|
SharedBufferClient::SharedBufferClient(SharedClient* sharedClient,
|
|
int surface, int num, int32_t identity)
|
|
: SharedBufferBase(sharedClient, surface, identity),
|
|
mNumBuffers(num), tail(0)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
tail = computeTail();
|
|
queued_head = stack.head;
|
|
}
|
|
|
|
int32_t SharedBufferClient::computeTail() const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return (mNumBuffers + stack.head - stack.available + 1) % mNumBuffers;
|
|
}
|
|
|
|
ssize_t SharedBufferClient::dequeue()
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
|
|
RWLock::AutoRLock _rd(mLock);
|
|
|
|
const nsecs_t dequeueTime = systemTime(SYSTEM_TIME_THREAD);
|
|
|
|
//LOGD("[%d] about to dequeue a buffer",
|
|
// mSharedStack->identity);
|
|
DequeueCondition condition(this);
|
|
status_t err = waitForCondition(condition);
|
|
if (err != NO_ERROR)
|
|
return ssize_t(err);
|
|
|
|
DequeueUpdate update(this);
|
|
updateCondition( update );
|
|
|
|
int dequeued = stack.index[tail];
|
|
tail = ((tail+1 >= mNumBuffers) ? 0 : tail+1);
|
|
LOGD_IF(DEBUG_ATOMICS, "dequeued=%d, tail++=%d, %s",
|
|
dequeued, tail, dump("").string());
|
|
|
|
mDequeueTime[dequeued] = dequeueTime;
|
|
|
|
return dequeued;
|
|
}
|
|
|
|
status_t SharedBufferClient::undoDequeue(int buf)
|
|
{
|
|
return cancel(buf);
|
|
}
|
|
|
|
status_t SharedBufferClient::cancel(int buf)
|
|
{
|
|
RWLock::AutoRLock _rd(mLock);
|
|
|
|
// calculate the new position of the tail index (essentially tail--)
|
|
int localTail = (tail + mNumBuffers - 1) % mNumBuffers;
|
|
CancelUpdate update(this, localTail, buf);
|
|
status_t err = updateCondition( update );
|
|
if (err == NO_ERROR) {
|
|
tail = localTail;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
status_t SharedBufferClient::lock(int buf)
|
|
{
|
|
RWLock::AutoRLock _rd(mLock);
|
|
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
LockCondition condition(this, buf);
|
|
status_t err = waitForCondition(condition);
|
|
return err;
|
|
}
|
|
|
|
status_t SharedBufferClient::queue(int buf)
|
|
{
|
|
RWLock::AutoRLock _rd(mLock);
|
|
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
|
|
queued_head = (queued_head + 1) % mNumBuffers;
|
|
stack.index[queued_head] = buf;
|
|
|
|
QueueUpdate update(this);
|
|
status_t err = updateCondition( update );
|
|
LOGD_IF(DEBUG_ATOMICS, "queued=%d, %s", buf, dump("").string());
|
|
|
|
const nsecs_t now = systemTime(SYSTEM_TIME_THREAD);
|
|
stack.stats.totalTime = ns2us(now - mDequeueTime[buf]);
|
|
|
|
return err;
|
|
}
|
|
|
|
bool SharedBufferClient::needNewBuffer(int buf) const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
const uint32_t mask = 1<<(31-buf);
|
|
return (android_atomic_and(~mask, &stack.reallocMask) & mask) != 0;
|
|
}
|
|
|
|
status_t SharedBufferClient::setCrop(int buf, const Rect& crop)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.setCrop(buf, crop);
|
|
}
|
|
|
|
status_t SharedBufferClient::setTransform(int buf, uint32_t transform)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.setTransform(buf, uint8_t(transform));
|
|
}
|
|
|
|
status_t SharedBufferClient::setDirtyRegion(int buf, const Region& reg)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.setDirtyRegion(buf, reg);
|
|
}
|
|
|
|
status_t SharedBufferClient::setBufferCount(
|
|
int bufferCount, const SetBufferCountCallback& ipc)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
if (uint32_t(bufferCount) >= SharedBufferStack::NUM_BUFFER_MAX)
|
|
return BAD_VALUE;
|
|
|
|
if (uint32_t(bufferCount) < SharedBufferStack::NUM_BUFFER_MIN)
|
|
return BAD_VALUE;
|
|
|
|
RWLock::AutoWLock _wr(mLock);
|
|
|
|
status_t err = ipc(bufferCount);
|
|
if (err == NO_ERROR) {
|
|
mNumBuffers = bufferCount;
|
|
queued_head = (stack.head + stack.queued) % mNumBuffers;
|
|
tail = computeTail();
|
|
}
|
|
return err;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
SharedBufferServer::SharedBufferServer(SharedClient* sharedClient,
|
|
int surface, int num, int32_t identity)
|
|
: SharedBufferBase(sharedClient, surface, identity),
|
|
mNumBuffers(num)
|
|
{
|
|
mSharedStack->init(identity);
|
|
mSharedStack->token = surface;
|
|
mSharedStack->head = num-1;
|
|
mSharedStack->available = num;
|
|
mSharedStack->queued = 0;
|
|
mSharedStack->reallocMask = 0;
|
|
memset(mSharedStack->buffers, 0, sizeof(mSharedStack->buffers));
|
|
for (int i=0 ; i<num ; i++) {
|
|
mBufferList.add(i);
|
|
mSharedStack->index[i] = i;
|
|
}
|
|
}
|
|
|
|
SharedBufferServer::~SharedBufferServer()
|
|
{
|
|
}
|
|
|
|
ssize_t SharedBufferServer::retireAndLock()
|
|
{
|
|
RWLock::AutoRLock _l(mLock);
|
|
|
|
RetireUpdate update(this, mNumBuffers);
|
|
ssize_t buf = updateCondition( update );
|
|
if (buf >= 0) {
|
|
if (uint32_t(buf) >= SharedBufferStack::NUM_BUFFER_MAX)
|
|
return BAD_VALUE;
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
buf = stack.index[buf];
|
|
LOGD_IF(DEBUG_ATOMICS && buf>=0, "retire=%d, %s",
|
|
int(buf), dump("").string());
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
status_t SharedBufferServer::unlock(int buf)
|
|
{
|
|
UnlockUpdate update(this, buf);
|
|
status_t err = updateCondition( update );
|
|
return err;
|
|
}
|
|
|
|
void SharedBufferServer::setStatus(status_t status)
|
|
{
|
|
if (status < NO_ERROR) {
|
|
StatusUpdate update(this, status);
|
|
updateCondition( update );
|
|
}
|
|
}
|
|
|
|
status_t SharedBufferServer::reallocateAll()
|
|
{
|
|
RWLock::AutoRLock _l(mLock);
|
|
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
uint32_t mask = mBufferList.getMask();
|
|
android_atomic_or(mask, &stack.reallocMask);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t SharedBufferServer::reallocateAllExcept(int buffer)
|
|
{
|
|
RWLock::AutoRLock _l(mLock);
|
|
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
BufferList temp(mBufferList);
|
|
temp.remove(buffer);
|
|
uint32_t mask = temp.getMask();
|
|
android_atomic_or(mask, &stack.reallocMask);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
int32_t SharedBufferServer::getQueuedCount() const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.queued;
|
|
}
|
|
|
|
Region SharedBufferServer::getDirtyRegion(int buf) const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.getDirtyRegion(buf);
|
|
}
|
|
|
|
Rect SharedBufferServer::getCrop(int buf) const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.getCrop(buf);
|
|
}
|
|
|
|
uint32_t SharedBufferServer::getTransform(int buf) const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.getTransform(buf);
|
|
}
|
|
|
|
/*
|
|
* NOTE: this is not thread-safe on the server-side, meaning
|
|
* 'head' cannot move during this operation. The client-side
|
|
* can safely operate an usual.
|
|
*
|
|
*/
|
|
status_t SharedBufferServer::resize(int newNumBuffers)
|
|
{
|
|
if ((unsigned int)(newNumBuffers) < SharedBufferStack::NUM_BUFFER_MIN ||
|
|
(unsigned int)(newNumBuffers) > SharedBufferStack::NUM_BUFFER_MAX) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
RWLock::AutoWLock _l(mLock);
|
|
|
|
if (newNumBuffers < mNumBuffers) {
|
|
return shrink(newNumBuffers);
|
|
} else {
|
|
return grow(newNumBuffers);
|
|
}
|
|
}
|
|
|
|
status_t SharedBufferServer::grow(int newNumBuffers)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
const int numBuffers = mNumBuffers;
|
|
const int extra = newNumBuffers - numBuffers;
|
|
|
|
// read the head, make sure it's valid
|
|
int32_t head = stack.head;
|
|
if (uint32_t(head) >= SharedBufferStack::NUM_BUFFER_MAX)
|
|
return BAD_VALUE;
|
|
|
|
int base = numBuffers;
|
|
int32_t avail = stack.available;
|
|
int tail = head - avail + 1;
|
|
|
|
if (tail >= 0) {
|
|
int8_t* const index = const_cast<int8_t*>(stack.index);
|
|
const int nb = numBuffers - head;
|
|
memmove(&index[head + extra], &index[head], nb);
|
|
base = head;
|
|
// move head 'extra' ahead, this doesn't impact stack.index[head];
|
|
stack.head = head + extra;
|
|
}
|
|
stack.available += extra;
|
|
|
|
// fill the new free space with unused buffers
|
|
BufferList::const_iterator curr(mBufferList.free_begin());
|
|
for (int i=0 ; i<extra ; i++) {
|
|
stack.index[base+i] = *curr;
|
|
mBufferList.add(*curr);
|
|
++curr;
|
|
}
|
|
|
|
mNumBuffers = newNumBuffers;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t SharedBufferServer::shrink(int newNumBuffers)
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
|
|
// Shrinking is only supported if there are no buffers currently dequeued.
|
|
int32_t avail = stack.available;
|
|
int32_t queued = stack.queued;
|
|
if (avail + queued != mNumBuffers) {
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
// Wait for any queued buffers to be displayed.
|
|
BuffersAvailableCondition condition(this, mNumBuffers);
|
|
status_t err = waitForCondition(condition);
|
|
if (err < 0) {
|
|
return err;
|
|
}
|
|
|
|
// Reset head to index 0 and make it refer to buffer 0. The same renaming
|
|
// (head -> 0) is done in the BufferManager.
|
|
int32_t head = stack.head;
|
|
int8_t* index = const_cast<int8_t*>(stack.index);
|
|
for (int8_t i = 0; i < newNumBuffers; i++) {
|
|
index[i] = i;
|
|
}
|
|
stack.head = 0;
|
|
stack.headBuf = 0;
|
|
|
|
// If one of the buffers is in use it must be the head buffer, which we are
|
|
// renaming to buffer 0.
|
|
if (stack.inUse > 0) {
|
|
stack.inUse = 0;
|
|
}
|
|
|
|
// Free the buffers from the end of the list that are no longer needed.
|
|
for (int i = newNumBuffers; i < mNumBuffers; i++) {
|
|
mBufferList.remove(i);
|
|
}
|
|
|
|
// Tell the client to reallocate all the buffers.
|
|
reallocateAll();
|
|
|
|
mNumBuffers = newNumBuffers;
|
|
stack.available = newNumBuffers;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
SharedBufferStack::Statistics SharedBufferServer::getStats() const
|
|
{
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
return stack.stats;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
status_t SharedBufferServer::BufferList::add(int value)
|
|
{
|
|
if (uint32_t(value) >= mCapacity)
|
|
return BAD_VALUE;
|
|
uint32_t mask = 1<<(31-value);
|
|
if (mList & mask)
|
|
return ALREADY_EXISTS;
|
|
mList |= mask;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t SharedBufferServer::BufferList::remove(int value)
|
|
{
|
|
if (uint32_t(value) >= mCapacity)
|
|
return BAD_VALUE;
|
|
uint32_t mask = 1<<(31-value);
|
|
if (!(mList & mask))
|
|
return NAME_NOT_FOUND;
|
|
mList &= ~mask;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
}; // namespace android
|