1/* 2 * Copyright 2016 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 "gm.h" 9#include "sk_tool_utils.h" 10 11#include "Resources.h" 12#include "SkColorPriv.h" 13#include "SkGradientShader.h" 14#include "SkTypeface.h" 15#include "SkStream.h" 16#include "SkPaint.h" 17#include "SkMipMap.h" 18#include "Resources.h" 19 20#define SHOW_MIP_COLOR 0xFF000000 21 22static SkBitmap make_bitmap(int w, int h) { 23 SkBitmap bm; 24 bm.allocN32Pixels(w, h); 25 SkCanvas canvas(bm); 26 canvas.clear(0xFFFFFFFF); 27 SkPaint paint; 28 paint.setStyle(SkPaint::kStroke_Style); 29 paint.setStrokeWidth(w / 16.0f); 30 paint.setColor(SHOW_MIP_COLOR); 31 canvas.drawCircle(w/2.0f, h/2.0f, w/3.0f, paint); 32 return bm; 33} 34 35static SkBitmap make_bitmap2(int w, int h) { 36 SkBitmap bm; 37 bm.allocN32Pixels(w, h); 38 SkCanvas canvas(bm); 39 canvas.clear(0xFFFFFFFF); 40 SkPaint paint; 41 paint.setColor(SHOW_MIP_COLOR); 42 paint.setStyle(SkPaint::kStroke_Style); 43 44 SkScalar inset = 2; 45 SkRect r = SkRect::MakeIWH(w, h).makeInset(0.5f, 0.5f); 46 while (r.width() > 4) { 47 canvas.drawRect(r, paint); 48 r.inset(inset, inset); 49 inset += 1; 50 } 51 return bm; 52} 53 54#include "SkNx.h" 55static SkBitmap make_bitmap3(int w, int h) { 56 SkBitmap bm; 57 bm.allocN32Pixels(w, h); 58 SkCanvas canvas(bm); 59 canvas.clear(0xFFFFFFFF); 60 SkPaint paint; 61 paint.setStyle(SkPaint::kStroke_Style); 62 paint.setStrokeWidth(2.1f); 63 paint.setColor(SHOW_MIP_COLOR); 64 65 SkScalar s = SkIntToScalar(w); 66 Sk4f p(s, -s, -s, s); 67 Sk4f d(5); 68 while (p[1] < s) { 69 canvas.drawLine(p[0],p[1], p[2], p[3], paint); 70 p = p + d; 71 } 72 return bm; 73} 74 75class ShowMipLevels : public skiagm::GM { 76 const int fN; 77 SkBitmap fBM[4]; 78 79public: 80 static unsigned gamma(unsigned n) { 81 float x = n / 255.0f; 82#if 0 83 x = sqrtf(x); 84#else 85 if (x > 0.0031308f) { 86 x = 1.055f * (powf(x, (1.0f / 2.4f))) - 0.055f; 87 } else { 88 x = 12.92f * x; 89 } 90#endif 91 return (int)(x * 255); 92 } 93 94 static void apply_gamma(const SkBitmap& bm) { 95 return; // below is our experiment for sRGB correction 96 for (int y = 0; y < bm.height(); ++y) { 97 for (int x = 0; x < bm.width(); ++x) { 98 SkPMColor c = *bm.getAddr32(x, y); 99 unsigned r = gamma(SkGetPackedR32(c)); 100 unsigned g = gamma(SkGetPackedG32(c)); 101 unsigned b = gamma(SkGetPackedB32(c)); 102 *bm.getAddr32(x, y) = SkPackARGB32(0xFF, r, g, b); 103 } 104 } 105 } 106 107 ShowMipLevels(int N) : fN(N) { } 108 109protected: 110 111 SkString onShortName() override { 112 SkString str; 113 str.printf("showmiplevels_%d", fN); 114 return str; 115 } 116 117 SkISize onISize() override { return { 150, 862 }; } 118 119 static void DrawAndFrame(SkCanvas* canvas, const SkBitmap& orig, SkScalar x, SkScalar y) { 120 SkBitmap bm; 121 sk_tool_utils::copy_to(&bm, orig.colorType(), orig); 122 apply_gamma(bm); 123 124 canvas->drawBitmap(bm, x, y, nullptr); 125 SkPaint paint; 126 paint.setStyle(SkPaint::kStroke_Style); 127 paint.setColor(0xFFFFCCCC); 128 canvas->drawRect(SkRect::MakeIWH(bm.width(), bm.height()).makeOffset(x, y).makeOutset(0.5f, 0.5f), paint); 129 } 130 131 template <typename F> void drawLevels(SkCanvas* canvas, const SkBitmap& baseBM, F func) { 132 SkScalar x = 4; 133 SkScalar y = 4; 134 135 SkPixmap prevPM; 136 baseBM.peekPixels(&prevPM); 137 138 SkDestinationSurfaceColorMode colorMode = SkDestinationSurfaceColorMode::kLegacy; 139 sk_sp<SkMipMap> mm(SkMipMap::Build(baseBM, colorMode, nullptr)); 140 141 int index = 0; 142 SkMipMap::Level level; 143 SkScalar scale = 0.5f; 144 while (mm->extractLevel(SkSize::Make(scale, scale), &level)) { 145 SkBitmap bm = func(prevPM, level.fPixmap); 146 DrawAndFrame(canvas, bm, x, y); 147 148 if (level.fPixmap.width() <= 2 || level.fPixmap.height() <= 2) { 149 break; 150 } 151 if (index & 1) { 152 x += level.fPixmap.width() + 4; 153 } else { 154 y += level.fPixmap.height() + 4; 155 } 156 scale /= 2; 157 prevPM = level.fPixmap; 158 index += 1; 159 } 160 } 161 162 void drawSet(SkCanvas* canvas, const SkBitmap& orig) { 163 SkAutoCanvasRestore acr(canvas, true); 164 165 drawLevels(canvas, orig, [](const SkPixmap& prev, const SkPixmap& curr) { 166 SkBitmap bm; 167 bm.installPixels(curr); 168 return bm; 169 }); 170 } 171 172 void onOnceBeforeDraw() override { 173 fBM[0] = sk_tool_utils::create_checkerboard_bitmap(fN, fN, SK_ColorBLACK, SK_ColorWHITE, 2); 174 fBM[1] = make_bitmap(fN, fN); 175 fBM[2] = make_bitmap2(fN, fN); 176 fBM[3] = make_bitmap3(fN, fN); 177 } 178 179 void onDraw(SkCanvas* canvas) override { 180 canvas->translate(4, 4); 181 for (const auto& bm : fBM) { 182 this->drawSet(canvas, bm); 183 // round so we always produce an integral translate, so the GOLD tool won't show 184 // unimportant diffs if this is drawn on a GPU with different rounding rules 185 // since we draw the bitmaps using nearest-neighbor 186 canvas->translate(0, SkScalarRoundToScalar(bm.height() * 0.85f)); 187 } 188 } 189 190private: 191 typedef skiagm::GM INHERITED; 192}; 193DEF_GM( return new ShowMipLevels(255); ) 194DEF_GM( return new ShowMipLevels(256); ) 195 196/////////////////////////////////////////////////////////////////////////////////////////////////// 197 198void copy_to(SkBitmap* dst, SkColorType dstColorType, const SkBitmap& src) { 199 if (kGray_8_SkColorType == dstColorType) { 200 return sk_tool_utils::copy_to_g8(dst, src); 201 } 202 203 const SkBitmap* srcPtr = &src; 204 SkBitmap tmp(src); 205 if (kRGB_565_SkColorType == dstColorType) { 206 tmp.setAlphaType(kOpaque_SkAlphaType); 207 srcPtr = &tmp; 208 } 209 210 sk_tool_utils::copy_to(dst, dstColorType, *srcPtr); 211} 212 213/** 214 * Show mip levels that were built, for all supported colortypes 215 */ 216class ShowMipLevels2 : public skiagm::GM { 217 const int fW, fH; 218 SkBitmap fBM[4]; 219 220public: 221 ShowMipLevels2(int w, int h) : fW(w), fH(h) { } 222 223protected: 224 225 SkString onShortName() override { 226 SkString str; 227 str.printf("showmiplevels2_%dx%d", fW, fH); 228 return str; 229 } 230 231 SkISize onISize() override { 232 return { 824, 862 }; 233 } 234 235 static void DrawAndFrame(SkCanvas* canvas, const SkBitmap& bm, SkScalar x, SkScalar y) { 236 canvas->drawBitmap(bm, x, y, nullptr); 237 SkPaint paint; 238 paint.setStyle(SkPaint::kStroke_Style); 239 paint.setColor(0xFFFFCCCC); 240 canvas->drawRect(SkRect::MakeIWH(bm.width(), bm.height()).makeOffset(x, y).makeOutset(0.5f, 0.5f), paint); 241 } 242 243 void drawLevels(SkCanvas* canvas, const SkBitmap& baseBM) { 244 SkScalar x = 4; 245 SkScalar y = 4; 246 247 SkDestinationSurfaceColorMode colorMode = SkDestinationSurfaceColorMode::kLegacy; 248 sk_sp<SkMipMap> mm(SkMipMap::Build(baseBM, colorMode, nullptr)); 249 250 int index = 0; 251 SkMipMap::Level level; 252 SkScalar scale = 0.5f; 253 while (mm->extractLevel(SkSize::Make(scale, scale), &level)) { 254 SkBitmap bm; 255 bm.installPixels(level.fPixmap); 256 DrawAndFrame(canvas, bm, x, y); 257 258 if (level.fPixmap.width() <= 2 || level.fPixmap.height() <= 2) { 259 break; 260 } 261 if (index & 1) { 262 x += level.fPixmap.width() + 4; 263 } else { 264 y += level.fPixmap.height() + 4; 265 } 266 scale /= 2; 267 index += 1; 268 } 269 } 270 271 void drawSet(SkCanvas* canvas, const SkBitmap& orig) { 272 const SkColorType ctypes[] = { 273 kN32_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, kGray_8_SkColorType 274 }; 275 276 SkAutoCanvasRestore acr(canvas, true); 277 278 for (auto ctype : ctypes) { 279 SkBitmap bm; 280 copy_to(&bm, ctype, orig); 281 drawLevels(canvas, bm); 282 canvas->translate(orig.width()/2 + 8.0f, 0); 283 } 284 } 285 286 void onOnceBeforeDraw() override { 287 fBM[0] = sk_tool_utils::create_checkerboard_bitmap(fW, fH, 288 SHOW_MIP_COLOR, SK_ColorWHITE, 2); 289 fBM[1] = make_bitmap(fW, fH); 290 fBM[2] = make_bitmap2(fW, fH); 291 fBM[3] = make_bitmap3(fW, fH); 292 } 293 294 void onDraw(SkCanvas* canvas) override { 295 canvas->translate(4, 4); 296 for (const auto& bm : fBM) { 297 this->drawSet(canvas, bm); 298 // round so we always produce an integral translate, so the GOLD tool won't show 299 // unimportant diffs if this is drawn on a GPU with different rounding rules 300 // since we draw the bitmaps using nearest-neighbor 301 canvas->translate(0, SkScalarRoundToScalar(bm.height() * 0.85f)); 302 } 303 } 304 305private: 306 typedef skiagm::GM INHERITED; 307}; 308DEF_GM( return new ShowMipLevels2(255, 255); ) 309DEF_GM( return new ShowMipLevels2(256, 255); ) 310DEF_GM( return new ShowMipLevels2(255, 256); ) 311DEF_GM( return new ShowMipLevels2(256, 256); ) 312