← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gears/karmic

« back to all changes in this revision

Viewing changes to third_party/skia/src/effects/SkColorFilters.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Lesicnik
  • Date: 2009-04-30 19:15:25 UTC
  • Revision ID: james.westby@ubuntu.com-20090430191525-0790sb5wzg8ou0xb
Tags: upstream-0.5.21.0~svn3334+dfsg
Import upstream version 0.5.21.0~svn3334+dfsg

Show diffs side-by-side

added added

removed removed

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