DM Namespace Reference

Classes
class	AndroidCodecSrc
class	BisectSrc
class	CodecSrc
class	ColorCodecSrc
class	DebugSink
class	GMSrc
class	GPUDDLSink
class	GPUPersistentCacheTestingSink
class	GPUPrecompileTestingSink
class	GPURemoteSlugSink
class	GPUSerializeSlugSink
class	GPUSink
class	GPUSlugSink
class	ImageGenSrc
struct	ImplicitString
class	JsonWriter
class	MSKPSrc
class	NullSink
class	PDFSink
class	RasterSink
class	Result
struct	Sink
struct	SinkFlags
class	SKPSink
class	SKPSrc
struct	Src
class	SVGSink
class	Via
class	ViaMatrix
class	ViaPicture
class	ViaRuntimeBlend
class	ViaSerialization
class	ViaSVG
class	ViaUpright
class	XPSSink

Typedefs
using	DrawToCanvasFn = std::function< DM::Result(SkCanvas *, Src::GraphiteTestContext *)>
typedef ImplicitString	Name
typedef ImplicitString	Path

Functions
static SkMutex &	bitmap_result_mutex ()
static SkString	get_scaled_name (const Path &path, float scale)
static bool	serial_from_path_name (const SkString &path)
static void	swap_rb_if_necessary (SkBitmap &bitmap, CodecSrc::DstColorType dstColorType)
static bool	get_decode_info (SkImageInfo *decodeInfo, SkColorType canvasColorType, CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType)
static void	draw_to_canvas (SkCanvas *canvas, const SkImageInfo &info, void *pixels, size_t rowBytes, CodecSrc::DstColorType dstColorType, SkScalar left=0, SkScalar top=0)
static void	set_bitmap_color_space (SkImageInfo *info)
static	DEFINE_int (skpViewportSize, 1000, "Width & height of the viewport used to crop skp rendering.")
static SkRect	get_cull_rect_for_skp (const char *path)
static Result	compare_bitmaps (const SkBitmap &reference, const SkBitmap &bitmap)
static	DEFINE_bool (gpuStats, false, "Append GPU stats to the log for each GPU task?")
static	DEFINE_bool (preAbandonGpuContext, false, "Test abandoning the GrContext before running the test.")
static	DEFINE_bool (abandonGpuContext, false, "Test abandoning the GrContext after running each test.")
static	DEFINE_bool (releaseAndAbandonGpuContext, false, "Test releasing all gpu resources and abandoning the GrContext " "after running each test")
static	DEFINE_bool (drawOpClip, false, "Clip each GrDrawOp to its device bounds for testing.")
static	DEFINE_bool (programBinaryCache, true, "Use in-memory program binary cache")
static Result	draw_skdocument (const Src &src, SkDocument *doc, SkWStream *dst)
static SkSerialProcs	serial_procs_using_png ()
static Result	draw_to_canvas (Sink *sink, SkBitmap *bitmap, SkWStream *stream, SkString *log, SkISize size, const DrawToCanvasFn &draw)
static	DEFINE_bool (check, true, "If true, have most Via- modes fail if they affect the output.")
static Result	check_against_reference (const SkBitmap *bitmap, const Src &src, Sink *sink)
static SkISize	auto_compute_translate (SkMatrix *matrix, int srcW, int srcH)

Variables
TArray< JsonWriter::BitmapResult >	gBitmapResults

Typedef Documentation

DrawToCanvasFn

using DM::DrawToCanvasFn = typedef std::function<DM::Result(SkCanvas*, Src::GraphiteTestContext*)>

Definition at line 2424 of file DMSrcSink.cpp.

Name

typedef ImplicitString DM::Name

Definition at line 38 of file DMSrcSink.h.

Path

typedef ImplicitString DM::Path

Definition at line 39 of file DMSrcSink.h.

Function Documentation

auto_compute_translate()

static SkISize DM::auto_compute_translate ( SkMatrix *  matrix, int  srcW, int  srcH  )

static

Definition at line 2468 of file DMSrcSink.cpp.

                                                                            {
    SkRect bounds = SkRect::MakeIWH(srcW, srcH);
    matrix->mapRect(&bounds);
    matrix->postTranslate(-bounds.x(), -bounds.y());
    return {SkScalarRoundToInt(bounds.width()), SkScalarRoundToInt(bounds.height())};
}

bitmap_result_mutex()

static SkMutex & DM::bitmap_result_mutex ( )

static

Definition at line 25 of file DMJsonWriter.cpp.

                                      {
    static SkMutex& mutex = *(new SkMutex);
    return mutex;
}

check_against_reference()

static Result DM::check_against_reference ( const SkBitmap *  bitmap, const Src &  src, Sink *  sink  )

static

