| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include <cstdio> |
| #include <cstdlib> |
| #include <sstream> |
| #include <string> |
| |
| #include "src/core/SkAutoPixmapStorage.h" |
| #include "src/core/SkMipmap.h" |
| #include "src/core/SkOpts.h" |
| #include "tools/flags/CommandLineFlags.h" |
| |
| #include "tools/fiddle/fiddle_main.h" |
| |
| static DEFINE_double(duration, 1.0, |
| "The total duration, in seconds, of the animation we are drawing."); |
| static DEFINE_double(frame, 1.0, |
| "A double value in [0, 1] that specifies the point in animation to draw."); |
| |
| #include "include/gpu/GrBackendSurface.h" |
| #include "src/gpu/ganesh/GrDirectContextPriv.h" |
| #include "src/gpu/ganesh/GrGpu.h" |
| #include "src/gpu/ganesh/GrRenderTarget.h" |
| #include "src/gpu/ganesh/GrResourceProvider.h" |
| #include "src/gpu/ganesh/GrTexture.h" |
| #include "tools/gpu/ManagedBackendTexture.h" |
| #include "tools/gpu/gl/GLTestContext.h" |
| |
| // Globals externed in fiddle_main.h |
| GrBackendTexture backEndTexture; |
| GrBackendRenderTarget backEndRenderTarget; |
| GrBackendTexture backEndTextureRenderTarget; |
| SkBitmap source; |
| sk_sp<SkImage> image; |
| double duration; // The total duration of the animation in seconds. |
| double frame; // A value in [0, 1] of where we are in the animation. |
| |
| // Global used by the local impl of SkDebugf. |
| std::ostringstream gTextOutput; |
| |
| // Global to record the GL driver info via create_direct_context(). |
| std::ostringstream gGLDriverInfo; |
| |
| sk_sp<sk_gpu_test::ManagedBackendTexture> managedBackendTextureRenderTarget; |
| sk_sp<sk_gpu_test::ManagedBackendTexture> managedBackendTexture; |
| sk_sp<GrRenderTarget> backingRenderTarget; |
| |
| void SkDebugf(const char * fmt, ...) { |
| va_list args; |
| va_start(args, fmt); |
| char formatbuffer[1024]; |
| int n = vsnprintf(formatbuffer, sizeof(formatbuffer), fmt, args); |
| va_end(args); |
| if (n>=0 && n<=int(sizeof(formatbuffer))) { |
| gTextOutput.write(formatbuffer, n); |
| } |
| } |
| |
| static void encode_to_base64(const void* data, size_t size, FILE* out) { |
| const uint8_t* input = reinterpret_cast<const uint8_t*>(data); |
| const uint8_t* end = &input[size]; |
| static const char codes[] = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| "abcdefghijklmnopqrstuvwxyz0123456789+/"; |
| while (input != end) { |
| uint8_t b = (*input & 0xFC) >> 2; |
| fputc(codes[b], out); |
| b = (*input & 0x03) << 4; |
| ++input; |
| if (input == end) { |
| fputc(codes[b], out); |
| fputs("==", out); |
| return; |
| } |
| b |= (*input & 0xF0) >> 4; |
| fputc(codes[b], out); |
| b = (*input & 0x0F) << 2; |
| ++input; |
| if (input == end) { |
| fputc(codes[b], out); |
| fputc('=', out); |
| return; |
| } |
| b |= (*input & 0xC0) >> 6; |
| fputc(codes[b], out); |
| b = *input & 0x3F; |
| fputc(codes[b], out); |
| ++input; |
| } |
| } |
| |
| |
| static void dump_output(const void* data, size_t size, |
| const char* name, bool last = true) { |
| printf("\t\"%s\": \"", name); |
| encode_to_base64(data, size, stdout); |
| fputs(last ? "\"\n" : "\",\n", stdout); |
| } |
| |
| static void dump_output(const sk_sp<SkData>& data, |
| const char* name, bool last = true) { |
| if (data) { |
| dump_output(data->data(), data->size(), name, last); |
| } |
| } |
| |
| static sk_sp<SkData> encode_snapshot(const sk_sp<SkSurface>& surface) { |
| sk_sp<SkImage> img(surface->makeImageSnapshot()); |
| return img ? img->encodeToData() : nullptr; |
| } |
| |
| static SkCanvas* prepare_canvas(SkCanvas * canvas) { |
| canvas->clear(SK_ColorWHITE); |
| return canvas; |
| } |
| |
| #ifdef SK_GL |
| static bool setup_backend_objects(GrDirectContext* dContext, |
| const SkBitmap& bm, |
| const DrawOptions& options) { |
| if (!dContext) { |
| fputs("Context is null.\n", stderr); |
| return false; |
| } |
| |
| // This config must match the SkColorType used in draw.cpp in the SkImage and Surface factories |
| GrBackendFormat renderableFormat = dContext->defaultBackendFormat(kRGBA_8888_SkColorType, |
| GrRenderable::kYes); |
| |
| if (!bm.empty()) { |
| SkPixmap originalPixmap; |
| SkPixmap* pixmap = &originalPixmap; |
| if (!bm.peekPixels(&originalPixmap)) { |
| fputs("Unable to peekPixels.\n", stderr); |
| return false; |
| } |
| |
| SkAutoPixmapStorage rgbaPixmap; |
| constexpr bool kRGBAIsNative = kN32_SkColorType == kRGBA_8888_SkColorType; |
| if ((!kRGBAIsNative)) { |
| if (!rgbaPixmap.tryAlloc(bm.info().makeColorType(kRGBA_8888_SkColorType))) { |
| fputs("Unable to alloc rgbaPixmap.\n", stderr); |
| return false; |
| } |
| if (!bm.readPixels(rgbaPixmap)) { |
| fputs("Unable to read rgbaPixmap.\n", stderr); |
| return false; |
| } |
| pixmap = &rgbaPixmap; |
| } |
| |
| managedBackendTexture = sk_gpu_test::ManagedBackendTexture::MakeFromPixmap( |
| dContext, |
| *pixmap, |
| options.fMipMapping, |
| GrRenderable::kNo, |
| GrProtected::kNo); |
| if (!managedBackendTexture) { |
| fputs("Failed to create backEndTexture.\n", stderr); |
| return false; |
| } |
| backEndTexture = managedBackendTexture->texture(); |
| } |
| |
| { |
| auto resourceProvider = dContext->priv().resourceProvider(); |
| |
| SkISize offscreenDims = {options.fOffScreenWidth, options.fOffScreenHeight}; |
| SkAutoTMalloc<uint32_t> data(offscreenDims.area()); |
| sk_memset32(data.get(), 0, offscreenDims.area()); |
| |
| // This backend object should be renderable but not textureable. Given the limitations |
| // of how we're creating it though it will wind up being secretly textureable. |
| // We use this fact to initialize it with data but don't allow mipmaps |
| GrMipLevel level0 = {data.get(), offscreenDims.width()*sizeof(uint32_t), nullptr}; |
| |
| constexpr int kSampleCnt = 1; |
| sk_sp<GrTexture> tmp = |
| resourceProvider->createTexture(offscreenDims, |
| renderableFormat, |
| GrTextureType::k2D, |
| GrColorType::kRGBA_8888, |
| GrRenderable::kYes, |
| kSampleCnt, |
| skgpu::Budgeted::kNo, |
| GrMipmapped::kNo, |
| GrProtected::kNo, |
| &level0, |
| /*label=*/"Fiddle_SetupBackendObjects"); |
| if (!tmp || !tmp->asRenderTarget()) { |
| fputs("GrTexture is invalid.\n", stderr); |
| return false; |
| } |
| |
| backingRenderTarget = sk_ref_sp(tmp->asRenderTarget()); |
| |
| backEndRenderTarget = backingRenderTarget->getBackendRenderTarget(); |
| if (!backEndRenderTarget.isValid()) { |
| fputs("BackEndRenderTarget is invalid.\n", stderr); |
| return false; |
| } |
| } |
| |
| { |
| managedBackendTextureRenderTarget = sk_gpu_test::ManagedBackendTexture::MakeWithData( |
| dContext, |
| options.fOffScreenWidth, |
| options.fOffScreenHeight, |
| renderableFormat, |
| SkColors::kTransparent, |
| options.fOffScreenMipMapping, |
| GrRenderable::kYes, |
| GrProtected::kNo); |
| if (!managedBackendTextureRenderTarget) { |
| fputs("Failed to create backendTextureRenderTarget.\n", stderr); |
| return false; |
| } |
| backEndTextureRenderTarget = managedBackendTextureRenderTarget->texture(); |
| } |
| |
| return true; |
| } |
| #endif |
| |
| int main(int argc, char** argv) { |
| CommandLineFlags::Parse(argc, argv); |
| duration = FLAGS_duration; |
| frame = FLAGS_frame; |
| DrawOptions options = GetDrawOptions(); |
| // If textOnly then only do one type of image, otherwise the text |
| // output is duplicated for each type. |
| if (options.textOnly) { |
| options.raster = true; |
| options.gpu = false; |
| options.pdf = false; |
| options.skp = false; |
| } |
| if (options.source) { |
| sk_sp<SkData> data(SkData::MakeFromFileName(options.source)); |
| if (!data) { |
| perror(options.source); |
| return 1; |
| } else { |
| image = SkImage::MakeFromEncoded(std::move(data)); |
| if (!image) { |
| perror("Unable to decode the source image."); |
| return 1; |
| } |
| SkAssertResult(image->asLegacyBitmap(&source)); |
| } |
| } |
| sk_sp<SkData> rasterData, gpuData, pdfData, skpData; |
| SkColorType colorType = kN32_SkColorType; |
| sk_sp<SkColorSpace> colorSpace = nullptr; |
| if (options.f16) { |
| SkASSERT(options.srgb); |
| colorType = kRGBA_F16_SkColorType; |
| colorSpace = SkColorSpace::MakeSRGBLinear(); |
| } else if (options.srgb) { |
| colorSpace = SkColorSpace::MakeSRGB(); |
| } |
| SkImageInfo info = SkImageInfo::Make(options.size.width(), options.size.height(), colorType, |
| kPremul_SkAlphaType, colorSpace); |
| if (options.raster) { |
| auto rasterSurface = SkSurface::MakeRaster(info); |
| srand(0); |
| draw(prepare_canvas(rasterSurface->getCanvas())); |
| rasterData = encode_snapshot(rasterSurface); |
| } |
| #ifdef SK_GL |
| if (options.gpu) { |
| std::unique_ptr<sk_gpu_test::GLTestContext> glContext; |
| sk_sp<GrDirectContext> direct = create_direct_context(gGLDriverInfo, &glContext); |
| if (!direct) { |
| fputs("Unable to get GrContext.\n", stderr); |
| } else { |
| if (!setup_backend_objects(direct.get(), source, options)) { |
| fputs("Unable to create backend objects.\n", stderr); |
| exit(1); |
| } |
| |
| auto surface = SkSurface::MakeRenderTarget(direct.get(), skgpu::Budgeted::kNo, info); |
| if (!surface) { |
| fputs("Unable to get render surface.\n", stderr); |
| exit(1); |
| } |
| srand(0); |
| draw(prepare_canvas(surface->getCanvas())); |
| gpuData = encode_snapshot(surface); |
| } |
| } |
| #endif |
| |
| #ifdef SK_SUPPORT_PDF |
| if (options.pdf) { |
| SkDynamicMemoryWStream pdfStream; |
| auto document = SkPDF::MakeDocument(&pdfStream); |
| if (document) { |
| srand(0); |
| draw(prepare_canvas(document->beginPage(options.size.width(), options.size.height()))); |
| document->close(); |
| pdfData = pdfStream.detachAsData(); |
| } |
| } |
| #endif |
| |
| if (options.skp) { |
| auto size = SkSize::Make(options.size); |
| SkPictureRecorder recorder; |
| srand(0); |
| draw(prepare_canvas(recorder.beginRecording(size.width(), size.height()))); |
| auto picture = recorder.finishRecordingAsPicture(); |
| SkDynamicMemoryWStream skpStream; |
| picture->serialize(&skpStream); |
| skpData = skpStream.detachAsData(); |
| } |
| |
| printf("{\n"); |
| if (!options.textOnly) { |
| dump_output(rasterData, "Raster", false); |
| dump_output(gpuData, "Gpu", false); |
| dump_output(pdfData, "Pdf", false); |
| dump_output(skpData, "Skp", false); |
| } else { |
| std::string textoutput = gTextOutput.str(); |
| dump_output(textoutput.c_str(), textoutput.length(), "Text", false); |
| } |
| std::string glinfo = gGLDriverInfo.str(); |
| dump_output(glinfo.c_str(), glinfo.length(), "GLInfo", true); |
| printf("}\n"); |
| |
| return 0; |
| } |