Home | History | Annotate | Download | only in skia 
      1 /*
      2  * Copyright (c) 2012, Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include "config.h"
     32 
     33 #include "platform/graphics/skia/OpaqueRegionSkia.h"
     34 
     35 #include "platform/graphics/GraphicsContext.h"
     36 
     37 #include "SkColorFilter.h"
     38 #include "SkShader.h"
     39 
     40 namespace WebCore {
     41 
     42 OpaqueRegionSkia::OpaqueRegionSkia()
     43     : m_opaqueRect(SkRect::MakeEmpty())
     44 {
     45 }
     46 
     47 IntRect OpaqueRegionSkia::asRect() const
     48 {
     49     // Returns the largest enclosed rect.
     50     // TODO: actually, this logic looks like its returning the smallest.
     51     //       to return largest, shouldn't we take floor of left/top
     52     //       and the ceil of right/bottom?
     53     int left = SkScalarCeilToInt(m_opaqueRect.fLeft);
     54     int top = SkScalarCeilToInt(m_opaqueRect.fTop);
     55     int right = SkScalarFloorToInt(m_opaqueRect.fRight);
     56     int bottom = SkScalarFloorToInt(m_opaqueRect.fBottom);
     57     return IntRect(left, top, right-left, bottom-top);
     58 }
     59 
     60 // Returns true if the xfermode will force the dst to be opaque, regardless of the current dst.
     61 static inline bool xfermodeIsOpaque(const SkPaint& paint, bool srcIsOpaque)
     62 {
     63     if (!srcIsOpaque)
     64         return false;
     65 
     66     SkXfermode* xfermode = paint.getXfermode();
     67     if (!xfermode)
     68         return true; // default to kSrcOver_Mode
     69     SkXfermode::Mode mode;
     70     if (!xfermode->asMode(&mode))
     71         return false;
     72 
     73     switch (mode) {
     74     case SkXfermode::kSrc_Mode: // source
     75     case SkXfermode::kSrcOver_Mode: // source + dest - source*dest
     76     case SkXfermode::kDstOver_Mode: // source + dest - source*dest
     77     case SkXfermode::kDstATop_Mode: // source
     78     case SkXfermode::kPlus_Mode: // source+dest
     79     default: // the rest are all source + dest - source*dest
     80         return true;
     81     case SkXfermode::kClear_Mode: // 0
     82     case SkXfermode::kDst_Mode: // dest
     83     case SkXfermode::kSrcIn_Mode: // source * dest
     84     case SkXfermode::kDstIn_Mode: // dest * source
     85     case SkXfermode::kSrcOut_Mode: // source * (1-dest)
     86     case SkXfermode::kDstOut_Mode: // dest * (1-source)
     87     case SkXfermode::kSrcATop_Mode: // dest
     88     case SkXfermode::kXor_Mode: // source + dest - 2*(source*dest)
     89         return false;
     90     }
     91 }
     92 
     93 // Returns true if the xfermode will keep the dst opaque, assuming the dst is already opaque.
     94 static inline bool xfermodePreservesOpaque(const SkPaint& paint, bool srcIsOpaque)
     95 {
     96     SkXfermode* xfermode = paint.getXfermode();
     97     if (!xfermode)
     98         return true; // default to kSrcOver_Mode
     99     SkXfermode::Mode mode;
    100     if (!xfermode->asMode(&mode))
    101         return false;
    102 
    103     switch (mode) {
    104     case SkXfermode::kDst_Mode: // dest
    105     case SkXfermode::kSrcOver_Mode: // source + dest - source*dest
    106     case SkXfermode::kDstOver_Mode: // source + dest - source*dest
    107     case SkXfermode::kSrcATop_Mode: // dest
    108     case SkXfermode::kPlus_Mode: // source+dest
    109     default: // the rest are all source + dest - source*dest
    110         return true;
    111     case SkXfermode::kClear_Mode: // 0
    112     case SkXfermode::kSrcOut_Mode: // source * (1-dest)
    113     case SkXfermode::kDstOut_Mode: // dest * (1-source)
    114     case SkXfermode::kXor_Mode: // source + dest - 2*(source*dest)
    115         return false;
    116     case SkXfermode::kSrc_Mode: // source
    117     case SkXfermode::kSrcIn_Mode: // source * dest
    118     case SkXfermode::kDstIn_Mode: // dest * source
    119     case SkXfermode::kDstATop_Mode: // source
    120         return srcIsOpaque;
    121     }
    122 }
    123 
    124 // Returns true if all pixels painted will be opaque.
    125 static inline bool paintIsOpaque(const SkPaint& paint, OpaqueRegionSkia::DrawType drawType, const SkBitmap* bitmap)
    126 {
    127     if (paint.getAlpha() < 0xFF)
    128         return false;
    129     bool checkFillOnly = drawType != OpaqueRegionSkia::FillOrStroke;
    130     if (!checkFillOnly && paint.getStyle() != SkPaint::kFill_Style && paint.isAntiAlias())
    131         return false;
    132     SkShader* shader = paint.getShader();
    133     if (shader && !shader->isOpaque())
    134         return false;
    135     if (bitmap && !bitmap->isOpaque())
    136         return false;
    137     if (paint.getLooper())
    138         return false;
    139     if (paint.getImageFilter())
    140         return false;
    141     if (paint.getMaskFilter())
    142         return false;
    143     SkColorFilter* colorFilter = paint.getColorFilter();
    144     if (colorFilter && !(colorFilter->getFlags() & SkColorFilter::kAlphaUnchanged_Flag))
    145         return false;
    146     return true;
    147 }
    148 
    149 // Returns true if there is a rectangular clip, with the result in |deviceClipRect|.
    150 static inline bool getDeviceClipAsRect(const GraphicsContext* context, SkRect& deviceClipRect)
    151 {
    152     // Get the current clip in device coordinate space.
    153     if (!context->canvas()->isClipRect())
    154         return false;
    155 
    156     SkIRect deviceClipIRect;
    157     if (context->canvas()->getClipDeviceBounds(&deviceClipIRect))
    158         deviceClipRect.set(deviceClipIRect);
    159     else
    160         deviceClipRect.setEmpty();
    161 
    162     return true;
    163 }
    164 
    165 void OpaqueRegionSkia::pushCanvasLayer(const SkPaint* paint)
    166 {
    167     CanvasLayerState state;
    168     if (paint)
    169         state.paint = *paint;
    170     m_canvasLayerStack.append(state);
    171 }
    172 
    173 void OpaqueRegionSkia::popCanvasLayer(const GraphicsContext* context)
    174 {
    175     ASSERT(!context->paintingDisabled());
    176     ASSERT(!m_canvasLayerStack.isEmpty());
    177     if (m_canvasLayerStack.isEmpty())
    178         return;
    179 
    180     const CanvasLayerState& canvasLayer = m_canvasLayerStack.last();
    181     SkRect layerOpaqueRect = canvasLayer.opaqueRect;
    182     SkPaint layerPaint = canvasLayer.paint;
    183 
    184     // Apply the image mask.
    185     if (canvasLayer.hasImageMask && !layerOpaqueRect.intersect(canvasLayer.imageOpaqueRect))
    186         layerOpaqueRect.setEmpty();
    187 
    188     m_canvasLayerStack.removeLast();
    189 
    190     applyOpaqueRegionFromLayer(context, layerOpaqueRect, layerPaint);
    191 }
    192 
    193 void OpaqueRegionSkia::setImageMask(const SkRect& imageOpaqueRect)
    194 {
    195     ASSERT(!m_canvasLayerStack.isEmpty());
    196     m_canvasLayerStack.last().hasImageMask = true;
    197     m_canvasLayerStack.last().imageOpaqueRect = imageOpaqueRect;
    198 }
    199 
    200 void OpaqueRegionSkia::didDrawRect(const GraphicsContext* context, const SkRect& fillRect, const SkPaint& paint, const SkBitmap* sourceBitmap)
    201 {
    202     ASSERT(!context->paintingDisabled());
    203     // Any stroking may put alpha in pixels even if the filling part does not.
    204     if (paint.getStyle() != SkPaint::kFill_Style) {
    205         bool fillsBounds = false;
    206 
    207         if (!paint.canComputeFastBounds())
    208             didDrawUnbounded(context, paint, FillOrStroke);
    209         else {
    210             SkRect strokeRect;
    211             strokeRect = paint.computeFastBounds(fillRect, &strokeRect);
    212             didDraw(context, strokeRect, paint, sourceBitmap, fillsBounds, FillOrStroke);
    213         }
    214     }
    215 
    216     bool fillsBounds = paint.getStyle() != SkPaint::kStroke_Style;
    217     didDraw(context, fillRect, paint, sourceBitmap, fillsBounds, FillOnly);
    218 }
    219 
    220 void OpaqueRegionSkia::didDrawPath(const GraphicsContext* context, const SkPath& path, const SkPaint& paint)
    221 {
    222     ASSERT(!context->paintingDisabled());
    223     SkRect rect;
    224     if (path.isRect(&rect)) {
    225         didDrawRect(context, rect, paint, 0);
    226         return;
    227     }
    228 
    229     bool fillsBounds = false;
    230 
    231     if (!paint.canComputeFastBounds())
    232         didDrawUnbounded(context, paint, FillOrStroke);
    233     else {
    234         rect = paint.computeFastBounds(path.getBounds(), &rect);
    235         didDraw(context, rect, paint, 0, fillsBounds, FillOrStroke);
    236     }
    237 }
    238 
    239 void OpaqueRegionSkia::didDrawPoints(const GraphicsContext* context, SkCanvas::PointMode mode, int numPoints, const SkPoint points[], const SkPaint& paint)
    240 {
    241     ASSERT(!context->paintingDisabled());
    242     if (!numPoints)
    243         return;
    244 
    245     SkRect rect;
    246     rect.fLeft = points[0].fX;
    247     rect.fRight = points[0].fX + 1;
    248     rect.fTop = points[0].fY;
    249     rect.fBottom = points[0].fY + 1;
    250 
    251     for (int i = 1; i < numPoints; ++i) {
    252         rect.fLeft = std::min(rect.fLeft, points[i].fX);
    253         rect.fRight = std::max(rect.fRight, points[i].fX + 1);
    254         rect.fTop = std::min(rect.fTop, points[i].fY);
    255         rect.fBottom = std::max(rect.fBottom, points[i].fY + 1);
    256     }
    257 
    258     bool fillsBounds = false;
    259 
    260     if (!paint.canComputeFastBounds())
    261         didDrawUnbounded(context, paint, FillOrStroke);
    262     else {
    263         rect = paint.computeFastBounds(rect, &rect);
    264         didDraw(context, rect, paint, 0, fillsBounds, FillOrStroke);
    265     }
    266 }
    267 
    268 void OpaqueRegionSkia::didDrawBounded(const GraphicsContext* context, const SkRect& bounds, const SkPaint& paint)
    269 {
    270     ASSERT(!context->paintingDisabled());
    271     bool fillsBounds = false;
    272 
    273     if (!paint.canComputeFastBounds())
    274         didDrawUnbounded(context, paint, FillOrStroke);
    275     else {
    276         SkRect rect;
    277         rect = paint.computeFastBounds(bounds, &rect);
    278         didDraw(context, rect, paint, 0, fillsBounds, FillOrStroke);
    279     }
    280 }
    281 
    282 void OpaqueRegionSkia::didDraw(const GraphicsContext* context, const SkRect& rect, const SkPaint& paint, const SkBitmap* sourceBitmap, bool fillsBounds, DrawType drawType)
    283 {
    284     ASSERT(!context->paintingDisabled());
    285     SkRect targetRect = rect;
    286 
    287     // Apply the transform to device coordinate space.
    288     SkMatrix canvasTransform = context->canvas()->getTotalMatrix();
    289     if (!canvasTransform.mapRect(&targetRect))
    290         fillsBounds = false;
    291 
    292     // Apply the current clip.
    293     SkRect deviceClipRect;
    294     if (!getDeviceClipAsRect(context, deviceClipRect))
    295         fillsBounds = false;
    296     else if (!targetRect.intersect(deviceClipRect))
    297         return;
    298 
    299     bool drawsOpaque = paintIsOpaque(paint, drawType, sourceBitmap);
    300     bool xfersOpaque = xfermodeIsOpaque(paint, drawsOpaque);
    301     bool preservesOpaque = xfermodePreservesOpaque(paint, drawsOpaque);
    302 
    303     if (fillsBounds && xfersOpaque)
    304         markRectAsOpaque(targetRect);
    305     else if (!preservesOpaque)
    306         markRectAsNonOpaque(targetRect);
    307 }
    308 
    309 void OpaqueRegionSkia::didDrawUnbounded(const GraphicsContext* context, const SkPaint& paint, DrawType drawType)
    310 {
    311     ASSERT(!context->paintingDisabled());
    312     bool drawsOpaque = paintIsOpaque(paint, drawType, 0);
    313     bool preservesOpaque = xfermodePreservesOpaque(paint, drawsOpaque);
    314 
    315     if (preservesOpaque)
    316         return;
    317 
    318     SkRect deviceClipRect;
    319     getDeviceClipAsRect(context, deviceClipRect);
    320     markRectAsNonOpaque(deviceClipRect);
    321 }
    322 
    323 void OpaqueRegionSkia::applyOpaqueRegionFromLayer(const GraphicsContext* context, const SkRect& layerOpaqueRect, const SkPaint& paint)
    324 {
    325     SkRect deviceClipRect;
    326     bool deviceClipIsARect = getDeviceClipAsRect(context, deviceClipRect);
    327 
    328     if (deviceClipRect.isEmpty())
    329         return;
    330 
    331     SkRect sourceOpaqueRect = layerOpaqueRect;
    332     // Save the opaque area in the destination, so we can preserve the parts of it under the source opaque area if possible.
    333     SkRect destinationOpaqueRect = currentTrackingOpaqueRect();
    334 
    335     bool outsideSourceOpaqueRectPreservesOpaque = xfermodePreservesOpaque(paint, false);
    336     if (!outsideSourceOpaqueRectPreservesOpaque)
    337         markRectAsNonOpaque(deviceClipRect);
    338 
    339     if (!deviceClipIsARect)
    340         return;
    341     if (!sourceOpaqueRect.intersect(deviceClipRect))
    342         return;
    343 
    344     bool sourceOpaqueRectDrawsOpaque = paintIsOpaque(paint, FillOnly, 0);
    345     bool sourceOpaqueRectXfersOpaque = xfermodeIsOpaque(paint, sourceOpaqueRectDrawsOpaque);
    346     bool sourceOpaqueRectPreservesOpaque = xfermodePreservesOpaque(paint, sourceOpaqueRectDrawsOpaque);
    347 
    348     // If the layer's opaque area is being drawn opaque in the layer below, then mark it opaque. Otherwise,
    349     // if it preserves opaque then keep the intersection of the two.
    350     if (sourceOpaqueRectXfersOpaque)
    351         markRectAsOpaque(sourceOpaqueRect);
    352     else if (sourceOpaqueRectPreservesOpaque && sourceOpaqueRect.intersect(destinationOpaqueRect))
    353         markRectAsOpaque(sourceOpaqueRect);
    354 }
    355 
    356 void OpaqueRegionSkia::markRectAsOpaque(const SkRect& rect)
    357 {
    358     // We want to keep track of an opaque region but bound its complexity at a constant size.
    359     // We keep track of the largest rectangle seen by area. If we can add the new rect to this
    360     // rectangle then we do that, as that is the cheapest way to increase the area returned
    361     // without increasing the complexity.
    362 
    363     SkRect& opaqueRect = currentTrackingOpaqueRect();
    364 
    365     if (rect.isEmpty())
    366         return;
    367     if (opaqueRect.contains(rect))
    368         return;
    369     if (rect.contains(opaqueRect)) {
    370         opaqueRect = rect;
    371         return;
    372     }
    373 
    374     if (rect.fTop <= opaqueRect.fTop && rect.fBottom >= opaqueRect.fBottom) {
    375         if (rect.fLeft < opaqueRect.fLeft && rect.fRight >= opaqueRect.fLeft)
    376             opaqueRect.fLeft = rect.fLeft;
    377         if (rect.fRight > opaqueRect.fRight && rect.fLeft <= opaqueRect.fRight)
    378             opaqueRect.fRight = rect.fRight;
    379     } else if (rect.fLeft <= opaqueRect.fLeft && rect.fRight >= opaqueRect.fRight) {
    380         if (rect.fTop < opaqueRect.fTop && rect.fBottom >= opaqueRect.fTop)
    381             opaqueRect.fTop = rect.fTop;
    382         if (rect.fBottom > opaqueRect.fBottom && rect.fTop <= opaqueRect.fBottom)
    383             opaqueRect.fBottom = rect.fBottom;
    384     }
    385 
    386     long opaqueArea = (long)opaqueRect.width() * (long)opaqueRect.height();
    387     long area = (long)rect.width() * (long)rect.height();
    388     if (area > opaqueArea)
    389         opaqueRect = rect;
    390 }
    391 
    392 void OpaqueRegionSkia::markRectAsNonOpaque(const SkRect& rect)
    393 {
    394     // We want to keep as much of the current opaque rectangle as we can, so find the one largest
    395     // rectangle inside m_opaqueRect that does not intersect with |rect|.
    396 
    397     SkRect& opaqueRect = currentTrackingOpaqueRect();
    398 
    399     if (!SkRect::Intersects(rect, opaqueRect))
    400         return;
    401     if (rect.contains(opaqueRect)) {
    402         markAllAsNonOpaque();
    403         return;
    404     }
    405 
    406     int deltaLeft = rect.fLeft - opaqueRect.fLeft;
    407     int deltaRight = opaqueRect.fRight - rect.fRight;
    408     int deltaTop = rect.fTop - opaqueRect.fTop;
    409     int deltaBottom = opaqueRect.fBottom - rect.fBottom;
    410 
    411     // horizontal is the larger of the two rectangles to the left or to the right of |rect| and inside opaqueRect.
    412     // vertical is the larger of the two rectangles above or below |rect| and inside opaqueRect.
    413     SkRect horizontal = opaqueRect;
    414     if (deltaTop > deltaBottom)
    415         horizontal.fBottom = rect.fTop;
    416     else
    417         horizontal.fTop = rect.fBottom;
    418     SkRect vertical = opaqueRect;
    419     if (deltaLeft > deltaRight)
    420         vertical.fRight = rect.fLeft;
    421     else
    422         vertical.fLeft = rect.fRight;
    423 
    424     if ((long)horizontal.width() * (long)horizontal.height() > (long)vertical.width() * (long)vertical.height())
    425         opaqueRect = horizontal;
    426     else
    427         opaqueRect = vertical;
    428 }
    429 
    430 void OpaqueRegionSkia::markAllAsNonOpaque()
    431 {
    432     SkRect& opaqueRect = currentTrackingOpaqueRect();
    433     opaqueRect.setEmpty();
    434 }
    435 
    436 SkRect& OpaqueRegionSkia::currentTrackingOpaqueRect()
    437 {
    438     // If we are drawing into a canvas layer, then track the opaque rect in that layer.
    439     return m_canvasLayerStack.isEmpty() ? m_opaqueRect : m_canvasLayerStack.last().opaqueRect;
    440 }
    441 
    442 } // namespace WebCore
    443