OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2012 Google Inc. |
| 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 #include "Test.h" |
| 9 #include "SkBitmap.h" |
| 10 #include "SkBlitter.h" |
| 11 #include "SkBlitRow.h" |
| 12 #include "SkColor.h" |
| 13 #include "SkColorPriv.h" |
| 14 #include "SkColorShader.h" |
| 15 #include "SkGradientShader.h" |
| 16 #include "SkPaint.h" |
| 17 |
| 18 #define COLOR_STEP 11 |
| 19 #define ALPHA_STEP 5 |
| 20 #define AA_STEP 7 |
| 21 |
| 22 typedef uint16_t PMColorOut; |
| 23 |
| 24 static bool next_color(SkColor& color) { |
| 25 unsigned a = SkColorGetA(color); |
| 26 unsigned r = SkColorGetR(color) + COLOR_STEP; |
| 27 unsigned g = SkColorGetG(color) + COLOR_STEP; |
| 28 unsigned b = SkColorGetB(color) + COLOR_STEP; |
| 29 |
| 30 // Spread the 3 color channels out |
| 31 if (r == COLOR_STEP) |
| 32 r -= COLOR_STEP/3; |
| 33 if (g == COLOR_STEP) |
| 34 g -= COLOR_STEP*2/3; |
| 35 |
| 36 if (r > 255) { |
| 37 if (a == 255) |
| 38 return false; |
| 39 r = g = b = 0; |
| 40 a += ALPHA_STEP; |
| 41 a = a <= 255 ? a : 255; |
| 42 } |
| 43 color = SkColorSetARGBInline(a, r, g, b); |
| 44 return true; |
| 45 } |
| 46 |
| 47 static bool next_aa(U8CPU& a) { |
| 48 if (a == 255) |
| 49 return false; |
| 50 a += AA_STEP; |
| 51 a = a <= 255 ? a : 255; |
| 52 return true; |
| 53 } |
| 54 |
| 55 static void skip_test(SkColor& dstIn, SkColor& srcIn) { |
| 56 dstIn = srcIn = 0xffffffff; |
| 57 } |
| 58 |
| 59 static void skip_test(SkColor& dstIn, SkColor& srcIn, U8CPU& aa) { |
| 60 skip_test(dstIn, srcIn); |
| 61 aa = 0xff; |
| 62 } |
| 63 |
| 64 struct BlendOp { virtual PMColorOut operator()(PMColorOut dstIn, SkPMColor srcIn
, SkColor srcInOrig, U8CPU aa) = 0; }; |
| 65 |
| 66 enum TestCaseFlags { |
| 67 kOnlyOpaque = 1 << 0, // Only opaque input colors are valid for this functio
n |
| 68 kOnlyOpaqueAA = 1 << 2, // Only opaque AA is valid for this function |
| 69 kOnlyNonOpaqueAA = 1 << 3, // Only non-opaque AA is valid for this function |
| 70 }; |
| 71 |
| 72 static bool testCaseValid(unsigned flags, SkPMColor srcIn, U8CPU aa) { |
| 73 if (flags & kOnlyOpaque && SkGetPackedA32(srcIn) != 0xff) |
| 74 return false; |
| 75 if (flags & kOnlyOpaqueAA && aa != 0xff) |
| 76 return false; |
| 77 if (flags & kOnlyNonOpaqueAA && aa == 0xff) |
| 78 return false; |
| 79 return true; |
| 80 } |
| 81 |
| 82 struct TestCase { |
| 83 unsigned flags; |
| 84 BlendOp* func; |
| 85 }; |
| 86 |
| 87 struct CompareTestCase { |
| 88 unsigned flags; |
| 89 BlendOp* funcA; |
| 90 BlendOp* funcB; |
| 91 }; |
| 92 |
| 93 // If srcAlpha == 0 then dstOut == dstIn |
| 94 static void test_src_alpha_0(skiatest::Reporter* reporter, TestCase tests[]) { |
| 95 SkColor srcIn = 0; |
| 96 SkColor dstIn = 0; |
| 97 U8CPU aa = 0; |
| 98 for (int i = 0; tests[i].func; ++i) { |
| 99 do { |
| 100 if (!SkColorGetA(srcIn)) { |
| 101 do { |
| 102 do { |
| 103 SkPMColor srcIn8888 = SkPreMultiplyColor(srcIn); |
| 104 PMColorOut dstIn4444 = SkPixel32ToPixel4444(SkPreMultipl
yColor(dstIn)); |
| 105 PMColorOut dstOut; |
| 106 |
| 107 if (!testCaseValid(tests[i].flags, srcIn8888, aa)) |
| 108 continue; |
| 109 |
| 110 dstOut = (*tests[i].func)(dstIn4444, srcIn8888, srcIn, a
a); |
| 111 if (dstOut != dstIn4444) { |
| 112 reporter->reportFailed("FAILED: dstOut == dstIn4444
: srcAlpha == 0 modified target pixels"); |
| 113 skip_test(dstIn, srcIn, aa); |
| 114 } |
| 115 } while (next_aa(aa)); |
| 116 } while (next_color(dstIn)); |
| 117 } |
| 118 } while (next_color(srcIn)); |
| 119 } |
| 120 } |
| 121 |
| 122 // If srcAlpha == 0xff then dstOut == srcIn |
| 123 static void test_src_alpha_ff(skiatest::Reporter* reporter, TestCase tests[]) { |
| 124 SkColor srcIn = 0; |
| 125 SkColor dstIn = 0; |
| 126 do { |
| 127 if (SkColorGetA(srcIn) == 0xff) { |
| 128 do { |
| 129 SkPMColor srcIn8888 = SkPreMultiplyColor(srcIn); |
| 130 PMColorOut srcIn4444 = SkPixel32ToPixel4444(SkPreMultiplyColor(s
rcIn)); |
| 131 PMColorOut dstIn4444 = SkPixel32ToPixel4444(SkPreMultiplyColor(d
stIn)); |
| 132 PMColorOut dstOut; |
| 133 |
| 134 for (int i = 0; tests[i].func; ++i) { |
| 135 if (!testCaseValid(tests[i].flags, srcIn8888, 0xff)) |
| 136 continue; |
| 137 |
| 138 dstOut = (*tests[i].func)(dstIn4444, srcIn8888, srcIn, 0xff)
; |
| 139 if (dstOut != srcIn4444) { |
| 140 reporter->reportFailed("dstOut == srcIn4444 : srcAlpha =
= 0xff didn't fully overwrite target pixels"); |
| 141 skip_test(dstIn, srcIn); |
| 142 } |
| 143 } |
| 144 } while (next_color(dstIn)); |
| 145 } |
| 146 } while (next_color(srcIn)); |
| 147 } |
| 148 |
| 149 // If dstAlpha == 0xff then dstOutAlpha == 0xff |
| 150 static void test_dst_alpha_ff(skiatest::Reporter* reporter, TestCase tests[]) { |
| 151 SkColor srcIn = 0; |
| 152 SkColor dstIn = 0; |
| 153 U8CPU aa = 0; |
| 154 do { |
| 155 if (SkColorGetA(dstIn) == 0xff) { |
| 156 do { |
| 157 do { |
| 158 SkPMColor srcIn8888 = SkPreMultiplyColor(srcIn); |
| 159 PMColorOut dstIn4444 = SkPixel32ToPixel4444(SkPreMultiplyCol
or(dstIn)); |
| 160 PMColorOut dstOut; |
| 161 |
| 162 for (int i = 0; tests[i].func; ++i) { |
| 163 if (!testCaseValid(tests[i].flags, srcIn8888, aa)) |
| 164 continue; |
| 165 |
| 166 dstOut = (*tests[i].func)(dstIn4444, srcIn8888, srcIn, a
a); |
| 167 if (SkGetPackedA4444(dstOut) != 0xf) { |
| 168 reporter->reportFailed("SkGetPackedA4444(dstOut) ==
0xf : dstAlpha == 0xff but became non-opaque from blend"); |
| 169 skip_test(dstIn, srcIn, aa); |
| 170 } |
| 171 } |
| 172 } while (next_aa(aa)); |
| 173 } while (next_color(srcIn)); |
| 174 } |
| 175 } while (next_color(dstIn)); |
| 176 } |
| 177 |
| 178 // Test two methods give the same results |
| 179 static void test_equal(skiatest::Reporter* reporter, CompareTestCase tests[]) { |
| 180 SkColor srcIn = 0; |
| 181 SkColor dstIn = 0; |
| 182 U8CPU aa = 0; |
| 183 do { |
| 184 do { |
| 185 do { |
| 186 SkPMColor srcIn8888 = SkPreMultiplyColor(srcIn); |
| 187 PMColorOut dstIn4444 = SkPixel32ToPixel4444(SkPreMultiplyColor(d
stIn)); |
| 188 PMColorOut dstOutA, dstOutB; |
| 189 |
| 190 for (int i = 0; tests[i].funcA; ++i) { |
| 191 if (!testCaseValid(tests[i].flags, srcIn8888, aa)) |
| 192 continue; |
| 193 |
| 194 dstOutA = (*tests[i].funcA)(dstIn4444, srcIn8888, srcIn, aa)
; |
| 195 dstOutB = (*tests[i].funcB)(dstIn4444, srcIn8888, srcIn, aa)
; |
| 196 if (dstOutA != dstOutB) { |
| 197 reporter->reportFailed("dstOutA == dstOutB : expected eq
ual outputs but they differ"); |
| 198 skip_test(dstIn, srcIn, aa); |
| 199 } |
| 200 } |
| 201 } while (next_aa(aa)); |
| 202 } while (next_color(dstIn)); |
| 203 } while (next_color(srcIn)); |
| 204 } |
| 205 |
| 206 ////////////////////////////////////////////////////////////////////////// |
| 207 |
| 208 // Operation types |
| 209 |
| 210 struct BitmapOp { virtual void operator()(SkBitmap&, SkPMColor srcIn, SkColor sr
cInOrig, U8CPU aa) = 0; }; |
| 211 struct BlitterOp { virtual void operator()(SkBlitter&, U8CPU aa) = 0; }; |
| 212 |
| 213 struct BlitterMaskOp : public BlitterOp { |
| 214 uint8_t image[1]; |
| 215 SkMask mask(U8CPU aa) { |
| 216 SkMask mask; |
| 217 image[0] = aa; |
| 218 mask.fImage = image; |
| 219 mask.fBounds = SkIRect::MakeWH(1, 1); |
| 220 mask.fRowBytes = 0; |
| 221 mask.fFormat = SkMask::kA8_Format; |
| 222 return mask; |
| 223 } |
| 224 }; |
| 225 |
| 226 // Operation adapters |
| 227 |
| 228 struct BlendToBitmap4444Op : public BlendOp { |
| 229 explicit BlendToBitmap4444Op(BitmapOp* bitmapOp) : fBitmapOp(bitmapOp) { } |
| 230 virtual ~BlendToBitmap4444Op() { delete fBitmapOp; } |
| 231 BitmapOp* fBitmapOp; |
| 232 |
| 233 virtual PMColorOut operator()(PMColorOut dstIn, SkPMColor srcIn, SkColor src
InOrig, U8CPU aa) { |
| 234 SkBitmap bitmap; |
| 235 bitmap.setConfig(SkBitmap::kARGB_4444_Config, 4, 4); |
| 236 bitmap.allocPixels(); |
| 237 bitmap.getAddr16(0, 0)[0] = dstIn; |
| 238 (*fBitmapOp)(bitmap, srcIn, srcInOrig, aa); |
| 239 SkPMColor out = *bitmap.getAddr16(0, 0); |
| 240 return out; |
| 241 } |
| 242 }; |
| 243 |
| 244 struct BitmapToBlitterOpColor : public BitmapOp { |
| 245 explicit BitmapToBlitterOpColor(BlitterOp* blitterOp) : fBlitterOp(blitterOp
) { } |
| 246 virtual ~BitmapToBlitterOpColor() { delete fBlitterOp; } |
| 247 BlitterOp* fBlitterOp; |
| 248 |
| 249 virtual void operator()(SkBitmap& bitmap, SkPMColor srcIn, SkColor srcInOrig
, U8CPU aa) { |
| 250 SkPaint paint; |
| 251 paint.setColor(srcInOrig); |
| 252 SkBlitter* blitter = SkBlitter::Choose(bitmap, SkMatrix::I(), paint); |
| 253 (*fBlitterOp)(*blitter, aa); |
| 254 delete blitter; |
| 255 } |
| 256 }; |
| 257 |
| 258 struct BitmapToBlitterOpColorShader : public BitmapOp { |
| 259 explicit BitmapToBlitterOpColorShader(BlitterOp* blitterOp) : fBlitterOp(bli
tterOp) { } |
| 260 virtual ~BitmapToBlitterOpColorShader() { delete fBlitterOp; } |
| 261 BlitterOp* fBlitterOp; |
| 262 |
| 263 virtual void operator()(SkBitmap& bitmap, SkPMColor srcIn, SkColor srcInOrig
, U8CPU aa) { |
| 264 SkPaint paint; |
| 265 paint.setShader(new SkColorShader(srcInOrig)); |
| 266 SkBlitter* blitter = SkBlitter::Choose(bitmap, SkMatrix::I(), paint); |
| 267 (*fBlitterOp)(*blitter, aa); |
| 268 delete blitter; |
| 269 } |
| 270 }; |
| 271 |
| 272 struct BitmapToBlitterOpGradientShader : public BitmapOp { |
| 273 explicit BitmapToBlitterOpGradientShader(BlitterOp* blitterOp) : fBlitterOp(
blitterOp) { } |
| 274 virtual ~BitmapToBlitterOpGradientShader() { delete fBlitterOp; } |
| 275 BlitterOp* fBlitterOp; |
| 276 |
| 277 virtual void operator()(SkBitmap& bitmap, SkPMColor srcIn, SkColor srcInOrig
, U8CPU aa) { |
| 278 SkPaint paint; |
| 279 SkPoint pts[2] = { SkPoint::Make(0, 0), SkPoint::Make(1, 1) }; |
| 280 SkColor colors[2] = { srcInOrig, srcInOrig }; |
| 281 paint.setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkS
hader::kRepeat_TileMode, NULL)); |
| 282 SkBlitter* blitter = SkBlitter::Choose(bitmap, SkMatrix::I(), paint); |
| 283 (*fBlitterOp)(*blitter, aa); |
| 284 delete blitter; |
| 285 } |
| 286 }; |
| 287 |
| 288 // Test operations |
| 289 |
| 290 struct S32_D4444_Opaque_BlitRowOp : public BlendOp { virtual PMColorOut operator
()(PMColorOut dstIn, SkPMColor srcIn, SkColor srcInOrig, U8CPU aa) { SkBlitRow::
Factory(0, SkBitmap::kARGB_4444_Config)(&dstIn, &srcIn, 1, aa, 0, 0); return dst
In; } }; |
| 291 struct S32_D4444_Blend_BlitRowOp : public BlendOp { virtual PMColorOut operator(
)(PMColorOut dstIn, SkPMColor srcIn, SkColor srcInOrig, U8CPU aa) { SkBlitRow::F
actory(1, SkBitmap::kARGB_4444_Config)(&dstIn, &srcIn, 1, aa, 0, 0); return dstI
n; } }; |
| 292 struct S32A_D4444_Opaque_BlitRowOp : public BlendOp { virtual PMColorOut operato
r()(PMColorOut dstIn, SkPMColor srcIn, SkColor srcInOrig, U8CPU aa) { SkBlitRow:
:Factory(2, SkBitmap::kARGB_4444_Config)(&dstIn, &srcIn, 1, aa, 0, 0); return ds
tIn; } }; |
| 293 struct S32A_D4444_Blend_BlitRowOp : public BlendOp { virtual PMColorOut operator
()(PMColorOut dstIn, SkPMColor srcIn, SkColor srcInOrig, U8CPU aa) { SkBlitRow::
Factory(3, SkBitmap::kARGB_4444_Config)(&dstIn, &srcIn, 1, aa, 0, 0); return dst
In; } }; |
| 294 struct ARGB4444_Blitter_BlitH : public BlitterOp { virtual void operator()(SkBli
tter& blitter, U8CPU aa) { blitter.blitH(0, 0, 1); } }; |
| 295 struct ARGB4444_Blitter_BlitV : public BlitterOp { virtual void operator()(SkBli
tter& blitter, U8CPU aa) { blitter.blitV(0, 0, 1, aa); } }; |
| 296 struct ARGB4444_Blitter_BlitAntiH : public BlitterOp { virtual void operator()(S
kBlitter& blitter, U8CPU aa) { int16_t runs[] = { 1, 0 }; SkAlpha aaArray[] = {
aa }; blitter.blitAntiH(0, 0, aaArray, runs); } }; |
| 297 struct ARGB4444_Blitter_BlitRect : public BlitterOp { virtual void operator()(Sk
Blitter& blitter, U8CPU aa) { blitter.blitRect(0, 0, 1, 1); } }; |
| 298 struct ARGB4444_Blitter_BlitAntiRect : public BlitterOp { virtual void operator(
)(SkBlitter& blitter, U8CPU aa) { blitter.blitAntiRect(0, 0, 2, 2, aa, aa); } }; |
| 299 struct ARGB4444_Blitter_BlitMask : public BlitterMaskOp { virtual void operator(
)(SkBlitter& blitter, U8CPU aa) { blitter.blitMask(mask(aa), SkIRect::MakeWH(1,
1)); } }; |
| 300 |
| 301 static TestCase tests[] = { |
| 302 { kOnlyOpaque | kOnlyOpaqueAA, new S32_D4444_Opaque_BlitRowOp() }, |
| 303 { kOnlyOpaque | kOnlyNonOpaqueAA, new S32_D4444_Blend_BlitRowOp() }, |
| 304 { kOnlyOpaqueAA, new S32A_D4444_Opaque_BlitRowOp() }, |
| 305 { kOnlyNonOpaqueAA, new S32A_D4444_Blend_BlitRowOp() }, |
| 306 |
| 307 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitH)) }, |
| 308 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitV())) }, |
| 309 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitAntiH())) }, |
| 310 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitRect())) }, |
| 311 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitAntiRect())) }, |
| 312 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitMask())) }, |
| 313 |
| 314 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
ColorShader(new ARGB4444_Blitter_BlitH)) }, |
| 315 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
ColorShader(new ARGB4444_Blitter_BlitV())) }, |
| 316 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
ColorShader(new ARGB4444_Blitter_BlitAntiH())) }, |
| 317 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
ColorShader(new ARGB4444_Blitter_BlitRect())) }, |
| 318 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
ColorShader(new ARGB4444_Blitter_BlitAntiRect())) }, |
| 319 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
ColorShader(new ARGB4444_Blitter_BlitMask())) }, |
| 320 |
| 321 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
GradientShader(new ARGB4444_Blitter_BlitH)) }, |
| 322 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
GradientShader(new ARGB4444_Blitter_BlitV())) }, |
| 323 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
GradientShader(new ARGB4444_Blitter_BlitAntiH())) }, |
| 324 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
GradientShader(new ARGB4444_Blitter_BlitRect())) }, |
| 325 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
GradientShader(new ARGB4444_Blitter_BlitAntiRect())) }, |
| 326 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
GradientShader(new ARGB4444_Blitter_BlitMask())) }, |
| 327 { 0, 0 } |
| 328 }; |
| 329 |
| 330 static CompareTestCase equal_tests[] = { |
| 331 { kOnlyOpaque | kOnlyOpaqueAA, new S32_D4444_Opaque_BlitRowOp(), new S32A
_D4444_Opaque_BlitRowOp() }, |
| 332 { kOnlyOpaque | kOnlyNonOpaqueAA, new S32_D4444_Blend_BlitRowOp(), new S32A
_D4444_Blend_BlitRowOp() }, |
| 333 |
| 334 { kOnlyOpaque | kOnlyOpaqueAA, new S32_D4444_Opaque_BlitRowOp(), new BlendT
oBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitH())) }, |
| 335 { kOnlyOpaqueAA, new S32A_D4444_Opaque_BlitRowOp(), new BlendT
oBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitH())) }, |
| 336 |
| 337 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter
_BlitH())), new BlendToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blit
ter_BlitV())) }, |
| 338 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter
_BlitH())), new BlendToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blit
ter_BlitRect())) }, |
| 339 |
| 340 { kOnlyOpaque | kOnlyOpaqueAA, new S32_D4444_Opaque_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiH())) }
, |
| 341 { kOnlyOpaque | kOnlyNonOpaqueAA, new S32_D4444_Blend_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiH())) }
, |
| 342 { kOnlyOpaqueAA, new S32A_D4444_Opaque_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiH())) }
, |
| 343 { kOnlyNonOpaqueAA, new S32A_D4444_Blend_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiH())) }
, |
| 344 |
| 345 { kOnlyOpaque | kOnlyOpaqueAA, new S32_D4444_Opaque_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiRect())
) }, |
| 346 { kOnlyOpaque | kOnlyNonOpaqueAA, new S32_D4444_Blend_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiRect())
) }, |
| 347 { kOnlyOpaqueAA, new S32A_D4444_Opaque_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiRect())
) }, |
| 348 { kOnlyNonOpaqueAA, new S32A_D4444_Blend_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitAntiRect())
) }, |
| 349 |
| 350 { kOnlyOpaque | kOnlyOpaqueAA, new S32_D4444_Opaque_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitMask())) }, |
| 351 { kOnlyOpaque | kOnlyNonOpaqueAA, new S32_D4444_Blend_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitMask())) }, |
| 352 { kOnlyOpaqueAA, new S32A_D4444_Opaque_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitMask())) }, |
| 353 { kOnlyNonOpaqueAA, new S32A_D4444_Blend_BlitRowOp(), new Ble
ndToBitmap4444Op(new BitmapToBlitterOpColor(new ARGB4444_Blitter_BlitMask())) }, |
| 354 |
| 355 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitH)), new BlendToBitmap4444Op(new BitmapT
oBlitterOpColorShader(new ARGB4444_Blitter_BlitH)) }, |
| 356 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitV())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpColorShader(new ARGB4444_Blitter_BlitV())) }, |
| 357 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitAntiH())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpColorShader(new ARGB4444_Blitter_BlitAntiH())) }, |
| 358 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitRect())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpColorShader(new ARGB4444_Blitter_BlitRect())) }, |
| 359 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitAntiRect())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpColorShader(new ARGB4444_Blitter_BlitAntiRect())) }, |
| 360 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitMask())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpColorShader(new ARGB4444_Blitter_BlitMask())) }, |
| 361 |
| 362 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitH)), new BlendToBitmap4444Op(new BitmapT
oBlitterOpGradientShader(new ARGB4444_Blitter_BlitH)) }, |
| 363 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitV())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpGradientShader(new ARGB4444_Blitter_BlitV())) }, |
| 364 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitAntiH())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpGradientShader(new ARGB4444_Blitter_BlitAntiH())) }, |
| 365 { kOnlyOpaqueAA, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitRect())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpGradientShader(new ARGB4444_Blitter_BlitRect())) }, |
| 366 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitAntiRect())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpGradientShader(new ARGB4444_Blitter_BlitAntiRect())) }, |
| 367 { 0, new BlendToBitmap4444Op(new BitmapToBlitterOp
Color(new ARGB4444_Blitter_BlitMask())), new BlendToBitmap4444Op(new BitmapT
oBlitterOpGradientShader(new ARGB4444_Blitter_BlitMask())) }, |
| 368 { 0, 0, 0 } |
| 369 }; |
| 370 |
| 371 static void cleanup_tests(TestCase tests[], CompareTestCase compareTests[]) |
| 372 { |
| 373 for (int i = 0; tests[i].func; ++i) |
| 374 delete tests[i].func; |
| 375 for (int i = 0; compareTests[i].funcA; ++i) { |
| 376 delete compareTests[i].funcA; |
| 377 delete compareTests[i].funcB; |
| 378 } |
| 379 } |
| 380 |
| 381 static void Test4444Blend(skiatest::Reporter* reporter) { |
| 382 SkBlitRow::UsePlatformOptsForFactory(true); |
| 383 test_src_alpha_0(reporter, tests); |
| 384 test_src_alpha_ff(reporter, tests); |
| 385 test_dst_alpha_ff(reporter, tests); |
| 386 test_equal(reporter, equal_tests); |
| 387 |
| 388 SkBlitRow::UsePlatformOptsForFactory(false); |
| 389 test_src_alpha_0(reporter, tests); |
| 390 test_src_alpha_ff(reporter, tests); |
| 391 test_dst_alpha_ff(reporter, tests); |
| 392 test_equal(reporter, equal_tests); |
| 393 |
| 394 cleanup_tests(tests, equal_tests); |
| 395 } |
| 396 |
| 397 #include "TestClassDef.h" |
| 398 DEFINE_TESTCLASS("Blend4444Test", TestBlend4444Class, Test4444Blend) |
OLD | NEW |