ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues 7 Pull Requests Releases Wiki Activity

am f17fdcaf: Merge changes I9f3cbbe0,I12a6f9a9 into jb-dev

Browse Source 
* commit 'f17fdcaf0a315b02a3992fb4c52d5d4e38f5d291':
  Fix "Battery/Status/Clock status bar area flickers when dragging down"
  minor refactoring in praparation of crop fix
This commit is contained in:
Mathias Agopian 2012-05-16 19:33:13 -07:00 committed by Android Git Automerger
commit 35fb5e3638
3 changed files with 85 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
services/surfaceflinger/Layer.cpp
View File

@ -232,27 +232,28 @@ Rect Layer::computeBufferCrop() const {
// ... then reduce that in the same proportions as the window crop reduces
// the window size.
const State& s(drawingState());
if (!s.crop.isEmpty()) {
if (!s.active.crop.isEmpty()) {
// Transform the window crop to match the buffer coordinate system,
// which means using the inverse of the current transform set on the
// SurfaceTexture.
uint32_t invTransform = mCurrentTransform;
int winWidth = s.w;
int winHeight = s.h;
int winWidth = s.active.w;
int winHeight = s.active.h;
if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
NATIVE_WINDOW_TRANSFORM_FLIP_H;
winWidth = s.h;
winHeight = s.w;
winWidth = s.active.h;
winHeight = s.active.w;
}
Rect winCrop = s.crop.transform(invTransform, s.w, s.h);
Rect winCrop = s.active.crop.transform(invTransform,
s.active.w, s.active.h);
float xScale = float(crop.width()) / float(winWidth);
float yScale = float(crop.height()) / float(winHeight);
crop.left += int(ceil(float(winCrop.left) * xScale));
crop.top += int(ceil(float(winCrop.top) * yScale));
crop.right -= int(ceil(float(winWidth - winCrop.right) * xScale));
crop.bottom -= int(ceil(float(winHeight - winCrop.bottom) * yScale));
crop.left += int(ceilf(float(winCrop.left) * xScale));
crop.top += int(ceilf(float(winCrop.top) * yScale));
crop.right -= int(ceilf(float(winWidth - winCrop.right) * xScale));
crop.bottom -= int(ceilf(float(winHeight - winCrop.bottom) * yScale));
}
return crop;
@ -427,32 +428,44 @@ uint32_t Layer::doTransaction(uint32_t flags)
const Layer::State& front(drawingState());
const Layer::State& temp(currentState());
const bool sizeChanged = (front.requested_w != temp.requested_w) ||
(front.requested_h != temp.requested_h);
const bool sizeChanged = (front.requested.w != temp.requested.w) ||
(front.requested.h != temp.requested.h);
if (sizeChanged) {
// the size changed, we need to ask our client to request a new buffer
ALOGD_IF(DEBUG_RESIZE,
"doTransaction: "
"resize (layer=%p), requested (%dx%d), drawing (%d,%d), "
"geometry (layer=%p), size: current (%dx%d), drawing (%dx%d), "
"crop: current (%d,%d,%d,%d [%dx%d]), drawing (%d,%d,%d,%d [%dx%d]), "
"scalingMode=%d",
this,
int(temp.requested_w), int(temp.requested_h),
int(front.requested_w), int(front.requested_h),
int(temp.requested.w), int(temp.requested.h),
int(front.requested.w), int(front.requested.h),
temp.requested.crop.left,
temp.requested.crop.top,
temp.requested.crop.right,
temp.requested.crop.bottom,
temp.requested.crop.getWidth(),
temp.requested.crop.getHeight(),
front.requested.crop.left,
front.requested.crop.top,
front.requested.crop.right,
front.requested.crop.bottom,
front.requested.crop.getWidth(),
front.requested.crop.getHeight(),
mCurrentScalingMode);
if (!isFixedSize()) {
// this will make sure LayerBase::doTransaction doesn't update
// the drawing state's size
// the drawing state's geometry
Layer::State& editDraw(mDrawingState);
editDraw.requested_w = temp.requested_w;
editDraw.requested_h = temp.requested_h;
editDraw.requested = temp.requested;
}
// record the new size, form this point on, when the client request
// a buffer, it'll get the new size.
mSurfaceTexture->setDefaultBufferSize(temp.requested_w,
temp.requested_h);
mSurfaceTexture->setDefaultBufferSize(
temp.requested.w, temp.requested.h);
}
return LayerBase::doTransaction(flags);
@ -551,11 +564,9 @@ void Layer::lockPageFlip(bool& recomputeVisibleRegions)
const Layer::State& front(drawingState());
// FIXME: mPostedDirtyRegion = dirty & bounds
mPostedDirtyRegion.set(front.w, front.h);
mPostedDirtyRegion.set(front.active.w, front.active.h);
if ((front.w != front.requested_w) ||
(front.h != front.requested_h))
{
if (front.active != front.requested) {
// check that we received a buffer of the right size
// (Take the buffer's orientation into account)
if (mCurrentTransform & Transform::ROT_90) {
@ -563,15 +574,14 @@ void Layer::lockPageFlip(bool& recomputeVisibleRegions)
}
if (isFixedSize() ||
(bufWidth == front.requested_w &&
bufHeight == front.requested_h))
(bufWidth == front.requested.w &&
bufHeight == front.requested.h))
{
// Here we pretend the transaction happened by updating the
// current and drawing states. Drawing state is only accessed
// in this thread, no need to have it locked
Layer::State& editDraw(mDrawingState);
editDraw.w = editDraw.requested_w;
editDraw.h = editDraw.requested_h;
editDraw.active = editDraw.requested;
// We also need to update the current state so that we don't
// end-up doing too much work during the next transaction.
@ -579,8 +589,7 @@ void Layer::lockPageFlip(bool& recomputeVisibleRegions)
// because State::w and State::h are only accessed from
// this thread
Layer::State& editTemp(currentState());
editTemp.w = editDraw.w;
editTemp.h = editDraw.h;
editTemp.active = editDraw.active;
// recompute visible region
recomputeVisibleRegions = true;
@ -592,7 +601,7 @@ void Layer::lockPageFlip(bool& recomputeVisibleRegions)
"requested (%dx%d)",
this,
bufWidth, bufHeight, mCurrentTransform,
front.requested_w, front.requested_h);
front.requested.w, front.requested.h);
}
}
}

