fiddle_main.cpp File Reference

#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <string>
#include "src/core/SkAutoPixmapStorage.h"
#include "src/core/SkMemset.h"
#include "src/core/SkMipmap.h"
#include "tools/flags/CommandLineFlags.h"
#include "tools/fiddle/fiddle_main.h"
#include "include/codec/SkCodec.h"
#include "include/codec/SkJpegDecoder.h"
#include "include/codec/SkPngDecoder.h"
#include "include/encode/SkPngEncoder.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.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"

Go to the source code of this file.

Functions
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.")
void	SkDebugf (const char *fmt,...)
static void	encode_to_base64 (const void *data, size_t size, FILE *out)
static void	dump_output (const void *data, size_t size, const char *name, bool last=true)
static void	dump_output (const sk_sp< SkData > &data, const char *name, bool last=true)
static sk_sp< SkData >	encode_snapshot (GrDirectContext *ctx, const sk_sp< SkSurface > &surface)
static SkCanvas *	prepare_canvas (SkCanvas *canvas)
int	main (int argc, char **argv)

Variables
GrBackendTexture	backEndTexture
GrBackendRenderTarget	backEndRenderTarget
GrBackendTexture	backEndTextureRenderTarget
SkBitmap	source
sk_sp< SkImage >	image
double	duration
double	frame
sk_sp< SkFontMgr >	fontMgr
std::ostringstream	gTextOutput
std::ostringstream	gGLDriverInfo
sk_sp< sk_gpu_test::ManagedBackendTexture >	managedBackendTextureRenderTarget
sk_sp< sk_gpu_test::ManagedBackendTexture >	managedBackendTexture
sk_sp< GrRenderTarget >	backingRenderTarget

Function Documentation

DEFINE_double() [1/2]

static DEFINE_double ( duration  , 1.  0, "The total  duration, in  seconds, of the animation we are drawing."    )

static

DEFINE_double() [2/2]

static DEFINE_double ( frame  , 1.  0, "A double value in that specifies the point in animation to draw."  [0, 1]  )

static

dump_output() [1/2]

static void dump_output ( const sk_sp< SkData > &  data, const char *  name, bool  last = true  )

static

Definition at line 117 of file fiddle_main.cpp.

                                                            {
    if (data) {
        dump_output(data->data(), data->size(), name, last);
    }
}

dump_output() [2/2]

static void dump_output ( const void *  data, size_t  size, const char *  name, bool  last = true  )

static

Definition at line 110 of file fiddle_main.cpp.

                                                            {
    printf("\t\"%s\": \"", name);
    encode_to_base64(data, size, stdout);
    fputs(last ? "\"\n" : "\",\n", stdout);
}

encode_snapshot()

static sk_sp< SkData > encode_snapshot ( GrDirectContext *  ctx, const sk_sp< SkSurface > &  surface  )

static

Definition at line 124 of file fiddle_main.cpp.

                                                                                            {
    sk_sp<SkImage> img(surface->makeImageSnapshot());
    return SkPngEncoder::Encode(ctx, img.get(), {});
}

encode_to_base64()

static void encode_to_base64 ( const void *  data, size_t  size, FILE *  out  )

static

Definition at line 76 of file fiddle_main.cpp.

                                                                       {
    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;
    }
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 242 of file fiddle_main.cpp.

                                {
    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 defined(SK_FONTMGR_FONTCONFIG_AVAILABLE)
    fontMgr = SkFontMgr_New_FontConfig(nullptr);
#else
    fontMgr = SkFontMgr::RefEmpty();
#endif
    if (options.source) {
        sk_sp<SkData> data(SkData::MakeFromFileName(options.source));
        if (!data) {
            perror(options.source);
            return 1;
        }
        std::unique_ptr<SkCodec> codec = nullptr;
        if (SkPngDecoder::IsPng(data->data(), data->size())) {
            codec = SkPngDecoder::Decode(data, nullptr);
        } else if (SkJpegDecoder::IsJpeg(data->data(), data->size())) {
            codec = SkJpegDecoder::Decode(data, nullptr);
        } else {
            perror("Unsupported file format\n");
            return 1;
        }
        if (!codec) {
            perror("Corrupt source image file\n");
            return 1;
        }
        image = std::get<0>(codec->getImage());
        if (!image) {
            perror("Unable to decode the source image.\n");
            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 = SkSurfaces::Raster(info);
        srand(0);
        draw(prepare_canvas(rasterSurface->getCanvas()));
        rasterData = encode_snapshot(nullptr, 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 = SkSurfaces::RenderTarget(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(direct.get(), 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;
}

prepare_canvas()

static SkCanvas * prepare_canvas ( SkCanvas *  canvas )

static

Definition at line 129 of file fiddle_main.cpp.

                                                   {
    canvas->clear(SK_ColorWHITE);
    return canvas;
}

SkDebugf()

void SkDebugf	(	const char *	fmt,
			...
	)

Definition at line 65 of file fiddle_main.cpp.

                                     {
    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);
    }
}

Variable Documentation

backEndRenderTarget

GrBackendRenderTarget backEndRenderTarget

Definition at line 47 of file fiddle_main.cpp.

backEndTexture

GrBackendTexture backEndTexture

Definition at line 46 of file fiddle_main.cpp.

backEndTextureRenderTarget

GrBackendTexture backEndTextureRenderTarget

Definition at line 48 of file fiddle_main.cpp.

backingRenderTarget

sk_sp<GrRenderTarget> backingRenderTarget

Definition at line 63 of file fiddle_main.cpp.

duration

double duration

Definition at line 51 of file fiddle_main.cpp.

fontMgr

sk_sp<SkFontMgr> fontMgr

Definition at line 53 of file fiddle_main.cpp.

frame

double frame

Definition at line 52 of file fiddle_main.cpp.

gGLDriverInfo

std::ostringstream gGLDriverInfo

Definition at line 59 of file fiddle_main.cpp.

gTextOutput

std::ostringstream gTextOutput

Definition at line 56 of file fiddle_main.cpp.

image

sk_sp<SkImage> image

Definition at line 50 of file fiddle_main.cpp.

managedBackendTexture

sk_sp<sk_gpu_test::ManagedBackendTexture> managedBackendTexture

Definition at line 62 of file fiddle_main.cpp.

managedBackendTextureRenderTarget

sk_sp<sk_gpu_test::ManagedBackendTexture> managedBackendTextureRenderTarget

Definition at line 61 of file fiddle_main.cpp.

source

SkBitmap source

Definition at line 49 of file fiddle_main.cpp.