DM::ImageGenSrc Class Reference

#include <DMSrcSink.h>

Inheritance diagram for DM::ImageGenSrc:

Public Types
enum	Mode { kCodec_Mode , kPlatform_Mode }
Public Types inherited from DM::Src
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext

Public Member Functions
	ImageGenSrc (Path, Mode, SkAlphaType, bool)
Result	draw (SkCanvas *, GraphiteTestContext *) const override
SkISize	size () const override
Name	name () const override
bool	veto (SinkFlags) const override
bool	serial () const override
Public Member Functions inherited from DM::Src
virtual	~Src ()
virtual void	modifyGrContextOptions (GrContextOptions *) const
virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const
virtual int	pageCount () const
virtual Result	draw (int page, SkCanvas *canvas, GraphiteTestContext *graphiteTestContext) const
virtual SkISize	size (int page) const

Detailed Description

Definition at line 232 of file DMSrcSink.h.

Member Enumeration Documentation

Mode

enum DM::ImageGenSrc::Mode

Enumerator
kCodec_Mode
kPlatform_Mode

Definition at line 234 of file DMSrcSink.h.

              {
        kCodec_Mode,    // Use CodecImageGenerator
        kPlatform_Mode, // Uses CG or WIC
    };

Constructor & Destructor Documentation

ImageGenSrc()

DM::ImageGenSrc::ImageGenSrc	(	Path	path,
		Mode	mode,
		SkAlphaType	alphaType,
		bool	isGpu
	)

Definition at line 954 of file DMSrcSink.cpp.

    : fPath(path)
    , fMode(mode)
    , fDstAlphaType(alphaType)
    , fIsGpu(isGpu)
    , fRunSerially(serial_from_path_name(path))
{}

Member Function Documentation

draw()

Result DM::ImageGenSrc::draw ( SkCanvas *  canvas, GraphiteTestContext *    ) const

overridevirtual

Implements DM::Src.

Definition at line 972 of file DMSrcSink.cpp.

                                                                     {
    if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
        return Result::Skip("Uninteresting to test image generator to 565.");
    }
 
    sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
    if (!encoded) {
        return Result::Fatal("Couldn't read %s.", fPath.c_str());
    }
 
#if defined(SK_BUILD_FOR_WIN)
    // Initialize COM in order to test with WIC.
    SkAutoCoInitialize com;
    if (!com.succeeded()) {
        return Result::Fatal("Could not initialize COM.");
    }
#endif
 
    std::unique_ptr<SkImageGenerator> gen(nullptr);
    switch (fMode) {
        case kCodec_Mode:
            gen = SkCodecImageGenerator::MakeFromEncodedCodec(encoded);
            if (!gen) {
                return Result::Fatal("Could not create codec image generator.");
            }
            break;
        case kPlatform_Mode: {
#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
            gen = SkImageGeneratorCG::MakeFromEncodedCG(encoded);
#elif defined(SK_BUILD_FOR_WIN)
            gen = SkImageGeneratorWIC::MakeFromEncodedWIC(encoded);
#elif defined(SK_ENABLE_NDK_IMAGES)
            gen = SkImageGeneratorNDK::MakeFromEncodedNDK(encoded);
#endif
            if (!gen) {
                return Result::Fatal("Could not create platform image generator.");
            }
            break;
        }
        default:
            SkASSERT(false);
            return Result::Fatal("Invalid image generator mode");
    }
 
    // Test deferred decoding path on GPU
    if (fIsGpu) {
        sk_sp<SkImage> image(SkImages::DeferredFromGenerator(std::move(gen)));
        if (!image) {
            return Result::Fatal("Could not create image from codec image generator.");
        }
        canvas->drawImage(image, 0, 0);
        return Result::Ok();
    }
 
    // Test various color and alpha types on CPU
    SkImageInfo decodeInfo = gen->getInfo().makeAlphaType(fDstAlphaType);
 
    int bpp = decodeInfo.bytesPerPixel();
    size_t rowBytes = decodeInfo.width() * bpp;
    SkAutoMalloc pixels(decodeInfo.height() * rowBytes);
    if (!gen->getPixels(decodeInfo, pixels.get(), rowBytes)) {
        Result::Status status = Result::Status::Fatal;
#if defined(SK_BUILD_FOR_WIN)
        if (kPlatform_Mode == fMode) {
            // Do not issue a fatal error for WIC flakiness.
            status = Result::Status::Skip;
        }
#endif
        return Result(
                status,
                SkStringPrintf("Image generator could not getPixels() for %s\n", fPath.c_str()));
    }
 
    set_bitmap_color_space(&decodeInfo);
    draw_to_canvas(canvas, decodeInfo, pixels.get(), rowBytes,
                   CodecSrc::kGetFromCanvas_DstColorType);
    return Result::Ok();
}

name()

Name DM::ImageGenSrc::name ( ) const

overridevirtual

Implements DM::Src.

Definition at line 1060 of file DMSrcSink.cpp.

                             {
    return SkOSPath::Basename(fPath.c_str());
}

serial()

bool DM::ImageGenSrc::serial ( ) const

inlineoverridevirtual

Reimplemented from DM::Src.

Definition at line 244 of file DMSrcSink.h.

{ return fRunSerially; }

size()

SkISize DM::ImageGenSrc::size ( ) const

overridevirtual

Implements DM::Src.

Definition at line 1051 of file DMSrcSink.cpp.

                                {
    sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
    std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(encoded));
    if (nullptr == codec) {
        return {0, 0};
    }
    return codec->getInfo().dimensions();
}

veto()

bool DM::ImageGenSrc::veto ( SinkFlags  flags ) const

overridevirtual

Reimplemented from DM::Src.

Definition at line 962 of file DMSrcSink.cpp.

                                            {
    if (fIsGpu) {
        // MSAA runs tend to run out of memory and tests the same code paths as regular gpu configs.
        return flags.type != SinkFlags::kGPU || flags.approach != SinkFlags::kDirect ||
               flags.multisampled == SinkFlags::kMultisampled;
    }
 
    return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
}

---

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

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