LCOV - app.info - gfx/skia/src/core/SkRasterClip.cpp

LCOV - code coverage report
| Current view: | directory - gfx/skia/src/core - SkRasterClip.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 154 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 27 | 0 | 0.0 %

           1                 : /*
           2                 :  * Copyright 2010 Google Inc.
           3                 :  *
           4                 :  * Use of this source code is governed by a BSD-style license that can be
           5                 :  * found in the LICENSE file.
           6                 :  */
           7                 :
           8                 : #include "SkRasterClip.h"
           9                 :
          10                 :
          11               0 : SkRasterClip::SkRasterClip() {
          12               0 :     fIsBW = true;
          13               0 : }
          14                 :
          15               0 : SkRasterClip::SkRasterClip(const SkRasterClip& src) {
          16               0 :     AUTO_RASTERCLIP_VALIDATE(src);
          17                 :
          18               0 :     fIsBW = src.fIsBW;
          19               0 :     if (fIsBW) {
          20               0 :         fBW = src.fBW;
          21                 :     } else {
          22               0 :         fAA = src.fAA;
          23                 :     }
          24               0 : }
          25                 :
          26               0 : SkRasterClip::SkRasterClip(const SkIRect& bounds) : fBW(bounds) {
          27               0 :     fIsBW = true;
          28               0 : }
          29                 :
          30               0 : SkRasterClip::~SkRasterClip() {
          31               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
          32               0 : }
          33                 :
          34               0 : bool SkRasterClip::isEmpty() const {
          35               0 :     return fIsBW ? fBW.isEmpty() : fAA.isEmpty();
          36                 : }
          37                 :
          38               0 : bool SkRasterClip::isRect() const {
          39               0 :     return fIsBW ? fBW.isRect() : false;
          40                 : }
          41                 :
          42               0 : bool SkRasterClip::isComplex() const {
          43               0 :     return fIsBW ? fBW.isComplex() : !fAA.isEmpty();
          44                 : }
          45                 :
          46               0 : const SkIRect& SkRasterClip::getBounds() const {
          47               0 :     return fIsBW ? fBW.getBounds() : fAA.getBounds();
          48                 : }
          49                 :
          50               0 : bool SkRasterClip::setEmpty() {
          51               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
          52                 :
          53               0 :     fIsBW = true;
          54               0 :     fBW.setEmpty();
          55               0 :     fAA.setEmpty();
          56               0 :     return false;
          57                 : }
          58                 :
          59               0 : bool SkRasterClip::setRect(const SkIRect& rect) {
          60               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
          61                 :
          62               0 :     fIsBW = true;
          63               0 :     fAA.setEmpty();
          64               0 :     return fBW.setRect(rect);
          65                 : }
          66                 :
          67               0 : bool SkRasterClip::setPath(const SkPath& path, const SkRegion& clip, bool doAA) {
          68               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
          69                 :
          70               0 :     if (this->isBW() && !doAA) {
          71               0 :         return fBW.setPath(path, clip);
          72                 :     } else {
          73               0 :         if (this->isBW()) {
          74               0 :             this->convertToAA();
          75                 :         }
          76               0 :         return fAA.setPath(path, &clip, doAA);
          77                 :     }
          78                 : }
          79                 :
          80               0 : bool SkRasterClip::setPath(const SkPath& path, const SkIRect& clip, bool doAA) {
          81               0 :     SkRegion tmp;
          82               0 :     tmp.setRect(clip);
          83               0 :     return this->setPath(path, tmp, doAA);
          84                 : }
          85                 :
          86               0 : bool SkRasterClip::setPath(const SkPath& path, const SkRasterClip& clip,
          87                 :                            bool doAA) {
          88               0 :     if (clip.isBW()) {
          89               0 :         return this->setPath(path, clip.bwRgn(), doAA);
          90                 :     } else {
          91               0 :         SkRegion tmp;
          92               0 :         tmp.setRect(clip.getBounds());
          93               0 :         if (!this->setPath(path, clip, doAA)) {
          94               0 :             return false;
          95                 :         }
          96               0 :         return this->op(clip, SkRegion::kIntersect_Op);
          97                 :     }
          98                 : }
          99                 :
         100               0 : bool SkRasterClip::op(const SkIRect& rect, SkRegion::Op op) {
         101               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         102                 :
         103               0 :     return fIsBW ? fBW.op(rect, op) : fAA.op(rect, op);
         104                 : }
         105                 :
         106               0 : bool SkRasterClip::op(const SkRegion& rgn, SkRegion::Op op) {
         107               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         108                 :
         109               0 :     if (fIsBW) {
         110               0 :         return fBW.op(rgn, op);
         111                 :     } else {
         112               0 :         SkAAClip tmp;
         113               0 :         tmp.setRegion(rgn);
         114               0 :         return fAA.op(tmp, op);
         115                 :     }
         116                 : }
         117                 :
         118               0 : bool SkRasterClip::op(const SkRasterClip& clip, SkRegion::Op op) {
         119               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         120               0 :     clip.validate();
         121                 :
         122               0 :     if (this->isBW() && clip.isBW()) {
         123               0 :         return fBW.op(clip.fBW, op);
         124                 :     } else {
         125               0 :         SkAAClip tmp;
         126                 :         const SkAAClip* other;
         127                 :
         128               0 :         if (this->isBW()) {
         129               0 :             this->convertToAA();
         130                 :         }
         131               0 :         if (clip.isBW()) {
         132               0 :             tmp.setRegion(clip.bwRgn());
         133               0 :             other = &tmp;
         134                 :         } else {
         135               0 :             other = &clip.aaRgn();
         136                 :         }
         137               0 :         return fAA.op(*other, op);
         138                 :     }
         139                 : }
         140                 :
         141                 : // return true if x is nearly integral (within 1/16) since that is the highest
         142                 : // precision our aa code can have.
         143               0 : static bool is_integral(SkScalar x) {
         144               0 :     int ix = SkScalarRoundToInt(x);
         145               0 :     SkScalar sx = SkIntToScalar(ix);
         146               0 :     return SkScalarAbs(sx - x) < (SK_Scalar1 / 16);
         147                 : }
         148                 :
         149               0 : bool SkRasterClip::op(const SkRect& r, SkRegion::Op op, bool doAA) {
         150               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         151                 :
         152               0 :     if (doAA) {
         153                 :         // check that the rect really needs aa
         154               0 :         if (is_integral(r.fLeft) && is_integral(r.fTop) &&
         155               0 :             is_integral(r.fRight) && is_integral(r.fBottom)) {
         156               0 :             doAA = false;
         157                 :         }
         158                 :     }
         159                 :
         160               0 :     if (fIsBW && !doAA) {
         161                 :         SkIRect ir;
         162               0 :         r.round(&ir);
         163               0 :         return fBW.op(ir, op);
         164                 :     } else {
         165               0 :         if (fIsBW) {
         166               0 :             this->convertToAA();
         167                 :         }
         168               0 :         return fAA.op(r, op, doAA);
         169                 :     }
         170                 : }
         171                 :
         172               0 : void SkRasterClip::translate(int dx, int dy, SkRasterClip* dst) const {
         173               0 :     if (NULL == dst) {
         174               0 :         return;
         175                 :     }
         176                 :
         177               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         178                 :
         179               0 :     if (this->isEmpty()) {
         180               0 :         dst->setEmpty();
         181                 :         return;
         182                 :     }
         183               0 :     if (0 == (dx | dy)) {
         184               0 :         *dst = *this;
         185                 :         return;
         186                 :     }
         187                 :
         188               0 :     dst->fIsBW = fIsBW;
         189               0 :     if (fIsBW) {
         190               0 :         fBW.translate(dx, dy, &dst->fBW);
         191               0 :         dst->fAA.setEmpty();
         192                 :     } else {
         193               0 :         fAA.translate(dx, dy, &dst->fAA);
         194               0 :         dst->fBW.setEmpty();
         195                 :     }
         196                 : }
         197                 :
         198               0 : bool SkRasterClip::quickContains(const SkIRect& ir) const {
         199               0 :     return fIsBW ? fBW.quickContains(ir) : fAA.quickContains(ir);
         200                 : }
         201                 :
         202                 : ///////////////////////////////////////////////////////////////////////////////
         203                 :
         204               0 : const SkRegion& SkRasterClip::forceGetBW() {
         205               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         206                 :
         207               0 :     if (!fIsBW) {
         208               0 :         fBW.setRect(fAA.getBounds());
         209                 :     }
         210               0 :     return fBW;
         211                 : }
         212                 :
         213               0 : void SkRasterClip::convertToAA() {
         214               0 :     AUTO_RASTERCLIP_VALIDATE(*this);
         215                 :
         216               0 :     SkASSERT(fIsBW);
         217               0 :     fAA.setRegion(fBW);
         218               0 :     fIsBW = false;
         219               0 : }
         220                 :
         221                 : #ifdef SK_DEBUG
         222               0 : void SkRasterClip::validate() const {
         223                 :     // can't ever assert that fBW is empty, since we may have called forceGetBW
         224               0 :     if (fIsBW) {
         225               0 :         SkASSERT(fAA.isEmpty());
         226                 :     }
         227                 :
         228               0 :     fBW.validate();
         229               0 :     fAA.validate();
         230               0 : }
         231                 : #endif
         232                 :
         233                 : ///////////////////////////////////////////////////////////////////////////////
         234                 :
         235               0 : SkAAClipBlitterWrapper::SkAAClipBlitterWrapper() {
         236               0 :     SkDEBUGCODE(fClipRgn = NULL;)
         237               0 :     SkDEBUGCODE(fBlitter = NULL;)
         238               0 : }
         239                 :
         240               0 : SkAAClipBlitterWrapper::SkAAClipBlitterWrapper(const SkRasterClip& clip,
         241               0 :                                                SkBlitter* blitter) {
         242               0 :     this->init(clip, blitter);
         243               0 : }
         244                 :
         245               0 : SkAAClipBlitterWrapper::SkAAClipBlitterWrapper(const SkAAClip* aaclip,
         246               0 :                                                SkBlitter* blitter) {
         247               0 :     SkASSERT(blitter);
         248               0 :     SkASSERT(aaclip);
         249               0 :     fBWRgn.setRect(aaclip->getBounds());
         250               0 :     fAABlitter.init(blitter, aaclip);
         251                 :     // now our return values
         252               0 :     fClipRgn = &fBWRgn;
         253               0 :     fBlitter = &fAABlitter;
         254               0 : }
         255                 :
         256               0 : void SkAAClipBlitterWrapper::init(const SkRasterClip& clip, SkBlitter* blitter) {
         257               0 :     SkASSERT(blitter);
         258               0 :     if (clip.isBW()) {
         259               0 :         fClipRgn = &clip.bwRgn();
         260               0 :         fBlitter = blitter;
         261                 :     } else {
         262               0 :         const SkAAClip& aaclip = clip.aaRgn();
         263               0 :         fBWRgn.setRect(aaclip.getBounds());
         264               0 :         fAABlitter.init(blitter, &aaclip);
         265                 :         // now our return values
         266               0 :         fClipRgn = &fBWRgn;
         267               0 :         fBlitter = &fAABlitter;
         268                 :     }
         269               0 : }
         270                 :

Generated by: LCOV version 1.7