1 : /*
2 : * Copyright 2006 The Android Open Source Project
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 : #ifndef SkCoreBlitters_DEFINED
9 : #define SkCoreBlitters_DEFINED
10 :
11 : #include "SkBlitter.h"
12 : #include "SkBlitRow.h"
13 :
14 0 : class SkRasterBlitter : public SkBlitter {
15 : public:
16 0 : SkRasterBlitter(const SkBitmap& device) : fDevice(device) {}
17 :
18 : protected:
19 : const SkBitmap& fDevice;
20 :
21 : private:
22 : typedef SkBlitter INHERITED;
23 : };
24 :
25 : class SkShaderBlitter : public SkRasterBlitter {
26 : public:
27 : SkShaderBlitter(const SkBitmap& device, const SkPaint& paint);
28 : virtual ~SkShaderBlitter();
29 :
30 : protected:
31 : uint32_t fShaderFlags;
32 : SkShader* fShader;
33 :
34 : private:
35 : // illegal
36 : SkShaderBlitter& operator=(const SkShaderBlitter&);
37 :
38 : typedef SkRasterBlitter INHERITED;
39 : };
40 :
41 : ///////////////////////////////////////////////////////////////////////////////
42 :
43 0 : class SkA8_Blitter : public SkRasterBlitter {
44 : public:
45 : SkA8_Blitter(const SkBitmap& device, const SkPaint& paint);
46 : virtual void blitH(int x, int y, int width);
47 : virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
48 : virtual void blitV(int x, int y, int height, SkAlpha alpha);
49 : virtual void blitRect(int x, int y, int width, int height);
50 : virtual void blitMask(const SkMask&, const SkIRect&);
51 : virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
52 :
53 : private:
54 : unsigned fSrcA;
55 :
56 : // illegal
57 : SkA8_Blitter& operator=(const SkA8_Blitter&);
58 :
59 : typedef SkRasterBlitter INHERITED;
60 : };
61 :
62 : class SkA8_Shader_Blitter : public SkShaderBlitter {
63 : public:
64 : SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint);
65 : virtual ~SkA8_Shader_Blitter();
66 : virtual void blitH(int x, int y, int width);
67 : virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
68 : virtual void blitMask(const SkMask&, const SkIRect&);
69 :
70 : private:
71 : SkXfermode* fXfermode;
72 : SkPMColor* fBuffer;
73 : uint8_t* fAAExpand;
74 :
75 : // illegal
76 : SkA8_Shader_Blitter& operator=(const SkA8_Shader_Blitter&);
77 :
78 : typedef SkShaderBlitter INHERITED;
79 : };
80 :
81 : ////////////////////////////////////////////////////////////////
82 :
83 0 : class SkARGB32_Blitter : public SkRasterBlitter {
84 : public:
85 : SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint);
86 : virtual void blitH(int x, int y, int width);
87 : virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
88 : virtual void blitV(int x, int y, int height, SkAlpha alpha);
89 : virtual void blitRect(int x, int y, int width, int height);
90 : virtual void blitMask(const SkMask&, const SkIRect&);
91 : virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
92 :
93 : protected:
94 : SkColor fColor;
95 : SkPMColor fPMColor;
96 : SkBlitRow::ColorProc fColor32Proc;
97 :
98 : private:
99 : unsigned fSrcA, fSrcR, fSrcG, fSrcB;
100 :
101 : // illegal
102 : SkARGB32_Blitter& operator=(const SkARGB32_Blitter&);
103 :
104 : typedef SkRasterBlitter INHERITED;
105 : };
106 :
107 0 : class SkARGB32_Opaque_Blitter : public SkARGB32_Blitter {
108 : public:
109 0 : SkARGB32_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint)
110 0 : : INHERITED(device, paint) { SkASSERT(paint.getAlpha() == 0xFF); }
111 : virtual void blitMask(const SkMask&, const SkIRect&);
112 :
113 : private:
114 : typedef SkARGB32_Blitter INHERITED;
115 : };
116 :
117 0 : class SkARGB32_Black_Blitter : public SkARGB32_Opaque_Blitter {
118 : public:
119 0 : SkARGB32_Black_Blitter(const SkBitmap& device, const SkPaint& paint)
120 0 : : INHERITED(device, paint) {}
121 : virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
122 :
123 : private:
124 : typedef SkARGB32_Opaque_Blitter INHERITED;
125 : };
126 :
127 : class SkARGB32_Shader_Blitter : public SkShaderBlitter {
128 : public:
129 : SkARGB32_Shader_Blitter(const SkBitmap& device, const SkPaint& paint);
130 : virtual ~SkARGB32_Shader_Blitter();
131 : virtual void blitH(int x, int y, int width);
132 : virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
133 : virtual void blitMask(const SkMask&, const SkIRect&);
134 :
135 : private:
136 : SkXfermode* fXfermode;
137 : SkPMColor* fBuffer;
138 : SkBlitRow::Proc32 fProc32;
139 : SkBlitRow::Proc32 fProc32Blend;
140 :
141 : // illegal
142 : SkARGB32_Shader_Blitter& operator=(const SkARGB32_Shader_Blitter&);
143 :
144 : typedef SkShaderBlitter INHERITED;
145 : };
146 :
147 : ///////////////////////////////////////////////////////////////////////////////
148 :
149 0 : class SkA1_Blitter : public SkRasterBlitter {
150 : public:
151 : SkA1_Blitter(const SkBitmap& device, const SkPaint& paint);
152 : virtual void blitH(int x, int y, int width);
153 :
154 : private:
155 : uint8_t fSrcA;
156 :
157 : // illegal
158 : SkA1_Blitter& operator=(const SkA1_Blitter&);
159 :
160 : typedef SkRasterBlitter INHERITED;
161 : };
162 :
163 : ///////////////////////////////////////////////////////////////////////////////
164 :
165 : /* These return the correct subclass of blitter for their device config.
166 :
167 : Currently, they make the following assumptions about the state of the
168 : paint:
169 :
170 : 1. If there is an xfermode, there will also be a shader
171 : 2. If there is a colorfilter, there will be a shader that itself handles
172 : calling the filter, so the blitter can always ignore the colorfilter obj
173 :
174 : These pre-conditions must be handled by the caller, in our case
175 : SkBlitter::Choose(...)
176 : */
177 :
178 : extern SkBlitter* SkBlitter_ChooseD4444(const SkBitmap& device,
179 : const SkPaint& paint,
180 : void* storage, size_t storageSize);
181 :
182 : extern SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device,
183 : const SkPaint& paint,
184 : void* storage, size_t storageSize);
185 :
186 : #endif
187 :
|