FuzzCreateDDL.cpp File Reference

#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/core/SkSurface.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/private/chromium/GrDeferredDisplayList.h"
#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "tools/gpu/GrContextFactory.h"
#include "fuzz/Fuzz.h"
#include <tuple>

Go to the source code of this file.

Typedefs
using	SurfaceAndChar = std::tuple< sk_sp< SkSurface >, GrSurfaceCharacterization >

Functions
static SkSurfaceProps	gen_fuzzed_surface_props (Fuzz *fuzz)
static SkPaint	gen_fuzzed_skpaint (Fuzz *fuzz)
static SkImageInfo	gen_fuzzed_imageinfo (Fuzz *fuzz, SkColorType surfaceType)
static GrSurfaceCharacterization	make_characterization (Fuzz *fuzz, GrDirectContext *dContext, SkImageInfo &ii, SkColorType surfaceType, GrSurfaceOrigin origin)
static sk_sp< GrDeferredDisplayList >	make_ddl (Fuzz *fuzz, GrDirectContext *dContext, const GrSurfaceCharacterization &c)
static sk_sp< SkSurface >	make_surface (Fuzz *fuzz, GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin)
static bool	draw_ddl (sk_sp< SkSurface > surface, sk_sp< const GrDeferredDisplayList > ddl)
static SurfaceAndChar	create_surface_and_characterization (Fuzz *fuzz, GrDirectContext *dContext, SkColorType surfaceType, GrSurfaceOrigin origin)
	DEF_FUZZ (CreateDDL, fuzz)

Variables
static constexpr int	kMaxWidth = 64
static constexpr int	kMaxHeight = 64
static constexpr int	kSampleCount = 1

Typedef Documentation

SurfaceAndChar

using SurfaceAndChar = std::tuple<sk_sp<SkSurface>, GrSurfaceCharacterization>

Definition at line 194 of file FuzzCreateDDL.cpp.

Function Documentation

create_surface_and_characterization()

static SurfaceAndChar create_surface_and_characterization ( Fuzz *  fuzz, GrDirectContext *  dContext, SkColorType  surfaceType, GrSurfaceOrigin  origin  )

static

Definition at line 195 of file FuzzCreateDDL.cpp.

                                                                                  {
    SkImageInfo ii = gen_fuzzed_imageinfo(fuzz, surfaceType);
    GrSurfaceCharacterization c = make_characterization(fuzz, dContext, ii, surfaceType, origin);
    if (!c.isValid()) {
       return {};
    }
 
    auto surface = make_surface(fuzz, dContext, ii, origin);
    if (!surface) {
        return {};
    }
    return {surface, c};
}

DEF_FUZZ()

DEF_FUZZ	(	CreateDDL	,
		fuzz
	)

Definition at line 211 of file FuzzCreateDDL.cpp.

                          {
    SkColorType surfaceType;
    GrSurfaceOrigin origin;
    fuzz->nextEnum(&surfaceType, SkColorType::kLastEnum_SkColorType);
    fuzz->nextEnum(&origin, GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin);
 
    sk_gpu_test::GrContextFactory factory;
    auto ctxInfo = factory.getContextInfo(skgpu::ContextType::kGL);
 
    GrDirectContext* dContext = ctxInfo.directContext();
    if (!dContext) {
        SkDebugf("Context creation failed");
        return;
    }
 
    auto[surface, c] = create_surface_and_characterization(fuzz, dContext, surfaceType, origin);
    if (!surface || !c.isValid()) {
        return;
    }
 
    sk_sp<GrDeferredDisplayList> ddl = make_ddl(fuzz, dContext, c);
    if (!ddl) {
        SkDebugf("Could not create ddl %s", GrBackendApiToStr(dContext->backend()));
        return;
    }
    if (!draw_ddl(std::move(surface), std::move(ddl))) {
        SkDebugf("Could not draw ddl in the backend");
    }
    return;
}

draw_ddl()

static bool draw_ddl ( sk_sp< SkSurface >  surface, sk_sp< const GrDeferredDisplayList >  ddl  )

static

Definition at line 190 of file FuzzCreateDDL.cpp.

                                                                                       {
    return skgpu::ganesh::DrawDDL(std::move(surface), std::move(ddl));
}

gen_fuzzed_imageinfo()

static SkImageInfo gen_fuzzed_imageinfo ( Fuzz *  fuzz, SkColorType  surfaceType  )

static

Definition at line 56 of file FuzzCreateDDL.cpp.

                                                                             {
    int width, height;
    fuzz->nextRange(&width, 1, kMaxWidth);
    fuzz->nextRange(&height, 1, kMaxHeight);
    SkAlphaType alphaType;
    fuzz->nextEnum(&alphaType, SkAlphaType::kLastEnum_SkAlphaType);
    skcms_TransferFunction skcmsFn;
    uint8_t skcms;
    fuzz->nextRange(&skcms, 0, 5);
    switch (skcms) {
        case 0: {
            skcmsFn = SkNamedTransferFn::kSRGB;
            break;
        }
        case 1: {
            skcmsFn = SkNamedTransferFn::k2Dot2;
            break;
        }
        case 2: {
            skcmsFn = SkNamedTransferFn::kHLG;
            break;
        }
        case 3: {
            skcmsFn = SkNamedTransferFn::kLinear;
            break;
        }
        case 4: {
            skcmsFn = SkNamedTransferFn::kPQ;
            break;
        }
        case 5: {
            skcmsFn = SkNamedTransferFn::kRec2020;
            break;
        }
        default:
            SkASSERT(false);
            break;
    }
    skcms_Matrix3x3 skcmsMat;
    fuzz->nextRange(&skcms, 0, 4);
    switch (skcms) {
        case 0: {
            skcmsMat = SkNamedGamut::kAdobeRGB;
            break;
        }
        case 1: {
            skcmsMat = SkNamedGamut::kDisplayP3;
            break;
        }
        case 2: {
            skcmsMat = SkNamedGamut::kRec2020;
            break;
        }
        case 3: {
            skcmsMat = SkNamedGamut::kSRGB;
            break;
        }
        case 4: {
            skcmsMat = SkNamedGamut::kXYZ;
            break;
        }
        default:
            SkASSERT(false);
            break;
    }
    return SkImageInfo::Make(width, height, surfaceType, alphaType,
                             SkColorSpace::MakeRGB(skcmsFn, skcmsMat));
}

