TEST_F(BitSet32Test, BitWiseAnd_Disjoint) {
b1.markBit(2);
b1.markBit(4);
b1.markBit(6);
BitSet32 tmp = b1 & b2;
EXPECT_TRUE(tmp.isEmpty());
// Check that the operator is symmetric
EXPECT_TRUE((b2 & b1) == (b1 & b2));
b2 &= b1;
EXPECT_TRUE(b2.isEmpty());
EXPECT_EQ(b1.count(), 3u);
EXPECT_TRUE(b1.hasBit(2) && b1.hasBit(4) && b1.hasBit(6));
}
TEST_F(BitSet32Test, BitWiseOr) {
b1.markBit(2);
b2.markBit(4);
BitSet32 tmp = b1 | b2;
EXPECT_EQ(tmp.count(), 2u);
EXPECT_TRUE(tmp.hasBit(2) && tmp.hasBit(4));
// Check that the operator is symmetric
EXPECT_TRUE((b2 | b1) == (b1 | b2));
b1 |= b2;
EXPECT_EQ(b1.count(), 2u);
EXPECT_TRUE(b1.hasBit(2) && b1.hasBit(4));
EXPECT_TRUE(b2.hasBit(4) && b2.count() == 1u);
}
MERROR
UsersManager::
haveAllUsersReleasedOrPreReleasedLocked() const
{
BitSet32 const consumer = mConsumerMap.mBitSetReleased | mConsumerMap.mBitSetPreReleased;
if ( consumer.count() != mConsumerMap.size() ) {
return UNKNOWN_ERROR;
}
//
BitSet32 const producer = mProducerMap.mBitSetReleased | mProducerMap.mBitSetPreReleased;
if ( producer.count() != mProducerMap.size() ) {
return UNKNOWN_ERROR;
}
//
return OK;
}
void VelocityTracker::clearPointers(BitSet32 idBits) {
BitSet32 remainingIdBits(mCurrentPointerIdBits.value & ~idBits.value);
mCurrentPointerIdBits = remainingIdBits;
if (mActivePointerId >= 0 && idBits.hasBit(mActivePointerId)) {
mActivePointerId = !remainingIdBits.isEmpty() ? remainingIdBits.firstMarkedBit() : -1;
}
mStrategy->clearPointers(idBits);
}
TEST_F(BitSet32Test, BitWiseAnd_NonDisjoint) {
b1.markBit(2);
b1.markBit(4);
b1.markBit(6);
b2.markBit(3);
b2.markBit(6);
b2.markBit(9);
BitSet32 tmp = b1 & b2;
EXPECT_EQ(tmp.count(), 1u);
EXPECT_TRUE(tmp.hasBit(6));
// Check that the operator is symmetric
EXPECT_TRUE((b2 & b1) == (b1 & b2));
b1 &= b2;
EXPECT_EQ(b1.count(), 1u);
EXPECT_EQ(b2.count(), 3u);
EXPECT_TRUE(b2.hasBit(3) && b2.hasBit(6) && b2.hasBit(9));
}
bool LightManager::lightScene( const char* callback, const char* param )
{
BitSet32 flags = 0;
if ( param )
{
if ( !dStricmp( param, "forceAlways" ) )
flags.set( SceneLighting::ForceAlways );
else if ( !dStricmp(param, "forceWritable" ) )
flags.set( SceneLighting::ForceWritable );
else if ( !dStricmp(param, "loadOnly" ) )
flags.set( SceneLighting::LoadOnly );
}
// The SceneLighting object will delete itself
// once the lighting process is complete.
SceneLighting* sl = new SceneLighting( getSceneLightingInterface() );
return sl->lightScene( callback, flags );
}
void VelocityTracker::AddMovement(const TimeTicks& event_time,
BitSet32 id_bits,
const PointerXY* positions) {
while (id_bits.count() > MAX_POINTERS)
id_bits.clear_last_marked_bit();
if ((current_pointer_id_bits_.value & id_bits.value) &&
(event_time - last_event_time_) >=
base::TimeDelta::FromMilliseconds(kAssumePointerMoveStoppedTimeMs)) {
// We have not received any movements for too long. Assume that all pointers
// have stopped.
strategy_->Clear();
}
last_event_time_ = event_time;
current_pointer_id_bits_ = id_bits;
if (active_pointer_id_ < 0 || !id_bits.has_bit(active_pointer_id_))
active_pointer_id_ = id_bits.is_empty() ? -1 : id_bits.first_marked_bit();
strategy_->AddMovement(event_time, id_bits, positions);
}
void VelocityTracker::ClearPointers(BitSet32 id_bits) {
BitSet32 remaining_id_bits(current_pointer_id_bits_.value & ~id_bits.value);
current_pointer_id_bits_ = remaining_id_bits;
if (active_pointer_id_ >= 0 && id_bits.has_bit(active_pointer_id_)) {
active_pointer_id_ = !remaining_id_bits.is_empty()
? remaining_id_bits.first_marked_bit()
: -1;
}
strategy_->ClearPointers(id_bits);
}
void VelocityTrackerState::getVelocity(int32_t id, float* outVx, float* outVy) {
if (id == ACTIVE_POINTER_ID) {
id = mVelocityTracker.getActivePointerId();
}
float vx, vy;
if (id >= 0 && id <= MAX_POINTER_ID && mCalculatedIdBits.hasBit(id)) {
uint32_t index = mCalculatedIdBits.getIndexOfBit(id);
const Velocity& velocity = mCalculatedVelocity[index];
vx = velocity.vx;
vy = velocity.vy;
} else {
vx = 0;
vy = 0;
}
if (outVx) {
*outVx = vx;
}
if (outVy) {
*outVy = vy;
}
}
void LegacyVelocityTrackerStrategy::addMovement(nsecs_t eventTime, BitSet32 idBits,
const VelocityTracker::Position* positions) {
if (++mIndex == HISTORY_SIZE) {
mIndex = 0;
}
Movement& movement = mMovements[mIndex];
movement.eventTime = eventTime;
movement.idBits = idBits;
uint32_t count = idBits.count();
for (uint32_t i = 0; i < count; i++) {
movement.positions[i] = positions[i];
}
}
void LeastSquaresVelocityTrackerStrategy::AddMovement(
const TimeTicks& event_time,
BitSet32 id_bits,
const PointerXY* positions) {
if (++index_ == kHistorySize) {
index_ = 0;
}
Movement& movement = movements_[index_];
movement.event_time = event_time;
movement.id_bits = id_bits;
uint32_t count = id_bits.count();
for (uint32_t i = 0; i < count; i++) {
movement.positions[i] = positions[i];
}
}
void PointerController::setSpots(const PointerCoords* spotCoords,
const uint32_t* spotIdToIndex, BitSet32 spotIdBits) {
#if DEBUG_POINTER_UPDATES
ALOGD("setSpots: idBits=%08x", spotIdBits.value);
for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
uint32_t id = idBits.firstMarkedBit();
idBits.clearBit(id);
const PointerCoords& c = spotCoords[spotIdToIndex[id]];
ALOGD(" spot %d: position=(%0.3f, %0.3f), pressure=%0.3f", id,
c.getAxisValue(AMOTION_EVENT_AXIS_X),
c.getAxisValue(AMOTION_EVENT_AXIS_Y),
c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
}
#endif
AutoMutex _l(mLock);
mSpriteController->openTransaction();
// Add or move spots for fingers that are down.
for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
uint32_t id = idBits.clearFirstMarkedBit();
const PointerCoords& c = spotCoords[spotIdToIndex[id]];
const SpriteIcon& icon = c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE) > 0
? mResources.spotTouch : mResources.spotHover;
float x = c.getAxisValue(AMOTION_EVENT_AXIS_X);
float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y);
Spot* spot = getSpotLocked(id);
if (!spot) {
spot = createAndAddSpotLocked(id);
}
spot->updateSprite(&icon, x, y);
}
// Remove spots for fingers that went up.
for (size_t i = 0; i < mLocked.spots.size(); i++) {
Spot* spot = mLocked.spots.itemAt(i);
if (spot->id != Spot::INVALID_ID
&& !spotIdBits.hasBit(spot->id)) {
fadeOutAndReleaseSpotLocked(spot);
}
}
mSpriteController->closeTransaction();
}
void VelocityTracker::addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions) {
while (idBits.count() > MAX_POINTERS) {
idBits.clearLastMarkedBit();
}
if ((mCurrentPointerIdBits.value & idBits.value)
&& eventTime >= mLastEventTime + ASSUME_POINTER_STOPPED_TIME) {
#if DEBUG_VELOCITY
ALOGD("VelocityTracker: stopped for %0.3f ms, clearing state.",
(eventTime - mLastEventTime) * 0.000001f);
#endif
// We have not received any movements for too long. Assume that all pointers
// have stopped.
mStrategy->clear();
}
mLastEventTime = eventTime;
mCurrentPointerIdBits = idBits;
if (mActivePointerId < 0 || !idBits.hasBit(mActivePointerId)) {
mActivePointerId = idBits.isEmpty() ? -1 : idBits.firstMarkedBit();
}
mStrategy->addMovement(eventTime, idBits, positions);
#if DEBUG_VELOCITY
ALOGD("VelocityTracker: addMovement eventTime=%" PRId64 ", idBits=0x%08x, activePointerId=%d",
eventTime, idBits.value, mActivePointerId);
for (BitSet32 iterBits(idBits); !iterBits.isEmpty(); ) {
uint32_t id = iterBits.firstMarkedBit();
uint32_t index = idBits.getIndexOfBit(id);
iterBits.clearBit(id);
Estimator estimator;
getEstimator(id, &estimator);
ALOGD(" %d: position (%0.3f, %0.3f), "
"estimator (degree=%d, xCoeff=%s, yCoeff=%s, confidence=%f)",
id, positions[index].x, positions[index].y,
int(estimator.degree),
vectorToString(estimator.xCoeff, estimator.degree + 1).c_str(),
vectorToString(estimator.yCoeff, estimator.degree + 1).c_str(),
estimator.confidence);
}
#endif
}
MVOID
MAIN_CLASS_NAME::
applyRelease(UserId_T userId)
{
NodeId_T const nodeId = userId;
sp<IAppCallback> pAppCallback;
List<MyListener> listeners;
BitSet32 nodeStatusUpdated;
NodeStatusUpdater updater(getFrameNo(), mLogLevel);
//
String8 const logTag = String8::format("frameNo:%u nodeId:%#"PRIxPTR, getFrameNo(), nodeId);
MY_LOG1("%s +", logTag.string());
//
{
RWLock::AutoWLock _lRWLock(mRWLock);
Mutex::Autolock _lMapLock(mItemMapLock);
//
// Update
MBOOL isAnyUpdate = updater.run(nodeId, mNodeStatusMap, nodeStatusUpdated);
//
// Is the entire frame released?
if ( isAnyUpdate && 0 == mNodeStatusMap.mInFlightNodeCount )
{
nodeStatusUpdated.markBit(IPipelineFrameListener::eMSG_FRAME_RELEASED);
//
mTimestampFrameDone = ::elapsedRealtimeNano();
//
#if 1
// mpPipelineNodeMap = 0;
// mpPipelineDAG = 0;
mpStreamInfoSet = 0;
#endif
MY_LOG1(
"Done frameNo:%u @ nodeId:%#"PRIxPTR" - timestamp:%"PRIu64"=%"PRIu64"-%"PRIu64,
getFrameNo(), nodeId,
(mTimestampFrameDone-mTimestampFrameCreated),
mTimestampFrameDone, mTimestampFrameCreated
);
}
//
if ( ! nodeStatusUpdated.isEmpty() ) {
listeners = mListeners;
}
//
pAppCallback = mpAppCallback.promote();
}
//
// Release (Hal) Buffers.
updater.handleResult();
//
// Callback to App.
if ( pAppCallback == 0 ) {
MY_LOGW("Caonnot promote AppCallback for frameNo:%u, userId:%#"PRIxPTR, getFrameNo(), userId);
}
else {
pAppCallback->updateFrame(getFrameNo(), userId);
}
//
// Callback to listeners if needed.
if ( ! nodeStatusUpdated.isEmpty() )
{
NSCam::Utils::CamProfile profile(__FUNCTION__, logTag.string());
//
List<MyListener>::iterator it = listeners.begin();
for (; it != listeners.end(); ++it) {
sp<MyListener::IListener> p = it->mpListener.promote();
if ( p == 0 ) {
continue;
}
//
if ( nodeStatusUpdated.hasBit(IPipelineFrameListener::eMSG_ALL_OUT_META_BUFFERS_RELEASED) ) {
MY_LOG2("%s O Meta Buffers Released", logTag.string());
p->onPipelineFrame(
getFrameNo(),
nodeId,
IPipelineFrameListener::eMSG_ALL_OUT_META_BUFFERS_RELEASED,
it->mpCookie
);
}
//
if ( nodeStatusUpdated.hasBit(IPipelineFrameListener::eMSG_ALL_OUT_IMAGE_BUFFERS_RELEASED) ) {
MY_LOG2("%s O Image Buffers Released", logTag.string());
p->onPipelineFrame(
getFrameNo(),
nodeId,
IPipelineFrameListener::eMSG_ALL_OUT_IMAGE_BUFFERS_RELEASED,
it->mpCookie
);
}
//
if ( nodeStatusUpdated.hasBit(IPipelineFrameListener::eMSG_FRAME_RELEASED) ) {
MY_LOG2("%s Frame Done", logTag.string());
p->onPipelineFrame(
getFrameNo(),
IPipelineFrameListener::eMSG_FRAME_RELEASED,
it->mpCookie
);
}
}
//
profile.print_overtime(3, "notify listeners (nodeStatusUpdated:%#x)", nodeStatusUpdated.value);
}
//
MY_LOG1("%s -", logTag.string());
}
void VelocityTrackerState::clear() {
mVelocityTracker.clear();
mActivePointerId = -1;
mCalculatedIdBits.clear();
}
void VelocityTracker::addMovement(const MotionEvent* event) {
int32_t actionMasked = event->getActionMasked();
switch (actionMasked) {
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_HOVER_ENTER:
// Clear all pointers on down before adding the new movement.
clear();
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN: {
// Start a new movement trace for a pointer that just went down.
// We do this on down instead of on up because the client may want to query the
// final velocity for a pointer that just went up.
BitSet32 downIdBits;
downIdBits.markBit(event->getPointerId(event->getActionIndex()));
clearPointers(downIdBits);
break;
}
case AMOTION_EVENT_ACTION_MOVE:
case AMOTION_EVENT_ACTION_HOVER_MOVE:
break;
default:
// Ignore all other actions because they do not convey any new information about
// pointer movement. We also want to preserve the last known velocity of the pointers.
// Note that ACTION_UP and ACTION_POINTER_UP always report the last known position
// of the pointers that went up. ACTION_POINTER_UP does include the new position of
// pointers that remained down but we will also receive an ACTION_MOVE with this
// information if any of them actually moved. Since we don't know how many pointers
// will be going up at once it makes sense to just wait for the following ACTION_MOVE
// before adding the movement.
return;
}
size_t pointerCount = event->getPointerCount();
if (pointerCount > MAX_POINTERS) {
pointerCount = MAX_POINTERS;
}
BitSet32 idBits;
for (size_t i = 0; i < pointerCount; i++) {
idBits.markBit(event->getPointerId(i));
}
uint32_t pointerIndex[MAX_POINTERS];
for (size_t i = 0; i < pointerCount; i++) {
pointerIndex[i] = idBits.getIndexOfBit(event->getPointerId(i));
}
nsecs_t eventTime;
Position positions[pointerCount];
size_t historySize = event->getHistorySize();
for (size_t h = 0; h < historySize; h++) {
eventTime = event->getHistoricalEventTime(h);
for (size_t i = 0; i < pointerCount; i++) {
uint32_t index = pointerIndex[i];
positions[index].x = event->getHistoricalX(i, h);
positions[index].y = event->getHistoricalY(i, h);
}
addMovement(eventTime, idBits, positions);
}
eventTime = event->getEventTime();
for (size_t i = 0; i < pointerCount; i++) {
uint32_t index = pointerIndex[i];
positions[index].x = event->getX(i);
positions[index].y = event->getY(i);
}
addMovement(eventTime, idBits, positions);
}
virtual void TearDown() {
b1.clear();
b2.clear();
}