Definition at line 2448 of file DMSrcSink.cpp.

                                                                                          {
    // We can only check raster outputs.
    // (Non-raster outputs like .pdf, .skp, .svg may differ but still draw identically.)
    if (FLAGS_check && bitmap) {
        SkBitmap reference;
        SkString log;
        SkDynamicMemoryWStream wStream;
        Result result = sink->draw(src, &reference, &wStream, &log);
        // If we can draw into this Sink via some pipeline, we should be able to draw directly.
        SkASSERT(result.isOk());
        if (!result.isOk()) {
            return result;
        }
        return compare_bitmaps(reference, *bitmap);
    }
    return Result::Ok();
}

compare_bitmaps()

static Result DM::compare_bitmaps ( const SkBitmap &  reference, const SkBitmap &  bitmap  )

static

Definition at line 1481 of file DMSrcSink.cpp.

                                                                                 {
    // The dimensions are a property of the Src only, and so should be identical.
    SkASSERT(reference.computeByteSize() == bitmap.computeByteSize());
    if (reference.computeByteSize() != bitmap.computeByteSize()) {
        return Result::Fatal("Dimensions don't match reference");
    }
    // All SkBitmaps in DM are tight, so this comparison is easy.
    if (0 != memcmp(reference.getPixels(), bitmap.getPixels(), reference.computeByteSize())) {
        SkString encoded;
        SkString errString("Pixels don't match reference");
        if (ToolUtils::BitmapToBase64DataURI(reference, &encoded)) {
            errString.append("\nExpected: ");
            errString.append(encoded);
        } else {
            errString.append("\nExpected image failed to encode: ");
            errString.append(encoded);
        }
        if (ToolUtils::BitmapToBase64DataURI(bitmap, &encoded)) {
            errString.append("\nActual: ");
            errString.append(encoded);
        } else {
            errString.append("\nActual image failed to encode: ");
            errString.append(encoded);
        }
        return Result(Result::Status::Fatal, errString);
    }
    return Result::Ok();
}

DEFINE_bool() [1/7]

static DM::DEFINE_bool ( abandonGpuContext  , false  , "Test abandoning the GrContext after running each test."    )

static

DEFINE_bool() [2/7]

static DM::DEFINE_bool ( check  , true  , "If  true, have most Via- modes fail if they affect the output."    )

static

DEFINE_bool() [3/7]

static DM::DEFINE_bool ( drawOpClip  , false  , "Clip each GrDrawOp to its device bounds for testing."    )

static

DEFINE_bool() [4/7]

static DM::DEFINE_bool ( gpuStats  , false  , "Append GPU stats to the log for each GPU task?"    )

static

DEFINE_bool() [5/7]

static DM::DEFINE_bool ( preAbandonGpuContext  , false  , "Test abandoning the GrContext before running the test."    )

static

DEFINE_bool() [6/7]

static DM::DEFINE_bool ( programBinaryCache  , true  , "Use in-memory program binary cache"    )

static

DEFINE_bool() [7/7]

static DM::DEFINE_bool ( releaseAndAbandonGpuContext  , false  , "Test releasing all gpu resources and abandoning the GrContext " "after running each test"    )

static

DEFINE_int()

static DM::DEFINE_int ( skpViewportSize  , 1000  , "Width & height of the viewport used to crop skp rendering."    )

static

draw_skdocument()

static Result DM::draw_skdocument ( const Src &  src, SkDocument *  doc, SkWStream *  dst  )

static

Definition at line 1972 of file DMSrcSink.cpp.

                                                                               {
    if (src.size().isEmpty()) {
        return Result::Fatal("Source has empty dimensions");
    }
    SkASSERT(doc);
    int pageCount = src.pageCount();
    for (int i = 0; i < pageCount; ++i) {
        int width = src.size(i).width(), height = src.size(i).height();
        SkCanvas* canvas =
                doc->beginPage(SkIntToScalar(width), SkIntToScalar(height));
        if (!canvas) {
            return Result::Fatal("SkDocument::beginPage(w,h) returned nullptr");
        }
        Result result = src.draw(i, canvas, /*GraphiteTestContext=*/nullptr);
        if (!result.isOk()) {
            return result;
        }
        doc->endPage();
    }
    doc->close();
    dst->flush();
    return Result::Ok();
}

draw_to_canvas() [1/2]

static Result DM::draw_to_canvas ( Sink *  sink, SkBitmap *  bitmap, SkWStream *  stream, SkString *  log, SkISize  size, const DrawToCanvasFn &  draw  )

static

Definition at line 2426 of file DMSrcSink.cpp.

                                                                                      {
    class ProxySrc : public Src {
    public:
        ProxySrc(SkISize size, const DrawToCanvasFn& draw) : fSize(size), fDraw(draw) {}
        Result draw(SkCanvas* canvas, GraphiteTestContext* testContext) const override {
            return fDraw(canvas, testContext);
        }
        Name    name() const override { return "ProxySrc"; }
        SkISize size() const override { return fSize; }
    private:
        SkISize               fSize;
        const DrawToCanvasFn& fDraw;
    };
    return sink->draw(ProxySrc(size, draw), bitmap, stream, log);
}

