CompositingImages Class Reference

Inheritance diagram for CompositingImages:

Public Member Functions
	CompositingImages (SkISize imageSize, SkISize tileSize, SkISize tileGridSize, ClampingMode clampMode, TransformMode transformMode, int layerCnt)
bool	isSuitableFor (Backend backend) override
Public Member Functions inherited from Benchmark
	Benchmark ()
const char *	getName ()
const char *	getUniqueName ()
SkISize	getSize ()
virtual bool	isSuitableFor (Backend backend)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual bool	shouldLoop () const
void	delayedSetup ()
void	perCanvasPreDraw (SkCanvas *)
void	perCanvasPostDraw (SkCanvas *)
void	preDraw (SkCanvas *)
void	postDraw (SkCanvas *)
void	draw (int loops, SkCanvas *)
virtual void	getGpuStats (SkCanvas *, skia_private::TArray< SkString > *keys, skia_private::TArray< double > *values)
virtual bool	getDMSAAStats (GrRecordingContext *)
int	getUnits () const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
const char *	onGetName () override
void	onPerCanvasPreDraw (SkCanvas *canvas) override
void	onPerCanvasPostDraw (SkCanvas *) override
void	onDraw (int loops, SkCanvas *canvas) override
Protected Member Functions inherited from Benchmark
void	setUnits (int units)
virtual void	setupPaint (SkPaint *paint)
virtual const char *	onGetName ()=0
virtual const char *	onGetUniqueName ()
virtual void	onDelayedSetup ()
virtual void	onPerCanvasPreDraw (SkCanvas *)
virtual void	onPerCanvasPostDraw (SkCanvas *)
virtual void	onPreDraw (SkCanvas *)
virtual void	onPostDraw (SkCanvas *)
virtual void	onDraw (int loops, SkCanvas *)=0
virtual SkISize	onGetSize ()

Additional Inherited Members
Public Types inherited from Benchmark
enum class	Backend {   kNonRendering , kRaster , kGanesh , kGraphite ,   kPDF , kHWUI }

Detailed Description

Simulates drawing layers images in a grid a la a tile based compositor.

Definition at line 48 of file CompositingImagesBench.cpp.

Constructor & Destructor Documentation

CompositingImages()

CompositingImages::CompositingImages ( SkISize  imageSize, SkISize  tileSize, SkISize  tileGridSize, ClampingMode  clampMode, TransformMode  transformMode, int  layerCnt  )

inline

Definition at line 50 of file CompositingImagesBench.cpp.

            : fImageSize(imageSize)
            , fTileSize(tileSize)
            , fTileGridSize(tileGridSize)
            , fClampMode(clampMode)
            , fTransformMode(transformMode)
            , fLayerCnt(layerCnt) {
        fName.appendf("compositing_images_tile_size_%dx%d_grid_%dx%d_layers_%d",
                      fTileSize.fWidth, fTileSize.fHeight, fTileGridSize.fWidth,
                      fTileGridSize.fHeight, fLayerCnt);
        if (imageSize != tileSize) {
            fName.appendf("_image_%dx%d", imageSize.fWidth, imageSize.fHeight);
        }
        switch(clampMode) {
            case ClampingMode::kAlwaysFast:
                fName.append("_fast");
                break;
            case ClampingMode::kAlwaysStrict:
                fName.append("_strict");
                break;
            case ClampingMode::kChromeTiling_RowMajor:
                fName.append("_chrome");
                break;
            case ClampingMode::kChromeTiling_Optimal:
                fName.append("_chrome_optimal");
                break;
        }
        switch(transformMode) {
            case TransformMode::kNone:
                break;
            case TransformMode::kSubpixel:
                fName.append("_subpixel");
                break;
            case TransformMode::kRotated:
                fName.append("_rotated");
                break;
            case TransformMode::kPerspective:
                fName.append("_persp");
                break;
        }
    }

Member Function Documentation

isSuitableFor()

bool CompositingImages::isSuitableFor ( Backend  backend )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 93 of file CompositingImagesBench.cpp.

{ return Backend::kGanesh == backend; }

onDraw()

