halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 8 | #include <cstdio> |
| 9 | #include <cstdlib> |
| 10 | #include <sstream> |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 11 | #include <string> |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 12 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 13 | #include "src/core/SkAutoPixmapStorage.h" |
Mike Reed | 13711eb | 2020-07-14 17:16:32 -0400 | [diff] [blame^] | 14 | #include "src/core/SkMipmap.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 15 | #include "src/core/SkUtils.h" |
| 16 | #include "tools/flags/CommandLineFlags.h" |
Joe Gregorio | 1e735c0 | 2017-04-19 14:05:14 -0400 | [diff] [blame] | 17 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 18 | #include "tools/fiddle/fiddle_main.h" |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 19 | |
Mike Klein | 84836b7 | 2019-03-21 11:31:36 -0500 | [diff] [blame] | 20 | static DEFINE_double(duration, 1.0, |
| 21 | "The total duration, in seconds, of the animation we are drawing."); |
| 22 | static DEFINE_double(frame, 1.0, |
| 23 | "A double value in [0, 1] that specifies the point in animation to draw."); |
Joe Gregorio | 1e735c0 | 2017-04-19 14:05:14 -0400 | [diff] [blame] | 24 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 25 | #include "include/gpu/GrBackendSurface.h" |
| 26 | #include "src/gpu/GrContextPriv.h" |
| 27 | #include "src/gpu/GrGpu.h" |
Brian Salomon | 201cdbb | 2019-08-14 17:00:30 -0400 | [diff] [blame] | 28 | #include "src/gpu/GrRenderTarget.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 29 | #include "tools/gpu/gl/GLTestContext.h" |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 30 | |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 31 | // Globals externed in fiddle_main.h |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 32 | sk_sp<GrTexture> backingTexture; // not externed |
| 33 | GrBackendTexture backEndTexture; |
| 34 | |
| 35 | sk_sp<GrRenderTarget> backingRenderTarget; // not externed |
| 36 | GrBackendRenderTarget backEndRenderTarget; |
| 37 | |
| 38 | sk_sp<GrTexture> backingTextureRenderTarget; // not externed |
| 39 | GrBackendTexture backEndTextureRenderTarget; |
| 40 | |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 41 | SkBitmap source; |
halcanary | 7b8b237 | 2016-04-18 08:17:56 -0700 | [diff] [blame] | 42 | sk_sp<SkImage> image; |
Joe Gregorio | 1e735c0 | 2017-04-19 14:05:14 -0400 | [diff] [blame] | 43 | double duration; // The total duration of the animation in seconds. |
| 44 | double frame; // A value in [0, 1] of where we are in the animation. |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 45 | |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 46 | // Global used by the local impl of SkDebugf. |
| 47 | std::ostringstream gTextOutput; |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 48 | |
Robert Phillips | f4f8011 | 2020-07-13 16:13:31 -0400 | [diff] [blame] | 49 | // Global to record the GL driver info via create_direct_context(). |
Joe Gregorio | 97b10ac | 2017-06-01 13:24:11 -0400 | [diff] [blame] | 50 | std::ostringstream gGLDriverInfo; |
| 51 | |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 52 | void SkDebugf(const char * fmt, ...) { |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 53 | va_list args; |
| 54 | va_start(args, fmt); |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 55 | char formatbuffer[1024]; |
| 56 | int n = vsnprintf(formatbuffer, sizeof(formatbuffer), fmt, args); |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 57 | va_end(args); |
| 58 | if (n>=0 && n<=int(sizeof(formatbuffer))) { |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 59 | gTextOutput.write(formatbuffer, n); |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 60 | } |
| 61 | } |
| 62 | |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 63 | static void encode_to_base64(const void* data, size_t size, FILE* out) { |
| 64 | const uint8_t* input = reinterpret_cast<const uint8_t*>(data); |
| 65 | const uint8_t* end = &input[size]; |
| 66 | static const char codes[] = |
| 67 | "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| 68 | "abcdefghijklmnopqrstuvwxyz0123456789+/"; |
| 69 | while (input != end) { |
| 70 | uint8_t b = (*input & 0xFC) >> 2; |
| 71 | fputc(codes[b], out); |
| 72 | b = (*input & 0x03) << 4; |
| 73 | ++input; |
| 74 | if (input == end) { |
| 75 | fputc(codes[b], out); |
| 76 | fputs("==", out); |
| 77 | return; |
| 78 | } |
| 79 | b |= (*input & 0xF0) >> 4; |
| 80 | fputc(codes[b], out); |
| 81 | b = (*input & 0x0F) << 2; |
| 82 | ++input; |
| 83 | if (input == end) { |
| 84 | fputc(codes[b], out); |
| 85 | fputc('=', out); |
| 86 | return; |
| 87 | } |
| 88 | b |= (*input & 0xC0) >> 6; |
| 89 | fputc(codes[b], out); |
| 90 | b = *input & 0x3F; |
| 91 | fputc(codes[b], out); |
| 92 | ++input; |
| 93 | } |
| 94 | } |
| 95 | |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 96 | |
| 97 | static void dump_output(const void* data, size_t size, |
| 98 | const char* name, bool last = true) { |
| 99 | printf("\t\"%s\": \"", name); |
| 100 | encode_to_base64(data, size, stdout); |
| 101 | fputs(last ? "\"\n" : "\",\n", stdout); |
| 102 | } |
| 103 | |
halcanary | d096459 | 2016-03-25 11:29:34 -0700 | [diff] [blame] | 104 | static void dump_output(const sk_sp<SkData>& data, |
| 105 | const char* name, bool last = true) { |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 106 | if (data) { |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 107 | dump_output(data->data(), data->size(), name, last); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 108 | } |
| 109 | } |
| 110 | |
Mike Reed | 6409f84 | 2017-07-11 16:03:13 -0400 | [diff] [blame] | 111 | static sk_sp<SkData> encode_snapshot(const sk_sp<SkSurface>& surface) { |
halcanary | 7b8b237 | 2016-04-18 08:17:56 -0700 | [diff] [blame] | 112 | sk_sp<SkImage> img(surface->makeImageSnapshot()); |
Mike Reed | 6409f84 | 2017-07-11 16:03:13 -0400 | [diff] [blame] | 113 | return img ? img->encodeToData() : nullptr; |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 114 | } |
| 115 | |
Joe Gregorio | 4f12f1e | 2017-06-14 15:54:32 -0400 | [diff] [blame] | 116 | static SkCanvas* prepare_canvas(SkCanvas * canvas) { |
| 117 | canvas->clear(SK_ColorWHITE); |
| 118 | return canvas; |
| 119 | } |
| 120 | |
Brian Salomon | f4ba4ec | 2020-03-19 15:54:28 -0400 | [diff] [blame] | 121 | #ifdef SK_GL |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 122 | static bool setup_backend_objects(GrContext* context, |
| 123 | const SkBitmap& bm, |
| 124 | const DrawOptions& options) { |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 125 | if (!context) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 126 | fputs("Context is null.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 127 | return false; |
| 128 | } |
| 129 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 130 | auto resourceProvider = context->priv().resourceProvider(); |
Robert Phillips | 6be756b | 2018-01-16 15:07:54 -0500 | [diff] [blame] | 131 | |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 132 | // This config must match the SkColorType used in draw.cpp in the SkImage and Surface factories |
Brian Salomon | 4eb38b7 | 2019-08-05 12:58:39 -0400 | [diff] [blame] | 133 | auto format = resourceProvider->caps()->getDefaultBackendFormat( |
| 134 | SkColorTypeToGrColorType(kRGBA_8888_SkColorType), GrRenderable::kNo); |
| 135 | auto renderableFormat = resourceProvider->caps()->getDefaultBackendFormat( |
| 136 | SkColorTypeToGrColorType(kRGBA_8888_SkColorType), GrRenderable::kYes); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 137 | |
| 138 | if (!bm.empty()) { |
Brian Osman | 250e6e8 | 2017-12-12 16:24:41 -0500 | [diff] [blame] | 139 | SkPixmap originalPixmap; |
| 140 | SkPixmap* pixmap = &originalPixmap; |
| 141 | if (!bm.peekPixels(&originalPixmap)) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 142 | fputs("Unable to peekPixels.\n", stderr); |
Brian Osman | 250e6e8 | 2017-12-12 16:24:41 -0500 | [diff] [blame] | 143 | return false; |
| 144 | } |
| 145 | |
| 146 | SkAutoPixmapStorage rgbaPixmap; |
| 147 | if (kN32_SkColorType != kRGBA_8888_SkColorType) { |
| 148 | if (!rgbaPixmap.tryAlloc(bm.info().makeColorType(kRGBA_8888_SkColorType))) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 149 | fputs("Unable to alloc rgbaPixmap.\n", stderr); |
Brian Osman | 250e6e8 | 2017-12-12 16:24:41 -0500 | [diff] [blame] | 150 | return false; |
| 151 | } |
| 152 | if (!bm.readPixels(rgbaPixmap)) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 153 | fputs("Unable to read rgbaPixmap.\n", stderr); |
Brian Osman | 250e6e8 | 2017-12-12 16:24:41 -0500 | [diff] [blame] | 154 | return false; |
| 155 | } |
| 156 | pixmap = &rgbaPixmap; |
| 157 | } |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 158 | int mipLevelCount = GrMipMapped::kYes == options.fMipMapping |
Mike Reed | 13711eb | 2020-07-14 17:16:32 -0400 | [diff] [blame^] | 159 | ? SkMipmap::ComputeLevelCount(bm.width(), bm.height()) |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 160 | : 1; |
| 161 | std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipLevelCount]); |
| 162 | |
Brian Osman | 250e6e8 | 2017-12-12 16:24:41 -0500 | [diff] [blame] | 163 | texels[0].fPixels = pixmap->addr(); |
| 164 | texels[0].fRowBytes = pixmap->rowBytes(); |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 165 | |
| 166 | for (int i = 1; i < mipLevelCount; i++) { |
| 167 | texels[i].fPixels = nullptr; |
| 168 | texels[i].fRowBytes = 0; |
| 169 | } |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 170 | |
Brian Salomon | a90382f | 2019-09-17 09:01:56 -0400 | [diff] [blame] | 171 | backingTexture = resourceProvider->createTexture( |
Brian Salomon | a56a746 | 2020-02-07 14:17:25 -0500 | [diff] [blame] | 172 | bm.dimensions(), format, GrColorType::kRGBA_8888, GrRenderable::kNo, 1, |
| 173 | SkBudgeted::kNo, GrProtected::kNo, texels.get(), mipLevelCount); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 174 | if (!backingTexture) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 175 | fputs("Failed to create backingTexture.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 176 | return false; |
| 177 | } |
| 178 | |
Robert Phillips | b67821d | 2017-12-13 15:00:45 -0500 | [diff] [blame] | 179 | backEndTexture = backingTexture->getBackendTexture(); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 180 | if (!backEndTexture.isValid()) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 181 | fputs("BackingTexture is invalid.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 182 | return false; |
| 183 | } |
| 184 | } |
| 185 | |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 186 | SkISize offscreenDims = {options.fOffScreenWidth, options.fOffScreenHeight}; |
| 187 | SkAutoTMalloc<uint32_t> data(offscreenDims.area()); |
| 188 | sk_memset32(data.get(), 0, offscreenDims.area()); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 189 | |
| 190 | { |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 191 | // This backend object should be renderable but not textureable. Given the limitations |
| 192 | // of how we're creating it though it will wind up being secretly textureable. |
| 193 | // We use this fact to initialize it with data but don't allow mipmaps |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 194 | GrMipLevel level0 = { data.get(), offscreenDims.width()*sizeof(uint32_t) }; |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 195 | |
Brian Salomon | e8a766b | 2019-07-19 14:24:36 -0400 | [diff] [blame] | 196 | sk_sp<GrTexture> tmp = resourceProvider->createTexture( |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 197 | offscreenDims, renderableFormat, GrColorType::kRGBA_8888, GrRenderable::kYes, |
Brian Salomon | a90382f | 2019-09-17 09:01:56 -0400 | [diff] [blame] | 198 | options.fOffScreenSampleCount, SkBudgeted::kNo, GrProtected::kNo, &level0, 1); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 199 | if (!tmp || !tmp->asRenderTarget()) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 200 | fputs("GrTexture is invalid.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 201 | return false; |
| 202 | } |
| 203 | |
| 204 | backingRenderTarget = sk_ref_sp(tmp->asRenderTarget()); |
| 205 | |
Robert Phillips | b67821d | 2017-12-13 15:00:45 -0500 | [diff] [blame] | 206 | backEndRenderTarget = backingRenderTarget->getBackendRenderTarget(); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 207 | if (!backEndRenderTarget.isValid()) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 208 | fputs("BackEndRenderTarget is invalid.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 209 | return false; |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | { |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 214 | int mipLevelCount = |
| 215 | GrMipMapped::kYes == options.fOffScreenMipMapping |
Mike Reed | 13711eb | 2020-07-14 17:16:32 -0400 | [diff] [blame^] | 216 | ? SkMipmap::ComputeLevelCount(offscreenDims.width(), offscreenDims.height()) |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 217 | : 1; |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 218 | std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipLevelCount]); |
| 219 | |
| 220 | texels[0].fPixels = data.get(); |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 221 | texels[0].fRowBytes = offscreenDims.width()*sizeof(uint32_t); |
Robert Phillips | c34aa9d | 2017-11-17 14:59:43 -0500 | [diff] [blame] | 222 | |
| 223 | for (int i = 1; i < mipLevelCount; i++) { |
| 224 | texels[i].fPixels = nullptr; |
| 225 | texels[i].fRowBytes = 0; |
| 226 | } |
| 227 | |
Brian Salomon | 4eb38b7 | 2019-08-05 12:58:39 -0400 | [diff] [blame] | 228 | backingTextureRenderTarget = resourceProvider->createTexture( |
Brian Salomon | 5dd64f3 | 2020-02-10 14:23:10 -0500 | [diff] [blame] | 229 | offscreenDims, renderableFormat, GrColorType::kRGBA_8888, GrRenderable::kYes, |
Brian Salomon | a90382f | 2019-09-17 09:01:56 -0400 | [diff] [blame] | 230 | options.fOffScreenSampleCount, SkBudgeted::kNo, GrProtected::kNo, texels.get(), |
| 231 | mipLevelCount); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 232 | if (!backingTextureRenderTarget || !backingTextureRenderTarget->asRenderTarget()) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 233 | fputs("backingTextureRenderTarget is invalid.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 234 | return false; |
| 235 | } |
| 236 | |
Robert Phillips | b67821d | 2017-12-13 15:00:45 -0500 | [diff] [blame] | 237 | backEndTextureRenderTarget = backingTextureRenderTarget->getBackendTexture(); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 238 | if (!backEndTextureRenderTarget.isValid()) { |
Joe Gregorio | 9a37fb6 | 2020-02-10 10:41:56 -0500 | [diff] [blame] | 239 | fputs("backEndTextureRenderTarget is invalid.\n", stderr); |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 240 | return false; |
| 241 | } |
| 242 | } |
| 243 | |
| 244 | |
| 245 | return true; |
| 246 | } |
Brian Salomon | f4ba4ec | 2020-03-19 15:54:28 -0400 | [diff] [blame] | 247 | #endif |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 248 | |
Joe Gregorio | 1e735c0 | 2017-04-19 14:05:14 -0400 | [diff] [blame] | 249 | int main(int argc, char** argv) { |
Mike Klein | 88544fb | 2019-03-20 10:50:33 -0500 | [diff] [blame] | 250 | CommandLineFlags::Parse(argc, argv); |
Joe Gregorio | 1e735c0 | 2017-04-19 14:05:14 -0400 | [diff] [blame] | 251 | duration = FLAGS_duration; |
| 252 | frame = FLAGS_frame; |
Joe Gregorio | 1fd1823 | 2017-02-13 11:39:43 -0500 | [diff] [blame] | 253 | DrawOptions options = GetDrawOptions(); |
| 254 | // If textOnly then only do one type of image, otherwise the text |
| 255 | // output is duplicated for each type. |
| 256 | if (options.textOnly) { |
| 257 | options.raster = true; |
| 258 | options.gpu = false; |
| 259 | options.pdf = false; |
| 260 | options.skp = false; |
| 261 | } |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 262 | if (options.source) { |
bungeman | 38d909e | 2016-08-02 14:40:46 -0700 | [diff] [blame] | 263 | sk_sp<SkData> data(SkData::MakeFromFileName(options.source)); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 264 | if (!data) { |
| 265 | perror(options.source); |
| 266 | return 1; |
| 267 | } else { |
halcanary | 7b8b237 | 2016-04-18 08:17:56 -0700 | [diff] [blame] | 268 | image = SkImage::MakeFromEncoded(std::move(data)); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 269 | if (!image) { |
| 270 | perror("Unable to decode the source image."); |
| 271 | return 1; |
| 272 | } |
Cary Clark | 4f5a79c | 2018-02-07 15:51:00 -0500 | [diff] [blame] | 273 | SkAssertResult(image->asLegacyBitmap(&source)); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 274 | } |
| 275 | } |
halcanary | d096459 | 2016-03-25 11:29:34 -0700 | [diff] [blame] | 276 | sk_sp<SkData> rasterData, gpuData, pdfData, skpData; |
Matt Sarett | a2f7126 | 2016-11-29 17:14:58 -0500 | [diff] [blame] | 277 | SkColorType colorType = kN32_SkColorType; |
| 278 | sk_sp<SkColorSpace> colorSpace = nullptr; |
| 279 | if (options.f16) { |
| 280 | SkASSERT(options.srgb); |
| 281 | colorType = kRGBA_F16_SkColorType; |
Matt Sarett | 77a7a1b | 2017-02-07 13:56:11 -0500 | [diff] [blame] | 282 | colorSpace = SkColorSpace::MakeSRGBLinear(); |
Matt Sarett | a2f7126 | 2016-11-29 17:14:58 -0500 | [diff] [blame] | 283 | } else if (options.srgb) { |
Matt Sarett | 77a7a1b | 2017-02-07 13:56:11 -0500 | [diff] [blame] | 284 | colorSpace = SkColorSpace::MakeSRGB(); |
Matt Sarett | a2f7126 | 2016-11-29 17:14:58 -0500 | [diff] [blame] | 285 | } |
| 286 | SkImageInfo info = SkImageInfo::Make(options.size.width(), options.size.height(), colorType, |
| 287 | kPremul_SkAlphaType, colorSpace); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 288 | if (options.raster) { |
Matt Sarett | a2f7126 | 2016-11-29 17:14:58 -0500 | [diff] [blame] | 289 | auto rasterSurface = SkSurface::MakeRaster(info); |
halcanary | f0270c3 | 2016-05-23 09:02:38 -0700 | [diff] [blame] | 290 | srand(0); |
Joe Gregorio | 4f12f1e | 2017-06-14 15:54:32 -0400 | [diff] [blame] | 291 | draw(prepare_canvas(rasterSurface->getCanvas())); |
Mike Reed | 6409f84 | 2017-07-11 16:03:13 -0400 | [diff] [blame] | 292 | rasterData = encode_snapshot(rasterSurface); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 293 | } |
Brian Salomon | f4ba4ec | 2020-03-19 15:54:28 -0400 | [diff] [blame] | 294 | #ifdef SK_GL |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 295 | if (options.gpu) { |
Joe Gregorio | 8e9810c | 2018-05-29 13:56:27 -0400 | [diff] [blame] | 296 | std::unique_ptr<sk_gpu_test::GLTestContext> glContext; |
Robert Phillips | f4f8011 | 2020-07-13 16:13:31 -0400 | [diff] [blame] | 297 | sk_sp<GrDirectContext> direct = create_direct_context(gGLDriverInfo, &glContext); |
| 298 | if (!direct) { |
mtklein | 7d10b9f | 2016-07-27 11:17:18 -0700 | [diff] [blame] | 299 | fputs("Unable to get GrContext.\n", stderr); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 300 | } else { |
Robert Phillips | f4f8011 | 2020-07-13 16:13:31 -0400 | [diff] [blame] | 301 | if (!setup_backend_objects(direct.get(), source, options)) { |
Robert Phillips | 57e0828 | 2017-11-16 14:59:48 -0500 | [diff] [blame] | 302 | fputs("Unable to create backend objects.\n", stderr); |
| 303 | exit(1); |
| 304 | } |
| 305 | |
Robert Phillips | f4f8011 | 2020-07-13 16:13:31 -0400 | [diff] [blame] | 306 | auto surface = SkSurface::MakeRenderTarget(direct.get(), SkBudgeted::kNo, info); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 307 | if (!surface) { |
| 308 | fputs("Unable to get render surface.\n", stderr); |
| 309 | exit(1); |
| 310 | } |
halcanary | f0270c3 | 2016-05-23 09:02:38 -0700 | [diff] [blame] | 311 | srand(0); |
Joe Gregorio | 4f12f1e | 2017-06-14 15:54:32 -0400 | [diff] [blame] | 312 | draw(prepare_canvas(surface->getCanvas())); |
Mike Reed | 6409f84 | 2017-07-11 16:03:13 -0400 | [diff] [blame] | 313 | gpuData = encode_snapshot(surface); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 314 | } |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 315 | } |
Brian Salomon | f4ba4ec | 2020-03-19 15:54:28 -0400 | [diff] [blame] | 316 | #endif |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 317 | if (options.pdf) { |
| 318 | SkDynamicMemoryWStream pdfStream; |
Hal Canary | 3026d4b | 2019-01-07 10:00:48 -0500 | [diff] [blame] | 319 | auto document = SkPDF::MakeDocument(&pdfStream); |
mtklein | cd01b03 | 2016-08-31 04:58:19 -0700 | [diff] [blame] | 320 | if (document) { |
| 321 | srand(0); |
Joe Gregorio | 4f12f1e | 2017-06-14 15:54:32 -0400 | [diff] [blame] | 322 | draw(prepare_canvas(document->beginPage(options.size.width(), options.size.height()))); |
mtklein | cd01b03 | 2016-08-31 04:58:19 -0700 | [diff] [blame] | 323 | document->close(); |
reed | 42943c8 | 2016-09-12 12:01:44 -0700 | [diff] [blame] | 324 | pdfData = pdfStream.detachAsData(); |
mtklein | cd01b03 | 2016-08-31 04:58:19 -0700 | [diff] [blame] | 325 | } |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 326 | } |
| 327 | if (options.skp) { |
Brian Salomon | 4e1066f | 2019-12-04 10:33:52 -0500 | [diff] [blame] | 328 | auto size = SkSize::Make(options.size); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 329 | SkPictureRecorder recorder; |
halcanary | f0270c3 | 2016-05-23 09:02:38 -0700 | [diff] [blame] | 330 | srand(0); |
Joe Gregorio | 4f12f1e | 2017-06-14 15:54:32 -0400 | [diff] [blame] | 331 | draw(prepare_canvas(recorder.beginRecording(size.width(), size.height()))); |
halcanary | d096459 | 2016-03-25 11:29:34 -0700 | [diff] [blame] | 332 | auto picture = recorder.finishRecordingAsPicture(); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 333 | SkDynamicMemoryWStream skpStream; |
| 334 | picture->serialize(&skpStream); |
reed | 42943c8 | 2016-09-12 12:01:44 -0700 | [diff] [blame] | 335 | skpData = skpStream.detachAsData(); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | printf("{\n"); |
Joe Gregorio | 0236cba | 2017-02-13 13:55:17 -0500 | [diff] [blame] | 339 | if (!options.textOnly) { |
Joe Gregorio | 97b10ac | 2017-06-01 13:24:11 -0400 | [diff] [blame] | 340 | dump_output(rasterData, "Raster", false); |
| 341 | dump_output(gpuData, "Gpu", false); |
| 342 | dump_output(pdfData, "Pdf", false); |
| 343 | dump_output(skpData, "Skp", false); |
Joe Gregorio | 0236cba | 2017-02-13 13:55:17 -0500 | [diff] [blame] | 344 | } else { |
Hal Canary | 169f37f | 2017-02-15 10:20:30 -0500 | [diff] [blame] | 345 | std::string textoutput = gTextOutput.str(); |
Joe Gregorio | 97b10ac | 2017-06-01 13:24:11 -0400 | [diff] [blame] | 346 | dump_output(textoutput.c_str(), textoutput.length(), "Text", false); |
Joe Gregorio | 0236cba | 2017-02-13 13:55:17 -0500 | [diff] [blame] | 347 | } |
Joe Gregorio | 97b10ac | 2017-06-01 13:24:11 -0400 | [diff] [blame] | 348 | std::string glinfo = gGLDriverInfo.str(); |
| 349 | dump_output(glinfo.c_str(), glinfo.length(), "GLInfo", true); |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 350 | printf("}\n"); |
| 351 | |
halcanary | decb21e | 2015-12-10 07:52:45 -0800 | [diff] [blame] | 352 | return 0; |
| 353 | } |