draw_to_canvas() [2/2]

static void DM::draw_to_canvas ( SkCanvas *  canvas, const SkImageInfo &  info, void *  pixels, size_t  rowBytes, CodecSrc::DstColorType  dstColorType, SkScalar  left = 0, SkScalar  top = 0  )

static

Definition at line 456 of file DMSrcSink.cpp.

                                                                {
    SkBitmap bitmap;
    bitmap.installPixels(info, pixels, rowBytes);
    swap_rb_if_necessary(bitmap, dstColorType);
    canvas->drawImage(bitmap.asImage(), left, top);
}

get_cull_rect_for_skp()

static SkRect DM::get_cull_rect_for_skp ( const char *  path )

static

Definition at line 1189 of file DMSrcSink.cpp.

                                                      {
    std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(path);
    if (!stream) {
        return SkRect::MakeEmpty();
    }
    SkPictInfo info;
    if (!SkPicture_StreamIsSKP(stream.get(), &info)) {
        return SkRect::MakeEmpty();
    }
 
    return info.fCullRect;
}

get_decode_info()

static bool DM::get_decode_info ( SkImageInfo *  decodeInfo, SkColorType  canvasColorType, CodecSrc::DstColorType  dstColorType, SkAlphaType  dstAlphaType  )

static

Definition at line 422 of file DMSrcSink.cpp.

                                                                                         {
    switch (dstColorType) {
        case CodecSrc::kGrayscale_Always_DstColorType:
            if (kRGB_565_SkColorType == canvasColorType) {
                return false;
            }
            *decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
            break;
        case CodecSrc::kNonNative8888_Always_DstColorType:
            if (kRGB_565_SkColorType == canvasColorType
                    || kRGBA_F16_SkColorType == canvasColorType) {
                return false;
            }
#ifdef SK_PMCOLOR_IS_RGBA
            *decodeInfo = decodeInfo->makeColorType(kBGRA_8888_SkColorType);
#else
            *decodeInfo = decodeInfo->makeColorType(kRGBA_8888_SkColorType);
#endif
            break;
        default:
            if (kRGB_565_SkColorType == canvasColorType &&
                    kOpaque_SkAlphaType != decodeInfo->alphaType()) {
                return false;
            }
 
            *decodeInfo = decodeInfo->makeColorType(canvasColorType);
            break;
    }
 
    *decodeInfo = decodeInfo->makeAlphaType(dstAlphaType);
    return true;
}

get_scaled_name()

static SkString DM::get_scaled_name ( const Path &  path, float  scale  )

static

Definition at line 199 of file DMSrcSink.cpp.

                                                               {
    return SkStringPrintf("%s_%.3f", SkOSPath::Basename(path.c_str()).c_str(), scale);
}

serial_from_path_name()

static bool DM::serial_from_path_name ( const SkString &  path )

static

Definition at line 376 of file DMSrcSink.cpp.

                                                        {
    if (!FLAGS_RAW_threading) {
        static const char* const exts[] = {
            "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
            "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
        };
        const char* actualExt = strrchr(path.c_str(), '.');
        if (actualExt) {
            actualExt++;
            for (auto* ext : exts) {
                if (0 == strcmp(ext, actualExt)) {
                    return true;
                }
            }
        }
    }
    return false;
}

serial_procs_using_png()

static SkSerialProcs DM::serial_procs_using_png ( )

static

Definition at line 2049 of file DMSrcSink.cpp.

                                              {
    static SkSerialProcs procs;
    procs.fImageProc = [](SkImage* img, void*) -> sk_sp<SkData> {
        return SkPngEncoder::Encode(as_IB(img)->directContext(), img, SkPngEncoder::Options{});
    };
    return procs;
}

set_bitmap_color_space()

static void DM::set_bitmap_color_space ( SkImageInfo *  info )

static

Definition at line 470 of file DMSrcSink.cpp.

                                                      {
    *info = info->makeColorSpace(SkColorSpace::MakeSRGB());
}

swap_rb_if_necessary()

static void DM::swap_rb_if_necessary ( SkBitmap &  bitmap, CodecSrc::DstColorType  dstColorType  )

static

Definition at line 411 of file DMSrcSink.cpp.

                                                                                      {
    if (CodecSrc::kNonNative8888_Always_DstColorType != dstColorType) {
        return;
    }
 
    for (int y = 0; y < bitmap.height(); y++) {
        uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
        SkOpts::RGBA_to_BGRA(row, row, bitmap.width());
    }
}

Variable Documentation

gBitmapResults

TArray<JsonWriter::BitmapResult> DM::gBitmapResults

Definition at line 24 of file DMJsonWriter.cpp.