skif::FilterResult Class Reference

#include <SkImageFilterTypes.h>

Classes
class	AutoSurface
class	Builder

Public Types
enum class	ShaderFlags : int { kNone = 0 , kSampledRepeatedly = 1 << 0 , kNonTrivialSampling = 1 << 1 }

Public Member Functions
	FilterResult ()
	FilterResult (sk_sp< SkSpecialImage > image)
	FilterResult (sk_sp< SkSpecialImage > image, const LayerSpace< SkIPoint > &origin)
	operator bool () const
const SkSpecialImage *	image () const
sk_sp< SkSpecialImage >	refImage () const
LayerSpace< SkIRect >	layerBounds () const
SkTileMode	tileMode () const
SkSamplingOptions	sampling () const
const SkColorFilter *	colorFilter () const
FilterResult	applyCrop (const Context &ctx, const LayerSpace< SkIRect > &crop, SkTileMode tileMode=SkTileMode::kDecal) const
FilterResult	applyTransform (const Context &ctx, const LayerSpace< SkMatrix > &transform, const SkSamplingOptions &sampling) const
FilterResult	applyColorFilter (const Context &ctx, sk_sp< SkColorFilter > colorFilter) const
sk_sp< SkSpecialImage >	imageAndOffset (const Context &ctx, SkIPoint *offset) const
std::pair< sk_sp< SkSpecialImage >, LayerSpace< SkIPoint > >	imageAndOffset (const Context &ctx) const
void	draw (const Context &ctx, SkDevice *target, const SkBlender *blender) const
FilterResult	insetForSaveLayer () const

Static Public Member Functions
static FilterResult	MakeFromPicture (const Context &ctx, sk_sp< SkPicture > pic, ParameterSpace< SkRect > cullRect)
static FilterResult	MakeFromShader (const Context &ctx, sk_sp< SkShader > shader, bool dither)
static FilterResult	MakeFromImage (const Context &ctx, sk_sp< SkImage > image, SkRect srcRect, ParameterSpace< SkRect > dstRect, const SkSamplingOptions &sampling)

Static Public Attributes
static constexpr SkSamplingOptions	kDefaultSampling {SkFilterMode::kLinear}

Friends
class	::FilterResultTestAccess

Detailed Description

Definition at line 695 of file SkImageFilterTypes.h.

Member Enumeration Documentation

ShaderFlags

enum class skif::FilterResult::ShaderFlags : int

strong

Enumerator
kNone
kSampledRepeatedly
kNonTrivialSampling

Definition at line 799 of file SkImageFilterTypes.h.

                           : int {
        kNone = 0,
        // A hint that the input FilterResult will be sampled repeatedly per pixel. If there's
        // colorspace conversions or deferred color filtering, it's worth resolving to a temporary
        // image so that those calculations are performed once per pixel instead of N times.
        kSampledRepeatedly = 1 << 0,
        // Specifies that the shader performs non-trivial operations on its coordinates to determine
        // how to sample any input FilterResults, so their sampling options should not be converted
        // to nearest-neighbor even if they appeared pixel-aligned with the output surface.
        kNonTrivialSampling = 1 << 1,
        // TODO: Add option to convey that the output can carry input tiling forward to make a
        // smaller backing surface somehow. May not be a flag and just args passed to eval().
    };

Constructor & Destructor Documentation

FilterResult() [1/3]

skif::FilterResult::FilterResult ( )

inline

Definition at line 697 of file SkImageFilterTypes.h.

: FilterResult(nullptr) {}

FilterResult() [2/3]

skif::FilterResult::FilterResult ( sk_sp< SkSpecialImage >  image )

inlineexplicit

Definition at line 699 of file SkImageFilterTypes.h.

            : FilterResult(std::move(image), LayerSpace<SkIPoint>({0, 0})) {}

FilterResult() [3/3]

skif::FilterResult::FilterResult ( sk_sp< SkSpecialImage >  image, const LayerSpace< SkIPoint > &  origin  )

inline

Definition at line 702 of file SkImageFilterTypes.h.

            : FilterResult(std::move(image), origin, PixelBoundary::kUnknown) {}

Member Function Documentation

applyColorFilter()

FilterResult skif::FilterResult::applyColorFilter	(	const Context &	ctx,
		sk_sp< SkColorFilter >	colorFilter
	)		const

