19957553cb
There is a new ANativeWindow::cancelBuffer() API that can be used to cancel any dequeued buffer, BEFORE it's been enqueued. The buffer is returned to the list of availlable buffers. dequeue and cancel are not mutually thread safe, they must be called from the same thread or external synchronization must be used. Change-Id: I86cc7985bace8b6a93ad2c75d2bef5c3c2cb4d61
690 lines
19 KiB
C++
690 lines
19 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] ||
|
|
(stack.queued > 0 && stack.inUse != buf));
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
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 );
|
|
|
|
if (stack.head == tail && stack.available == mNumBuffers) {
|
|
LOGW("dequeue: tail=%d, head=%d, avail=%d, queued=%d",
|
|
tail, stack.head, stack.available, stack.queued);
|
|
}
|
|
|
|
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;
|
|
}
|
|
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 (uint32_t(newNumBuffers) >= SharedBufferStack::NUM_BUFFER_MAX)
|
|
return BAD_VALUE;
|
|
|
|
RWLock::AutoWLock _l(mLock);
|
|
|
|
// for now we're not supporting shrinking
|
|
const int numBuffers = mNumBuffers;
|
|
if (newNumBuffers < numBuffers)
|
|
return BAD_VALUE;
|
|
|
|
SharedBufferStack& stack( *mSharedStack );
|
|
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;
|
|
}
|
|
|
|
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
|