halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 8 | #include "SkSurface.h" |
| 9 | #include "Resources.h" |
| 10 | #include "gm.h" |
Mike Klein | 33d2055 | 2017-03-22 13:47:51 -0400 | [diff] [blame] | 11 | #include "sk_tool_utils.h" |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 12 | |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 13 | #include "SkColorPriv.h" |
Mike Reed | 94cca60 | 2018-12-02 16:04:27 -0500 | [diff] [blame] | 14 | #include "SkFont.h" |
| 15 | #include "SkMath.h" |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 16 | |
| 17 | static SkBitmap copy_bitmap(const SkBitmap& src, SkColorType colorType) { |
Matt Sarett | 68b8e3d | 2017-04-28 11:15:22 -0400 | [diff] [blame] | 18 | const SkBitmap* srcPtr = &src; |
| 19 | SkBitmap tmp(src); |
| 20 | if (kRGB_565_SkColorType == colorType) { |
| 21 | tmp.setAlphaType(kOpaque_SkAlphaType); |
| 22 | srcPtr = &tmp; |
| 23 | } |
| 24 | |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 25 | SkBitmap copy; |
Matt Sarett | 68b8e3d | 2017-04-28 11:15:22 -0400 | [diff] [blame] | 26 | sk_tool_utils::copy_to(©, colorType, *srcPtr); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 27 | copy.setImmutable(); |
| 28 | return copy; |
| 29 | } |
| 30 | |
| 31 | #define SCALE 128 |
| 32 | |
| 33 | // Make either A8 or gray8 bitmap. |
| 34 | static SkBitmap make_bitmap(SkColorType ct) { |
| 35 | SkBitmap bm; |
| 36 | switch (ct) { |
| 37 | case kAlpha_8_SkColorType: |
| 38 | bm.allocPixels(SkImageInfo::MakeA8(SCALE, SCALE)); |
| 39 | break; |
| 40 | case kGray_8_SkColorType: |
| 41 | bm.allocPixels( |
| 42 | SkImageInfo::Make(SCALE, SCALE, ct, kOpaque_SkAlphaType)); |
| 43 | break; |
| 44 | default: |
| 45 | SkASSERT(false); |
| 46 | return bm; |
| 47 | } |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 48 | uint8_t spectrum[256]; |
| 49 | for (int y = 0; y < 256; ++y) { |
| 50 | spectrum[y] = y; |
| 51 | } |
| 52 | for (int y = 0; y < 128; ++y) { |
| 53 | // Shift over one byte each scanline. |
| 54 | memcpy(bm.getAddr8(0, y), &spectrum[y], 128); |
| 55 | } |
| 56 | bm.setImmutable(); |
| 57 | return bm; |
| 58 | } |
| 59 | |
Mike Reed | 94cca60 | 2018-12-02 16:04:27 -0500 | [diff] [blame] | 60 | static void draw_center_letter(char c, const SkFont& font, SkColor color, |
| 61 | SkScalar x, SkScalar y, SkCanvas* canvas) { |
| 62 | SkPaint paint; |
| 63 | paint.setColor(color); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 64 | SkRect bounds; |
Mike Reed | 94cca60 | 2018-12-02 16:04:27 -0500 | [diff] [blame] | 65 | font.measureText(&c, 1, kUTF8_SkTextEncoding, &bounds); |
| 66 | canvas->drawSimpleText(&c, 1, kUTF8_SkTextEncoding, |
| 67 | x - bounds.centerX(), y - bounds.centerY(), |
| 68 | font, paint); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | static void color_wheel_native(SkCanvas* canvas) { |
| 72 | SkAutoCanvasRestore autoCanvasRestore(canvas, true); |
| 73 | canvas->translate(0.5f * SCALE, 0.5f * SCALE); |
| 74 | SkPaint p; |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 75 | p.setColor(SK_ColorWHITE); |
| 76 | canvas->drawCircle(0.0f, 0.0f, SCALE * 0.5f, p); |
| 77 | |
| 78 | const double sqrt_3_over_2 = 0.8660254037844387; |
| 79 | const SkScalar Z = 0.0f; |
| 80 | const SkScalar D = 0.3f * SkIntToScalar(SCALE); |
| 81 | const SkScalar X = SkDoubleToScalar(D * sqrt_3_over_2); |
| 82 | const SkScalar Y = D * SK_ScalarHalf; |
Mike Reed | 94cca60 | 2018-12-02 16:04:27 -0500 | [diff] [blame] | 83 | |
| 84 | SkFont font; |
| 85 | font.setEdging(SkFont::Edging::kAlias); |
| 86 | font.setTypeface(sk_tool_utils::create_portable_typeface(nullptr, SkFontStyle::Bold())); |
| 87 | font.setSize(0.28125f * SCALE); |
| 88 | draw_center_letter('K', font, SK_ColorBLACK, Z, Z, canvas); |
| 89 | draw_center_letter('R', font, SK_ColorRED, Z, D, canvas); |
| 90 | draw_center_letter('G', font, SK_ColorGREEN, -X, -Y, canvas); |
| 91 | draw_center_letter('B', font, SK_ColorBLUE, X, -Y, canvas); |
| 92 | draw_center_letter('C', font, SK_ColorCYAN, Z, -D, canvas); |
| 93 | draw_center_letter('M', font, SK_ColorMAGENTA, X, Y, canvas); |
| 94 | draw_center_letter('Y', font, SK_ColorYELLOW, -X, Y, canvas); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | template <typename T> |
| 98 | int find(T* array, int N, T item) { |
| 99 | for (int i = 0; i < N; ++i) { |
| 100 | if (array[i] == item) { |
| 101 | return i; |
| 102 | } |
| 103 | } |
| 104 | return -1; |
| 105 | } |
| 106 | |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 107 | static void draw(SkCanvas* canvas, |
| 108 | const SkPaint& p, |
| 109 | const SkBitmap& src, |
| 110 | SkColorType colorType, |
| 111 | const char text[]) { |
| 112 | SkASSERT(src.colorType() == colorType); |
| 113 | canvas->drawBitmap(src, 0.0f, 0.0f); |
Cary Clark | 2a475ea | 2017-04-28 15:35:12 -0400 | [diff] [blame] | 114 | canvas->drawString(text, 0.0f, 12.0f, p); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 115 | } |
| 116 | |
Brian Osman | 567f4fd | 2018-09-12 11:48:38 -0400 | [diff] [blame] | 117 | DEF_SIMPLE_GM(all_bitmap_configs, canvas, SCALE, 6 * SCALE) { |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 118 | SkAutoCanvasRestore autoCanvasRestore(canvas, true); |
| 119 | SkPaint p; |
| 120 | p.setColor(SK_ColorBLACK); |
| 121 | p.setAntiAlias(true); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 122 | sk_tool_utils::set_portable_typeface(&p, nullptr); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 123 | |
| 124 | sk_tool_utils::draw_checkerboard(canvas, SK_ColorLTGRAY, SK_ColorWHITE, 8); |
| 125 | |
| 126 | SkBitmap bitmap; |
Hal Canary | c465d13 | 2017-12-08 10:21:31 -0500 | [diff] [blame] | 127 | if (GetResourceAsBitmap("images/color_wheel.png", &bitmap)) { |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 128 | bitmap.setImmutable(); |
| 129 | draw(canvas, p, bitmap, kN32_SkColorType, "Native 32"); |
| 130 | |
| 131 | canvas->translate(0.0f, SkIntToScalar(SCALE)); |
| 132 | SkBitmap copy565 = copy_bitmap(bitmap, kRGB_565_SkColorType); |
| 133 | p.setColor(SK_ColorRED); |
| 134 | draw(canvas, p, copy565, kRGB_565_SkColorType, "RGB 565"); |
| 135 | p.setColor(SK_ColorBLACK); |
| 136 | |
| 137 | canvas->translate(0.0f, SkIntToScalar(SCALE)); |
| 138 | SkBitmap copy4444 = copy_bitmap(bitmap, kARGB_4444_SkColorType); |
| 139 | draw(canvas, p, copy4444, kARGB_4444_SkColorType, "ARGB 4444"); |
Brian Osman | 567f4fd | 2018-09-12 11:48:38 -0400 | [diff] [blame] | 140 | |
| 141 | canvas->translate(0.0f, SkIntToScalar(SCALE)); |
| 142 | SkBitmap copyF16 = copy_bitmap(bitmap, kRGBA_F16_SkColorType); |
| 143 | draw(canvas, p, copyF16, kRGBA_F16_SkColorType, "RGBA F16"); |
| 144 | |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 145 | } else { |
Brian Osman | 567f4fd | 2018-09-12 11:48:38 -0400 | [diff] [blame] | 146 | canvas->translate(0.0f, SkIntToScalar(3 * SCALE)); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 147 | } |
| 148 | |
| 149 | canvas->translate(0.0f, SkIntToScalar(SCALE)); |
halcanary | db0dcc7 | 2015-03-20 12:31:52 -0700 | [diff] [blame] | 150 | SkBitmap bitmapA8 = make_bitmap(kAlpha_8_SkColorType); |
| 151 | draw(canvas, p, bitmapA8, kAlpha_8_SkColorType, "Alpha 8"); |
| 152 | |
| 153 | p.setColor(SK_ColorRED); |
| 154 | canvas->translate(0.0f, SkIntToScalar(SCALE)); |
| 155 | SkBitmap bitmapG8 = make_bitmap(kGray_8_SkColorType); |
| 156 | draw(canvas, p, bitmapG8, kGray_8_SkColorType, "Gray 8"); |
| 157 | } |
halcanary | aa4ba90 | 2015-11-06 07:27:23 -0800 | [diff] [blame] | 158 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 159 | sk_sp<SkImage> make_not_native32_color_wheel() { |
halcanary | aa4ba90 | 2015-11-06 07:27:23 -0800 | [diff] [blame] | 160 | SkBitmap n32bitmap, notN32bitmap; |
| 161 | n32bitmap.allocN32Pixels(SCALE, SCALE); |
| 162 | n32bitmap.eraseColor(SK_ColorTRANSPARENT); |
| 163 | SkCanvas n32canvas(n32bitmap); |
| 164 | color_wheel_native(&n32canvas); |
| 165 | n32canvas.flush(); |
| 166 | #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) |
| 167 | const SkColorType ct = kRGBA_8888_SkColorType; |
| 168 | #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) |
| 169 | const SkColorType ct = kBGRA_8888_SkColorType; |
| 170 | #endif |
| 171 | static_assert(ct != kN32_SkColorType, "BRGA!=RGBA"); |
Matt Sarett | 68b8e3d | 2017-04-28 11:15:22 -0400 | [diff] [blame] | 172 | SkAssertResult(sk_tool_utils::copy_to(¬N32bitmap, ct, n32bitmap)); |
halcanary | aa4ba90 | 2015-11-06 07:27:23 -0800 | [diff] [blame] | 173 | SkASSERT(notN32bitmap.colorType() == ct); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 174 | return SkImage::MakeFromBitmap(notN32bitmap); |
halcanary | aa4ba90 | 2015-11-06 07:27:23 -0800 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | DEF_SIMPLE_GM(not_native32_bitmap_config, canvas, SCALE, SCALE) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 178 | sk_sp<SkImage> notN32image(make_not_native32_color_wheel()); |
halcanary | aa4ba90 | 2015-11-06 07:27:23 -0800 | [diff] [blame] | 179 | SkASSERT(notN32image); |
| 180 | sk_tool_utils::draw_checkerboard(canvas, SK_ColorLTGRAY, SK_ColorWHITE, 8); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 181 | canvas->drawImage(notN32image.get(), 0.0f, 0.0f); |
halcanary | aa4ba90 | 2015-11-06 07:27:23 -0800 | [diff] [blame] | 182 | } |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 183 | |
| 184 | static uint32_t make_pixel(int x, int y, SkAlphaType alphaType) { |
| 185 | SkASSERT(x >= 0 && x < SCALE); |
| 186 | SkASSERT(y >= 0 && y < SCALE); |
| 187 | |
| 188 | SkScalar R = SCALE / 2.0f; |
| 189 | |
| 190 | uint32_t alpha = 0x00; |
| 191 | |
| 192 | if ((x - R) * (x - R) + (y - R) * (y - R) < R * R) { |
| 193 | alpha = 0xFF; |
| 194 | } |
| 195 | |
| 196 | uint32_t component; |
| 197 | switch (alphaType) { |
| 198 | case kPremul_SkAlphaType: |
| 199 | component = alpha; |
| 200 | break; |
| 201 | case kUnpremul_SkAlphaType: |
| 202 | component = 0xFF; |
| 203 | break; |
| 204 | default: |
Ben Wagner | b4aab9a | 2017-08-16 10:53:04 -0400 | [diff] [blame] | 205 | SK_ABORT("Should not get here - invalid alpha type"); |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 206 | return 0xFF000000; |
| 207 | } |
| 208 | return alpha << 24 | component; |
| 209 | } |
| 210 | |
| 211 | static void make_color_test_bitmap_variant( |
| 212 | SkColorType colorType, |
| 213 | SkAlphaType alphaType, |
brianosman | 52ede1d | 2016-06-20 08:25:02 -0700 | [diff] [blame] | 214 | sk_sp<SkColorSpace> colorSpace, |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 215 | SkBitmap* bm) |
| 216 | { |
| 217 | SkASSERT(colorType == kRGBA_8888_SkColorType || colorType == kBGRA_8888_SkColorType); |
| 218 | SkASSERT(alphaType == kPremul_SkAlphaType || alphaType == kUnpremul_SkAlphaType); |
| 219 | bm->allocPixels( |
brianosman | 52ede1d | 2016-06-20 08:25:02 -0700 | [diff] [blame] | 220 | SkImageInfo::Make(SCALE, SCALE, colorType, alphaType, colorSpace)); |
Hal Canary | 99578d2 | 2017-12-14 21:13:47 -0500 | [diff] [blame] | 221 | const SkPixmap& pm = bm->pixmap(); |
Hal Canary | a088365 | 2017-12-14 15:33:23 -0500 | [diff] [blame] | 222 | for (int y = 0; y < pm.height(); y++) { |
| 223 | for (int x = 0; x < pm.width(); x++) { |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 224 | *pm.writable_addr32(x, y) = make_pixel(x, y, alphaType); |
| 225 | } |
| 226 | } |
| 227 | } |
| 228 | |
Joe Gregorio | c485907 | 2017-01-20 14:21:27 +0000 | [diff] [blame] | 229 | DEF_SIMPLE_GM(all_variants_8888, canvas, 4 * SCALE + 30, 2 * SCALE + 10) { |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 230 | sk_tool_utils::draw_checkerboard(canvas, SK_ColorLTGRAY, SK_ColorWHITE, 8); |
| 231 | |
brianosman | 52ede1d | 2016-06-20 08:25:02 -0700 | [diff] [blame] | 232 | sk_sp<SkColorSpace> colorSpaces[] { |
Matt Sarett | 77a7a1b | 2017-02-07 13:56:11 -0500 | [diff] [blame] | 233 | SkColorSpace::MakeSRGB(), |
brianosman | 52ede1d | 2016-06-20 08:25:02 -0700 | [diff] [blame] | 234 | nullptr, |
brianosman | 52ede1d | 2016-06-20 08:25:02 -0700 | [diff] [blame] | 235 | }; |
| 236 | for (auto colorSpace : colorSpaces) { |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 237 | canvas->save(); |
| 238 | for (auto alphaType : {kPremul_SkAlphaType, kUnpremul_SkAlphaType}) { |
| 239 | canvas->save(); |
| 240 | for (auto colorType : {kRGBA_8888_SkColorType, kBGRA_8888_SkColorType}) { |
| 241 | SkBitmap bm; |
brianosman | 52ede1d | 2016-06-20 08:25:02 -0700 | [diff] [blame] | 242 | make_color_test_bitmap_variant(colorType, alphaType, colorSpace, &bm); |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 243 | canvas->drawBitmap(bm, 0.0f, 0.0f); |
| 244 | canvas->translate(SCALE + 10, 0.0f); |
| 245 | } |
| 246 | canvas->restore(); |
Joe Gregorio | c485907 | 2017-01-20 14:21:27 +0000 | [diff] [blame] | 247 | canvas->translate(0.0f, SCALE + 10); |
herb | 5823846 | 2016-06-03 09:44:53 -0700 | [diff] [blame] | 248 | } |
| 249 | canvas->restore(); |
| 250 | canvas->translate(2 * (SCALE + 10), 0.0f); |
| 251 | } |
| 252 | } |