Definition at line 917 of file SkImageFilterTypes.cpp.

                                                                                    {
    // A null filter is the identity, so it should have been caught during image filter DAG creation
    SkASSERT(colorFilter);
 
    if (ctx.desiredOutput().isEmpty()) {
        return {};
    }
 
    // Color filters are applied after the transform and image sampling, but before the fLayerBounds
    // crop. We can compose 'colorFilter' with any previously applied color filter regardless
    // of the transform/sample state, so long as it respects the effect of the current crop.
    LayerSpace<SkIRect> newLayerBounds = fLayerBounds;
    if (as_CFB(colorFilter)->affectsTransparentBlack()) {
        if (!fImage || !newLayerBounds.intersect(ctx.desiredOutput())) {
            // The current image's intersection with the desired output is fully transparent, but
            // the new color filter converts that into a non-transparent color. The desired output
            // is filled with this color, but use a 1x1 surface and clamp tiling.
            AutoSurface surface{ctx,
                                LayerSpace<SkIRect>{SkIRect::MakeXYWH(ctx.desiredOutput().left(),
                                                                      ctx.desiredOutput().top(),
                                                                      1, 1)},
                                PixelBoundary::kInitialized,
                                /*renderInParameterSpace=*/false};
            if (surface) {
                SkPaint paint;
                paint.setColor4f(SkColors::kTransparent, /*colorSpace=*/nullptr);
                paint.setColorFilter(std::move(colorFilter));
                surface->drawPaint(paint);
            }
            FilterResult solidColor = surface.snap();
            solidColor.updateTileMode(ctx, SkTileMode::kClamp);
            return solidColor;
        }
 
        if (this->analyzeBounds(ctx.desiredOutput()) & BoundsAnalysis::kRequiresLayerCrop) {
            // Since 'colorFilter' modifies transparent black, the new result's layer bounds must
            // be the desired output. But if the current image is cropped we need to resolve the
            // image to avoid losing the effect of the current 'fLayerBounds'.
            newLayerBounds.outset(LayerSpace<SkISize>({1, 1}));
            SkAssertResult(newLayerBounds.intersect(ctx.desiredOutput()));
            FilterResult filtered = this->resolve(ctx, newLayerBounds,
                                                  /*preserveDstBounds=*/true);
            filtered.fColorFilter = std::move(colorFilter);
            filtered.updateTileMode(ctx, SkTileMode::kClamp);
            return filtered;
        }
 
        // otherwise we can fill out to the desired output without worrying about losing the crop.
        newLayerBounds = ctx.desiredOutput();
    } else {
        if (!fImage || !LayerSpace<SkIRect>::Intersects(newLayerBounds, ctx.desiredOutput())) {
            // The color filter does not modify transparent black, so it remains transparent
            return {};
        }
        // otherwise a non-transparent affecting color filter can always be lifted before any crop
        // because it does not change the "shape" of the prior FilterResult.
    }
 
    // If we got here we can compose the new color filter with the previous filter and the prior
    // layer bounds are either soft-cropped to the desired output, or we fill out the desired output
    // when the new color filter affects transparent black. We don't check if the entire composed
    // filter affects transparent black because earlier floods are restricted by the layer bounds.
    FilterResult filtered = *this;
    filtered.fLayerBounds = newLayerBounds;
    filtered.fColorFilter = SkColorFilters::Compose(std::move(colorFilter), fColorFilter);
    return filtered;
}

applyCrop()

FilterResult skif::FilterResult::applyCrop	(	const Context &	ctx,
		const LayerSpace< SkIRect > &	crop,
		SkTileMode	tileMode = SkTileMode::kDecal
	)		const

