DM::GPUSink Class Reference

#include <DMSrcSink.h>

Inheritance diagram for DM::GPUSink:

Public Member Functions
	GPUSink (const SkCommandLineConfigGpu *, const GrContextOptions &)
Result	draw (const Src &, SkBitmap *, SkWStream *, SkString *) const override
Result	onDraw (const Src &, SkBitmap *, SkWStream *, SkString *, const GrContextOptions &baseOptions, std::function< void(GrDirectContext *)> initContext=nullptr, std::function< SkCanvas *(SkCanvas *)> wrapCanvas=nullptr) const
skgpu::ContextType	contextType () const
const sk_gpu_test::GrContextFactory::ContextOverrides &	contextOverrides () const
SkCommandLineConfigGpu::SurfType	surfType () const
bool	serial () const override
const char *	fileExtension () const override
SinkFlags	flags () const override
const GrContextOptions &	baseContextOptions () const
void	setColorSpace (sk_sp< SkColorSpace > colorSpace) override
SkColorInfo	colorInfo () const override
Public Member Functions inherited from DM::Sink
virtual	~Sink ()

Protected Member Functions
sk_sp< SkSurface >	createDstSurface (GrDirectContext *, SkISize size) const
bool	readBack (SkSurface *, SkBitmap *dst) const

Detailed Description

Definition at line 367 of file DMSrcSink.h.

Constructor & Destructor Documentation

GPUSink()

DM::GPUSink::GPUSink	(	const SkCommandLineConfigGpu *	config,
		const GrContextOptions &	grCtxOptions
	)

Definition at line 1523 of file DMSrcSink.cpp.

        : fContextType(config->getContextType())
        , fContextOverrides(config->getContextOverrides())
        , fSurfType(config->getSurfType())
        , fSampleCount(config->getSamples())
        , fSurfaceFlags(config->getSurfaceFlags())
        , fColorType(config->getColorType())
        , fAlphaType(config->getAlphaType())
        , fBaseContextOptions(grCtxOptions) {
    if (FLAGS_programBinaryCache) {
        fBaseContextOptions.fPersistentCache = &fMemoryCache;
    }
}

Member Function Documentation

baseContextOptions()

const GrContextOptions & DM::GPUSink::baseContextOptions ( ) const

inline

Definition at line 389 of file DMSrcSink.h.

{ return fBaseContextOptions; }

colorInfo()

SkColorInfo DM::GPUSink::colorInfo ( ) const

inlineoverridevirtual

Returns the color type and space used by the sink.

Reimplemented from DM::Sink.

Definition at line 391 of file DMSrcSink.h.

                                           {
        return SkColorInfo(fColorType, fAlphaType, fColorSpace);
    }

contextOverrides()

const sk_gpu_test::GrContextFactory::ContextOverrides & DM::GPUSink::contextOverrides ( ) const

inline

Definition at line 378 of file DMSrcSink.h.

                                                                                {
        return fContextOverrides;
    }

contextType()

skgpu::ContextType DM::GPUSink::contextType ( ) const

inline

Definition at line 377 of file DMSrcSink.h.

{ return fContextType; }

createDstSurface()

sk_sp< SkSurface > DM::GPUSink::createDstSurface ( GrDirectContext *  context, SkISize  size  ) const

protected

Definition at line 1542 of file DMSrcSink.cpp.

                                                                                       {
    sk_sp<SkSurface> surface;
 
    SkImageInfo info = SkImageInfo::Make(size, this->colorInfo());
    SkSurfaceProps props(fSurfaceFlags, kRGB_H_SkPixelGeometry);
 
    switch (fSurfType) {
        case SkCommandLineConfigGpu::SurfType::kDefault:
            surface = SkSurfaces::RenderTarget(
                    context, skgpu::Budgeted::kNo, info, fSampleCount, &props);
            break;
        case SkCommandLineConfigGpu::SurfType::kBackendTexture:
            surface = sk_gpu_test::MakeBackendTextureSurface(context,
                                                             info,
                                                             kTopLeft_GrSurfaceOrigin,
                                                             fSampleCount,
                                                             skgpu::Mipmapped::kNo,
                                                             GrProtected::kNo,
                                                             &props);
            break;
        case SkCommandLineConfigGpu::SurfType::kBackendRenderTarget:
            surface = sk_gpu_test::MakeBackendRenderTargetSurface(context,
                                                                  info,
                                                                  kBottomLeft_GrSurfaceOrigin,
                                                                  fSampleCount,
                                                                  GrProtected::kNo,
                                                                  &props);
            break;
    }
 
    return surface;
}

draw()

Result DM::GPUSink::draw ( const Src &  src, SkBitmap *  dst, SkWStream *  dstStream, SkString *  log  ) const