63
services/surfaceflinger/LayerBase.cpp
View File

@ -84,16 +84,15 @@ void LayerBase::initStates(uint32_t w, uint32_t h, uint32_t flags)
if (flags & ISurfaceComposer::eNonPremultiplied)
mPremultipliedAlpha = false;
mCurrentState.z = 0;
mCurrentState.w = w;
mCurrentState.h = h;
mCurrentState.requested_w = w;
mCurrentState.requested_h = h;
mCurrentState.alpha = 0xFF;
mCurrentState.flags = layerFlags;
mCurrentState.sequence = 0;
mCurrentState.active.w = w;
mCurrentState.active.h = h;
mCurrentState.active.crop.makeInvalid();
mCurrentState.z = 0;
mCurrentState.alpha = 0xFF;
mCurrentState.flags = layerFlags;
mCurrentState.sequence = 0;
mCurrentState.transform.set(0, 0);
mCurrentState.crop.makeInvalid();
mCurrentState.requested = mCurrentState.active;
// drawing state & current state are identical
mDrawingState = mCurrentState;
@ -136,10 +135,10 @@ bool LayerBase::setLayer(uint32_t z) {
return true;
}
bool LayerBase::setSize(uint32_t w, uint32_t h) {
if (mCurrentState.requested_w == w && mCurrentState.requested_h == h)
if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)
return false;
mCurrentState.requested_w = w;
mCurrentState.requested_h = h;
mCurrentState.requested.w = w;
mCurrentState.requested.h = h;
requestTransaction();
return true;
}
@ -174,10 +173,10 @@ bool LayerBase::setFlags(uint8_t flags, uint8_t mask) {
return true;
}
bool LayerBase::setCrop(const Rect& crop) {
if (mCurrentState.crop == crop)
if (mCurrentState.requested.crop == crop)
return false;
mCurrentState.sequence++;
mCurrentState.crop = crop;
mCurrentState.requested.crop = crop;
requestTransaction();
return true;
}
@ -202,15 +201,13 @@ uint32_t LayerBase::doTransaction(uint32_t flags)
const Layer::State& front(drawingState());
const Layer::State& temp(currentState());
if ((front.requested_w != temp.requested_w) ||
(front.requested_h != temp.requested_h)) {
// resize the layer, set the physical size to the requested size
if (front.requested != temp.requested) {
// geometry of the layer has changed, set the active geometry
// to the requested geometry.
Layer::State& editTemp(currentState());
editTemp.w = temp.requested_w;
editTemp.h = temp.requested_h;
editTemp.active = temp.requested;
}
if ((front.w != temp.w) || (front.h != temp.h)) {
if (front.active != temp.active) {
// invalidate and recompute the visible regions if needed
flags |= Layer::eVisibleRegion;
}
@ -238,9 +235,9 @@ void LayerBase::validateVisibility(const Transform& planeTransform)
const bool transformed = tr.transformed();
const DisplayHardware& hw(graphicPlane(0).displayHardware());
const uint32_t hw_h = hw.getHeight();
const Rect& crop(s.crop);
const Rect& crop(s.active.crop);
Rect win(s.w, s.h);
Rect win(s.active.w, s.active.h);
if (!crop.isEmpty()) {
win.intersect(crop, &win);
}
@ -403,14 +400,14 @@ void LayerBase::drawWithOpenGL(const Region& clip) const
GLfloat v;
};
Rect crop(s.w, s.h);
if (!s.crop.isEmpty()) {
crop = s.crop;
Rect crop(s.active.w, s.active.h);
if (!s.active.crop.isEmpty()) {
crop = s.active.crop;
}
GLfloat left = GLfloat(crop.left) / GLfloat(s.w);
GLfloat top = GLfloat(crop.top) / GLfloat(s.h);
GLfloat right = GLfloat(crop.right) / GLfloat(s.w);
GLfloat bottom = GLfloat(crop.bottom) / GLfloat(s.h);
GLfloat left = GLfloat(crop.left) / GLfloat(s.active.w);
GLfloat top = GLfloat(crop.top) / GLfloat(s.active.h);
GLfloat right = GLfloat(crop.right) / GLfloat(s.active.w);
GLfloat bottom = GLfloat(crop.bottom) / GLfloat(s.active.h);
TexCoords texCoords[4];
texCoords[0].u = left;
@ -449,10 +446,12 @@ void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const
snprintf(buffer, SIZE,
" "
"z=%9d, pos=(%g,%g), size=(%4d,%4d), "
"z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), "
"isOpaque=%1d, needsDithering=%1d, invalidate=%1d, "
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
s.z, s.transform.tx(), s.transform.ty(), s.w, s.h,
s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h,
s.active.crop.left, s.active.crop.top,
s.active.crop.right, s.active.crop.bottom,
isOpaque(), needsDithering(), contentDirty,
s.alpha, s.flags,
s.transform[0][0], s.transform[0][1],

20
services/surfaceflinger/LayerBase.h
View File

@ -65,20 +65,28 @@ public:
Region coveredRegionScreen;
int32_t sequence;
struct Geometry {
uint32_t w;
uint32_t h;
Rect crop;
inline bool operator == (const Geometry& rhs) const {
return (w==rhs.w && h==rhs.h && crop==rhs.crop);
}
inline bool operator != (const Geometry& rhs) const {
return !operator == (rhs);
}
};
struct State {
uint32_t w;
uint32_t h;
uint32_t requested_w;
uint32_t requested_h;
Geometry active;
Geometry requested;
uint32_t z;
uint8_t alpha;
uint8_t flags;
uint8_t reserved[2];
int32_t sequence; // changes when visible regions can change
uint32_t tint;
Transform transform;
Region transparentRegion;
Rect crop;
};
virtual void setName(const String8& name);