gen_fuzzed_skpaint()

static SkPaint gen_fuzzed_skpaint ( Fuzz *  fuzz )

static

Definition at line 46 of file FuzzCreateDDL.cpp.

                                              {
    float R, G, B, Alpha;
    fuzz->nextRange(&R, -1, 2);
    fuzz->nextRange(&G, -1, 2);
    fuzz->nextRange(&B, -1, 2);
    fuzz->nextRange(&Alpha, 0, 1);
    SkColor4f color = {R, G, B, Alpha};
    return SkPaint(color);
}

gen_fuzzed_surface_props()

static SkSurfaceProps gen_fuzzed_surface_props ( Fuzz *  fuzz )

static

Definition at line 40 of file FuzzCreateDDL.cpp.

                                                           {
    SkPixelGeometry pixel;
    fuzz->nextEnum(&pixel, kBGR_V_SkPixelGeometry);
    return SkSurfaceProps(0x0, pixel);
}

make_characterization()

static GrSurfaceCharacterization make_characterization ( Fuzz *  fuzz, GrDirectContext *  dContext, SkImageInfo &  ii, SkColorType  surfaceType, GrSurfaceOrigin  origin  )

static

Definition at line 125 of file FuzzCreateDDL.cpp.

                                                                               {
    if (!dContext->colorTypeSupportedAsSurface(surfaceType)) {
        SkDebugf("Couldn't create backend texture in the backend %s",
                 GrBackendApiToStr(dContext->backend()));
        return {};
    }
 
    GrBackendFormat backendFormat = dContext->defaultBackendFormat(surfaceType,
                                                                   GrRenderable::kYes);
    if (!backendFormat.isValid()) {
        SkDebugf("Color Type is not supported in the backend %s",
                 GrBackendApiToStr(dContext->backend()));
        return {};
    }
    GrProtected protect = GrProtected::kNo;
#ifdef SK_VULKAN
    fuzz->nextEnum(&protect, GrProtected::kYes);
#endif
    GrSurfaceCharacterization c;
    size_t maxResourceBytes = dContext->getResourceCacheLimit();
    c = dContext->threadSafeProxy()->createCharacterization(maxResourceBytes,
                                                            ii,
                                                            backendFormat,
                                                            kSampleCount,
                                                            origin,
                                                            gen_fuzzed_surface_props(fuzz),
                                                            skgpu::Mipmapped::kYes,
                                                            false,
                                                            true,
                                                            protect);
    if (!c.isValid()) {
        SkDebugf("Could not create Characterization in the backend %s",
                 GrBackendApiToStr(dContext->backend()));
        return {};
    }
    return c;
}

make_ddl()

static sk_sp< GrDeferredDisplayList > make_ddl ( Fuzz *  fuzz, GrDirectContext *  dContext, const GrSurfaceCharacterization &  c  )

static

Definition at line 165 of file FuzzCreateDDL.cpp.

                                                                                 {
    GrDeferredDisplayListRecorder r(c);
    SkCanvas* canvas = r.getCanvas();
    if (!canvas) {
        SkDebugf("Could not create canvas for backend %s", GrBackendApiToStr(dContext->backend()));
        return nullptr;
    }
    // For now we only draw a rect into the DDL. This will be scaled up to draw more varied content.
    SkRect tile;
    fuzz->next(&tile);
    canvas->drawRect(tile, gen_fuzzed_skpaint(fuzz));
    return r.detach();
}

make_surface()

static sk_sp< SkSurface > make_surface ( Fuzz *  fuzz, GrDirectContext *  dContext, const SkImageInfo &  ii, GrSurfaceOrigin  origin  )

static

Definition at line 180 of file FuzzCreateDDL.cpp.

                                                             {
    skgpu::Budgeted budgeted;
    fuzz->nextEnum(&budgeted, skgpu::Budgeted::kYes);
    SkSurfaceProps surfaceProps = gen_fuzzed_surface_props(fuzz);
    auto surface =
            SkSurfaces::RenderTarget(dContext, budgeted, ii, kSampleCount, origin, &surfaceProps);
    return surface;
}

Variable Documentation

kMaxHeight

constexpr int kMaxHeight = 64

staticconstexpr

Definition at line 37 of file FuzzCreateDDL.cpp.

kMaxWidth

constexpr int kMaxWidth = 64

staticconstexpr

The fuzzer aims to fuzz the use of GrDeferredDisplayList. It mainly consists of three parts.

1. In create_surface_characterization, (make_characterization) Create GrSurfaceCharacterization by using GrDirectContext of ContextType::kGL as it can be applied on all platform, and (make_surface) create a GPU backend surface of the same GrDirectContext
2. (make_ddl) Create GrDeferredDisplayListRecorder from the GrSurfaceCharacterization, and test the recoder's corresponding canvas.
3. (make_ddl, draw_ddl) Create GrDeferredDisplayList from the SkDeferredDisplayRecorder and draw the ddl on a GPU backend surface.

Definition at line 36 of file FuzzCreateDDL.cpp.

kSampleCount

constexpr int kSampleCount = 1

staticconstexpr

Definition at line 38 of file FuzzCreateDDL.cpp.