Definition at line 820 of file SkImageFilterTypes.cpp.

                                                                {
    static const LayerSpace<SkMatrix> kIdentity{SkMatrix::I()};
 
    if (crop.isEmpty() || ctx.desiredOutput().isEmpty()) {
        // An empty crop cannot be anything other than fully transparent
        return {};
    }
 
    // First, determine how this image's layer bounds interact with the crop rect, which determines
    // the portion of 'crop' that could have non-transparent content.
    LayerSpace<SkIRect> cropContent = crop;
    if (!fImage ||
        !cropContent.intersect(fLayerBounds)) {
        // The pixels within 'crop' would be fully transparent, and tiling won't change that.
        return {};
    }
 
    // Second, determine the subset of 'crop' that is relevant to ctx.desiredOutput().
    LayerSpace<SkIRect> fittedCrop = crop.relevantSubset(ctx.desiredOutput(), tileMode);
 
    // Third, check if there's overlap with the known non-transparent cropped content and what's
    // used to tile the desired output. If not, the image is known to be empty. This modifies
    // 'cropContent' and not 'fittedCrop' so that any transparent padding remains if we have to
    // apply repeat/mirror tiling to the original geometry.
    if (!cropContent.intersect(fittedCrop)) {
        return {};
    }
 
    // Fourth, a periodic tiling that covers the output with a single instance of the image can be
    // simplified to just a transform.
    auto periodicTransform = periodic_axis_transform(tileMode, fittedCrop, ctx.desiredOutput());
    if (periodicTransform) {
        return this->applyTransform(ctx, *periodicTransform, FilterResult::kDefaultSampling);
    }
 
    bool preserveTransparencyInCrop = false;
    if (tileMode == SkTileMode::kDecal) {
        // We can reduce the crop dimensions to what's non-transparent
        fittedCrop = cropContent;
    } else if (fittedCrop.contains(ctx.desiredOutput())) {
        tileMode = SkTileMode::kDecal;
        fittedCrop = ctx.desiredOutput();
    } else if (!cropContent.contains(fittedCrop)) {
        // There is transparency in fittedCrop that must be resolved in order to maintain the new
        // tiling geometry.
        preserveTransparencyInCrop = true;
        if (fTileMode == SkTileMode::kDecal && tileMode == SkTileMode::kClamp) {
            // include 1px buffer for transparency from original kDecal tiling
            cropContent.outset(skif::LayerSpace<SkISize>({1, 1}));
            SkAssertResult(fittedCrop.intersect(cropContent));
        }
    } // Otherwise cropContent == fittedCrop
 
    // Fifth, when the transform is an integer translation, any prior tiling and the new tiling
    // can sometimes be addressed analytically without producing a new image. Moving the crop into
    // the image dimensions allows future operations like applying a transform or color filter to
    // be composed without rendering a new image since there will not be an intervening crop.
    const bool doubleClamp = fTileMode == SkTileMode::kClamp && tileMode == SkTileMode::kClamp;
    LayerSpace<SkIPoint> origin;
    if (!preserveTransparencyInCrop &&
        is_nearly_integer_translation(fTransform, &origin) &&
        (doubleClamp ||
         !(this->analyzeBounds(fittedCrop) & BoundsAnalysis::kHasLayerFillingEffect))) {
        // Since the transform is axis-aligned, the tile mode can be applied to the original
        // image pre-transformation and still be consistent with the 'crop' geometry. When the
        // original tile mode is decal, extract_subset is always valid. When the original mode is
        // mirror/repeat, !kHasLayerFillingEffect ensures that 'fittedCrop' is contained within
        // the base image bounds, so extract_subset is valid. When the original mode is clamp
        // and the new mode is not clamp, that is also the case. When both modes are clamp, we have
        // to consider how 'fittedCrop' intersects (or doesn't) with the base image bounds.
        FilterResult restrictedOutput = this->subset(origin, fittedCrop, doubleClamp);
        restrictedOutput.updateTileMode(ctx, tileMode);
        if (restrictedOutput.fBoundary == PixelBoundary::kInitialized ||
            tileMode != SkTileMode::kDecal) {
            // Discard kInitialized since a crop is a strict constraint on sampling outside of it.
            // But preserve (kTransparent+kDecal) if this is a no-op crop.
            restrictedOutput.fBoundary = PixelBoundary::kUnknown;
        }
        return restrictedOutput;
    } else if (tileMode == SkTileMode::kDecal) {
        // A decal crop can always be applied as the final operation by adjusting layer bounds, and
        // does not modify any prior tile mode.
        SkASSERT(!preserveTransparencyInCrop);
        FilterResult restrictedOutput = *this;
        restrictedOutput.fLayerBounds = fittedCrop;
        return restrictedOutput;
    } else {
        // There is a non-trivial transform to the image data that must be applied before the
        // non-decal tilemode is meant to be applied to the axis-aligned 'crop'.
        FilterResult tiled = this->resolve(ctx, fittedCrop, /*preserveDstBounds=*/true);
        tiled.updateTileMode(ctx, tileMode);
        return tiled;
    }
}

