| /* |
| * Copyright (c) 2006,2007,2008, Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "platform/graphics/skia/SkiaUtils.h" |
| |
| #include "platform/graphics/GraphicsContext.h" |
| #include "third_party/skia/include/effects/SkCornerPathEffect.h" |
| |
| namespace blink { |
| |
| static const struct CompositOpToXfermodeMode { |
| CompositeOperator mCompositOp; |
| SkXfermode::Mode m_xfermodeMode; |
| } gMapCompositOpsToXfermodeModes[] = { |
| {CompositeClear, SkXfermode::kClear_Mode}, |
| {CompositeCopy, SkXfermode::kSrc_Mode}, |
| {CompositeSourceOver, SkXfermode::kSrcOver_Mode}, |
| {CompositeSourceIn, SkXfermode::kSrcIn_Mode}, |
| {CompositeSourceOut, SkXfermode::kSrcOut_Mode}, |
| {CompositeSourceAtop, SkXfermode::kSrcATop_Mode}, |
| {CompositeDestinationOver, SkXfermode::kDstOver_Mode}, |
| {CompositeDestinationIn, SkXfermode::kDstIn_Mode}, |
| {CompositeDestinationOut, SkXfermode::kDstOut_Mode}, |
| {CompositeDestinationAtop, SkXfermode::kDstATop_Mode}, |
| {CompositeXOR, SkXfermode::kXor_Mode}, |
| {CompositePlusLighter, SkXfermode::kPlus_Mode}}; |
| |
| // Keep this array in sync with the WebBlendMode enum in |
| // public/platform/WebBlendMode.h. |
| static const SkXfermode::Mode gMapBlendOpsToXfermodeModes[] = { |
| SkXfermode::kClear_Mode, // WebBlendModeNormal |
| SkXfermode::kMultiply_Mode, // WebBlendModeMultiply |
| SkXfermode::kScreen_Mode, // WebBlendModeScreen |
| SkXfermode::kOverlay_Mode, // WebBlendModeOverlay |
| SkXfermode::kDarken_Mode, // WebBlendModeDarken |
| SkXfermode::kLighten_Mode, // WebBlendModeLighten |
| SkXfermode::kColorDodge_Mode, // WebBlendModeColorDodge |
| SkXfermode::kColorBurn_Mode, // WebBlendModeColorBurn |
| SkXfermode::kHardLight_Mode, // WebBlendModeHardLight |
| SkXfermode::kSoftLight_Mode, // WebBlendModeSoftLight |
| SkXfermode::kDifference_Mode, // WebBlendModeDifference |
| SkXfermode::kExclusion_Mode, // WebBlendModeExclusion |
| SkXfermode::kHue_Mode, // WebBlendModeHue |
| SkXfermode::kSaturation_Mode, // WebBlendModeSaturation |
| SkXfermode::kColor_Mode, // WebBlendModeColor |
| SkXfermode::kLuminosity_Mode // WebBlendModeLuminosity |
| }; |
| |
| SkXfermode::Mode WebCoreCompositeToSkiaComposite(CompositeOperator op, |
| WebBlendMode blendMode) { |
| ASSERT(op == CompositeSourceOver || blendMode == WebBlendModeNormal); |
| if (blendMode != WebBlendModeNormal) { |
| if (static_cast<uint8_t>(blendMode) >= |
| SK_ARRAY_COUNT(gMapBlendOpsToXfermodeModes)) { |
| SkDEBUGF( |
| ("GraphicsContext::setPlatformCompositeOperation unknown " |
| "WebBlendMode %d\n", |
| blendMode)); |
| return SkXfermode::kSrcOver_Mode; |
| } |
| return gMapBlendOpsToXfermodeModes[static_cast<uint8_t>(blendMode)]; |
| } |
| |
| const CompositOpToXfermodeMode* table = gMapCompositOpsToXfermodeModes; |
| if (static_cast<uint8_t>(op) >= |
| SK_ARRAY_COUNT(gMapCompositOpsToXfermodeModes)) { |
| SkDEBUGF( |
| ("GraphicsContext::setPlatformCompositeOperation unknown " |
| "CompositeOperator %d\n", |
| op)); |
| return SkXfermode::kSrcOver_Mode; |
| } |
| SkASSERT(table[static_cast<uint8_t>(op)].mCompositOp == op); |
| return table[static_cast<uint8_t>(op)].m_xfermodeMode; |
| } |
| |
| CompositeOperator compositeOperatorFromSkia(SkXfermode::Mode xferMode) { |
| switch (xferMode) { |
| case SkXfermode::kClear_Mode: |
| return CompositeClear; |
| case SkXfermode::kSrc_Mode: |
| return CompositeCopy; |
| case SkXfermode::kSrcOver_Mode: |
| return CompositeSourceOver; |
| case SkXfermode::kSrcIn_Mode: |
| return CompositeSourceIn; |
| case SkXfermode::kSrcOut_Mode: |
| return CompositeSourceOut; |
| case SkXfermode::kSrcATop_Mode: |
| return CompositeSourceAtop; |
| case SkXfermode::kDstOver_Mode: |
| return CompositeDestinationOver; |
| case SkXfermode::kDstIn_Mode: |
| return CompositeDestinationIn; |
| case SkXfermode::kDstOut_Mode: |
| return CompositeDestinationOut; |
| case SkXfermode::kDstATop_Mode: |
| return CompositeDestinationAtop; |
| case SkXfermode::kXor_Mode: |
| return CompositeXOR; |
| case SkXfermode::kPlus_Mode: |
| return CompositePlusLighter; |
| default: |
| break; |
| } |
| return CompositeSourceOver; |
| } |
| |
| WebBlendMode blendModeFromSkia(SkXfermode::Mode xferMode) { |
| switch (xferMode) { |
| case SkXfermode::kSrcOver_Mode: |
| return WebBlendModeNormal; |
| case SkXfermode::kMultiply_Mode: |
| return WebBlendModeMultiply; |
| case SkXfermode::kScreen_Mode: |
| return WebBlendModeScreen; |
| case SkXfermode::kOverlay_Mode: |
| return WebBlendModeOverlay; |
| case SkXfermode::kDarken_Mode: |
| return WebBlendModeDarken; |
| case SkXfermode::kLighten_Mode: |
| return WebBlendModeLighten; |
| case SkXfermode::kColorDodge_Mode: |
| return WebBlendModeColorDodge; |
| case SkXfermode::kColorBurn_Mode: |
| return WebBlendModeColorBurn; |
| case SkXfermode::kHardLight_Mode: |
| return WebBlendModeHardLight; |
| case SkXfermode::kSoftLight_Mode: |
| return WebBlendModeSoftLight; |
| case SkXfermode::kDifference_Mode: |
| return WebBlendModeDifference; |
| case SkXfermode::kExclusion_Mode: |
| return WebBlendModeExclusion; |
| case SkXfermode::kHue_Mode: |
| return WebBlendModeHue; |
| case SkXfermode::kSaturation_Mode: |
| return WebBlendModeSaturation; |
| case SkXfermode::kColor_Mode: |
| return WebBlendModeColor; |
| case SkXfermode::kLuminosity_Mode: |
| return WebBlendModeLuminosity; |
| default: |
| break; |
| } |
| return WebBlendModeNormal; |
| } |
| |
| SkMatrix affineTransformToSkMatrix(const AffineTransform& source) { |
| SkMatrix result; |
| |
| result.setScaleX(WebCoreDoubleToSkScalar(source.a())); |
| result.setSkewX(WebCoreDoubleToSkScalar(source.c())); |
| result.setTranslateX(WebCoreDoubleToSkScalar(source.e())); |
| |
| result.setScaleY(WebCoreDoubleToSkScalar(source.d())); |
| result.setSkewY(WebCoreDoubleToSkScalar(source.b())); |
| result.setTranslateY(WebCoreDoubleToSkScalar(source.f())); |
| |
| // FIXME: Set perspective properly. |
| result.setPerspX(0); |
| result.setPerspY(0); |
| result.set(SkMatrix::kMPersp2, SK_Scalar1); |
| |
| return result; |
| } |
| |
| bool nearlyIntegral(float value) { |
| return fabs(value - floorf(value)) < std::numeric_limits<float>::epsilon(); |
| } |
| |
| InterpolationQuality limitInterpolationQuality( |
| const GraphicsContext& context, |
| InterpolationQuality resampling) { |
| return std::min(resampling, context.imageInterpolationQuality()); |
| } |
| |
| InterpolationQuality computeInterpolationQuality(float srcWidth, |
| float srcHeight, |
| float destWidth, |
| float destHeight, |
| bool isDataComplete) { |
| // The percent change below which we will not resample. This usually means |
| // an off-by-one error on the web page, and just doing nearest neighbor |
| // sampling is usually good enough. |
| const float kFractionalChangeThreshold = 0.025f; |
| |
| // Images smaller than this in either direction are considered "small" and |
| // are not resampled ever (see below). |
| const int kSmallImageSizeThreshold = 8; |
| |
| // The amount an image can be stretched in a single direction before we |
| // say that it is being stretched so much that it must be a line or |
| // background that doesn't need resampling. |
| const float kLargeStretch = 3.0f; |
| |
| // Figure out if we should resample this image. We try to prune out some |
| // common cases where resampling won't give us anything, since it is much |
| // slower than drawing stretched. |
| float diffWidth = fabs(destWidth - srcWidth); |
| float diffHeight = fabs(destHeight - srcHeight); |
| bool widthNearlyEqual = diffWidth < std::numeric_limits<float>::epsilon(); |
| bool heightNearlyEqual = diffHeight < std::numeric_limits<float>::epsilon(); |
| // We don't need to resample if the source and destination are the same. |
| if (widthNearlyEqual && heightNearlyEqual) |
| return InterpolationNone; |
| |
| if (srcWidth <= kSmallImageSizeThreshold || |
| srcHeight <= kSmallImageSizeThreshold || |
| destWidth <= kSmallImageSizeThreshold || |
| destHeight <= kSmallImageSizeThreshold) { |
| // Small image detected. |
| |
| // Resample in the case where the new size would be non-integral. |
| // This can cause noticeable breaks in repeating patterns, except |
| // when the source image is only one pixel wide in that dimension. |
| if ((!nearlyIntegral(destWidth) && |
| srcWidth > 1 + std::numeric_limits<float>::epsilon()) || |
| (!nearlyIntegral(destHeight) && |
| srcHeight > 1 + std::numeric_limits<float>::epsilon())) |
| return InterpolationLow; |
| |
| // Otherwise, don't resample small images. These are often used for |
| // borders and rules (think 1x1 images used to make lines). |
| return InterpolationNone; |
| } |
| |
| if (srcHeight * kLargeStretch <= destHeight || |
| srcWidth * kLargeStretch <= destWidth) { |
| // Large image detected. |
| |
| // Don't resample if it is being stretched a lot in only one direction. |
| // This is trying to catch cases where somebody has created a border |
| // (which might be large) and then is stretching it to fill some part |
| // of the page. |
| if (widthNearlyEqual || heightNearlyEqual) |
| return InterpolationNone; |
| |
| // The image is growing a lot and in more than one direction. Resampling |
| // is slow and doesn't give us very much when growing a lot. |
| return InterpolationLow; |
| } |
| |
| if ((diffWidth / srcWidth < kFractionalChangeThreshold) && |
| (diffHeight / srcHeight < kFractionalChangeThreshold)) { |
| // It is disappointingly common on the web for image sizes to be off by |
| // one or two pixels. We don't bother resampling if the size difference |
| // is a small fraction of the original size. |
| return InterpolationNone; |
| } |
| |
| // When the image is not yet done loading, use linear. We don't cache the |
| // partially resampled images, and as they come in incrementally, it causes |
| // us to have to resample the whole thing every time. |
| if (!isDataComplete) |
| return InterpolationLow; |
| |
| // Everything else gets resampled at high quality. |
| return InterpolationHigh; |
| } |
| |
| int clampedAlphaForBlending(float alpha) { |
| if (alpha < 0) |
| return 0; |
| int roundedAlpha = roundf(alpha * 256); |
| if (roundedAlpha > 256) |
| roundedAlpha = 256; |
| return roundedAlpha; |
| } |
| |
| SkColor scaleAlpha(SkColor color, float alpha) { |
| return scaleAlpha(color, clampedAlphaForBlending(alpha)); |
| } |
| |
| SkColor scaleAlpha(SkColor color, int alpha) { |
| int a = (SkColorGetA(color) * alpha) >> 8; |
| return (color & 0x00FFFFFF) | (a << 24); |
| } |
| |
| template <typename PrimitiveType> |
| void drawFocusRingPrimitive(const PrimitiveType&, |
| SkCanvas*, |
| const SkPaint&, |
| float cornerRadius) { |
| ASSERT_NOT_REACHED(); // Missing an explicit specialization? |
| } |
| |
| template <> |
| void drawFocusRingPrimitive<SkRect>(const SkRect& rect, |
| SkCanvas* canvas, |
| const SkPaint& paint, |
| float cornerRadius) { |
| SkRRect rrect; |
| rrect.setRectXY(rect, SkFloatToScalar(cornerRadius), |
| SkFloatToScalar(cornerRadius)); |
| canvas->drawRRect(rrect, paint); |
| } |
| |
| template <> |
| void drawFocusRingPrimitive<SkPath>(const SkPath& path, |
| SkCanvas* canvas, |
| const SkPaint& paint, |
| float cornerRadius) { |
| SkPaint pathPaint = paint; |
| pathPaint.setPathEffect( |
| SkCornerPathEffect::Make(SkFloatToScalar(cornerRadius))); |
| canvas->drawPath(path, pathPaint); |
| } |
| |
| template <typename PrimitiveType> |
| void drawPlatformFocusRing(const PrimitiveType& primitive, |
| SkCanvas* canvas, |
| SkColor color, |
| int width) { |
| SkPaint paint; |
| paint.setAntiAlias(true); |
| paint.setStyle(SkPaint::kStroke_Style); |
| paint.setColor(color); |
| paint.setStrokeWidth(GraphicsContext::focusRingWidth(width)); |
| |
| #if OS(MACOSX) |
| paint.setAlpha(64); |
| const float cornerRadius = (width - 1) * 0.5f; |
| #else |
| const float cornerRadius = 1; |
| #endif |
| |
| drawFocusRingPrimitive(primitive, canvas, paint, cornerRadius); |
| |
| #if OS(MACOSX) |
| // Inner part |
| paint.setAlpha(128); |
| paint.setStrokeWidth(paint.getStrokeWidth() * 0.5f); |
| drawFocusRingPrimitive(primitive, canvas, paint, cornerRadius); |
| #endif |
| } |
| |
| template void PLATFORM_EXPORT drawPlatformFocusRing<SkRect>(const SkRect&, |
| SkCanvas*, |
| SkColor, |
| int width); |
| template void PLATFORM_EXPORT drawPlatformFocusRing<SkPath>(const SkPath&, |
| SkCanvas*, |
| SkColor, |
| int width); |
| |
| } // namespace blink |
