skif Namespace Reference

Classes
class	Backend
class	Context
class	DeviceSpace
class	FilterResult
struct	IVector
class	LayerSpace
class	LayerSpace< IVector >
class	LayerSpace< SkIPoint >
class	LayerSpace< SkIRect >
class	LayerSpace< SkISize >
class	LayerSpace< SkMatrix >
class	LayerSpace< SkPoint >
class	LayerSpace< SkRect >
class	LayerSpace< SkSize >
class	LayerSpace< Vector >
class	LayerSpace< ZValue >
class	Mapping
class	ParameterSpace
struct	Stats
struct	Vector

Typedefs
template<typename T >
using	PixelSpace = LayerSpace< T >

Enumerations
enum class	MatrixCapability { kTranslate , kScaleTranslate , kComplex }

Functions
sk_sp< Backend >	MakeRasterBackend (const SkSurfaceProps &surfaceProps, SkColorType colorType)
SkIRect	RoundOut (SkRect r)
SkIRect	RoundIn (SkRect r)
static bool	compatible_sampling (const SkSamplingOptions &currentSampling, bool currentXformWontAffectNearest, SkSamplingOptions *nextSampling, bool nextXformWontAffectNearest)
static int	downscale_step_count (float netScaleFactor)
sk_sp< Backend >	MakeGaneshBackend (sk_sp< GrRecordingContext > context, GrSurfaceOrigin origin, const SkSurfaceProps &surfaceProps, SkColorType colorType)

Typedef Documentation

PixelSpace

template<typename T >

using skif::PixelSpace = typedef LayerSpace<T>

Definition at line 1471 of file SkImageFilterTypes.cpp.

Enumeration Type Documentation

MatrixCapability

enum class skif::MatrixCapability

strong

Most ImageFilters can natively handle scaling and translate components in the CTM. Only some of them can handle affine (or more complex) matrices. Some may only handle translation.

Enumerator
kTranslate
kScaleTranslate
kComplex

Definition at line 545 of file SkImageFilterTypes.h.

                            {
    kTranslate,
    kScaleTranslate,
    kComplex,
};

Function Documentation

compatible_sampling()

static bool skif::compatible_sampling ( const SkSamplingOptions &  currentSampling, bool  currentXformWontAffectNearest, SkSamplingOptions *  nextSampling, bool  nextXformWontAffectNearest  )

static

Definition at line 987 of file SkImageFilterTypes.cpp.

                                                                 {
    // Both transforms could perform non-trivial sampling, but if they are similar enough we
    // assume performing one non-trivial sampling operation with the concatenated transform will
    // not be visually distinguishable from sampling twice.
    // TODO(michaelludwig): For now ignore mipmap policy, SkSpecialImages are not supposed to be
    // drawn with mipmapping, and the majority of filter steps produce images that are at the
    // proper scale and do not define mip levels. The main exception is the ::Image() filter
    // leaf but that doesn't use this system yet.
    if (currentSampling.isAniso() && nextSampling->isAniso()) {
        // Assume we can get away with one sampling at the highest anisotropy level
        *nextSampling =  SkSamplingOptions::Aniso(std::max(currentSampling.maxAniso,
                                                           nextSampling->maxAniso));
        return true;
    } else if (currentSampling.isAniso() && nextSampling->filter == SkFilterMode::kLinear) {
        // Assume we can get away with the current anisotropic filter since the next is linear
        *nextSampling = currentSampling;
        return true;
    } else if (nextSampling->isAniso() && currentSampling.filter == SkFilterMode::kLinear) {
        // Mirror of the above, assume we can just get away with next's anisotropic filter
        return true;
    } else if (currentSampling.useCubic && (nextSampling->filter == SkFilterMode::kLinear ||
                                            (nextSampling->useCubic &&
                                             currentSampling.cubic.B == nextSampling->cubic.B &&
                                             currentSampling.cubic.C == nextSampling->cubic.C))) {
        // Assume we can get away with the current bicubic filter, since the next is the same
        // or a bilerp that can be upgraded.
        *nextSampling = currentSampling;
        return true;
    } else if (nextSampling->useCubic && currentSampling.filter == SkFilterMode::kLinear) {
        // Mirror of the above, assume we can just get away with next's cubic resampler
        return true;
    } else if (currentSampling.filter == SkFilterMode::kLinear &&
               nextSampling->filter == SkFilterMode::kLinear) {
        // Assume we can get away with a single bilerp vs. the two
        return true;
    } else if (nextSampling->filter == SkFilterMode::kNearest && currentXformWontAffectNearest) {
        // The next transform and nearest-neighbor filtering isn't impacted by the current transform
        SkASSERT(currentSampling.filter == SkFilterMode::kLinear);
        return true;
    } else if (currentSampling.filter == SkFilterMode::kNearest && nextXformWontAffectNearest) {
        // The next transform doesn't change the nearest-neighbor filtering of the current transform
        SkASSERT(nextSampling->filter == SkFilterMode::kLinear);
        *nextSampling = currentSampling;
        return true;
    } else {
        // The current or next sampling is nearest neighbor, and will produce visible texels
        // oriented with the current transform; assume this is a desired effect and preserve it.
        return false;
    }
}