applyTransform()

FilterResult skif::FilterResult::applyTransform	(	const Context &	ctx,
		const LayerSpace< SkMatrix > &	transform,
		const SkSamplingOptions &	sampling
	)		const

Definition at line 1040 of file SkImageFilterTypes.cpp.

                                                                                   {
    if (!fImage || ctx.desiredOutput().isEmpty()) {
        // Transformed transparent black remains transparent black.
        SkASSERT(!fColorFilter);
        return {};
    }
 
    // Extract the sampling options that matter based on the current and next transforms.
    // We make sure the new sampling is bilerp (default) if the new transform doesn't matter
    // (and assert that the current is bilerp if its transform didn't matter). Bilerp can be
    // maximally combined, so simplifies the logic in compatible_sampling().
    const bool currentXformIsInteger = is_nearly_integer_translation(fTransform);
    const bool nextXformIsInteger = is_nearly_integer_translation(transform);
 
    SkASSERT(!currentXformIsInteger || fSamplingOptions == kDefaultSampling);
    SkSamplingOptions nextSampling = nextXformIsInteger ? kDefaultSampling : sampling;
 
    // Determine if the image is being visibly cropped by the layer bounds, in which case we can't
    // merge this transform with any previous transform (unless the new transform is an integer
    // translation in which case any visible edge is aligned with the desired output and can be
    // resolved by intersecting the transformed layer bounds and the output bounds).
    bool isCropped = !nextXformIsInteger &&
                     (this->analyzeBounds(SkMatrix(transform), SkIRect(ctx.desiredOutput()))
                            & BoundsAnalysis::kRequiresLayerCrop);
 
    FilterResult transformed;
    if (!isCropped && compatible_sampling(fSamplingOptions, currentXformIsInteger,
                                          &nextSampling, nextXformIsInteger)) {
        // We can concat transforms and 'nextSampling' will be either fSamplingOptions,
        // sampling, or a merged combination depending on the two transforms in play.
        transformed = *this;
    } else {
        // We'll have to resolve this FilterResult first before 'transform' and 'sampling' can be
        // correctly evaluated. 'nextSampling' will always be 'sampling'.
        LayerSpace<SkIRect> tightBounds;
        if (transform.inverseMapRect(ctx.desiredOutput(), &tightBounds)) {
            transformed = this->resolve(ctx, tightBounds);
        }
 
        if (!transformed.fImage) {
            // Transform not invertible or resolve failed to create an image
            return {};
        }
    }
 
    transformed.fSamplingOptions = nextSampling;
    transformed.fTransform.postConcat(transform);
    // Rebuild the layer bounds and then restrict to the current desired output. The original value
    // of fLayerBounds includes the image mapped by the original fTransform as well as any
    // accumulated soft crops from desired outputs of prior stages. To prevent discarding that info,
    // we map fLayerBounds by the additional transform, instead of re-mapping the image bounds.
    transformed.fLayerBounds = transform.mapRect(transformed.fLayerBounds);
    if (!LayerSpace<SkIRect>::Intersects(transformed.fLayerBounds, ctx.desiredOutput())) {
        // The transformed output doesn't touch the desired, so it would just be transparent black.
        return {};
    }
 
    return transformed;
}

colorFilter()

const SkColorFilter * skif::FilterResult::colorFilter ( ) const

inline

Definition at line 747 of file SkImageFilterTypes.h.

{ return fColorFilter.get(); }

draw()

void skif::FilterResult::draw	(	const Context &	ctx,
		SkDevice *	target,
		const SkBlender *	blender
	)		const

Definition at line 1182 of file SkImageFilterTypes.cpp.

                                                                                            {
    SkAutoDeviceTransformRestore adtr{target, ctx.mapping().layerToDevice()};
    this->draw(ctx, target, /*preserveDeviceState=*/true, blender);
}

image()

const SkSpecialImage * skif::FilterResult::image ( ) const

inline

Definition at line 739 of file SkImageFilterTypes.h.

{ return fImage.get(); }

imageAndOffset() [1/2]

