LEFT | RIGHT |
(no file at all) | |
1 /* | 1 /* |
2 * Copyright 2011 Google Inc. | 2 * Copyright 2011 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkBlitRow.h" | 8 #include "SkBlitRow.h" |
9 #include "SkBlitMask.h" | 9 #include "SkBlitMask.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkUtils.h" | 11 #include "SkUtils.h" |
| 12 |
| 13 static bool gUsePlatformOptsForFactory = false; |
12 | 14 |
13 #define UNROLL | 15 #define UNROLL |
14 | 16 |
15 static void S32_Opaque_BlitRow32(SkPMColor* SK_RESTRICT dst, | 17 static void S32_Opaque_BlitRow32(SkPMColor* SK_RESTRICT dst, |
16 const SkPMColor* SK_RESTRICT src, | 18 const SkPMColor* SK_RESTRICT src, |
17 int count, U8CPU alpha) { | 19 int count, U8CPU alpha) { |
18 SkASSERT(255 == alpha); | 20 SkASSERT(255 == alpha); |
19 memcpy(dst, src, count * sizeof(SkPMColor)); | 21 memcpy(dst, src, count * sizeof(SkPMColor)); |
20 } | 22 } |
21 | 23 |
22 static void S32_Blend_BlitRow32(SkPMColor* SK_RESTRICT dst, | 24 static void S32_Blend_BlitRow32(SkPMColor* SK_RESTRICT dst, |
23 const SkPMColor* SK_RESTRICT src, | 25 const SkPMColor* SK_RESTRICT src, |
24 int count, U8CPU alpha) { | 26 int count, U8CPU alpha) { |
25 SkASSERT(alpha <= 255); | 27 SkASSERT(alpha <= 255); |
26 if (count > 0) { | 28 if (count > 0) { |
27 unsigned src_scale = SkAlpha255To256(alpha); | 29 unsigned src_scale = SkAlpha255To256(alpha); |
28 unsigned dst_scale = 256 - src_scale; | 30 unsigned dst_scale = 256 - alpha; |
29 | 31 |
30 #ifdef UNROLL | 32 #ifdef UNROLL |
31 if (count & 1) { | 33 if (count & 1) { |
32 *dst = SkAlphaMulQ(*(src++), src_scale) + SkAlphaMulQ(*dst, dst_scal
e); | 34 *dst = SkAlphaMulQ(*(src++), src_scale) + SkAlphaMulQ(*dst, dst_scal
e); |
33 dst += 1; | 35 dst += 1; |
34 count -= 1; | 36 count -= 1; |
35 } | 37 } |
36 | 38 |
37 const SkPMColor* SK_RESTRICT srcEnd = src + count; | 39 const SkPMColor* SK_RESTRICT srcEnd = src + count; |
38 while (src != srcEnd) { | 40 while (src != srcEnd) { |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
131 S32A_Opaque_BlitRow32, | 133 S32A_Opaque_BlitRow32, |
132 S32A_Blend_BlitRow32 | 134 S32A_Blend_BlitRow32 |
133 }; | 135 }; |
134 | 136 |
135 SkBlitRow::Proc32 SkBlitRow::Factory32(unsigned flags) { | 137 SkBlitRow::Proc32 SkBlitRow::Factory32(unsigned flags) { |
136 SkASSERT(flags < SK_ARRAY_COUNT(gDefault_Procs32)); | 138 SkASSERT(flags < SK_ARRAY_COUNT(gDefault_Procs32)); |
137 // just so we don't crash | 139 // just so we don't crash |
138 flags &= kFlags32_Mask; | 140 flags &= kFlags32_Mask; |
139 | 141 |
140 SkBlitRow::Proc32 proc = PlatformProcs32(flags); | 142 SkBlitRow::Proc32 proc = PlatformProcs32(flags); |
141 if (NULL == proc) { | 143 if (NULL == proc || !gUsePlatformOptsForFactory) { |
142 proc = gDefault_Procs32[flags]; | 144 proc = gDefault_Procs32[flags]; |
143 } | 145 } |
144 SkASSERT(proc); | 146 SkASSERT(proc); |
145 return proc; | 147 return proc; |
146 } | 148 } |
147 | 149 |
148 SkBlitRow::Proc32 SkBlitRow::ColorProcFactory() { | 150 SkBlitRow::Proc32 SkBlitRow::ColorProcFactory() { |
149 SkBlitRow::ColorProc proc = PlatformColorProc(); | 151 SkBlitRow::ColorProc proc = PlatformColorProc(); |
150 if (NULL == proc) { | 152 if (NULL == proc || !gUsePlatformOptsForFactory) { |
151 proc = Color32; | 153 proc = Color32; |
152 } | 154 } |
153 SkASSERT(proc); | 155 SkASSERT(proc); |
154 return proc; | 156 return proc; |
| 157 } |
| 158 |
| 159 void SkBlitRow::UsePlatformOptsForFactory(bool opts) |
| 160 { |
| 161 gUsePlatformOptsForFactory = opts; |
155 } | 162 } |
156 | 163 |
157 void SkBlitRow::Color32(SkPMColor* SK_RESTRICT dst, | 164 void SkBlitRow::Color32(SkPMColor* SK_RESTRICT dst, |
158 const SkPMColor* SK_RESTRICT src, | 165 const SkPMColor* SK_RESTRICT src, |
159 int count, SkPMColor color) { | 166 int count, SkPMColor color) { |
160 if (count > 0) { | 167 if (count > 0) { |
161 if (0 == color) { | 168 if (0 == color) { |
162 if (src != dst) { | 169 if (src != dst) { |
163 memcpy(dst, src, count * sizeof(SkPMColor)); | 170 memcpy(dst, src, count * sizeof(SkPMColor)); |
164 } | 171 } |
165 return; | 172 return; |
166 } | 173 } |
167 unsigned colorA = SkGetPackedA32(color); | 174 unsigned colorA = SkGetPackedA32(color); |
168 if (255 == colorA) { | 175 if (255 == colorA) { |
169 sk_memset32(dst, color, count); | 176 sk_memset32(dst, color, count); |
170 } else { | 177 } else { |
171 unsigned scale = 256 - SkAlpha255To256(colorA); | 178 unsigned scale = 256 - colorA; |
172 do { | 179 do { |
173 *dst = color + SkAlphaMulQ(*src, scale); | 180 *dst = color + SkAlphaMulQ(*src, scale); |
174 src += 1; | 181 src += 1; |
175 dst += 1; | 182 dst += 1; |
176 } while (--count); | 183 } while (--count); |
177 } | 184 } |
178 } | 185 } |
179 } | 186 } |
180 | 187 |
LEFT | RIGHT |