downscale_step_count()

static int skif::downscale_step_count ( float  netScaleFactor )

static

Definition at line 1445 of file SkImageFilterTypes.cpp.

                                                      {
    int steps = SkNextLog2(sk_float_ceil2int(1.f / netScaleFactor));
    // There are (steps-1) 1/2x steps and then one step that will be between 1/2-1x. If the
    // final step is practically the identity scale, we can save a render pass and not incur too
    // much sampling error by reducing the step count and using a final scale that's slightly less
    // than 1/2.
    if (steps > 0) {
        // For a multipass rescale, we allow for a lot of tolerance when deciding to collapse the
        // final step. If there's only a single pass, we require the scale factor to be very close
        // to the identity since it causes the step count to go to 0.
        static constexpr float kMultiPassLimit = 0.8f;
        static constexpr float kNearIdentityLimit = 1.f - kRoundEpsilon; // 1px error in 1000px img
 
        float finalStepScale = netScaleFactor * (1 << (steps - 1));
        float limit = steps == 1 ? kNearIdentityLimit : kMultiPassLimit;
        if (finalStepScale >= limit) {
            steps--;
        }
    }
 
    return steps;
}

MakeGaneshBackend()

sk_sp< Backend > skif::MakeGaneshBackend	(	sk_sp< GrRecordingContext >	context,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	surfaceProps,
		SkColorType	colorType
	)

Definition at line 853 of file GrImageUtils.cpp.

                                                        {
    SkASSERT(context);
    return sk_make_sp<GaneshBackend>(std::move(context), origin, surfaceProps, colorType);
}

MakeRasterBackend()

sk_sp< Backend > skif::MakeRasterBackend	(	const SkSurfaceProps &	surfaceProps,
		SkColorType	colorType
	)

Definition at line 218 of file SkImageFilterTypes.cpp.

                                                                                            {
    // TODO (skbug:14286): Remove this forcing to 8888. Many legacy image filters only support
    // N32 on CPU, but once they are implemented in terms of draws and SkSL they will support
    // all color types, like the GPU backends.
    colorType = kN32_SkColorType;
 
    return sk_make_sp<RasterBackend>(surfaceProps, colorType);
}

RoundIn()

SkIRect skif::RoundIn

(

SkRect

r

)

Definition at line 255 of file SkImageFilterTypes.cpp.

{ return r.makeOutset(kRoundEpsilon, kRoundEpsilon).roundIn(); }

RoundOut()

SkIRect skif::RoundOut

(

SkRect

r

)

Definition at line 253 of file SkImageFilterTypes.cpp.

{ return r.makeInset(kRoundEpsilon, kRoundEpsilon).roundOut(); }