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