1 :
2 : /*
3 : * Copyright 2011 Google Inc.
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 : #include "SkUtils.h"
9 :
10 : #if DSTSIZE==32
11 : #define DSTTYPE SkPMColor
12 : #elif DSTSIZE==16
13 : #define DSTTYPE uint16_t
14 : #else
15 : #error "need DSTSIZE to be 32 or 16"
16 : #endif
17 :
18 : #if (DSTSIZE == 32)
19 : #define BITMAPPROC_MEMSET(ptr, value, n) sk_memset32(ptr, value, n)
20 : #elif (DSTSIZE == 16)
21 : #define BITMAPPROC_MEMSET(ptr, value, n) sk_memset16(ptr, value, n)
22 : #else
23 : #error "unsupported DSTSIZE"
24 : #endif
25 :
26 0 : void MAKENAME(_nofilter_DXDY)(const SkBitmapProcState& s,
27 : const uint32_t* SK_RESTRICT xy,
28 : int count, DSTTYPE* SK_RESTRICT colors) {
29 0 : SkASSERT(count > 0 && colors != NULL);
30 0 : SkASSERT(s.fDoFilter == false);
31 0 : SkDEBUGCODE(CHECKSTATE(s);)
32 :
33 : #ifdef PREAMBLE
34 0 : PREAMBLE(s);
35 : #endif
36 0 : const char* SK_RESTRICT srcAddr = (const char*)s.fBitmap->getPixels();
37 0 : int i, rb = s.fBitmap->rowBytes();
38 :
39 : uint32_t XY;
40 : SRCTYPE src;
41 :
42 0 : for (i = (count >> 1); i > 0; --i) {
43 0 : XY = *xy++;
44 0 : SkASSERT((XY >> 16) < (unsigned)s.fBitmap->height() &&
45 : (XY & 0xFFFF) < (unsigned)s.fBitmap->width());
46 0 : src = ((const SRCTYPE*)(srcAddr + (XY >> 16) * rb))[XY & 0xFFFF];
47 0 : *colors++ = RETURNDST(src);
48 :
49 0 : XY = *xy++;
50 0 : SkASSERT((XY >> 16) < (unsigned)s.fBitmap->height() &&
51 : (XY & 0xFFFF) < (unsigned)s.fBitmap->width());
52 0 : src = ((const SRCTYPE*)(srcAddr + (XY >> 16) * rb))[XY & 0xFFFF];
53 0 : *colors++ = RETURNDST(src);
54 : }
55 0 : if (count & 1) {
56 0 : XY = *xy++;
57 0 : SkASSERT((XY >> 16) < (unsigned)s.fBitmap->height() &&
58 : (XY & 0xFFFF) < (unsigned)s.fBitmap->width());
59 0 : src = ((const SRCTYPE*)(srcAddr + (XY >> 16) * rb))[XY & 0xFFFF];
60 0 : *colors++ = RETURNDST(src);
61 : }
62 :
63 : #ifdef POSTAMBLE
64 0 : POSTAMBLE(s);
65 : #endif
66 0 : }
67 :
68 0 : void MAKENAME(_nofilter_DX)(const SkBitmapProcState& s,
69 : const uint32_t* SK_RESTRICT xy,
70 : int count, DSTTYPE* SK_RESTRICT colors) {
71 0 : SkASSERT(count > 0 && colors != NULL);
72 0 : SkASSERT(s.fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask));
73 0 : SkASSERT(s.fDoFilter == false);
74 0 : SkDEBUGCODE(CHECKSTATE(s);)
75 :
76 : #ifdef PREAMBLE
77 0 : PREAMBLE(s);
78 : #endif
79 0 : const SRCTYPE* SK_RESTRICT srcAddr = (const SRCTYPE*)s.fBitmap->getPixels();
80 :
81 : // buffer is y32, x16, x16, x16, x16, x16
82 : // bump srcAddr to the proper row, since we're told Y never changes
83 0 : SkASSERT((unsigned)xy[0] < (unsigned)s.fBitmap->height());
84 : srcAddr = (const SRCTYPE*)((const char*)srcAddr +
85 0 : xy[0] * s.fBitmap->rowBytes());
86 0 : xy += 1;
87 :
88 : SRCTYPE src;
89 :
90 0 : if (1 == s.fBitmap->width()) {
91 0 : src = srcAddr[0];
92 0 : DSTTYPE dstValue = RETURNDST(src);
93 0 : BITMAPPROC_MEMSET(colors, dstValue, count);
94 : } else {
95 : int i;
96 0 : for (i = (count >> 2); i > 0; --i) {
97 0 : uint32_t xx0 = *xy++;
98 0 : uint32_t xx1 = *xy++;
99 0 : SRCTYPE x0 = srcAddr[UNPACK_PRIMARY_SHORT(xx0)];
100 0 : SRCTYPE x1 = srcAddr[UNPACK_SECONDARY_SHORT(xx0)];
101 0 : SRCTYPE x2 = srcAddr[UNPACK_PRIMARY_SHORT(xx1)];
102 0 : SRCTYPE x3 = srcAddr[UNPACK_SECONDARY_SHORT(xx1)];
103 :
104 0 : *colors++ = RETURNDST(x0);
105 0 : *colors++ = RETURNDST(x1);
106 0 : *colors++ = RETURNDST(x2);
107 0 : *colors++ = RETURNDST(x3);
108 : }
109 0 : const uint16_t* SK_RESTRICT xx = (const uint16_t*)(xy);
110 0 : for (i = (count & 3); i > 0; --i) {
111 0 : SkASSERT(*xx < (unsigned)s.fBitmap->width());
112 0 : src = srcAddr[*xx++]; *colors++ = RETURNDST(src);
113 : }
114 : }
115 :
116 : #ifdef POSTAMBLE
117 0 : POSTAMBLE(s);
118 : #endif
119 0 : }
120 :
121 : ///////////////////////////////////////////////////////////////////////////////
122 :
123 0 : void MAKENAME(_filter_DX)(const SkBitmapProcState& s,
124 : const uint32_t* SK_RESTRICT xy,
125 : int count, DSTTYPE* SK_RESTRICT colors) {
126 0 : SkASSERT(count > 0 && colors != NULL);
127 0 : SkASSERT(s.fDoFilter);
128 0 : SkDEBUGCODE(CHECKSTATE(s);)
129 :
130 : #ifdef PREAMBLE
131 0 : PREAMBLE(s);
132 : #endif
133 0 : const char* SK_RESTRICT srcAddr = (const char*)s.fBitmap->getPixels();
134 0 : unsigned rb = s.fBitmap->rowBytes();
135 : unsigned subY;
136 : const SRCTYPE* SK_RESTRICT row0;
137 : const SRCTYPE* SK_RESTRICT row1;
138 :
139 : // setup row ptrs and update proc_table
140 : {
141 0 : uint32_t XY = *xy++;
142 0 : unsigned y0 = XY >> 14;
143 0 : row0 = (const SRCTYPE*)(srcAddr + (y0 >> 4) * rb);
144 0 : row1 = (const SRCTYPE*)(srcAddr + (XY & 0x3FFF) * rb);
145 0 : subY = y0 & 0xF;
146 : }
147 :
148 0 : do {
149 0 : uint32_t XX = *xy++; // x0:14 | 4 | x1:14
150 0 : unsigned x0 = XX >> 14;
151 0 : unsigned x1 = XX & 0x3FFF;
152 0 : unsigned subX = x0 & 0xF;
153 0 : x0 >>= 4;
154 :
155 0 : FILTER_PROC(subX, subY,
156 : SRC_TO_FILTER(row0[x0]),
157 : SRC_TO_FILTER(row0[x1]),
158 : SRC_TO_FILTER(row1[x0]),
159 : SRC_TO_FILTER(row1[x1]),
160 0 : colors);
161 0 : colors += 1;
162 :
163 : } while (--count != 0);
164 :
165 : #ifdef POSTAMBLE
166 0 : POSTAMBLE(s);
167 : #endif
168 0 : }
169 0 : void MAKENAME(_filter_DXDY)(const SkBitmapProcState& s,
170 : const uint32_t* SK_RESTRICT xy,
171 : int count, DSTTYPE* SK_RESTRICT colors) {
172 0 : SkASSERT(count > 0 && colors != NULL);
173 0 : SkASSERT(s.fDoFilter);
174 0 : SkDEBUGCODE(CHECKSTATE(s);)
175 :
176 : #ifdef PREAMBLE
177 0 : PREAMBLE(s);
178 : #endif
179 0 : const char* SK_RESTRICT srcAddr = (const char*)s.fBitmap->getPixels();
180 0 : int rb = s.fBitmap->rowBytes();
181 :
182 0 : do {
183 0 : uint32_t data = *xy++;
184 0 : unsigned y0 = data >> 14;
185 0 : unsigned y1 = data & 0x3FFF;
186 0 : unsigned subY = y0 & 0xF;
187 0 : y0 >>= 4;
188 :
189 0 : data = *xy++;
190 0 : unsigned x0 = data >> 14;
191 0 : unsigned x1 = data & 0x3FFF;
192 0 : unsigned subX = x0 & 0xF;
193 0 : x0 >>= 4;
194 :
195 0 : const SRCTYPE* SK_RESTRICT row0 = (const SRCTYPE*)(srcAddr + y0 * rb);
196 0 : const SRCTYPE* SK_RESTRICT row1 = (const SRCTYPE*)(srcAddr + y1 * rb);
197 :
198 0 : FILTER_PROC(subX, subY,
199 : SRC_TO_FILTER(row0[x0]),
200 : SRC_TO_FILTER(row0[x1]),
201 : SRC_TO_FILTER(row1[x0]),
202 : SRC_TO_FILTER(row1[x1]),
203 0 : colors);
204 0 : colors += 1;
205 : } while (--count != 0);
206 :
207 : #ifdef POSTAMBLE
208 0 : POSTAMBLE(s);
209 : #endif
210 0 : }
211 :
212 : #undef MAKENAME
213 : #undef DSTSIZE
214 : #undef DSTTYPE
215 : #undef SRCTYPE
216 : #undef CHECKSTATE
217 : #undef RETURNDST
218 : #undef SRC_TO_FILTER
219 : #undef FILTER_TO_DST
220 :
221 : #ifdef PREAMBLE
222 : #undef PREAMBLE
223 : #endif
224 : #ifdef POSTAMBLE
225 : #undef POSTAMBLE
226 : #endif
227 :
228 : #undef FILTER_PROC_TYPE
229 : #undef GET_FILTER_TABLE
230 : #undef GET_FILTER_ROW
231 : #undef GET_FILTER_ROW_PROC
232 : #undef GET_FILTER_PROC
233 : #undef BITMAPPROC_MEMSET
|