void CompositingImages::onDraw ( int  loops, SkCanvas *  canvas  )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 123 of file CompositingImagesBench.cpp.

                                                      {
        SkPaint paint;
        paint.setAntiAlias(true);
        SkSamplingOptions sampling(SkFilterMode::kLinear);
 
        canvas->save();
        canvas->concat(this->getTransform());
 
        for (int loop = 0; loop < loops; ++loop) {
            for (int l = 0; l < fLayerCnt; ++l) {
                AutoTArray<SkCanvas::ImageSetEntry> set(
                        fTileGridSize.fWidth * fTileGridSize.fHeight);
 
                if (fClampMode == ClampingMode::kAlwaysFast ||
                    fClampMode == ClampingMode::kAlwaysStrict) {
                    // Simple 2D for loop, submit everything as a single batch
                    int i = 0;
                    for (int y = 0; y < fTileGridSize.fHeight; ++y) {
                        for (int x = 0; x < fTileGridSize.fWidth; ++x) {
                            set[i++] = this->getEntry(x, y, l);
                        }
                    }
 
                    SkCanvas::SrcRectConstraint constraint =
                            fClampMode == ClampingMode::kAlwaysFast
                                    ? SkCanvas::kFast_SrcRectConstraint
                                    : SkCanvas::kStrict_SrcRectConstraint;
                    canvas->experimental_DrawEdgeAAImageSet(set.get(), i, nullptr, nullptr,
                                                            sampling, &paint, constraint);
                } else if (fClampMode == ClampingMode::kChromeTiling_RowMajor) {
                    // Same tile order, but break batching between fast and strict sections, and
                    // adjust bottom and right tiles to encode content area distinct from src rect.
                    int i = 0;
                    for (int y = 0; y < fTileGridSize.fHeight - 1; ++y) {
                        int rowStart = i;
                        for (int x = 0; x < fTileGridSize.fWidth - 1; ++x) {
                            set[i++] = this->getEntry(x, y, l);
                        }
                        // Flush "fast" horizontal row
                        canvas->experimental_DrawEdgeAAImageSet(set.get() + rowStart,
                                fTileGridSize.fWidth - 1, nullptr, nullptr, sampling, &paint,
                                SkCanvas::kFast_SrcRectConstraint);
                        // Then flush a single adjusted entry for the right edge
                        SkPoint dstQuad[4];
                        set[i++] = this->getAdjustedEntry(fTileGridSize.fWidth - 1, y, l, dstQuad);
                        canvas->experimental_DrawEdgeAAImageSet(
                                set.get() + fTileGridSize.fWidth - 1, 1, dstQuad, nullptr, sampling,
                                &paint, SkCanvas::kStrict_SrcRectConstraint);
                    }
                    // For last row, accumulate it as a single strict batch
                    int rowStart = i;
                    AutoTArray<SkPoint> dstQuads(4 * (fTileGridSize.fWidth - 1));
                    for (int x = 0; x < fTileGridSize.fWidth - 1; ++x) {
                        set[i++] = this->getAdjustedEntry(x, fTileGridSize.fHeight - 1, l,
                                                          dstQuads.get() + x * 4);
                    }
                    // The corner can use conventional strict mode without geometric adjustment
                    set[i++] = this->getEntry(
                            fTileGridSize.fWidth - 1, fTileGridSize.fHeight - 1, l);
                    canvas->experimental_DrawEdgeAAImageSet(set.get() + rowStart,
                            fTileGridSize.fWidth, dstQuads.get(), nullptr, sampling, &paint,
                            SkCanvas::kStrict_SrcRectConstraint);
                } else {
                    SkASSERT(fClampMode == ClampingMode::kChromeTiling_Optimal);
                    int i = 0;
                    // Interior fast tiles
                    for (int y = 0; y < fTileGridSize.fHeight - 1; ++y) {
                        for (int x = 0; x < fTileGridSize.fWidth - 1; ++x) {
                            set[i++] = this->getEntry(x, y, l);
                        }
                    }
                    canvas->experimental_DrawEdgeAAImageSet(set.get(), i, nullptr, nullptr,
                                                            sampling, &paint,
                                                            SkCanvas::kFast_SrcRectConstraint);
 
                    // Right edge
                    int strictStart = i;
                    AutoTArray<SkPoint> dstQuads(
                            4 * (fTileGridSize.fWidth + fTileGridSize.fHeight - 2));
                    for (int y = 0; y < fTileGridSize.fHeight - 1; ++y) {
                        set[i++] = this->getAdjustedEntry(fTileGridSize.fWidth - 1, y, l,
                                                          dstQuads.get() + y * 4);
                    }
                    canvas->experimental_DrawEdgeAAImageSet(set.get() + strictStart,
                            i - strictStart, dstQuads.get(), nullptr, sampling, &paint,
                            SkCanvas::kStrict_SrcRectConstraint);
                    int quadStart = 4 * (fTileGridSize.fHeight - 1);
                    strictStart = i;
                    for (int x = 0; x < fTileGridSize.fWidth - 1; ++x) {
                        set[i++] = this->getAdjustedEntry(x, fTileGridSize.fHeight - 1, l,
                                                          dstQuads.get() + quadStart + x * 4);
                    }
                    set[i++] = this->getEntry(
                            fTileGridSize.fWidth - 1, fTileGridSize.fHeight - 1, l);
                    canvas->experimental_DrawEdgeAAImageSet(set.get() + strictStart,
                            i - strictStart, dstQuads.get() + quadStart, nullptr, sampling, &paint,
                            SkCanvas::kStrict_SrcRectConstraint);
                }
            }
            // Prevent any batching between composited "frames".
            skgpu::Flush(canvas->getSurface());
        }
        canvas->restore();
    }

onGetName()

const char * CompositingImages::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 96 of file CompositingImagesBench.cpp.

{ return fName.c_str(); }

onPerCanvasPostDraw()

void CompositingImages::onPerCanvasPostDraw ( SkCanvas *  )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 121 of file CompositingImagesBench.cpp.

{ fImages.reset(); }

onPerCanvasPreDraw()

void CompositingImages::onPerCanvasPreDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 98 of file CompositingImagesBench.cpp.

                                                       {
        // Use image size, which may be larger than the tile size (emulating how Chrome specifies
        // their tiles).
        auto ii = SkImageInfo::Make(fImageSize.fWidth, fImageSize.fHeight, kRGBA_8888_SkColorType,
                                    kPremul_SkAlphaType, nullptr);
        SkRandom random;
        int numImages = fLayerCnt * fTileGridSize.fWidth * fTileGridSize.fHeight;
        fImages = std::make_unique<sk_sp<SkImage>[]>(numImages);
        for (int i = 0; i < numImages; ++i) {
            auto surf = canvas->makeSurface(ii);
            SkColor color = random.nextU();
            surf->getCanvas()->clear(color);
            SkPaint paint;
            paint.setColor(~color);
            paint.setBlendMode(SkBlendMode::kSrc);
            // While the image may be bigger than fTileSize, prepare its content as if fTileSize
            // is what will be visible.
            surf->getCanvas()->drawRect(
                    SkRect::MakeLTRB(3, 3, fTileSize.fWidth - 3, fTileSize.fHeight - 3), paint);
            fImages[i] = surf->makeImageSnapshot();
        }
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/bench/CompositingImagesBench.cpp