From 7cf12ddb8c1c2cf7a0eec63439148cc6b2bc104a Mon Sep 17 00:00:00 2001 From: herb Date: Mon, 11 Jan 2016 08:08:56 -0800 Subject: Fix radii calculation code to handle large radii. BUG=472147 GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1569403002 Review URL: https://codereview.chromium.org/1569403002 --- src/core/SkScaleToSides.h | 61 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/core/SkScaleToSides.h (limited to 'src/core/SkScaleToSides.h') diff --git a/src/core/SkScaleToSides.h b/src/core/SkScaleToSides.h new file mode 100644 index 0000000000..77637a3ac2 --- /dev/null +++ b/src/core/SkScaleToSides.h @@ -0,0 +1,61 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkScaleToSides_DEFINED +#define SkScaleToSides_DEFINED + +#include +#include "SkScalar.h" +#include "SkTypes.h" + +class ScaleToSides { +public: + // This code assumes that a and b fit in in a float, and therefore the resulting smaller value + // of a and b will fit in a float. The side of the rectangle may be larger than a float. + // Scale must be less than or equal to the ratio limit / (*a + *b). + // This code assumes that NaN and Inf are never passed in. + static void AdjustRadii(double limit, double scale, SkScalar* a, SkScalar* b) { + SkASSERTF(scale < 1.0 && scale > 0.0, "scale: %g", scale); + + *a = (float)((double)*a * scale); + *b = (float)((double)*b * scale); + + // This check is conservative. (double)*a + (double)*b >= (double)(*a + *b) + if ((double)*a + (double)*b > limit) { + float* minRadius = a; + float* maxRadius = b; + + // Force minRadius to be the smaller of the two. + if (*minRadius > *maxRadius) { + SkTSwap(minRadius, maxRadius); + } + + // newMinRadius must be float in order to give the actual value of the radius. + // The newMinRadius will always be smaller than limit. The largest that minRadius can be + // is 1/2 the ratio of minRadius : (minRadius + maxRadius), therefore in the resulting + // division, minRadius can be no larger than 1/2 limit + ULP. + float newMinRadius = *minRadius; + + // Because newMaxRadius is the result of a double to float conversion, it can be larger + // than limit, but only by one ULP. + float newMaxRadius = (float)(limit - newMinRadius); + + // If newMaxRadius forces the total over the limit, then it needs to be + // reduced by one ULP to be less than limit - newMinRadius. + // Note: nexttowardf is a c99 call and should be std::nexttoward, but this is not + // implemented in the ARM compiler. + if ((double)newMaxRadius + (double)newMinRadius > limit) { + newMaxRadius = nexttowardf(newMaxRadius, 0.0); + } + *maxRadius = newMaxRadius; + } + + SkASSERTF(*a >= 0.0f && *b >= 0.0f, "a: %g, b: %g", *a, *b); + SkASSERTF((*a + *b) <= limit, "limit: %g, a: %g, b: %g", limit, *a, *b); + } +}; +#endif // ScaleToSides_DEFINED -- cgit v1.2.3