std::pair< sk_sp< SkSpecialImage >, LayerSpace< SkIPoint > > skif::FilterResult::imageAndOffset

(

const Context &

ctx

)

const

Definition at line 624 of file SkImageFilterTypes.cpp.

                                  {
    FilterResult resolved = this->resolve(ctx, ctx.desiredOutput());
    return {resolved.fImage, resolved.layerBounds().topLeft()};
}

imageAndOffset() [2/2]

sk_sp< SkSpecialImage > skif::FilterResult::imageAndOffset	(	const Context &	ctx,
		SkIPoint *	offset
	)		const

Definition at line 618 of file SkImageFilterTypes.cpp.

                                                                                             {
    auto [image, origin] = this->imageAndOffset(ctx);
    *offset = SkIPoint(origin);
    return image;
}

insetForSaveLayer()

FilterResult skif::FilterResult::insetForSaveLayer

(

)

const

Definition at line 630 of file SkImageFilterTypes.cpp.

                                                   {
    if (!fImage) {
        return {};
    }
 
    // SkCanvas processing should have prepared a decal-tiled image before calling this.
    SkASSERT(fTileMode == SkTileMode::kDecal);
 
    // PixelBoundary tracking assumes the special image's subset does not include the padding, so
    // inset by a single pixel.
    FilterResult inset = this->insetByPixel();
    // Trust that SkCanvas configured the layer's SkDevice to ensure the padding remained
    // transparent. Upgrading this pixel boundary knowledge allows the source image to use the
    // simpler clamp math (vs. decal math) when used in a shader context.
    SkASSERT(inset.fBoundary == PixelBoundary::kInitialized &&
             inset.fTileMode == SkTileMode::kDecal);
    inset.fBoundary = PixelBoundary::kTransparent;
    return inset;
}

layerBounds()

LayerSpace< SkIRect > skif::FilterResult::layerBounds ( ) const

inline

Definition at line 743 of file SkImageFilterTypes.h.

{ return fLayerBounds; }

MakeFromImage()

FilterResult skif::FilterResult::MakeFromImage ( const Context &  ctx, sk_sp< SkImage >  image, SkRect  srcRect, ParameterSpace< SkRect >  dstRect, const SkSamplingOptions &  sampling  )

static

Definition at line 1895 of file SkImageFilterTypes.cpp.

                                                                            {
    SkASSERT(image);
 
    SkRect imageBounds = SkRect::Make(image->dimensions());
    if (!imageBounds.contains(srcRect)) {
        SkMatrix srcToDst = SkMatrix::RectToRect(srcRect, SkRect(dstRect));
        if (!srcRect.intersect(imageBounds)) {
            return {}; // No overlap, so return an empty/transparent image
        }
        // Adjust dstRect to match the updated srcRect
        dstRect = ParameterSpace<SkRect>{srcToDst.mapRect(srcRect)};
    }
 
    if (SkRect(dstRect).isEmpty()) {
        return {}; // Output collapses to empty
    }
 
    // Check for direct conversion to an SkSpecialImage and then FilterResult. Eventually this
    // whole function should be replaceable with:
    //    FilterResult(fImage, fSrcRect, fDstRect).applyTransform(mapping.layerMatrix(), fSampling);
    SkIRect srcSubset = RoundOut(srcRect);
    if (SkRect::Make(srcSubset) == srcRect) {
        // Construct an SkSpecialImage from the subset directly instead of drawing.
        sk_sp<SkSpecialImage> specialImage = ctx.backend()->makeImage(srcSubset, std::move(image));
 
        // Treat the srcRect's top left as "layer" space since we are folding the src->dst transform
        // and the param->layer transform into a single transform step. We don't override the
        // PixelBoundary from kUnknown even if srcRect is contained within the 'image' because the
        // client could be doing their own external approximate-fit texturing.
        skif::FilterResult subset{std::move(specialImage),
                                  skif::LayerSpace<SkIPoint>(srcSubset.topLeft())};
        SkMatrix transform = SkMatrix::Concat(ctx.mapping().layerMatrix(),
                                              SkMatrix::RectToRect(srcRect, SkRect(dstRect)));
        return subset.applyTransform(ctx, skif::LayerSpace<SkMatrix>(transform), sampling);
    }
 
    // For now, draw the src->dst subset of image into a new image.
    LayerSpace<SkIRect> dstBounds = ctx.mapping().paramToLayer(dstRect).roundOut();
    if (!dstBounds.intersect(ctx.desiredOutput())) {
        return {};
    }
 
    AutoSurface surface{ctx, dstBounds, PixelBoundary::kTransparent,
                        /*renderInParameterSpace=*/true};
    if (surface) {
        SkPaint paint;
        paint.setAntiAlias(true);
        surface->drawImageRect(std::move(image), srcRect, SkRect(dstRect), sampling, &paint,
                               SkCanvas::kStrict_SrcRectConstraint);
    }
    return surface.snap();
}

