mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011 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 | |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 8 | #include <functional> |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 9 | #include "gm.h" |
robertphillips | c5035e7 | 2016-03-17 06:58:39 -0700 | [diff] [blame] | 10 | #include "SkAutoPixmapStorage.h" |
mike@reedtribe.org | d829b5c | 2012-07-31 03:57:11 +0000 | [diff] [blame] | 11 | #include "SkData.h" |
reed | f803da1 | 2015-01-23 05:58:07 -0800 | [diff] [blame] | 12 | #include "SkCanvas.h" |
| 13 | #include "SkRandom.h" |
| 14 | #include "SkStream.h" |
| 15 | #include "SkSurface.h" |
mike@reedtribe.org | d829b5c | 2012-07-31 03:57:11 +0000 | [diff] [blame] | 16 | |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 17 | #if SK_SUPPORT_GPU |
| 18 | #include "GrContext.h" |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 19 | #endif |
reed@google.com | 97af1a6 | 2012-08-28 12:19:02 +0000 | [diff] [blame] | 20 | |
mike@reedtribe.org | d829b5c | 2012-07-31 03:57:11 +0000 | [diff] [blame] | 21 | static void drawJpeg(SkCanvas* canvas, const SkISize& size) { |
scroggo@google.com | ccd7afb | 2013-05-28 16:45:07 +0000 | [diff] [blame] | 22 | // TODO: Make this draw a file that is checked in, so it can |
| 23 | // be exercised on machines other than mike's. Will require a |
| 24 | // rebaseline. |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 25 | sk_sp<SkData> data(SkData::MakeFromFileName("/Users/mike/Downloads/skia.google.jpeg")); |
| 26 | if (nullptr == data) { |
reed | 48925e3 | 2014-09-18 13:57:05 -0700 | [diff] [blame] | 27 | return; |
| 28 | } |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 29 | sk_sp<SkImage> image = SkImage::MakeFromEncoded(std::move(data)); |
mike@reedtribe.org | d829b5c | 2012-07-31 03:57:11 +0000 | [diff] [blame] | 30 | if (image) { |
| 31 | SkAutoCanvasRestore acr(canvas, true); |
| 32 | canvas->scale(size.width() * 1.0f / image->width(), |
| 33 | size.height() * 1.0f / image->height()); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 34 | canvas->drawImage(image, 0, 0, nullptr); |
mike@reedtribe.org | d829b5c | 2012-07-31 03:57:11 +0000 | [diff] [blame] | 35 | } |
| 36 | } |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 37 | |
| 38 | static void drawContents(SkSurface* surface, SkColor fillC) { |
skia.committer@gmail.com | 04ba448 | 2012-09-07 02:01:30 +0000 | [diff] [blame] | 39 | SkSize size = SkSize::Make(SkIntToScalar(surface->width()), |
robertphillips@google.com | 94acc70 | 2012-09-06 18:43:21 +0000 | [diff] [blame] | 40 | SkIntToScalar(surface->height())); |
mike@reedtribe.org | d2782ed | 2012-07-31 02:45:15 +0000 | [diff] [blame] | 41 | SkCanvas* canvas = surface->getCanvas(); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 42 | |
| 43 | SkScalar stroke = size.fWidth / 10; |
| 44 | SkScalar radius = (size.fWidth - stroke) / 2; |
| 45 | |
| 46 | SkPaint paint; |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 47 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 48 | paint.setAntiAlias(true); |
| 49 | paint.setColor(fillC); |
| 50 | canvas->drawCircle(size.fWidth/2, size.fHeight/2, radius, paint); |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 51 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 52 | paint.setStyle(SkPaint::kStroke_Style); |
| 53 | paint.setStrokeWidth(stroke); |
| 54 | paint.setColor(SK_ColorBLACK); |
| 55 | canvas->drawCircle(size.fWidth/2, size.fHeight/2, radius, paint); |
| 56 | } |
| 57 | |
commit-bot@chromium.org | dfec28d | 2013-07-23 15:52:16 +0000 | [diff] [blame] | 58 | static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) { |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 59 | drawContents(surf, SK_ColorRED); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 60 | sk_sp<SkImage> imgR = surf->makeImageSnapshot(); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 61 | |
reed@google.com | 97af1a6 | 2012-08-28 12:19:02 +0000 | [diff] [blame] | 62 | if (true) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 63 | sk_sp<SkImage> imgR2 = surf->makeImageSnapshot(); |
reed@google.com | 97af1a6 | 2012-08-28 12:19:02 +0000 | [diff] [blame] | 64 | SkASSERT(imgR == imgR2); |
reed@google.com | 97af1a6 | 2012-08-28 12:19:02 +0000 | [diff] [blame] | 65 | } |
| 66 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 67 | drawContents(surf, SK_ColorGREEN); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 68 | sk_sp<SkImage> imgG = surf->makeImageSnapshot(); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 69 | |
reed@google.com | 97af1a6 | 2012-08-28 12:19:02 +0000 | [diff] [blame] | 70 | // since we've drawn after we snapped imgR, imgG will be a different obj |
| 71 | SkASSERT(imgR != imgG); |
| 72 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 73 | drawContents(surf, SK_ColorBLUE); |
| 74 | |
mike@reedtribe.org | d2782ed | 2012-07-31 02:45:15 +0000 | [diff] [blame] | 75 | SkPaint paint; |
| 76 | // paint.setFilterBitmap(true); |
| 77 | // paint.setAlpha(0x80); |
| 78 | |
reed | fe63045 | 2016-03-25 09:08:00 -0700 | [diff] [blame] | 79 | canvas->drawImage(imgR, 0, 0, usePaint ? &paint : nullptr); |
| 80 | canvas->drawImage(imgG, 0, 80, usePaint ? &paint : nullptr); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 81 | surf->draw(canvas, 0, 160, usePaint ? &paint : nullptr); |
commit-bot@chromium.org | dfec28d | 2013-07-23 15:52:16 +0000 | [diff] [blame] | 82 | |
| 83 | SkRect src1, src2, src3; |
| 84 | src1.iset(0, 0, surf->width(), surf->height()); |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 85 | src2.iset(-surf->width() / 2, -surf->height() / 2, |
commit-bot@chromium.org | dfec28d | 2013-07-23 15:52:16 +0000 | [diff] [blame] | 86 | surf->width(), surf->height()); |
| 87 | src3.iset(0, 0, surf->width() / 2, surf->height() / 2); |
| 88 | |
| 89 | SkRect dst1, dst2, dst3, dst4; |
| 90 | dst1.set(0, 240, 65, 305); |
| 91 | dst2.set(0, 320, 65, 385); |
| 92 | dst3.set(0, 400, 65, 465); |
| 93 | dst4.set(0, 480, 65, 545); |
| 94 | |
reed | fe63045 | 2016-03-25 09:08:00 -0700 | [diff] [blame] | 95 | canvas->drawImageRect(imgR, src1, dst1, usePaint ? &paint : nullptr); |
| 96 | canvas->drawImageRect(imgG, src2, dst2, usePaint ? &paint : nullptr); |
| 97 | canvas->drawImageRect(imgR, src3, dst3, usePaint ? &paint : nullptr); |
| 98 | canvas->drawImageRect(imgG, dst4, usePaint ? &paint : nullptr); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | class ImageGM : public skiagm::GM { |
| 102 | void* fBuffer; |
reed@google.com | 58b21ec | 2012-07-30 18:20:12 +0000 | [diff] [blame] | 103 | size_t fBufferSize; |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 104 | SkSize fSize; |
| 105 | enum { |
| 106 | W = 64, |
| 107 | H = 64, |
| 108 | RB = W * 4 + 8, |
| 109 | }; |
| 110 | public: |
| 111 | ImageGM() { |
reed@google.com | 58b21ec | 2012-07-30 18:20:12 +0000 | [diff] [blame] | 112 | fBufferSize = RB * H; |
| 113 | fBuffer = sk_malloc_throw(fBufferSize); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 114 | fSize.set(SkIntToScalar(W), SkIntToScalar(H)); |
| 115 | } |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 116 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 117 | virtual ~ImageGM() { |
| 118 | sk_free(fBuffer); |
| 119 | } |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 120 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 121 | protected: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 122 | SkString onShortName() override { |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 123 | return SkString("image-surface"); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 124 | } |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 125 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 126 | SkISize onISize() override { |
commit-bot@chromium.org | dfec28d | 2013-07-23 15:52:16 +0000 | [diff] [blame] | 127 | return SkISize::Make(960, 1200); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 128 | } |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 129 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 130 | void onDraw(SkCanvas* canvas) override { |
mike@reedtribe.org | d829b5c | 2012-07-31 03:57:11 +0000 | [diff] [blame] | 131 | drawJpeg(canvas, this->getISize()); |
| 132 | |
mike@reedtribe.org | d2782ed | 2012-07-31 02:45:15 +0000 | [diff] [blame] | 133 | canvas->scale(2, 2); |
| 134 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame^] | 135 | const char* kLabel1 = "Original Img"; |
| 136 | const char* kLabel2 = "Modified Img"; |
| 137 | const char* kLabel3 = "Cur Surface"; |
| 138 | const char* kLabel4 = "Full Crop"; |
| 139 | const char* kLabel5 = "Over-crop"; |
| 140 | const char* kLabel6 = "Upper-left"; |
| 141 | const char* kLabel7 = "No Crop"; |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 142 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame^] | 143 | const char* kLabel8 = "Pre-Alloc Img"; |
| 144 | const char* kLabel9 = "New Alloc Img"; |
| 145 | const char* kLabel10 = "GPU"; |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 146 | |
| 147 | SkPaint textPaint; |
commit-bot@chromium.org | cae54f1 | 2014-04-11 18:34:35 +0000 | [diff] [blame] | 148 | textPaint.setAntiAlias(true); |
caryclark | 1818acb | 2015-07-24 12:09:25 -0700 | [diff] [blame] | 149 | sk_tool_utils::set_portable_typeface(&textPaint); |
commit-bot@chromium.org | cae54f1 | 2014-04-11 18:34:35 +0000 | [diff] [blame] | 150 | textPaint.setTextSize(8); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 151 | |
| 152 | canvas->drawText(kLabel1, strlen(kLabel1), 10, 60, textPaint); |
| 153 | canvas->drawText(kLabel2, strlen(kLabel2), 10, 140, textPaint); |
| 154 | canvas->drawText(kLabel3, strlen(kLabel3), 10, 220, textPaint); |
commit-bot@chromium.org | dfec28d | 2013-07-23 15:52:16 +0000 | [diff] [blame] | 155 | canvas->drawText(kLabel4, strlen(kLabel4), 10, 300, textPaint); |
| 156 | canvas->drawText(kLabel5, strlen(kLabel5), 10, 380, textPaint); |
| 157 | canvas->drawText(kLabel6, strlen(kLabel6), 10, 460, textPaint); |
| 158 | canvas->drawText(kLabel7, strlen(kLabel7), 10, 540, textPaint); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 159 | |
commit-bot@chromium.org | dfec28d | 2013-07-23 15:52:16 +0000 | [diff] [blame] | 160 | canvas->drawText(kLabel8, strlen(kLabel8), 80, 10, textPaint); |
| 161 | canvas->drawText(kLabel9, strlen(kLabel9), 160, 10, textPaint); |
reed | a9cb871 | 2015-01-16 14:21:40 -0800 | [diff] [blame] | 162 | canvas->drawText(kLabel10, strlen(kLabel10), 265, 10, textPaint); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 163 | |
| 164 | canvas->translate(80, 20); |
| 165 | |
reed@google.com | 58b21ec | 2012-07-30 18:20:12 +0000 | [diff] [blame] | 166 | // since we draw into this directly, we need to start fresh |
| 167 | sk_bzero(fBuffer, fBufferSize); |
| 168 | |
commit-bot@chromium.org | 32678d9 | 2014-01-15 02:38:22 +0000 | [diff] [blame] | 169 | SkImageInfo info = SkImageInfo::MakeN32Premul(W, H); |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 170 | sk_sp<SkSurface> surf0(SkSurface::MakeRasterDirect(info, fBuffer, RB)); |
| 171 | sk_sp<SkSurface> surf1(SkSurface::MakeRaster(info)); |
| 172 | sk_sp<SkSurface> surf2; // gpu |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 173 | |
reed | a9cb871 | 2015-01-16 14:21:40 -0800 | [diff] [blame] | 174 | #if SK_SUPPORT_GPU |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 175 | surf2 = SkSurface::MakeRenderTarget(canvas->getGrContext(), SkBudgeted::kNo, info); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 176 | #endif |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 177 | |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 178 | test_surface(canvas, surf0.get(), true); |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 179 | canvas->translate(80, 0); |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 180 | test_surface(canvas, surf1.get(), true); |
reed | a9cb871 | 2015-01-16 14:21:40 -0800 | [diff] [blame] | 181 | if (surf2) { |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 182 | canvas->translate(80, 0); |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 183 | test_surface(canvas, surf2.get(), true); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 184 | } |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 185 | } |
rmistry@google.com | ae933ce | 2012-08-23 18:19:56 +0000 | [diff] [blame] | 186 | |
mike@reedtribe.org | 70e3590 | 2012-07-29 20:38:16 +0000 | [diff] [blame] | 187 | private: |
| 188 | typedef skiagm::GM INHERITED; |
| 189 | }; |
reed | a9cb871 | 2015-01-16 14:21:40 -0800 | [diff] [blame] | 190 | DEF_GM( return new ImageGM; ) |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 191 | |
| 192 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 193 | |
| 194 | #include "SkPictureRecorder.h" |
| 195 | |
| 196 | static void draw_pixmap(SkCanvas* canvas, const SkPixmap& pmap) { |
| 197 | SkBitmap bitmap; |
halcanary | e36ec87 | 2015-12-09 11:36:59 -0800 | [diff] [blame] | 198 | bitmap.installPixels(pmap); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 199 | canvas->drawBitmap(bitmap, 0, 0, nullptr); |
| 200 | } |
| 201 | |
| 202 | static void show_scaled_pixels(SkCanvas* canvas, SkImage* image) { |
| 203 | SkAutoCanvasRestore acr(canvas, true); |
| 204 | |
| 205 | canvas->drawImage(image, 0, 0, nullptr); |
| 206 | canvas->translate(110, 10); |
| 207 | |
| 208 | const SkImageInfo info = SkImageInfo::MakeN32Premul(40, 40); |
| 209 | SkAutoPixmapStorage storage; |
| 210 | storage.alloc(info); |
| 211 | |
| 212 | const SkImage::CachingHint chints[] = { |
reed | 6868c3f | 2015-11-24 11:44:47 -0800 | [diff] [blame] | 213 | SkImage::kAllow_CachingHint, SkImage::kDisallow_CachingHint, |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 214 | }; |
| 215 | const SkFilterQuality qualities[] = { |
| 216 | kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality, kHigh_SkFilterQuality, |
| 217 | }; |
| 218 | |
| 219 | for (auto ch : chints) { |
| 220 | canvas->save(); |
| 221 | for (auto q : qualities) { |
| 222 | if (image->scalePixels(storage, q, ch)) { |
| 223 | draw_pixmap(canvas, storage); |
| 224 | } |
| 225 | canvas->translate(70, 0); |
| 226 | } |
| 227 | canvas->restore(); |
| 228 | canvas->translate(0, 45); |
| 229 | } |
| 230 | } |
| 231 | |
| 232 | static void draw_contents(SkCanvas* canvas) { |
| 233 | SkPaint paint; |
| 234 | paint.setStyle(SkPaint::kStroke_Style); |
| 235 | paint.setStrokeWidth(20); |
| 236 | canvas->drawCircle(50, 50, 35, paint); |
| 237 | } |
| 238 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 239 | static sk_sp<SkImage> make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 240 | auto surface(SkSurface::MakeRaster(info)); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 241 | draw(surface->getCanvas()); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 242 | return surface->makeImageSnapshot(); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 243 | } |
| 244 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 245 | static sk_sp<SkImage> make_picture(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 246 | SkPictureRecorder recorder; |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 247 | draw(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height()))); |
reed | ca2622b | 2016-03-18 07:25:55 -0700 | [diff] [blame] | 248 | return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), |
| 249 | info.dimensions(), nullptr, nullptr); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 250 | } |
| 251 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 252 | static sk_sp<SkImage> make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { |
| 253 | sk_sp<SkImage> image(make_raster(info, nullptr, draw)); |
| 254 | sk_sp<SkData> data(image->encode()); |
| 255 | return SkImage::MakeFromEncoded(data); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 256 | } |
| 257 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 258 | static sk_sp<SkImage> make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) { |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 259 | if (!ctx) { return nullptr; } |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 260 | auto surface(SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info)); |
scroggo | e6f0d6e | 2016-05-13 07:25:44 -0700 | [diff] [blame] | 261 | if (!surface) { return nullptr; } |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 262 | draw(surface->getCanvas()); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 263 | return surface->makeImageSnapshot(); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 264 | } |
| 265 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 266 | typedef sk_sp<SkImage> (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*)); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 267 | |
| 268 | class ScalePixelsGM : public skiagm::GM { |
| 269 | public: |
| 270 | ScalePixelsGM() {} |
| 271 | |
| 272 | protected: |
| 273 | SkString onShortName() override { |
| 274 | return SkString("scale-pixels"); |
| 275 | } |
| 276 | |
| 277 | SkISize onISize() override { |
| 278 | return SkISize::Make(960, 1200); |
| 279 | } |
| 280 | |
| 281 | void onDraw(SkCanvas* canvas) override { |
| 282 | const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); |
| 283 | |
| 284 | const ImageMakerProc procs[] = { |
reed | 6868c3f | 2015-11-24 11:44:47 -0800 | [diff] [blame] | 285 | make_codec, make_raster, make_picture, make_codec, make_gpu, |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 286 | }; |
| 287 | for (auto& proc : procs) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 288 | sk_sp<SkImage> image(proc(info, canvas->getGrContext(), draw_contents)); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 289 | if (image) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 290 | show_scaled_pixels(canvas, image.get()); |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 291 | } |
| 292 | canvas->translate(0, 120); |
| 293 | } |
| 294 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 295 | |
reed | 0955303 | 2015-11-23 12:32:16 -0800 | [diff] [blame] | 296 | private: |
| 297 | typedef skiagm::GM INHERITED; |
| 298 | }; |
| 299 | DEF_GM( return new ScalePixelsGM; ) |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 300 | |
| 301 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 302 | |
| 303 | #include "SkImageGenerator.h" |
| 304 | |
| 305 | static SkImageInfo make_info(SkImage* img) { |
brianosman | 69c166d | 2016-08-17 14:01:05 -0700 | [diff] [blame] | 306 | return SkImageInfo::MakeN32(img->width(), img->height(), img->alphaType()); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 307 | } |
| 308 | |
| 309 | // Its simple, but I wonder if we should expose this formally? |
| 310 | // |
| 311 | class ImageGeneratorFromImage : public SkImageGenerator { |
| 312 | public: |
| 313 | ImageGeneratorFromImage(SkImage* img) : INHERITED(make_info(img)), fImg(SkRef(img)) {} |
| 314 | |
| 315 | protected: |
| 316 | bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, SkPMColor ctable[], |
| 317 | int* ctableCount) override { |
| 318 | return fImg->readPixels(info, pixels, rowBytes, 0, 0); |
| 319 | } |
| 320 | |
| 321 | private: |
| 322 | SkAutoTUnref<SkImage> fImg; |
| 323 | |
| 324 | typedef SkImageGenerator INHERITED; |
| 325 | }; |
| 326 | |
| 327 | static void draw_opaque_contents(SkCanvas* canvas) { |
| 328 | canvas->drawColor(0xFFFF8844); |
| 329 | |
| 330 | SkPaint paint; |
| 331 | paint.setStyle(SkPaint::kStroke_Style); |
| 332 | paint.setStrokeWidth(20); |
| 333 | canvas->drawCircle(50, 50, 35, paint); |
| 334 | } |
| 335 | |
| 336 | static SkImageGenerator* gen_raster(const SkImageInfo& info) { |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 337 | auto surface(SkSurface::MakeRaster(info)); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 338 | draw_opaque_contents(surface->getCanvas()); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 339 | return new ImageGeneratorFromImage(surface->makeImageSnapshot().get()); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 340 | } |
| 341 | |
| 342 | static SkImageGenerator* gen_picture(const SkImageInfo& info) { |
| 343 | SkPictureRecorder recorder; |
| 344 | draw_opaque_contents(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height()))); |
reed | ca2622b | 2016-03-18 07:25:55 -0700 | [diff] [blame] | 345 | sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture()); |
| 346 | return SkImageGenerator::NewFromPicture(info.dimensions(), pict.get(), nullptr, nullptr); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 347 | } |
| 348 | |
| 349 | static SkImageGenerator* gen_png(const SkImageInfo& info) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 350 | sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents)); |
bungeman | ffae30d | 2016-08-03 13:32:32 -0700 | [diff] [blame] | 351 | sk_sp<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100)); |
| 352 | return SkImageGenerator::NewFromEncoded(data.get()); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 353 | } |
| 354 | |
| 355 | static SkImageGenerator* gen_jpg(const SkImageInfo& info) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 356 | sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents)); |
bungeman | ffae30d | 2016-08-03 13:32:32 -0700 | [diff] [blame] | 357 | sk_sp<SkData> data(image->encode(SkImageEncoder::kJPEG_Type, 100)); |
| 358 | return SkImageGenerator::NewFromEncoded(data.get()); |
reed | 7850eb2 | 2015-12-02 14:19:47 -0800 | [diff] [blame] | 359 | } |
| 360 | |
| 361 | typedef SkImageGenerator* (*GeneratorMakerProc)(const SkImageInfo&); |
| 362 | |
| 363 | static void show_scaled_generator(SkCanvas* canvas, SkImageGenerator* gen) { |
| 364 | const SkImageInfo genInfo = gen->getInfo(); |
| 365 | |
| 366 | SkAutoCanvasRestore acr(canvas, true); |
| 367 | |
| 368 | SkBitmap bm; |
| 369 | bm.allocPixels(genInfo); |
| 370 | if (gen->getPixels(bm.info(), bm.getPixels(), bm.rowBytes())) { |
| 371 | canvas->drawBitmap(bm, 0, 0, nullptr); |
| 372 | } |
| 373 | canvas->translate(110, 0); |
| 374 | |
| 375 | const float scales[] = { 0.75f, 0.5f, 0.25f }; |
| 376 | for (auto scale : scales) { |
| 377 | SkImageGenerator::SupportedSizes sizes; |
| 378 | if (gen->computeScaledDimensions(scale, &sizes)) { |
| 379 | const SkImageInfo info = SkImageInfo::MakeN32Premul(sizes.fSizes[0].width(), |
| 380 | sizes.fSizes[0].height()); |
| 381 | bm.allocPixels(info); |
| 382 | SkPixmap pmap; |
| 383 | bm.peekPixels(&pmap); |
| 384 | if (gen->generateScaledPixels(pmap)) { |
| 385 | canvas->drawBitmap(bm, 0, SkIntToScalar(genInfo.height() - info.height())/2); |
| 386 | } |
| 387 | } |
| 388 | canvas->translate(100, 0); |
| 389 | } |
| 390 | } |
| 391 | |
| 392 | class ScaleGeneratorGM : public skiagm::GM { |
| 393 | public: |
| 394 | ScaleGeneratorGM() {} |
| 395 | |
| 396 | protected: |
| 397 | SkString onShortName() override { |
| 398 | return SkString("scale-generator"); |
| 399 | } |
| 400 | |
| 401 | SkISize onISize() override { |
| 402 | return SkISize::Make(500, 500); |
| 403 | } |
| 404 | |
| 405 | void onDraw(SkCanvas* canvas) override { |
| 406 | canvas->translate(10, 10); |
| 407 | |
| 408 | // explicitly make it opaque, so we can test JPEG (which is only ever opaque) |
| 409 | const SkImageInfo info = SkImageInfo::MakeN32(100, 100, kOpaque_SkAlphaType); |
| 410 | |
| 411 | const GeneratorMakerProc procs[] = { |
| 412 | gen_raster, gen_picture, gen_png, gen_jpg, |
| 413 | }; |
| 414 | for (auto& proc : procs) { |
| 415 | SkAutoTDelete<SkImageGenerator> gen(proc(info)); |
| 416 | if (gen) { |
| 417 | show_scaled_generator(canvas, gen); |
| 418 | } |
| 419 | canvas->translate(0, 120); |
| 420 | } |
| 421 | } |
| 422 | |
| 423 | private: |
| 424 | typedef skiagm::GM INHERITED; |
| 425 | }; |
| 426 | DEF_GM( return new ScaleGeneratorGM; ) |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 427 | |
| 428 | #if SK_SUPPORT_GPU |
| 429 | #include "GrContextFactory.h" |
| 430 | #endif |
| 431 | |
| 432 | DEF_SIMPLE_GM(new_texture_image, canvas, 225, 60) { |
| 433 | GrContext* context = nullptr; |
| 434 | #if SK_SUPPORT_GPU |
| 435 | context = canvas->getGrContext(); |
bsalomon | 3724e57 | 2016-03-30 18:56:19 -0700 | [diff] [blame] | 436 | sk_gpu_test::GrContextFactory factory; |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 437 | #endif |
| 438 | if (!context) { |
| 439 | skiagm::GM::DrawGpuOnlyMessage(canvas); |
| 440 | return; |
| 441 | } |
| 442 | |
| 443 | auto render_image = [](SkCanvas* canvas) { |
| 444 | canvas->clear(SK_ColorBLUE); |
| 445 | SkPaint paint; |
| 446 | paint.setColor(SK_ColorRED); |
| 447 | canvas->drawRect(SkRect::MakeXYWH(10.f,10.f,10.f,10.f), paint); |
| 448 | paint.setColor(SK_ColorGREEN); |
| 449 | canvas->drawRect(SkRect::MakeXYWH(30.f,10.f,10.f,10.f), paint); |
| 450 | paint.setColor(SK_ColorYELLOW); |
| 451 | canvas->drawRect(SkRect::MakeXYWH(10.f,30.f,10.f,10.f), paint); |
| 452 | paint.setColor(SK_ColorCYAN); |
| 453 | canvas->drawRect(SkRect::MakeXYWH(30.f,30.f,10.f,10.f), paint); |
| 454 | }; |
| 455 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame^] | 456 | static constexpr int kSize = 50; |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 457 | SkBitmap bmp; |
| 458 | bmp.allocN32Pixels(kSize, kSize); |
| 459 | SkCanvas bmpCanvas(bmp); |
| 460 | render_image(&bmpCanvas); |
| 461 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 462 | std::function<sk_sp<SkImage>()> imageFactories[] = { |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 463 | // Create sw raster image. |
| 464 | [bmp] { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 465 | return SkImage::MakeFromBitmap(bmp); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 466 | }, |
| 467 | // Create encoded image. |
| 468 | [bmp] { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 469 | sk_sp<SkData> src( |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 470 | SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100)); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 471 | return SkImage::MakeFromEncoded(std::move(src)); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 472 | }, |
| 473 | // Create a picture image. |
| 474 | [render_image] { |
| 475 | SkPictureRecorder recorder; |
| 476 | SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize)); |
| 477 | render_image(canvas); |
reed | ca2622b | 2016-03-18 07:25:55 -0700 | [diff] [blame] | 478 | return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), |
| 479 | SkISize::Make(kSize, kSize), nullptr, nullptr); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 480 | }, |
| 481 | // Create a texture image |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 482 | [context, render_image]() -> sk_sp<SkImage> { |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 483 | auto surface( |
| 484 | SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, |
| 485 | SkImageInfo::MakeN32Premul(kSize, kSize))); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 486 | if (!surface) { |
| 487 | return nullptr; |
| 488 | } |
| 489 | render_image(surface->getCanvas()); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 490 | return surface->makeImageSnapshot(); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 491 | } |
| 492 | }; |
| 493 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame^] | 494 | constexpr SkScalar kPad = 5.f; |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 495 | canvas->translate(kPad, kPad); |
| 496 | for (auto factory : imageFactories) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 497 | auto image(factory()); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 498 | if (!image) { |
| 499 | continue; |
| 500 | } |
| 501 | if (context) { |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 502 | sk_sp<SkImage> texImage(image->makeTextureImage(context)); |
bsalomon | 8e74f80 | 2016-01-30 10:01:40 -0800 | [diff] [blame] | 503 | if (texImage) { |
| 504 | canvas->drawImage(texImage, 0, 0); |
| 505 | } |
| 506 | } |
| 507 | canvas->translate(image->width() + kPad, 0); |
| 508 | } |
| 509 | } |