overridevirtual

Implements DM::Sink.

Reimplemented in DM::GPUSlugSink.

Definition at line 1538 of file DMSrcSink.cpp.

                                                                                             {
    return this->onDraw(src, dst, dstStream, log, fBaseContextOptions);
}

fileExtension()

const char * DM::GPUSink::fileExtension ( ) const

inlineoverridevirtual

Implements DM::Sink.

Definition at line 383 of file DMSrcSink.h.

{ return "png"; }

flags()

SinkFlags DM::GPUSink::flags ( ) const

inlineoverridevirtual

Implements DM::Sink.

Definition at line 384 of file DMSrcSink.h.

                                     {
        SinkFlags::Multisampled ms = fSampleCount > 1 ? SinkFlags::kMultisampled
                                                      : SinkFlags::kNotMultisampled;
        return SinkFlags{ SinkFlags::kGPU, SinkFlags::kDirect, ms };
    }

onDraw()

Result DM::GPUSink::onDraw	(	const Src &	src,
		SkBitmap *	dst,
		SkWStream *	,
		SkString *	log,
		const GrContextOptions &	baseOptions,
		std::function< void(GrDirectContext *)>	initContext = nullptr,
		std::function< SkCanvas *(SkCanvas *)>	wrapCanvas = nullptr
	)		const

Definition at line 1584 of file DMSrcSink.cpp.

                                                                           {
    GrContextOptions grOptions = baseOptions;
 
    // We don't expect the src to mess with the persistent cache or the executor.
    SkDEBUGCODE(auto cache = grOptions.fPersistentCache);
    SkDEBUGCODE(auto exec = grOptions.fExecutor);
    src.modifyGrContextOptions(&grOptions);
    SkASSERT(cache == grOptions.fPersistentCache);
    SkASSERT(exec == grOptions.fExecutor);
 
    GrContextFactory factory(grOptions);
    auto direct = factory.getContextInfo(fContextType, fContextOverrides).directContext();
    if (initContext) {
        initContext(direct);
    }
 
    const int maxDimension = direct->priv().caps()->maxTextureSize();
    if (maxDimension < std::max(src.size().width(), src.size().height())) {
        return Result::Skip("Src too large to create a texture.\n");
    }
 
    sk_sp<SkSurface> surface = this->createDstSurface(direct, src.size());
    if (!surface) {
        return Result::Fatal("Could not create a surface.");
    }
    if (FLAGS_preAbandonGpuContext) {
        factory.abandonContexts();
    }
 
    auto canvas = surface->getCanvas();
    if (wrapCanvas != nullptr) {
        canvas = wrapCanvas(canvas);
    }
 
    Result result = src.draw(canvas, /*GraphiteTestContext=*/nullptr);
    if (!result.isOk()) {
        return result;
    }
    direct->flushAndSubmit(surface.get(), GrSyncCpu::kNo);
    if (FLAGS_gpuStats) {
        direct->priv().dumpCacheStats(log);
        direct->priv().dumpGpuStats(log);
        direct->priv().dumpContextStats(log);
    }
 
    this->readBack(surface.get(), dst);
 
    if (FLAGS_abandonGpuContext) {
        factory.abandonContexts();
    } else if (FLAGS_releaseAndAbandonGpuContext) {
        factory.releaseResourcesAndAbandonContexts();
    }
 
    if (grOptions.fPersistentCache) {
        direct->storeVkPipelineCacheData();
    }
    return Result::Ok();
}

readBack()

bool DM::GPUSink::readBack ( SkSurface *  surface, SkBitmap *  dst  ) const

protected

Definition at line 1575 of file DMSrcSink.cpp.

                                                              {
    SkCanvas* canvas = surface->getCanvas();
    SkISize size = surface->imageInfo().dimensions();
 
    SkImageInfo info = SkImageInfo::Make(size, this->colorInfo());
    dst->allocPixels(info);
    return canvas->readPixels(*dst, 0, 0);
}

serial()

bool DM::GPUSink::serial ( ) const

inlineoverridevirtual

Reimplemented from DM::Sink.

Definition at line 382 of file DMSrcSink.h.

{ return true; }

setColorSpace()

void DM::GPUSink::setColorSpace ( sk_sp< SkColorSpace >  colorSpace )

inlineoverridevirtual

Reimplemented from DM::Sink.

Definition at line 390 of file DMSrcSink.h.

{ fColorSpace = colorSpace; }

surfType()

SkCommandLineConfigGpu::SurfType DM::GPUSink::surfType ( ) const

inline

Definition at line 381 of file DMSrcSink.h.

{ return fSurfType; }

---

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

• third_party/skia/dm/DMSrcSink.h
• third_party/skia/dm/DMSrcSink.cpp