MakeFromPicture()

FilterResult skif::FilterResult::MakeFromPicture ( const Context &  ctx, sk_sp< SkPicture >  pic, ParameterSpace< SkRect >  cullRect  )

static

Definition at line 1849 of file SkImageFilterTypes.cpp.

                                                                            {
    SkASSERT(pic);
    LayerSpace<SkIRect> dstBounds = ctx.mapping().paramToLayer(cullRect).roundOut();
    if (!dstBounds.intersect(ctx.desiredOutput())) {
        return {};
    }
 
    // Given the standard usage of the picture image filter (i.e., to render content at a fixed
    // resolution that, most likely, differs from the screen's) disable LCD text by removing any
    // knowledge of the pixel geometry.
    // TODO: Should we just generally do this for layers with image filters? Or can we preserve it
    // for layers that are still axis-aligned?
    SkSurfaceProps props = ctx.backend()->surfaceProps()
                                         .cloneWithPixelGeometry(kUnknown_SkPixelGeometry);
    // TODO(b/329700315): The SkPicture may contain dithered content, which would be affected by any
    // boundary padding. Until we can control the dither origin, force it to have no padding.
    AutoSurface surface{ctx, dstBounds, PixelBoundary::kUnknown,
                        /*renderInParameterSpace=*/true, &props};
    if (surface) {
        surface->clipRect(SkRect(cullRect));
        surface->drawPicture(std::move(pic));
    }
    return surface.snap();
}

MakeFromShader()

FilterResult skif::FilterResult::MakeFromShader ( const Context &  ctx, sk_sp< SkShader >  shader, bool  dither  )

static

Definition at line 1876 of file SkImageFilterTypes.cpp.

                                                       {
    SkASSERT(shader);
 
    // TODO(b/329700315): Using a boundary other than unknown shifts the origin of dithering, which
    // complicates layout test validation in chrome. Until we can control the dither origin,
    // force dithered shader FilterResults to have no padding.
    PixelBoundary boundary = dither ? PixelBoundary::kUnknown : PixelBoundary::kTransparent;
    AutoSurface surface{ctx, ctx.desiredOutput(), boundary, /*renderInParameterSpace=*/true};
    if (surface) {
        SkPaint paint;
        paint.setShader(shader);
        paint.setDither(dither);
        surface->drawPaint(paint);
    }
    return surface.snap();
}

operator bool()

skif::FilterResult::operator bool ( ) const

inlineexplicit

Definition at line 734 of file SkImageFilterTypes.h.

{ return SkToBool(fImage); }

refImage()

sk_sp< SkSpecialImage > skif::FilterResult::refImage ( ) const

inline

Definition at line 740 of file SkImageFilterTypes.h.

{ return fImage; }

sampling()

SkSamplingOptions skif::FilterResult::sampling ( ) const

inline

Definition at line 745 of file SkImageFilterTypes.h.

{ return fSamplingOptions; }

tileMode()

SkTileMode skif::FilterResult::tileMode ( ) const

inline

Definition at line 744 of file SkImageFilterTypes.h.

{ return fTileMode; }

Friends And Related Function Documentation

::FilterResultTestAccess

friend class ::FilterResultTestAccess

friend

Definition at line 815 of file SkImageFilterTypes.h.

Member Data Documentation

kDefaultSampling

constexpr SkSamplingOptions skif::FilterResult::kDefaultSampling {SkFilterMode::kLinear}

staticconstexpr

Definition at line 732 of file SkImageFilterTypes.h.

---

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

• third_party/skia/src/core/SkImageFilterTypes.h
• third_party/skia/src/core/SkImageFilterTypes.cpp