SkCanvas.cpp File Reference

#include "include/core/SkCanvas.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlender.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkRRect.h"
#include "include/core/SkRSXform.h"
#include "include/core/SkRasterHandleAllocator.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkRegion.h"
#include "include/core/SkShader.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTextBlob.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/core/SkVertices.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkSafe32.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "include/private/chromium/Slug.h"
#include "include/utils/SkNoDrawCanvas.h"
#include "src/base/SkEnumBitMask.h"
#include "src/base/SkMSAN.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkBlurMaskFilterImpl.h"
#include "src/core/SkCanvasPriv.h"
#include "src/core/SkDevice.h"
#include "src/core/SkImageFilterTypes.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkImagePriv.h"
#include "src/core/SkLatticeIter.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkMatrixPriv.h"
#include "src/core/SkPaintPriv.h"
#include "src/core/SkSpecialImage.h"
#include "src/core/SkSurfacePriv.h"
#include "src/core/SkTraceEvent.h"
#include "src/core/SkVerticesPriv.h"
#include "src/effects/colorfilters/SkColorFilterBase.h"
#include "src/image/SkSurface_Base.h"
#include "src/text/GlyphRun.h"
#include "src/utils/SkPatchUtils.h"
#include <algorithm>
#include <memory>
#include <new>
#include <optional>
#include <tuple>
#include <utility>

Go to the source code of this file.

Classes
class	SkCanvas::AutoUpdateQRBounds
struct	FilterToSpan

Macros
#define	RETURN_ON_NULL(ptr)   do { if (nullptr == (ptr)) return; } while (0)
#define	RETURN_ON_FALSE(pred)   do { if (!(pred)) return; } while (0)

Typedefs
using	Slug = sktext::gpu::Slug

Functions
static skif::ParameterSpace< SkPoint >	compute_decomposition_center (const SkMatrix &dstToLocal, std::optional< skif::ParameterSpace< SkRect > > contentBounds, const skif::DeviceSpace< SkIRect > &targetOutput)
static std::optional< std::pair< skif::Mapping, skif::LayerSpace< SkIRect > > >	get_layer_mapping_and_bounds (SkCanvas::FilterSpan filters, const SkMatrix &localToDst, const skif::DeviceSpace< SkIRect > &targetOutput, std::optional< skif::ParameterSpace< SkRect > > contentBounds={}, SkScalar scaleFactor=1.0f)
static SkColorType	image_filter_color_type (const SkColorInfo &dstInfo)
static skif::FilterResult	apply_alpha_and_colorfilter (const skif::Context &ctx, const skif::FilterResult &image, const SkPaint &paint)
static bool	fillable (const SkRect &r)
static SkPaint	clean_paint_for_lattice (const SkPaint *paint)
static const SkBlurMaskFilterImpl *	can_attempt_blurred_rrect_draw (const SkPaint &paint)
static SkPaint	clean_paint_for_drawImage (const SkPaint *paint)
static SkPaint	clean_paint_for_drawVertices (SkPaint paint)
static SkSamplingOptions	clean_sampling_for_constraint (const SkSamplingOptions &sampling, SkCanvas::SrcRectConstraint constraint)
static bool	install (SkBitmap *bm, const SkImageInfo &info, const SkRasterHandleAllocator::Rec &rec)

Macro Definition Documentation

RETURN_ON_FALSE

#define RETURN_ON_FALSE

(

pred

)

do { if (!(pred)) return; } while (0)

Definition at line 79 of file SkCanvas.cpp.

RETURN_ON_NULL

#define RETURN_ON_NULL

(

ptr

)

do { if (nullptr == (ptr)) return; } while (0)

Definition at line 78 of file SkCanvas.cpp.

Typedef Documentation

Slug

using Slug = sktext::gpu::Slug

Definition at line 85 of file SkCanvas.cpp.

Function Documentation

apply_alpha_and_colorfilter()

static skif::FilterResult apply_alpha_and_colorfilter ( const skif::Context &  ctx, const skif::FilterResult &  image, const SkPaint &  paint  )

static

Definition at line 697 of file SkCanvas.cpp.

                                                                            {
    // The only effects that apply to layers (other than the SkImageFilter that made this image in
    // the first place) are transparency and color filters.
    skif::FilterResult result = image;
    if (paint.getAlphaf() < 1.f) {
        result = result.applyColorFilter(ctx, SkColorFilters::Blend(paint.getColor4f(),
                                                                    /*colorSpace=*/nullptr,
                                                                    SkBlendMode::kDstIn));
    }
    if (paint.getColorFilter()) {
        result = result.applyColorFilter(ctx, paint.refColorFilter());
    }
    return result;
}

can_attempt_blurred_rrect_draw()

static const SkBlurMaskFilterImpl * can_attempt_blurred_rrect_draw ( const SkPaint &  paint )

static

