Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "textureview_readback"

Browse Source 
* changes:
  Improve integer aligned coordinate detection
  Improve logic when to use filtering in readback and TextureView
This commit is contained in:
Treehugger Robot
2019-09-27 17:36:31 +00:00
committed by Gerrit Code Review
parent f2a739d5f0 819698bb99
commit fc733e1d5e
1 changed files with 50 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
libs/hwui/pipeline/skia/LayerDrawable.cpp
View File

@@ -33,21 +33,51 @@ void LayerDrawable::onDraw(SkCanvas* canvas) {
}
}
// This is a less-strict matrix.isTranslate() that will still report being translate-only
// on imperceptibly small scaleX & scaleY values.
static bool isBasicallyTranslate(const SkMatrix& matrix) {
if (!matrix.isScaleTranslate()) return false;
return MathUtils::isOne(matrix.getScaleX()) && MathUtils::isOne(matrix.getScaleY());
static inline SkScalar isIntegerAligned(SkScalar x) {
return fabsf(roundf(x) - x) <= NON_ZERO_EPSILON;
}
static bool shouldFilter(const SkMatrix& matrix) {
if (!matrix.isScaleTranslate()) return true;
// We only care about meaningful scale here
bool noScale = MathUtils::isOne(matrix.getScaleX()) && MathUtils::isOne(matrix.getScaleY());
bool pixelAligned =
SkScalarIsInt(matrix.getTranslateX()) && SkScalarIsInt(matrix.getTranslateY());
return !(noScale && pixelAligned);
// Disable filtering when there is no scaling in screen coordinates and the corners have the same
// fraction (for translate) or zero fraction (for any other rect-to-rect transform).
static bool shouldFilterRect(const SkMatrix& matrix, const SkRect& srcRect, const SkRect& dstRect) {
if (!matrix.rectStaysRect()) return true;
SkRect dstDevRect = matrix.mapRect(dstRect);
float dstW, dstH;
bool requiresIntegerTranslate = false;
if (MathUtils::isZero(matrix.getScaleX()) && MathUtils::isZero(matrix.getScaleY())) {
// Has a 90 or 270 degree rotation, although total matrix may also have scale factors
// in m10 and m01. Those scalings are automatically handled by mapRect so comparing
// dimensions is sufficient, but swap width and height comparison.
dstW = dstDevRect.height();
dstH = dstDevRect.width();
requiresIntegerTranslate = true;
} else {
// Handle H/V flips or 180 rotation matrices. Axes may have been mirrored, but
// dimensions are still safe to compare directly.
dstW = dstDevRect.width();
dstH = dstDevRect.height();
requiresIntegerTranslate =
matrix.getScaleX() < -NON_ZERO_EPSILON || matrix.getScaleY() < -NON_ZERO_EPSILON;
}
if (!(MathUtils::areEqual(dstW, srcRect.width()) &&
MathUtils::areEqual(dstH, srcRect.height()))) {
return true;
}
if (requiresIntegerTranslate) {
// Device rect and source rect should be integer aligned to ensure there's no difference
// in how nearest-neighbor sampling is resolved.
return !(isIntegerAligned(srcRect.x()) &&
isIntegerAligned(srcRect.y()) &&
isIntegerAligned(dstDevRect.x()) &&
isIntegerAligned(dstDevRect.y()));
} else {
// As long as src and device rects are translated by the same fractional amount,
// filtering won't be needed
return !(MathUtils::areEqual(SkScalarFraction(srcRect.x()),
SkScalarFraction(dstDevRect.x())) &&
MathUtils::areEqual(SkScalarFraction(srcRect.y()),
SkScalarFraction(dstDevRect.y())));
}
}
bool LayerDrawable::DrawLayer(GrContext* context, SkCanvas* canvas, Layer* layer,
@@ -114,24 +144,21 @@ bool LayerDrawable::DrawLayer(GrContext* context, SkCanvas* canvas, Layer* layer
skiaDestRect = SkRect::MakeIWH(layerWidth, layerHeight);
}
matrixInv.mapRect(&skiaDestRect);
// If (matrix is identity or an integer translation) and (src/dst buffers size match),
// If (matrix is a rect-to-rect transform)
// and (src/dst buffers size match in screen coordinates)
// and (src/dst corners align fractionally),
// then use nearest neighbor, otherwise use bilerp sampling.
// Integer translation is defined as when src rect and dst rect align fractionally.
// Skia TextureOp has the above logic build-in, but not NonAAFillRectOp. TextureOp works
// only for SrcOver blending and without color filter (readback uses Src blending).
bool isIntegerTranslate =
isBasicallyTranslate(totalMatrix) &&
SkScalarFraction(skiaDestRect.fLeft + totalMatrix[SkMatrix::kMTransX]) ==
SkScalarFraction(skiaSrcRect.fLeft) &&
SkScalarFraction(skiaDestRect.fTop + totalMatrix[SkMatrix::kMTransY]) ==
SkScalarFraction(skiaSrcRect.fTop);
if (layer->getForceFilter() || !isIntegerTranslate) {
if (layer->getForceFilter() ||
shouldFilterRect(totalMatrix, skiaSrcRect, skiaDestRect)) {
paint.setFilterQuality(kLow_SkFilterQuality);
}
canvas->drawImageRect(layerImage.get(), skiaSrcRect, skiaDestRect, &paint,
SkCanvas::kFast_SrcRectConstraint);
} else {
if (layer->getForceFilter() || shouldFilter(totalMatrix)) {
SkRect imageRect = SkRect::MakeIWH(layerImage->width(), layerImage->height());
if (layer->getForceFilter() || shouldFilterRect(totalMatrix, imageRect, imageRect)) {
paint.setFilterQuality(kLow_SkFilterQuality);
}
canvas->drawImage(layerImage.get(), 0, 0, &paint);