Home | History | Annotate | Download | only in gm 
      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 "SkBitmapScaler.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 
     22 static 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 
     35 static 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"
     55 static 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 
     75 class ShowMipLevels : public skiagm::GM {
     76     const int fN;
     77     SkBitmap  fBM[4];
     78 
     79 public:
     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 
    109 protected:
    110 
    111     SkString onShortName() override {
    112         SkString str;
    113         str.printf("showmiplevels_%d", fN);
    114         return str;
    115     }
    116 
    117     SkISize onISize() override {
    118         return { 824, 862 };
    119     }
    120 
    121     static void DrawAndFrame(SkCanvas* canvas, const SkBitmap& orig, SkScalar x, SkScalar y) {
    122         SkBitmap bm;
    123         sk_tool_utils::copy_to(&bm, orig.colorType(), orig);
    124         apply_gamma(bm);
    125 
    126         canvas->drawBitmap(bm, x, y, nullptr);
    127         SkPaint paint;
    128         paint.setStyle(SkPaint::kStroke_Style);
    129         paint.setColor(0xFFFFCCCC);
    130         canvas->drawRect(SkRect::MakeIWH(bm.width(), bm.height()).makeOffset(x, y).makeOutset(0.5f, 0.5f), paint);
    131     }
    132 
    133     template <typename F> void drawLevels(SkCanvas* canvas, const SkBitmap& baseBM, F func) {
    134         SkScalar x = 4;
    135         SkScalar y = 4;
    136 
    137         SkPixmap prevPM;
    138         baseBM.peekPixels(&prevPM);
    139 
    140         SkDestinationSurfaceColorMode colorMode = SkDestinationSurfaceColorMode::kLegacy;
    141         sk_sp<SkMipMap> mm(SkMipMap::Build(baseBM, colorMode, nullptr));
    142 
    143         int index = 0;
    144         SkMipMap::Level level;
    145         SkScalar scale = 0.5f;
    146         while (mm->extractLevel(SkSize::Make(scale, scale), &level)) {
    147             SkBitmap bm = func(prevPM, level.fPixmap);
    148             DrawAndFrame(canvas, bm, x, y);
    149 
    150             if (level.fPixmap.width() <= 2 || level.fPixmap.height() <= 2) {
    151                 break;
    152             }
    153             if (index & 1) {
    154                 x += level.fPixmap.width() + 4;
    155             } else {
    156                 y += level.fPixmap.height() + 4;
    157             }
    158             scale /= 2;
    159             prevPM = level.fPixmap;
    160             index += 1;
    161         }
    162     }
    163 
    164     void drawSet(SkCanvas* canvas, const SkBitmap& orig) {
    165         SkAutoCanvasRestore acr(canvas, true);
    166 
    167         drawLevels(canvas, orig, [](const SkPixmap& prev, const SkPixmap& curr) {
    168             SkBitmap bm;
    169             bm.installPixels(curr);
    170             return bm;
    171         });
    172 
    173         const SkBitmapScaler::ResizeMethod methods[] = {
    174             SkBitmapScaler::RESIZE_BOX,
    175             SkBitmapScaler::RESIZE_TRIANGLE,
    176             SkBitmapScaler::RESIZE_LANCZOS3,
    177             SkBitmapScaler::RESIZE_HAMMING,
    178             SkBitmapScaler::RESIZE_MITCHELL,
    179         };
    180 
    181         SkPixmap basePM;
    182         orig.peekPixels(&basePM);
    183         for (auto method : methods) {
    184             canvas->translate(orig.width()/2 + 8.0f, 0);
    185             drawLevels(canvas, orig, [method](const SkPixmap& prev, const SkPixmap& curr) {
    186                 SkBitmap bm;
    187                 SkBitmapScaler::Resize(&bm, prev, method, curr.width(), curr.height());
    188                 return bm;
    189             });
    190         }
    191     }
    192 
    193     void onOnceBeforeDraw() override {
    194         fBM[0] = sk_tool_utils::create_checkerboard_bitmap(fN, fN, SK_ColorBLACK, SK_ColorWHITE, 2);
    195         fBM[1] = make_bitmap(fN, fN);
    196         fBM[2] = make_bitmap2(fN, fN);
    197         fBM[3] = make_bitmap3(fN, fN);
    198     }
    199 
    200     void onDraw(SkCanvas* canvas) override {
    201         canvas->translate(4, 4);
    202         for (const auto& bm : fBM) {
    203             this->drawSet(canvas, bm);
    204             // round so we always produce an integral translate, so the GOLD tool won't show
    205             // unimportant diffs if this is drawn on a GPU with different rounding rules
    206             // since we draw the bitmaps using nearest-neighbor
    207             canvas->translate(0, SkScalarRoundToScalar(bm.height() * 0.85f));
    208         }
    209     }
    210 
    211 private:
    212     typedef skiagm::GM INHERITED;
    213 };
    214 DEF_GM( return new ShowMipLevels(255); )
    215 DEF_GM( return new ShowMipLevels(256); )
    216 
    217 ///////////////////////////////////////////////////////////////////////////////////////////////////
    218 
    219 void copy_to(SkBitmap* dst, SkColorType dstColorType, const SkBitmap& src) {
    220     if (kGray_8_SkColorType == dstColorType) {
    221         return sk_tool_utils::copy_to_g8(dst, src);
    222     }
    223 
    224     const SkBitmap* srcPtr = &src;
    225     SkBitmap tmp(src);
    226     if (kRGB_565_SkColorType == dstColorType) {
    227         tmp.setAlphaType(kOpaque_SkAlphaType);
    228         srcPtr = &tmp;
    229     }
    230 
    231     sk_tool_utils::copy_to(dst, dstColorType, *srcPtr);
    232 }
    233 
    234 /**
    235  *  Show mip levels that were built, for all supported colortypes
    236  */
    237 class ShowMipLevels2 : public skiagm::GM {
    238     const int fW, fH;
    239     SkBitmap  fBM[4];
    240 
    241 public:
    242     ShowMipLevels2(int w, int h) : fW(w), fH(h) { }
    243 
    244 protected:
    245 
    246     SkString onShortName() override {
    247         SkString str;
    248         str.printf("showmiplevels2_%dx%d", fW, fH);
    249         return str;
    250     }
    251 
    252     SkISize onISize() override {
    253         return { 824, 862 };
    254     }
    255 
    256     static void DrawAndFrame(SkCanvas* canvas, const SkBitmap& bm, SkScalar x, SkScalar y) {
    257         canvas->drawBitmap(bm, x, y, nullptr);
    258         SkPaint paint;
    259         paint.setStyle(SkPaint::kStroke_Style);
    260         paint.setColor(0xFFFFCCCC);
    261         canvas->drawRect(SkRect::MakeIWH(bm.width(), bm.height()).makeOffset(x, y).makeOutset(0.5f, 0.5f), paint);
    262     }
    263 
    264     void drawLevels(SkCanvas* canvas, const SkBitmap& baseBM) {
    265         SkScalar x = 4;
    266         SkScalar y = 4;
    267 
    268         SkDestinationSurfaceColorMode colorMode = SkDestinationSurfaceColorMode::kLegacy;
    269         sk_sp<SkMipMap> mm(SkMipMap::Build(baseBM, colorMode, nullptr));
    270 
    271         int index = 0;
    272         SkMipMap::Level level;
    273         SkScalar scale = 0.5f;
    274         while (mm->extractLevel(SkSize::Make(scale, scale), &level)) {
    275             SkBitmap bm;
    276             bm.installPixels(level.fPixmap);
    277             DrawAndFrame(canvas, bm, x, y);
    278 
    279             if (level.fPixmap.width() <= 2 || level.fPixmap.height() <= 2) {
    280                 break;
    281             }
    282             if (index & 1) {
    283                 x += level.fPixmap.width() + 4;
    284             } else {
    285                 y += level.fPixmap.height() + 4;
    286             }
    287             scale /= 2;
    288             index += 1;
    289         }
    290     }
    291 
    292     void drawSet(SkCanvas* canvas, const SkBitmap& orig) {
    293         const SkColorType ctypes[] = {
    294             kN32_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, kGray_8_SkColorType
    295         };
    296 
    297         SkAutoCanvasRestore acr(canvas, true);
    298 
    299         for (auto ctype : ctypes) {
    300             SkBitmap bm;
    301             copy_to(&bm, ctype, orig);
    302             drawLevels(canvas, bm);
    303             canvas->translate(orig.width()/2 + 8.0f, 0);
    304         }
    305     }
    306 
    307     void onOnceBeforeDraw() override {
    308         fBM[0] = sk_tool_utils::create_checkerboard_bitmap(fW, fH,
    309                                                            SHOW_MIP_COLOR, SK_ColorWHITE, 2);
    310         fBM[1] = make_bitmap(fW, fH);
    311         fBM[2] = make_bitmap2(fW, fH);
    312         fBM[3] = make_bitmap3(fW, fH);
    313     }
    314 
    315     void onDraw(SkCanvas* canvas) override {
    316         canvas->translate(4, 4);
    317         for (const auto& bm : fBM) {
    318             this->drawSet(canvas, bm);
    319             // round so we always produce an integral translate, so the GOLD tool won't show
    320             // unimportant diffs if this is drawn on a GPU with different rounding rules
    321             // since we draw the bitmaps using nearest-neighbor
    322             canvas->translate(0, SkScalarRoundToScalar(bm.height() * 0.85f));
    323         }
    324     }
    325 
    326 private:
    327     typedef skiagm::GM INHERITED;
    328 };
    329 DEF_GM( return new ShowMipLevels2(255, 255); )
    330 DEF_GM( return new ShowMipLevels2(256, 255); )
    331 DEF_GM( return new ShowMipLevels2(255, 256); )
    332 DEF_GM( return new ShowMipLevels2(256, 256); )
    333