Definition at line 2265 of file SkCanvas.cpp.

                                                                                        {
    if (paint.getPathEffect()) {
        return nullptr;
    }
 
    // TODO: Once stroke-and-fill goes away, we can check the paint's style directly.
    if (SkStrokeRec(paint).getStyle() != SkStrokeRec::kFill_Style) {
        return nullptr;
    }
 
    const SkMaskFilterBase* maskFilter = as_MFB(paint.getMaskFilter());
    if (!maskFilter || maskFilter->type() != SkMaskFilterBase::Type::kBlur) {
        return nullptr;
    }
 
    const SkBlurMaskFilterImpl* blurMaskFilter =
            static_cast<const SkBlurMaskFilterImpl*>(maskFilter);
    if (blurMaskFilter->blurStyle() != kNormal_SkBlurStyle) {
        return nullptr;
    }
 
    return blurMaskFilter;
}

clean_paint_for_drawImage()

static SkPaint clean_paint_for_drawImage ( const SkPaint *  paint )

static

Definition at line 2525 of file SkCanvas.cpp.

                                                               {
    SkPaint cleaned;
    if (paint) {
        cleaned = *paint;
        cleaned.setStyle(SkPaint::kFill_Style);
        cleaned.setPathEffect(nullptr);
    }
    return cleaned;
}

clean_paint_for_drawVertices()

static SkPaint clean_paint_for_drawVertices ( SkPaint  paint )

static

Definition at line 2537 of file SkCanvas.cpp.

                                                           {
    paint.setStyle(SkPaint::kFill_Style);
    paint.setMaskFilter(nullptr);
    paint.setPathEffect(nullptr);
    return paint;
}

clean_paint_for_lattice()

static SkPaint clean_paint_for_lattice ( const SkPaint *  paint )

static

Definition at line 2083 of file SkCanvas.cpp.

                                                             {
    SkPaint cleaned;
    if (paint) {
        cleaned = *paint;
        cleaned.setMaskFilter(nullptr);
        cleaned.setAntiAlias(false);
    }
    return cleaned;
}

clean_sampling_for_constraint()

static SkSamplingOptions clean_sampling_for_constraint ( const SkSamplingOptions &  sampling, SkCanvas::SrcRectConstraint  constraint  )

static

Definition at line 2612 of file SkCanvas.cpp.

                                              {
    if (constraint == SkCanvas::kStrict_SrcRectConstraint) {
        if (sampling.mipmap != SkMipmapMode::kNone) {
            return SkSamplingOptions(sampling.filter);
        }
        if (sampling.isAniso()) {
            return SkSamplingOptions(SkFilterMode::kLinear);
        }
    }
    return sampling;
}

compute_decomposition_center()

static skif::ParameterSpace< SkPoint > compute_decomposition_center ( const SkMatrix &  dstToLocal, std::optional< skif::ParameterSpace< SkRect > >  contentBounds, const skif::DeviceSpace< SkIRect > &  targetOutput  )

static

Definition at line 536 of file SkCanvas.cpp.

                                                      {
    // Will use the inverse and center of the device bounds if the content bounds aren't provided.
    SkRect rect = contentBounds ? SkRect(*contentBounds) : SkRect::Make(SkIRect(targetOutput));
    SkPoint center = {rect.centerX(), rect.centerY()};
    if (!contentBounds) {
        // Theoretically, the inverse transform could put center's homogeneous coord behind W = 0,
        // but that case is handled automatically in Mapping::decomposeCTM later.
        dstToLocal.mapPoints(&center, 1);
    }
 
    return skif::ParameterSpace<SkPoint>(center);
}

fillable()

static bool fillable ( const SkRect &  r )

static

Definition at line 2077 of file SkCanvas.cpp.

                                      {
    SkScalar w = r.width();
    SkScalar h = r.height();
    return SkIsFinite(w, h) && w > 0 && h > 0;
}

get_layer_mapping_and_bounds()

static std::optional< std::pair< skif::Mapping, skif::LayerSpace< SkIRect > > > get_layer_mapping_and_bounds ( SkCanvas::FilterSpan  filters, const SkMatrix &  localToDst, const skif::DeviceSpace< SkIRect > &  targetOutput, std::optional< skif::ParameterSpace< SkRect > >  contentBounds = {}, SkScalar  scaleFactor = 1.0f  )

static

Definition at line 572 of file SkCanvas.cpp.

                                                                {},
#if defined(SK_RESOLVE_FILTERS_BEFORE_RESTORE)
        bool mustCoverDst = true,
