LCOV - code coverage report
Current view: directory - gfx/skia/src/effects - SkColorFilters.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 285 9 3.2 %
Date: 2012-06-02 Functions: 86 2 2.3 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       4                 :  *
       5                 :  * Use of this source code is governed by a BSD-style license that can be
       6                 :  * found in the LICENSE file.
       7                 :  */
       8                 : 
       9                 : 
      10                 : #include "SkBlitRow.h"
      11                 : #include "SkColorFilter.h"
      12                 : #include "SkColorPriv.h"
      13                 : #include "SkUtils.h"
      14                 : 
      15                 : #define ILLEGAL_XFERMODE_MODE   ((SkXfermode::Mode)-1)
      16                 : 
      17                 : // baseclass for filters that store a color and mode
      18               0 : class SkModeColorFilter : public SkColorFilter {
      19                 : public:
      20                 :     SkModeColorFilter(SkColor color) {
      21                 :         fColor = color;
      22                 :         fMode = ILLEGAL_XFERMODE_MODE;
      23                 : 
      24                 :         fPMColor = SkPreMultiplyColor(fColor);
      25                 :     }
      26                 : 
      27               0 :     SkModeColorFilter(SkColor color, SkXfermode::Mode mode) {
      28               0 :         fColor = color;
      29               0 :         fMode = mode;
      30                 : 
      31               0 :         fPMColor = SkPreMultiplyColor(fColor);
      32               0 :     };
      33                 : 
      34               0 :     virtual bool asColorMode(SkColor* color, SkXfermode::Mode* mode) {
      35               0 :         if (ILLEGAL_XFERMODE_MODE == fMode) {
      36               0 :             return false;
      37                 :         }
      38                 : 
      39               0 :         if (color) {
      40               0 :             *color = fColor;
      41                 :         }
      42               0 :         if (mode) {
      43               0 :             *mode = fMode;
      44                 :         }
      45               0 :         return true;
      46                 :     }
      47                 : 
      48                 :     SkColor getColor() const { return fColor; }
      49                 :     SkXfermode::Mode getMode() const { return fMode; }
      50                 :     bool isModeValid() const { return ILLEGAL_XFERMODE_MODE != fMode; }
      51                 : 
      52                 : protected:
      53               0 :     virtual void flatten(SkFlattenableWriteBuffer& buffer) {
      54               0 :         this->INHERITED::flatten(buffer);
      55               0 :         buffer.write32(fColor);
      56               0 :         buffer.write32(fMode);
      57               0 :     }
      58                 : 
      59               0 :     SkModeColorFilter(SkFlattenableReadBuffer& buffer) {
      60               0 :         fColor = buffer.readU32();
      61               0 :         fMode = (SkXfermode::Mode)buffer.readU32();
      62                 : 
      63               0 :         fPMColor = SkPreMultiplyColor(fColor);
      64               0 :     }
      65                 : 
      66                 :     // cache of fColor in premultiply space
      67                 :     SkPMColor   fPMColor;
      68                 : 
      69                 : private:
      70                 :     SkColor             fColor;
      71                 :     SkXfermode::Mode    fMode;
      72                 : 
      73                 :     typedef SkColorFilter INHERITED;
      74                 : };
      75                 : 
      76               0 : class Src_SkModeColorFilter : public SkModeColorFilter {
      77                 : public:
      78               0 :     Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}
      79                 : 
      80               0 :     virtual uint32_t getFlags() {
      81               0 :         if (SkGetPackedA32(fPMColor) == 0xFF) {
      82               0 :             return kAlphaUnchanged_Flag | kHasFilter16_Flag;
      83                 :         } else {
      84               0 :             return 0;
      85                 :         }
      86                 :     }
      87                 : 
      88               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
      89                 :                             SkPMColor result[]) {
      90               0 :         sk_memset32(result, fPMColor, count);
      91               0 :     }
      92                 : 
      93               0 :     virtual void filterSpan16(const uint16_t shader[], int count,
      94                 :                               uint16_t result[]) {
      95               0 :         SkASSERT(this->getFlags() & kHasFilter16_Flag);
      96               0 :         sk_memset16(result, SkPixel32ToPixel16(fPMColor), count);
      97               0 :     }
      98                 : 
      99               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     100               0 :         return SkNEW_ARGS(Src_SkModeColorFilter, (buffer));
     101                 :     }
     102                 : 
     103                 : protected:
     104               0 :     virtual Factory getFactory() { return CreateProc; }
     105                 : 
     106               0 :     Src_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
     107               0 :         : INHERITED(buffer) {}
     108                 : 
     109                 : private:
     110                 :     typedef SkModeColorFilter INHERITED;
     111                 : };
     112                 : 
     113               0 : class SrcOver_SkModeColorFilter : public SkModeColorFilter {
     114                 : public:
     115               0 :     SrcOver_SkModeColorFilter(SkColor color)
     116               0 :             : INHERITED(color, SkXfermode::kSrcOver_Mode) {
     117               0 :         fColor32Proc = NULL;
     118               0 :     }
     119                 : 
     120               0 :     virtual uint32_t getFlags() {
     121               0 :         if (SkGetPackedA32(fPMColor) == 0xFF) {
     122               0 :             return kAlphaUnchanged_Flag | kHasFilter16_Flag;
     123                 :         } else {
     124               0 :             return 0;
     125                 :         }
     126                 :     }
     127                 : 
     128               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
     129                 :                             SkPMColor result[]) {
     130               0 :         if (NULL == fColor32Proc) {
     131               0 :             fColor32Proc = SkBlitRow::ColorProcFactory();
     132                 :         }
     133               0 :         fColor32Proc(result, shader, count, fPMColor);
     134               0 :     }
     135                 : 
     136               0 :     virtual void filterSpan16(const uint16_t shader[], int count,
     137                 :                               uint16_t result[]) {
     138               0 :         SkASSERT(this->getFlags() & kHasFilter16_Flag);
     139               0 :         sk_memset16(result, SkPixel32ToPixel16(fPMColor), count);
     140               0 :     }
     141                 : 
     142               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     143               0 :         return SkNEW_ARGS(SrcOver_SkModeColorFilter, (buffer));
     144                 :     }
     145                 : 
     146                 : protected:
     147               0 :     virtual Factory getFactory() { return CreateProc;  }
     148                 : 
     149               0 :     SrcOver_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
     150               0 :         : INHERITED(buffer), fColor32Proc(NULL) {}
     151                 : 
     152                 : private:
     153                 : 
     154                 :     SkBlitRow::ColorProc fColor32Proc;
     155                 : 
     156                 :     typedef SkModeColorFilter INHERITED;
     157                 : };
     158                 : 
     159                 : ///////////////////////////////////////////////////////////////////////////////
     160                 : 
     161               0 : class Proc_SkModeColorFilter : public SkModeColorFilter {
     162                 : public:
     163               0 :     Proc_SkModeColorFilter(SkColor color, SkXfermode::Mode mode) : INHERITED(color, mode) {
     164               0 :         fProc = SkXfermode::GetProc(mode);
     165               0 :         fProc16 = SkXfermode::GetProc16(mode, color);
     166               0 :     }
     167                 : 
     168               0 :     Proc_SkModeColorFilter(SkColor color,
     169                 :                            SkXfermodeProc proc, SkXfermodeProc16 proc16)
     170               0 :             : INHERITED(color, ILLEGAL_XFERMODE_MODE) {
     171               0 :         fProc = proc;
     172               0 :         fProc16 = proc16;
     173               0 :     }
     174                 : 
     175               0 :     virtual uint32_t getFlags() {
     176               0 :         return fProc16 ? (kAlphaUnchanged_Flag | kHasFilter16_Flag) : 0;
     177                 :     }
     178                 : 
     179               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
     180                 :                             SkPMColor result[]) {
     181               0 :         SkPMColor       color = fPMColor;
     182               0 :         SkXfermodeProc  proc = fProc;
     183                 : 
     184               0 :         for (int i = 0; i < count; i++) {
     185               0 :             result[i] = proc(color, shader[i]);
     186                 :         }
     187               0 :     }
     188                 : 
     189               0 :     virtual void filterSpan16(const uint16_t shader[], int count,
     190                 :                               uint16_t result[]) {
     191               0 :         SkASSERT(this->getFlags() & kHasFilter16_Flag);
     192                 : 
     193               0 :         SkPMColor        color = fPMColor;
     194               0 :         SkXfermodeProc16 proc16 = fProc16;
     195                 : 
     196               0 :         for (int i = 0; i < count; i++) {
     197               0 :             result[i] = proc16(color, shader[i]);
     198                 :         }
     199               0 :     }
     200                 : 
     201               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     202               0 :         return SkNEW_ARGS(Proc_SkModeColorFilter, (buffer));
     203                 :     }
     204                 : 
     205                 : protected:
     206               0 :     virtual void flatten(SkFlattenableWriteBuffer& buffer) {
     207               0 :         this->INHERITED::flatten(buffer);
     208               0 :         buffer.writeFunctionPtr((void*)fProc);
     209               0 :         buffer.writeFunctionPtr((void*)fProc16);
     210               0 :     }
     211                 : 
     212               0 :     virtual Factory getFactory() {
     213               0 :         return CreateProc;
     214                 :     }
     215                 : 
     216               0 :     Proc_SkModeColorFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
     217               0 :         fProc = (SkXfermodeProc) buffer.readFunctionPtr();
     218               0 :         fProc16 = (SkXfermodeProc16) buffer.readFunctionPtr();
     219               0 :     }
     220                 : 
     221                 : private:
     222                 :     SkXfermodeProc   fProc;
     223                 :     SkXfermodeProc16 fProc16;
     224                 : 
     225                 :     typedef SkModeColorFilter INHERITED;
     226                 : };
     227                 : 
     228               0 : SkColorFilter* SkColorFilter::CreateProcFilter(SkColor color,
     229                 :                                                SkXfermodeProc proc,
     230                 :                                                SkXfermodeProc16 proc16) {
     231                 :     return proc ?
     232               0 :             SkNEW_ARGS(Proc_SkModeColorFilter, (color, proc, proc16)) :
     233               0 :             NULL;
     234                 : }
     235                 : 
     236                 : ///////////////////////////////////////////////////////////////////////////////
     237                 : 
     238               0 : SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color,
     239                 :                                                SkXfermode::Mode mode) {
     240               0 :     unsigned alpha = SkColorGetA(color);
     241                 : 
     242                 :     // first collaps some modes if possible
     243                 : 
     244               0 :     if (SkXfermode::kClear_Mode == mode) {
     245               0 :         color = 0;
     246               0 :         mode = SkXfermode::kSrc_Mode;
     247               0 :     } else if (SkXfermode::kSrcOver_Mode == mode) {
     248               0 :         if (0 == alpha) {
     249               0 :             mode = SkXfermode::kDst_Mode;
     250               0 :         } else if (255 == alpha) {
     251               0 :             mode = SkXfermode::kSrc_Mode;
     252                 :         }
     253                 :         // else just stay srcover
     254                 :     }
     255                 : 
     256                 :     // weed out combinations that are noops, and just return null
     257               0 :     if (SkXfermode::kDst_Mode == mode ||
     258                 :         (0 == alpha && (SkXfermode::kSrcOver_Mode == mode ||
     259                 :                         SkXfermode::kDstOver_Mode == mode ||
     260                 :                         SkXfermode::kDstOut_Mode == mode ||
     261                 :                         SkXfermode::kSrcATop_Mode == mode ||
     262                 :                         SkXfermode::kXor_Mode == mode ||
     263                 :                         SkXfermode::kDarken_Mode == mode)) ||
     264                 :             (0xFF == alpha && SkXfermode::kDstIn_Mode == mode)) {
     265               0 :         return NULL;
     266                 :     }
     267                 : 
     268               0 :     switch (mode) {
     269                 :         case SkXfermode::kSrc_Mode:
     270               0 :             return SkNEW_ARGS(Src_SkModeColorFilter, (color));
     271                 :         case SkXfermode::kSrcOver_Mode:
     272               0 :             return SkNEW_ARGS(SrcOver_SkModeColorFilter, (color));
     273                 :         default:
     274               0 :             return SkNEW_ARGS(Proc_SkModeColorFilter, (color, mode));
     275                 :     }
     276                 : }
     277                 : 
     278                 : ///////////////////////////////////////////////////////////////////////////////
     279                 : 
     280               0 : static inline unsigned pin(unsigned value, unsigned max) {
     281               0 :     if (value > max) {
     282               0 :         value = max;
     283                 :     }
     284               0 :     return value;
     285                 : }
     286                 : 
     287                 : static inline unsigned SkUClampMax(unsigned value, unsigned max) {
     288                 :     SkASSERT((int32_t)value >= 0);
     289                 :     SkASSERT((int32_t)max >= 0);
     290                 : 
     291                 :     int diff = max - value;
     292                 :     // clear diff if diff is positive
     293                 :     diff &= diff >> 31;
     294                 : 
     295                 :     return value + diff;
     296                 : }
     297                 : 
     298               0 : class SkLightingColorFilter : public SkColorFilter {
     299                 : public:
     300               0 :     SkLightingColorFilter(SkColor mul, SkColor add) : fMul(mul), fAdd(add) {}
     301                 : 
     302               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
     303                 :                             SkPMColor result[]) {
     304               0 :         unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
     305               0 :         unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
     306               0 :         unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
     307                 : 
     308               0 :         unsigned addR = SkColorGetR(fAdd);
     309               0 :         unsigned addG = SkColorGetG(fAdd);
     310               0 :         unsigned addB = SkColorGetB(fAdd);
     311                 : 
     312               0 :         for (int i = 0; i < count; i++) {
     313               0 :             SkPMColor c = shader[i];
     314               0 :             if (c) {
     315               0 :                 unsigned a = SkGetPackedA32(c);
     316               0 :                 unsigned scaleA = SkAlpha255To256(a);
     317               0 :                 unsigned r = pin(SkAlphaMul(SkGetPackedR32(c), scaleR) + SkAlphaMul(addR, scaleA), a);
     318               0 :                 unsigned g = pin(SkAlphaMul(SkGetPackedG32(c), scaleG) + SkAlphaMul(addG, scaleA), a);
     319               0 :                 unsigned b = pin(SkAlphaMul(SkGetPackedB32(c), scaleB) + SkAlphaMul(addB, scaleA), a);
     320               0 :                 c = SkPackARGB32(a, r, g, b);
     321                 :             }
     322               0 :             result[i] = c;
     323                 :         }
     324               0 :     }
     325                 : 
     326               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     327               0 :         return SkNEW_ARGS(SkLightingColorFilter, (buffer));
     328                 :     }
     329                 : 
     330                 : protected:
     331               0 :     virtual void flatten(SkFlattenableWriteBuffer& buffer) {
     332               0 :         this->INHERITED::flatten(buffer);
     333               0 :         buffer.write32(fMul);
     334               0 :         buffer.write32(fAdd);
     335               0 :     }
     336                 : 
     337               0 :     virtual Factory getFactory() {
     338               0 :         return CreateProc;
     339                 :     }
     340                 : 
     341               0 :     SkLightingColorFilter(SkFlattenableReadBuffer& buffer) {
     342               0 :         fMul = buffer.readU32();
     343               0 :         fAdd = buffer.readU32();
     344               0 :     }
     345                 : 
     346                 :     SkColor fMul, fAdd;
     347                 : 
     348                 : private:
     349                 :     typedef SkColorFilter INHERITED;
     350                 : };
     351                 : 
     352               0 : class SkLightingColorFilter_JustAdd : public SkLightingColorFilter {
     353                 : public:
     354               0 :     SkLightingColorFilter_JustAdd(SkColor mul, SkColor add)
     355               0 :         : INHERITED(mul, add) {}
     356                 : 
     357               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
     358                 :                             SkPMColor result[]) {
     359               0 :         unsigned addR = SkColorGetR(fAdd);
     360               0 :         unsigned addG = SkColorGetG(fAdd);
     361               0 :         unsigned addB = SkColorGetB(fAdd);
     362                 : 
     363               0 :         for (int i = 0; i < count; i++) {
     364               0 :             SkPMColor c = shader[i];
     365               0 :             if (c) {
     366               0 :                 unsigned a = SkGetPackedA32(c);
     367               0 :                 unsigned scaleA = SkAlpha255To256(a);
     368               0 :                 unsigned r = pin(SkGetPackedR32(c) + SkAlphaMul(addR, scaleA), a);
     369               0 :                 unsigned g = pin(SkGetPackedG32(c) + SkAlphaMul(addG, scaleA), a);
     370               0 :                 unsigned b = pin(SkGetPackedB32(c) + SkAlphaMul(addB, scaleA), a);
     371               0 :                 c = SkPackARGB32(a, r, g, b);
     372                 :             }
     373               0 :             result[i] = c;
     374                 :         }
     375               0 :     }
     376                 : 
     377               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)  {
     378               0 :         return SkNEW_ARGS(SkLightingColorFilter_JustAdd, (buffer));
     379                 :     }
     380                 : 
     381                 : protected:
     382               0 :     virtual Factory getFactory() { return CreateProc; }
     383                 : 
     384               0 :     SkLightingColorFilter_JustAdd(SkFlattenableReadBuffer& buffer)
     385               0 :         : INHERITED(buffer) {}
     386                 : 
     387                 : private:
     388                 :     typedef SkLightingColorFilter INHERITED;
     389                 : };
     390                 : 
     391               0 : class SkLightingColorFilter_JustMul : public SkLightingColorFilter {
     392                 : public:
     393               0 :     SkLightingColorFilter_JustMul(SkColor mul, SkColor add)
     394               0 :         : INHERITED(mul, add) {}
     395                 : 
     396               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
     397                 :                             SkPMColor result[]) {
     398               0 :         unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
     399               0 :         unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
     400               0 :         unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
     401                 : 
     402               0 :         for (int i = 0; i < count; i++) {
     403               0 :             SkPMColor c = shader[i];
     404               0 :             if (c) {
     405               0 :                 unsigned a = SkGetPackedA32(c);
     406               0 :                 unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR);
     407               0 :                 unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG);
     408               0 :                 unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB);
     409               0 :                 c = SkPackARGB32(a, r, g, b);
     410                 :             }
     411               0 :             result[i] = c;
     412                 :         }
     413               0 :     }
     414                 : 
     415               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     416               0 :         return SkNEW_ARGS(SkLightingColorFilter_JustMul, (buffer));
     417                 :     }
     418                 : 
     419                 : protected:
     420               0 :     virtual Factory getFactory() { return CreateProc; }
     421                 : 
     422               0 :     SkLightingColorFilter_JustMul(SkFlattenableReadBuffer& buffer)
     423               0 :         : INHERITED(buffer) {}
     424                 : 
     425                 : private:
     426                 :     typedef SkLightingColorFilter INHERITED;
     427                 : };
     428                 : 
     429               0 : class SkLightingColorFilter_SingleMul : public SkLightingColorFilter {
     430                 : public:
     431               0 :     SkLightingColorFilter_SingleMul(SkColor mul, SkColor add)
     432               0 :             : INHERITED(mul, add) {
     433               0 :         SkASSERT(SkColorGetR(add) == 0);
     434               0 :         SkASSERT(SkColorGetG(add) == 0);
     435               0 :         SkASSERT(SkColorGetB(add) == 0);
     436               0 :         SkASSERT(SkColorGetR(mul) == SkColorGetG(mul));
     437               0 :         SkASSERT(SkColorGetR(mul) == SkColorGetB(mul));
     438               0 :     }
     439                 : 
     440               0 :     virtual uint32_t getFlags() {
     441               0 :         return this->INHERITED::getFlags() | (kAlphaUnchanged_Flag | kHasFilter16_Flag);
     442                 :     }
     443                 : 
     444               0 :     virtual void filterSpan16(const uint16_t shader[], int count,
     445                 :                               uint16_t result[]) {
     446                 :         // all mul components are the same
     447               0 :         unsigned scale = SkAlpha255To256(SkColorGetR(fMul));
     448                 : 
     449               0 :         if (count > 0) {
     450               0 :             do {
     451               0 :                 *result++ = SkAlphaMulRGB16(*shader++, scale);
     452                 :             } while (--count > 0);
     453                 :         }
     454               0 :     }
     455                 : 
     456               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     457               0 :         return SkNEW_ARGS(SkLightingColorFilter_SingleMul, (buffer));
     458                 :     }
     459                 : 
     460                 : protected:
     461               0 :     virtual Factory getFactory() { return CreateProc; }
     462                 : 
     463               0 :     SkLightingColorFilter_SingleMul(SkFlattenableReadBuffer& buffer)
     464               0 :         : INHERITED(buffer) {}
     465                 : 
     466                 : private:
     467                 :     typedef SkLightingColorFilter INHERITED;
     468                 : };
     469                 : 
     470               0 : class SkLightingColorFilter_NoPin : public SkLightingColorFilter {
     471                 : public:
     472               0 :     SkLightingColorFilter_NoPin(SkColor mul, SkColor add)
     473               0 :     : INHERITED(mul, add) {}
     474                 : 
     475               0 :     virtual void filterSpan(const SkPMColor shader[], int count,
     476                 :                             SkPMColor result[]) {
     477               0 :         unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
     478               0 :         unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
     479               0 :         unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
     480                 : 
     481               0 :         unsigned addR = SkColorGetR(fAdd);
     482               0 :         unsigned addG = SkColorGetG(fAdd);
     483               0 :         unsigned addB = SkColorGetB(fAdd);
     484                 : 
     485               0 :         for (int i = 0; i < count; i++) {
     486               0 :             SkPMColor c = shader[i];
     487               0 :             if (c) {
     488               0 :                 unsigned a = SkGetPackedA32(c);
     489               0 :                 unsigned scaleA = SkAlpha255To256(a);
     490               0 :                 unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR) + SkAlphaMul(addR, scaleA);
     491               0 :                 unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG) + SkAlphaMul(addG, scaleA);
     492               0 :                 unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB) + SkAlphaMul(addB, scaleA);
     493               0 :                 c = SkPackARGB32(a, r, g, b);
     494                 :             }
     495               0 :             result[i] = c;
     496                 :         }
     497               0 :     }
     498                 : 
     499               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     500               0 :         return SkNEW_ARGS(SkLightingColorFilter_NoPin, (buffer));
     501                 :     }
     502                 : 
     503                 : protected:
     504               0 :     virtual Factory getFactory() { return CreateProc; }
     505                 : 
     506               0 :     SkLightingColorFilter_NoPin(SkFlattenableReadBuffer& buffer)
     507               0 :         : INHERITED(buffer) {}
     508                 : 
     509                 : private:
     510                 :     typedef SkLightingColorFilter INHERITED;
     511                 : };
     512                 : 
     513                 : ///////////////////////////////////////////////////////////////////////////////
     514                 : 
     515               0 : class SkSimpleColorFilter : public SkColorFilter {
     516                 : public:
     517               0 :     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
     518               0 :         return SkNEW(SkSimpleColorFilter);
     519                 :     }
     520                 : 
     521                 : protected:
     522               0 :     void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
     523               0 :         if (result != src) {
     524               0 :             memcpy(result, src, count * sizeof(SkPMColor));
     525                 :         }
     526               0 :     }
     527                 : 
     528               0 :     virtual void flatten(SkFlattenableWriteBuffer& buffer) {}
     529                 : 
     530               0 :     virtual Factory getFactory() {
     531               0 :         return CreateProc;
     532                 :     }
     533                 : 
     534                 : };
     535                 : 
     536               0 : SkColorFilter* SkColorFilter::CreateLightingFilter(SkColor mul, SkColor add) {
     537               0 :     mul &= 0x00FFFFFF;
     538               0 :     add &= 0x00FFFFFF;
     539                 : 
     540               0 :     if (0xFFFFFF == mul) {
     541               0 :         if (0 == add) {
     542               0 :             return SkNEW(SkSimpleColorFilter);   // no change to the colors
     543                 :         } else {
     544               0 :             return SkNEW_ARGS(SkLightingColorFilter_JustAdd, (mul, add));
     545                 :         }
     546                 :     }
     547                 : 
     548               0 :     if (0 == add) {
     549               0 :         if (SkColorGetR(mul) == SkColorGetG(mul) &&
     550                 :                 SkColorGetR(mul) == SkColorGetB(mul)) {
     551               0 :             return SkNEW_ARGS(SkLightingColorFilter_SingleMul, (mul, add));
     552                 :         } else {
     553               0 :             return SkNEW_ARGS(SkLightingColorFilter_JustMul, (mul, add));
     554                 :         }
     555                 :     }
     556                 : 
     557               0 :     if (SkColorGetR(mul) + SkColorGetR(add) <= 255 &&
     558                 :         SkColorGetG(mul) + SkColorGetG(add) <= 255 &&
     559                 :         SkColorGetB(mul) + SkColorGetB(add) <= 255) {
     560               0 :             return SkNEW_ARGS(SkLightingColorFilter_NoPin, (mul, add));
     561                 :     }
     562                 : 
     563               0 :     return SkNEW_ARGS(SkLightingColorFilter, (mul, add));
     564                 : }
     565                 : 
     566                 : SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkColorFilter)
     567            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Src_SkModeColorFilter)
     568            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SrcOver_SkModeColorFilter)
     569            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Proc_SkModeColorFilter)
     570            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter)
     571            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustAdd)
     572            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustMul)
     573            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_SingleMul)
     574            1464 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_NoPin)
     575            4392 :     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSimpleColorFilter)
     576                 : SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
     577                 : 

Generated by: LCOV version 1.7