SkShader.cpp revision ba28d03e94dc221d6a803bf2a84a420b9159255c 
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 "SkScalar.h"
11#include "SkShader.h"
12#include "SkPaint.h"
13#include "SkMallocPixelRef.h"
14
15SkShader::SkShader() : fLocalMatrix(NULL) {
16    SkDEBUGCODE(fInSession = false;)
17}
18
19SkShader::SkShader(SkFlattenableReadBuffer& buffer)
20        : INHERITED(buffer), fLocalMatrix(NULL) {
21    if (buffer.readBool()) {
22        SkMatrix matrix;
23        SkReadMatrix(&buffer, &matrix);
24        setLocalMatrix(matrix);
25    }
26    SkDEBUGCODE(fInSession = false;)
27}
28
29SkShader::~SkShader() {
30    SkASSERT(!fInSession);
31    sk_free(fLocalMatrix);
32}
33
34void SkShader::beginSession() {
35    SkASSERT(!fInSession);
36    SkDEBUGCODE(fInSession = true;)
37}
38
39void SkShader::endSession() {
40    SkASSERT(fInSession);
41    SkDEBUGCODE(fInSession = false;)
42}
43
44void SkShader::flatten(SkFlattenableWriteBuffer& buffer) {
45    this->INHERITED::flatten(buffer);
46    buffer.writeBool(fLocalMatrix != NULL);
47    if (fLocalMatrix) {
48        SkWriteMatrix(&buffer, *fLocalMatrix);
49    }
50}
51
52bool SkShader::getLocalMatrix(SkMatrix* localM) const {
53    if (fLocalMatrix) {
54        if (localM) {
55            *localM = *fLocalMatrix;
56        }
57        return true;
58    } else {
59        if (localM) {
60            localM->reset();
61        }
62        return false;
63    }
64}
65
66void SkShader::setLocalMatrix(const SkMatrix& localM) {
67    if (localM.isIdentity()) {
68        this->resetLocalMatrix();
69    } else {
70        if (fLocalMatrix == NULL) {
71            fLocalMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));
72        }
73        *fLocalMatrix = localM;
74    }
75}
76
77void SkShader::resetLocalMatrix() {
78    if (fLocalMatrix) {
79        sk_free(fLocalMatrix);
80        fLocalMatrix = NULL;
81    }
82}
83
84bool SkShader::setContext(const SkBitmap& device,
85                          const SkPaint& paint,
86                          const SkMatrix& matrix) {
87    const SkMatrix* m = &matrix;
88    SkMatrix        total;
89
90    fDeviceConfig = SkToU8(device.getConfig());
91    fPaintAlpha = paint.getAlpha();
92    if (fLocalMatrix) {
93        total.setConcat(matrix, *fLocalMatrix);
94        m = &total;
95    }
96    if (m->invert(&fTotalInverse)) {
97        fTotalInverseClass = (uint8_t)ComputeMatrixClass(fTotalInverse);
98        return true;
99    }
100    return false;
101}
102
103#include "SkColorPriv.h"
104
105void SkShader::shadeSpan16(int x, int y, uint16_t span16[], int count) {
106    SkASSERT(span16);
107    SkASSERT(count > 0);
108    SkASSERT(this->canCallShadeSpan16());
109
110    // basically, if we get here, the subclass screwed up
111    SkDEBUGFAIL("kHasSpan16 flag is set, but shadeSpan16() not implemented");
112}
113
114#define kTempColorQuadCount 6   // balance between speed (larger) and saving stack-space
115#define kTempColorCount     (kTempColorQuadCount << 2)
116
117#ifdef SK_CPU_BENDIAN
118    #define SkU32BitShiftToByteOffset(shift)    (3 - ((shift) >> 3))
119#else
120    #define SkU32BitShiftToByteOffset(shift)    ((shift) >> 3)
121#endif
122
123void SkShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
124    SkASSERT(count > 0);
125
126    SkPMColor   colors[kTempColorCount];
127
128    while ((count -= kTempColorCount) >= 0) {
129        this->shadeSpan(x, y, colors, kTempColorCount);
130        x += kTempColorCount;
131
132        const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
133        int quads = kTempColorQuadCount;
134        do {
135            U8CPU a0 = srcA[0];
136            U8CPU a1 = srcA[4];
137            U8CPU a2 = srcA[8];
138            U8CPU a3 = srcA[12];
139            srcA += 4*4;
140            *alpha++ = SkToU8(a0);
141            *alpha++ = SkToU8(a1);
142            *alpha++ = SkToU8(a2);
143            *alpha++ = SkToU8(a3);
144        } while (--quads != 0);
145    }
146    SkASSERT(count < 0);
147    SkASSERT(count + kTempColorCount >= 0);
148    if (count += kTempColorCount) {
149        this->shadeSpan(x, y, colors, count);
150
151        const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
152        do {
153            *alpha++ = *srcA;
154            srcA += 4;
155        } while (--count != 0);
156    }
157#if 0
158    do {
159        int n = count;
160        if (n > kTempColorCount)
161            n = kTempColorCount;
162        SkASSERT(n > 0);
163
164        this->shadeSpan(x, y, colors, n);
165        x += n;
166        count -= n;
167
168        const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
169        do {
170            *alpha++ = *srcA;
171            srcA += 4;
172        } while (--n != 0);
173    } while (count > 0);
174#endif
175}
176
177SkShader::MatrixClass SkShader::ComputeMatrixClass(const SkMatrix& mat) {
178    MatrixClass mc = kLinear_MatrixClass;
179
180    if (mat.hasPerspective()) {
181        if (mat.fixedStepInX(0, NULL, NULL)) {
182            mc = kFixedStepInX_MatrixClass;
183        } else {
184            mc = kPerspective_MatrixClass;
185        }
186    }
187    return mc;
188}
189
190//////////////////////////////////////////////////////////////////////////////
191
192SkShader::BitmapType SkShader::asABitmap(SkBitmap*, SkMatrix*,
193                                         TileMode*, SkScalar*) const {
194    return kNone_BitmapType;
195}
196
197SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const {
198    return kNone_GradientType;
199}
200
201SkShader* SkShader::CreateBitmapShader(const SkBitmap& src,
202                                       TileMode tmx, TileMode tmy) {
203    return SkShader::CreateBitmapShader(src, tmx, tmy, NULL, 0);
204}
205
206//////////////////////////////////////////////////////////////////////////////
207
208#include "SkColorShader.h"
209#include "SkUtils.h"
210
211SkColorShader::SkColorShader() {
212    fFlags = 0;
213    fInheritColor = true;
214}
215
216SkColorShader::SkColorShader(SkColor c) {
217    fFlags = 0;
218    fColor = c;
219    fInheritColor = false;
220}
221
222SkColorShader::~SkColorShader() {}
223
224bool SkColorShader::isOpaque() const {
225    if (fInheritColor) {
226        return true; // using paint's alpha
227    }
228    return SkColorGetA(fColor) == 255;
229}
230
231SkColorShader::SkColorShader(SkFlattenableReadBuffer& b) : INHERITED(b) {
232    fFlags = 0; // computed in setContext
233
234    fInheritColor = b.readU8();
235    if (fInheritColor) {
236        return;
237    }
238    fColor = b.readU32();
239}
240
241void SkColorShader::flatten(SkFlattenableWriteBuffer& buffer) {
242    this->INHERITED::flatten(buffer);
243    buffer.write8(fInheritColor);
244    if (fInheritColor) {
245        return;
246    }
247    buffer.write32(fColor);
248}
249
250uint32_t SkColorShader::getFlags() {
251    return fFlags;
252}
253
254uint8_t SkColorShader::getSpan16Alpha() const {
255    return SkGetPackedA32(fPMColor);
256}
257
258bool SkColorShader::setContext(const SkBitmap& device, const SkPaint& paint,
259                               const SkMatrix& matrix) {
260    if (!this->INHERITED::setContext(device, paint, matrix)) {
261        return false;
262    }
263
264    unsigned a;
265
266    if (fInheritColor) {
267        fColor = paint.getColor();
268        a = SkColorGetA(fColor);
269    } else {
270        a = SkAlphaMul(SkColorGetA(fColor), SkAlpha255To256(paint.getAlpha()));
271    }
272
273    unsigned r = SkColorGetR(fColor);
274    unsigned g = SkColorGetG(fColor);
275    unsigned b = SkColorGetB(fColor);
276
277    // we want this before we apply any alpha
278    fColor16 = SkPack888ToRGB16(r, g, b);
279
280    if (a != 255) {
281        r = SkMulDiv255Round(r, a);
282        g = SkMulDiv255Round(g, a);
283        b = SkMulDiv255Round(b, a);
284    }
285    fPMColor = SkPackARGB32(a, r, g, b);
286
287    fFlags = kConstInY32_Flag;
288    if (255 == a) {
289        fFlags |= kOpaqueAlpha_Flag;
290        if (paint.isDither() == false) {
291            fFlags |= kHasSpan16_Flag;
292        }
293    }
294
295    return true;
296}
297
298void SkColorShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
299    sk_memset32(span, fPMColor, count);
300}
301
302void SkColorShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
303    sk_memset16(span, fColor16, count);
304}
305
306void SkColorShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
307    memset(alpha, SkGetPackedA32(fPMColor), count);
308}
309
310// if we had a asAColor method, that would be more efficient...
311SkShader::BitmapType SkColorShader::asABitmap(SkBitmap* bitmap, SkMatrix* matrix,
312                                              TileMode modes[],
313                                      SkScalar* twoPointRadialParams) const {
314    return kNone_BitmapType;
315}
316
317SkShader::GradientType SkColorShader::asAGradient(GradientInfo* info) const {
318    if (info) {
319        if (info->fColors && info->fColorCount >= 1) {
320            info->fColors[0] = fColor;
321        }
322        info->fColorCount = 1;
323        info->fTileMode = SkShader::kRepeat_TileMode;
324    }
325    return kColor_GradientType;
326}
327
328SK_DEFINE_FLATTENABLE_REGISTRAR(SkColorShader)
329
330///////////////////////////////////////////////////////////////////////////////
331
332#include "SkEmptyShader.h"
333
334SkEmptyShader::SkEmptyShader(SkFlattenableReadBuffer& b) : INHERITED(b) {}
335
336uint32_t SkEmptyShader::getFlags() { return 0; }
337uint8_t SkEmptyShader::getSpan16Alpha() const { return 0; }
338
339bool SkEmptyShader::setContext(const SkBitmap&, const SkPaint&,
340                               const SkMatrix&) { return false; }
341
342void SkEmptyShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
343    SkDEBUGFAIL("should never get called, since setContext() returned false");
344}
345
346void SkEmptyShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
347    SkDEBUGFAIL("should never get called, since setContext() returned false");
348}
349
350void SkEmptyShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
351    SkDEBUGFAIL("should never get called, since setContext() returned false");
352}
353
354void SkEmptyShader::flatten(SkFlattenableWriteBuffer& buffer) {
355    this->INHERITED::flatten(buffer);
356}
357
358SK_DEFINE_FLATTENABLE_REGISTRAR(SkEmptyShader)
359