SF: Switch computeBounds to return FloatRect
Switches Layer::computeBounds to return a FloatRect instead of a Rect.
During the computation of the bounds, we apply the layer transformation
to its nominal dimensions, clip it against its bounds (which are either
its parents bounds or the screen bounds), and apply the inverse of the
layer transformation.
Previously, the intermediate position (after transformation/clip, but
before inverse transformation) was stored as Rect, which is to say that
it was truncated to integer coordinates. After applying the inverse
transformation, this loss of precision can cause glitches where a layer
that should be clipped against, e.g., the side of the screen no longer
creates a watertight seal against that side.
In order to fix this, we now store the intermediate value as a FloatRect
and propagate float precision back through computeBounds. The callers of
computeBounds tend to then immediately apply the transform again, at
which point it is safe to round back to integer.
Bug: 64070729
Bug: 66431327
Bug: 69935057
Test: Modified android.view.cts.SurfaceViewSyncTest#
testSurfaceViewBigScale no longer produces bogus display frames
Change-Id: If5987ca4ad76657f9670a5f59258f896180352e2
diff --git a/libs/ui/include/ui/FloatRect.h b/libs/ui/include/ui/FloatRect.h
index 270675c..6a7479a 100644
--- a/libs/ui/include/ui/FloatRect.h
+++ b/libs/ui/include/ui/FloatRect.h
@@ -27,6 +27,17 @@
float getWidth() const { return right - left; }
float getHeight() const { return bottom - top; }
+ FloatRect intersect(const FloatRect& other) const {
+ return {
+ // Inline to avoid tromping on other min/max defines or adding a
+ // dependency on STL
+ (left > other.left) ? left : other.left,
+ (top > other.top) ? top : other.top,
+ (right < other.right) ? right : other.right,
+ (bottom < other.bottom) ? bottom : other.bottom
+ };
+ }
+
float left = 0.0f;
float top = 0.0f;
float right = 0.0f;
diff --git a/libs/ui/include/ui/Rect.h b/libs/ui/include/ui/Rect.h
index 437fc14..0bec0b7 100644
--- a/libs/ui/include/ui/Rect.h
+++ b/libs/ui/include/ui/Rect.h
@@ -69,6 +69,15 @@
bottom = rb.y;
}
+ inline explicit Rect(const FloatRect& floatRect) {
+ // Ideally we would use std::round, but we don't want to add an STL
+ // dependency here, so we use an approximation
+ left = static_cast<int32_t>(floatRect.left + 0.5f);
+ top = static_cast<int32_t>(floatRect.top + 0.5f);
+ right = static_cast<int32_t>(floatRect.right + 0.5f);
+ bottom = static_cast<int32_t>(floatRect.bottom + 0.5f);
+ }
+
void makeInvalid();
inline void clear() {
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp
index b52bef3..f16e1ba 100644
--- a/services/surfaceflinger/BufferLayer.cpp
+++ b/services/surfaceflinger/BufferLayer.cpp
@@ -787,16 +787,17 @@
* minimal value)? Or, we could make GL behave like HWC -- but this feel
* like more of a hack.
*/
- Rect win(computeBounds());
+ const Rect bounds{computeBounds()}; // Rounds from FloatRect
Transform t = getTransform();
+ Rect win = bounds;
if (!s.finalCrop.isEmpty()) {
win = t.transform(win);
if (!win.intersect(s.finalCrop, &win)) {
win.clear();
}
win = t.inverse().transform(win);
- if (!win.intersect(computeBounds(), &win)) {
+ if (!win.intersect(bounds, &win)) {
win.clear();
}
}
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 13df1e2..a5d0c3a 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -285,6 +285,14 @@
return Region(win).subtract(exclude).getBounds();
}
+static FloatRect reduce(const FloatRect& win, const Region& exclude) {
+ if (CC_LIKELY(exclude.isEmpty())) {
+ return win;
+ }
+ // Convert through Rect (by rounding) for lack of FloatRegion
+ return Region(Rect{win}).subtract(exclude).getBounds().toFloatRect();
+}
+
Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const {
const Layer::State& s(getDrawingState());
Rect win(s.active.w, s.active.h);
@@ -323,12 +331,12 @@
return win;
}
-Rect Layer::computeBounds() const {
+FloatRect Layer::computeBounds() const {
const Layer::State& s(getDrawingState());
return computeBounds(s.activeTransparentRegion);
}
-Rect Layer::computeBounds(const Region& activeTransparentRegion) const {
+FloatRect Layer::computeBounds(const Region& activeTransparentRegion) const {
const Layer::State& s(getDrawingState());
Rect win(s.active.w, s.active.h);
@@ -345,14 +353,16 @@
}
Transform t = getTransform();
+
+ FloatRect floatWin = win.toFloatRect();
if (p != nullptr) {
- win = t.transform(win);
- win.intersect(bounds, &win);
- win = t.inverse().transform(win);
+ floatWin = t.transform(floatWin);
+ floatWin = floatWin.intersect(bounds.toFloatRect());
+ floatWin = t.inverse().transform(floatWin);
}
// subtract the transparent region and snap to the bounds
- return reduce(win, activeTransparentRegion);
+ return reduce(floatWin, activeTransparentRegion);
}
Rect Layer::computeInitialCrop(const sp<const DisplayDevice>& hw) const {
@@ -528,7 +538,9 @@
Rect(activeCrop.right, activeCrop.top, s.active.w, activeCrop.bottom));
}
- Rect frame(t.transform(computeBounds(activeTransparentRegion)));
+ // computeBounds returns a FloatRect to provide more accuracy during the
+ // transformation. We then round upon constructing 'frame'.
+ Rect frame{t.transform(computeBounds(activeTransparentRegion))};
if (!s.finalCrop.isEmpty()) {
if (!frame.intersect(s.finalCrop, &frame)) {
frame.clear();
@@ -807,7 +819,7 @@
const Layer::State& s(getDrawingState());
const Transform renderAreaTransform(renderArea.getTransform());
const uint32_t height = renderArea.getHeight();
- Rect win = computeBounds();
+ FloatRect win = computeBounds();
vec2 lt = vec2(win.left, win.top);
vec2 lb = vec2(win.left, win.bottom);
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index cf7fc50..e44ccf8 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -24,6 +24,7 @@
#include <utils/String8.h>
#include <utils/Timers.h>
+#include <ui/FloatRect.h>
#include <ui/FrameStats.h>
#include <ui/GraphicBuffer.h>
#include <ui/PixelFormat.h>
@@ -303,8 +304,8 @@
}
void computeGeometry(const RenderArea& renderArea, Mesh& mesh, bool useIdentityTransform) const;
- Rect computeBounds(const Region& activeTransparentRegion) const;
- Rect computeBounds() const;
+ FloatRect computeBounds(const Region& activeTransparentRegion) const;
+ FloatRect computeBounds() const;
int32_t getSequence() const { return sequence; }
diff --git a/services/surfaceflinger/Transform.cpp b/services/surfaceflinger/Transform.cpp
index 37925a1..e05ed53 100644
--- a/services/surfaceflinger/Transform.cpp
+++ b/services/surfaceflinger/Transform.cpp
@@ -224,6 +224,27 @@
return r;
}
+FloatRect Transform::transform(const FloatRect& bounds) const
+{
+ vec2 lt(bounds.left, bounds.top);
+ vec2 rt(bounds.right, bounds.top);
+ vec2 lb(bounds.left, bounds.bottom);
+ vec2 rb(bounds.right, bounds.bottom);
+
+ lt = transform(lt);
+ rt = transform(rt);
+ lb = transform(lb);
+ rb = transform(rb);
+
+ FloatRect r;
+ r.left = min(lt[0], rt[0], lb[0], rb[0]);
+ r.top = min(lt[1], rt[1], lb[1], rb[1]);
+ r.right = max(lt[0], rt[0], lb[0], rb[0]);
+ r.bottom = max(lt[1], rt[1], lb[1], rb[1]);
+
+ return r;
+}
+
Region Transform::transform(const Region& reg) const
{
Region out;
diff --git a/services/surfaceflinger/Transform.h b/services/surfaceflinger/Transform.h
index bfc66ec..b11d057 100644
--- a/services/surfaceflinger/Transform.h
+++ b/services/surfaceflinger/Transform.h
@@ -84,6 +84,7 @@
Region transform(const Region& reg) const;
Rect transform(const Rect& bounds,
bool roundOutwards = false) const;
+ FloatRect transform(const FloatRect& bounds) const;
Transform operator * (const Transform& rhs) const;
// assumes the last row is < 0 , 0 , 1 >
vec2 transform(const vec2& v) const;