#endif
        SkScalar scaleFactor = 1.0f) {
    SkMatrix dstToLocal;
    if (!localToDst.isFinite() ||
        !localToDst.invert(&dstToLocal)) {
        return {};
    }
 
    skif::ParameterSpace<SkPoint> center =
            compute_decomposition_center(dstToLocal, contentBounds, targetOutput);
#if defined(SK_RESOLVE_FILTERS_BEFORE_RESTORE)
    // *after* possibly getting a representative point from the provided content bounds, it might
    // be necessary to discard the bounds for subsequent layer calculations.
    if (mustCoverDst) {
        contentBounds.reset();
    }
#endif
 
    // Determine initial mapping and a reasonable maximum dimension to prevent layer-to-device
    // transforms with perspective and skew from triggering excessive buffer allocations.
    skif::Mapping mapping;
    skif::MatrixCapability capability = skif::MatrixCapability::kComplex;
    for (const sk_sp<SkImageFilter>& filter : filters) {
        if (filter) {
            capability = std::min(capability, as_IFB(filter)->getCTMCapability());
        }
    }
    if (!mapping.decomposeCTM(localToDst, capability, center)) {
        return {};
    }
    // Push scale factor into layer matrix and device matrix (net no change, but the layer will have
    // its resolution adjusted in comparison to the final device).
    if (scaleFactor != 1.0f &&
        !mapping.adjustLayerSpace(SkMatrix::Scale(scaleFactor, scaleFactor))) {
        return {};
    }
 
    // Perspective and skew could exceed this since mapping.deviceToLayer(targetOutput) is
    // theoretically unbounded under those conditions. Under a 45 degree rotation, a layer needs to
    // be 2X larger per side of the prior device in order to fully cover it. We use the max of that
    // and 2048 for a reasonable upper limit (this allows small layers under extreme transforms to
    // use more relative resolution than a larger layer).
    static const int kMinDimThreshold = 2048;
    int maxLayerDim = std::max(Sk64_pin_to_s32(2 * std::max(SkIRect(targetOutput).width64(),
                                                            SkIRect(targetOutput).height64())),
                               kMinDimThreshold);
 
    auto baseLayerBounds = mapping.deviceToLayer(targetOutput);
    if (contentBounds) {
        // For better or for worse, user bounds currently act as a hard clip on the layer's
        // extent (i.e., they implement the CSS filter-effects 'filter region' feature).
        skif::LayerSpace<SkIRect> knownBounds = mapping.paramToLayer(*contentBounds).roundOut();
        if (!baseLayerBounds.intersect(knownBounds)) {
            baseLayerBounds = skif::LayerSpace<SkIRect>::Empty();
        }
    }
 
    skif::LayerSpace<SkIRect> layerBounds;
    if (!filters.empty()) {
        layerBounds = skif::LayerSpace<SkIRect>::Union(filters.size(), [&](int i) {
            return filters[i] ? as_IFB(filters[i])
                                        ->getInputBounds(mapping, targetOutput, contentBounds)
                              : baseLayerBounds;
        });
        // When a filter is involved, the layer size may be larger than the default maxLayerDim due
        // to required inputs for filters (e.g. a displacement map with a large radius).
        if (layerBounds.width() > maxLayerDim || layerBounds.height() > maxLayerDim) {
            skif::Mapping idealMapping{mapping.layerMatrix()};
            for (const sk_sp<SkImageFilter>& filter : filters) {
                if (filter) {
                    auto idealLayerBounds = as_IFB(filter)->getInputBounds(
                            idealMapping, targetOutput, contentBounds);
                    maxLayerDim = std::max(std::max(idealLayerBounds.width(),
                                                    idealLayerBounds.height()),
                                                    maxLayerDim);
                }
            }
        }
    } else {
        if (baseLayerBounds.isEmpty()) {
            return {};
        }
        layerBounds = baseLayerBounds;
    }
 
    if (layerBounds.width() > maxLayerDim || layerBounds.height() > maxLayerDim) {
        skif::LayerSpace<SkIRect> newLayerBounds(
                SkIRect::MakeWH(std::min(layerBounds.width(), maxLayerDim),
                                std::min(layerBounds.height(), maxLayerDim)));
        SkMatrix adjust = SkMatrix::MakeRectToRect(SkRect::Make(SkIRect(layerBounds)),
                                                   SkRect::Make(SkIRect(newLayerBounds)),
                                                   SkMatrix::kFill_ScaleToFit);
        if (!mapping.adjustLayerSpace(adjust)) {
            return {};
        } else {
            layerBounds = newLayerBounds;
        }
    }
 
    return std::make_pair(mapping, layerBounds);
}

image_filter_color_type()

static SkColorType image_filter_color_type ( const SkColorInfo &  dstInfo )

static

Definition at line 684 of file SkCanvas.cpp.

                                                                       {
    if (dstInfo.bytesPerPixel() <= 4 &&
        dstInfo.colorType() != kRGBA_8888_SkColorType &&
        dstInfo.colorType() != kBGRA_8888_SkColorType) {
        // "Upgrade" A8, G8, 565, 4444, 1010102, 101010x, and 888x to 8888
        return kN32_SkColorType;
    } else {
        return dstInfo.colorType();
    }
}

install()

static bool install ( SkBitmap *  bm, const SkImageInfo &  info, const SkRasterHandleAllocator::Rec &  rec  )

static

Definition at line 3283 of file SkCanvas.cpp.

                                                           {
    return bm->installPixels(info, rec.fPixels, rec.fRowBytes, rec.fReleaseProc, rec.fReleaseCtx);
}