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
8 #include <functional>
9 #include "gm.h"
10 #include "sk_tool_utils.h"
11 #include "SkAutoPixmapStorage.h"
12 #include "SkData.h"
13 #include "SkCanvas.h"
14 #include "SkRandom.h"
15 #include "SkStream.h"
16 #include "SkSurface.h"
17
18 #if SK_SUPPORT_GPU
19 #include "GrContext.h"
20 #endif
21
drawJpeg(SkCanvas * canvas,const SkISize & size)22 static void drawJpeg(SkCanvas* canvas, const SkISize& size) {
23 // TODO: Make this draw a file that is checked in, so it can
24 // be exercised on machines other than mike's. Will require a
25 // rebaseline.
26 sk_sp<SkData> data(SkData::MakeFromFileName("/Users/mike/Downloads/skia.google.jpeg"));
27 if (nullptr == data) {
28 return;
29 }
30 sk_sp<SkImage> image = SkImage::MakeFromEncoded(std::move(data));
31 if (image) {
32 SkAutoCanvasRestore acr(canvas, true);
33 canvas->scale(size.width() * 1.0f / image->width(),
34 size.height() * 1.0f / image->height());
35 canvas->drawImage(image, 0, 0, nullptr);
36 }
37 }
38
drawContents(SkSurface * surface,SkColor fillC)39 static void drawContents(SkSurface* surface, SkColor fillC) {
40 SkSize size = SkSize::Make(SkIntToScalar(surface->width()),
41 SkIntToScalar(surface->height()));
42 SkCanvas* canvas = surface->getCanvas();
43
44 SkScalar stroke = size.fWidth / 10;
45 SkScalar radius = (size.fWidth - stroke) / 2;
46
47 SkPaint paint;
48
49 paint.setAntiAlias(true);
50 paint.setColor(fillC);
51 canvas->drawCircle(size.fWidth/2, size.fHeight/2, radius, paint);
52
53 paint.setStyle(SkPaint::kStroke_Style);
54 paint.setStrokeWidth(stroke);
55 paint.setColor(SK_ColorBLACK);
56 canvas->drawCircle(size.fWidth/2, size.fHeight/2, radius, paint);
57 }
58
test_surface(SkCanvas * canvas,SkSurface * surf,bool usePaint)59 static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) {
60 drawContents(surf, SK_ColorRED);
61 sk_sp<SkImage> imgR = surf->makeImageSnapshot();
62
63 if (true) {
64 sk_sp<SkImage> imgR2 = surf->makeImageSnapshot();
65 SkASSERT(imgR == imgR2);
66 }
67
68 drawContents(surf, SK_ColorGREEN);
69 sk_sp<SkImage> imgG = surf->makeImageSnapshot();
70
71 // since we've drawn after we snapped imgR, imgG will be a different obj
72 SkASSERT(imgR != imgG);
73
74 drawContents(surf, SK_ColorBLUE);
75
76 SkPaint paint;
77 // paint.setFilterBitmap(true);
78 // paint.setAlpha(0x80);
79
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);
83
84 SkRect src1, src2, src3;
85 src1.iset(0, 0, surf->width(), surf->height());
86 src2.iset(-surf->width() / 2, -surf->height() / 2,
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
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);
100 }
101
102 class ImageGM : public skiagm::GM {
103 void* fBuffer;
104 size_t fBufferSize;
105 SkSize fSize;
106 enum {
107 W = 64,
108 H = 64,
109 RB = W * 4 + 8,
110 };
111 public:
ImageGM()112 ImageGM() {
113 fBufferSize = RB * H;
114 fBuffer = sk_malloc_throw(fBufferSize);
115 fSize.set(SkIntToScalar(W), SkIntToScalar(H));
116 }
117
~ImageGM()118 ~ImageGM() override {
119 sk_free(fBuffer);
120 }
121
122 protected:
onShortName()123 SkString onShortName() override {
124 return SkString("image-surface");
125 }
126
onISize()127 SkISize onISize() override {
128 return SkISize::Make(960, 1200);
129 }
130
onDraw(SkCanvas * canvas)131 void onDraw(SkCanvas* canvas) override {
132 drawJpeg(canvas, this->getISize());
133
134 canvas->scale(2, 2);
135
136 const char* kLabel1 = "Original Img";
137 const char* kLabel2 = "Modified Img";
138 const char* kLabel3 = "Cur Surface";
139 const char* kLabel4 = "Full Crop";
140 const char* kLabel5 = "Over-crop";
141 const char* kLabel6 = "Upper-left";
142 const char* kLabel7 = "No Crop";
143
144 const char* kLabel8 = "Pre-Alloc Img";
145 const char* kLabel9 = "New Alloc Img";
146 const char* kLabel10 = "GPU";
147
148 SkPaint textPaint;
149 textPaint.setAntiAlias(true);
150 sk_tool_utils::set_portable_typeface(&textPaint);
151 textPaint.setTextSize(8);
152
153 canvas->drawText(kLabel1, strlen(kLabel1), 10, 60, textPaint);
154 canvas->drawText(kLabel2, strlen(kLabel2), 10, 140, textPaint);
155 canvas->drawText(kLabel3, strlen(kLabel3), 10, 220, textPaint);
156 canvas->drawText(kLabel4, strlen(kLabel4), 10, 300, textPaint);
157 canvas->drawText(kLabel5, strlen(kLabel5), 10, 380, textPaint);
158 canvas->drawText(kLabel6, strlen(kLabel6), 10, 460, textPaint);
159 canvas->drawText(kLabel7, strlen(kLabel7), 10, 540, textPaint);
160
161 canvas->drawText(kLabel8, strlen(kLabel8), 80, 10, textPaint);
162 canvas->drawText(kLabel9, strlen(kLabel9), 160, 10, textPaint);
163 canvas->drawText(kLabel10, strlen(kLabel10), 265, 10, textPaint);
164
165 canvas->translate(80, 20);
166
167 // since we draw into this directly, we need to start fresh
168 sk_bzero(fBuffer, fBufferSize);
169
170 SkImageInfo info = SkImageInfo::MakeN32Premul(W, H);
171 sk_sp<SkSurface> surf0(SkSurface::MakeRasterDirect(info, fBuffer, RB));
172 sk_sp<SkSurface> surf1(SkSurface::MakeRaster(info));
173 sk_sp<SkSurface> surf2; // gpu
174
175 #if SK_SUPPORT_GPU
176 surf2 = SkSurface::MakeRenderTarget(canvas->getGrContext(), SkBudgeted::kNo, info);
177 #endif
178
179 test_surface(canvas, surf0.get(), true);
180 canvas->translate(80, 0);
181 test_surface(canvas, surf1.get(), true);
182 if (surf2) {
183 canvas->translate(80, 0);
184 test_surface(canvas, surf2.get(), true);
185 }
186 }
187
188 private:
189 typedef skiagm::GM INHERITED;
190 };
DEF_GM(return new ImageGM;)191 DEF_GM( return new ImageGM; )
192
193 ///////////////////////////////////////////////////////////////////////////////////////////////////
194
195 #include "SkPictureRecorder.h"
196
197 static void draw_pixmap(SkCanvas* canvas, const SkPixmap& pmap) {
198 SkBitmap bitmap;
199 bitmap.installPixels(pmap);
200 canvas->drawBitmap(bitmap, 0, 0, nullptr);
201 }
202
show_scaled_pixels(SkCanvas * canvas,SkImage * image)203 static void show_scaled_pixels(SkCanvas* canvas, SkImage* image) {
204 SkAutoCanvasRestore acr(canvas, true);
205
206 canvas->drawImage(image, 0, 0, nullptr);
207 canvas->translate(110, 10);
208
209 const SkImageInfo info = SkImageInfo::MakeN32Premul(40, 40);
210 SkAutoPixmapStorage storage;
211 storage.alloc(info);
212
213 const SkImage::CachingHint chints[] = {
214 SkImage::kAllow_CachingHint, SkImage::kDisallow_CachingHint,
215 };
216 const SkFilterQuality qualities[] = {
217 kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality, kHigh_SkFilterQuality,
218 };
219
220 for (auto ch : chints) {
221 canvas->save();
222 for (auto q : qualities) {
223 if (image->scalePixels(storage, q, ch)) {
224 draw_pixmap(canvas, storage);
225 }
226 canvas->translate(70, 0);
227 }
228 canvas->restore();
229 canvas->translate(0, 45);
230 }
231 }
232
draw_contents(SkCanvas * canvas)233 static void draw_contents(SkCanvas* canvas) {
234 SkPaint paint;
235 paint.setStyle(SkPaint::kStroke_Style);
236 paint.setStrokeWidth(20);
237 canvas->drawCircle(50, 50, 35, paint);
238 }
239
make_raster(const SkImageInfo & info,GrContext *,void (* draw)(SkCanvas *))240 static sk_sp<SkImage> make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
241 auto surface(SkSurface::MakeRaster(info));
242 draw(surface->getCanvas());
243 return surface->makeImageSnapshot();
244 }
245
make_picture(const SkImageInfo & info,GrContext *,void (* draw)(SkCanvas *))246 static sk_sp<SkImage> make_picture(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
247 SkPictureRecorder recorder;
248 draw(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height())));
249 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
250 info.dimensions(), nullptr, nullptr, SkImage::BitDepth::kU8,
251 SkColorSpace::MakeSRGB());
252 }
253
make_codec(const SkImageInfo & info,GrContext *,void (* draw)(SkCanvas *))254 static sk_sp<SkImage> make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
255 sk_sp<SkImage> image(make_raster(info, nullptr, draw));
256 sk_sp<SkData> data(image->encode());
257 return SkImage::MakeFromEncoded(data);
258 }
259
make_gpu(const SkImageInfo & info,GrContext * ctx,void (* draw)(SkCanvas *))260 static sk_sp<SkImage> make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) {
261 if (!ctx) { return nullptr; }
262 auto surface(SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info));
263 if (!surface) { return nullptr; }
264 draw(surface->getCanvas());
265 return surface->makeImageSnapshot();
266 }
267
268 typedef sk_sp<SkImage> (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*));
269
270 class ScalePixelsGM : public skiagm::GM {
271 public:
ScalePixelsGM()272 ScalePixelsGM() {}
273
274 protected:
onShortName()275 SkString onShortName() override {
276 return SkString("scale-pixels");
277 }
278
onISize()279 SkISize onISize() override {
280 return SkISize::Make(960, 1200);
281 }
282
onDraw(SkCanvas * canvas)283 void onDraw(SkCanvas* canvas) override {
284 const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
285
286 const ImageMakerProc procs[] = {
287 make_codec, make_raster, make_picture, make_codec, make_gpu,
288 };
289 for (auto& proc : procs) {
290 sk_sp<SkImage> image(proc(info, canvas->getGrContext(), draw_contents));
291 if (image) {
292 show_scaled_pixels(canvas, image.get());
293 }
294 canvas->translate(0, 120);
295 }
296 }
297
298 private:
299 typedef skiagm::GM INHERITED;
300 };
301 DEF_GM( return new ScalePixelsGM; )
302
303 ///////////////////////////////////////////////////////////////////////////////////////////////////
304
305 DEF_SIMPLE_GM(new_texture_image, canvas, 280, 60) {
306 GrContext* context = canvas->getGrContext();
307 if (!context) {
308 skiagm::GM::DrawGpuOnlyMessage(canvas);
309 return;
310 }
311
__anon2b1cbbbe0202(SkCanvas* canvas) 312 auto render_image = [](SkCanvas* canvas) {
313 canvas->clear(SK_ColorBLUE);
314 SkPaint paint;
315 paint.setColor(SK_ColorRED);
316 canvas->drawRect(SkRect::MakeXYWH(10.f,10.f,10.f,10.f), paint);
317 paint.setColor(SK_ColorGREEN);
318 canvas->drawRect(SkRect::MakeXYWH(30.f,10.f,10.f,10.f), paint);
319 paint.setColor(SK_ColorYELLOW);
320 canvas->drawRect(SkRect::MakeXYWH(10.f,30.f,10.f,10.f), paint);
321 paint.setColor(SK_ColorCYAN);
322 canvas->drawRect(SkRect::MakeXYWH(30.f,30.f,10.f,10.f), paint);
323 };
324
325 static constexpr int kSize = 50;
326 SkBitmap bmp;
327 bmp.allocPixels(SkImageInfo::MakeS32(kSize, kSize, kPremul_SkAlphaType));
328 SkCanvas bmpCanvas(bmp);
329 render_image(&bmpCanvas);
330
331 std::function<sk_sp<SkImage>()> imageFactories[] = {
332 // Create sw raster image.
__anon2b1cbbbe0302null333 [bmp] {
334 return SkImage::MakeFromBitmap(bmp);
335 },
336 // Create encoded image.
__anon2b1cbbbe0402null337 [bmp] {
338 sk_sp<SkData> src(
339 sk_tool_utils::EncodeImageToData(bmp, SkEncodedImageFormat::kPNG, 100));
340 return SkImage::MakeFromEncoded(std::move(src));
341 },
342 // Create YUV encoded image.
__anon2b1cbbbe0502null343 [bmp] {
344 sk_sp<SkData> src(
345 sk_tool_utils::EncodeImageToData(bmp, SkEncodedImageFormat::kJPEG, 100));
346 return SkImage::MakeFromEncoded(std::move(src));
347 },
348 // Create a picture image.
__anon2b1cbbbe0602null349 [render_image] {
350 SkPictureRecorder recorder;
351 SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize));
352 render_image(canvas);
353 sk_sp<SkColorSpace> srgbColorSpace = SkColorSpace::MakeSRGB();
354 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
355 SkISize::Make(kSize, kSize), nullptr, nullptr,
356 SkImage::BitDepth::kU8, srgbColorSpace);
357 },
358 // Create a texture image
__anon2b1cbbbe0702() 359 [context, render_image]() -> sk_sp<SkImage> {
360 auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
361 SkImageInfo::MakeS32(kSize, kSize,
362 kPremul_SkAlphaType)));
363 if (!surface) {
364 return nullptr;
365 }
366 render_image(surface->getCanvas());
367 return surface->makeImageSnapshot();
368 }
369 };
370
371 constexpr SkScalar kPad = 5.f;
372 canvas->translate(kPad, kPad);
373 for (auto factory : imageFactories) {
374 auto image(factory());
375 if (image) {
376 sk_sp<SkImage> texImage(image->makeTextureImage(context,
377 canvas->imageInfo().colorSpace()));
378 if (texImage) {
379 canvas->drawImage(texImage, 0, 0);
380 }
381 }
382 canvas->translate(kSize + kPad, 0);
383 }
384 }
385
