chromium/third_party/skia/src/core/SkImageFilter.cpp

/*
 * Copyright 2012 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/core/SkImageFilter.h"

#include "include/core/SkColorFilter.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTemplates.h"
#include "src/core/SkImageFilterCache.h"
#include "src/core/SkImageFilterTypes.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkLocalMatrixImageFilter.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkRectPriv.h"
#include "src/core/SkSpecialImage.h"
#include "src/core/SkValidationUtils.h"
#include "src/core/SkWriteBuffer.h"
#include "src/effects/colorfilters/SkColorFilterBase.h"

#include <algorithm>
#include <atomic>
#include <cstdint>
#include <optional>
#include <utility>

///////////////////////////////////////////////////////////////////////////////////////////////////
// SkImageFilter - A number of the public APIs on SkImageFilter downcast to SkImageFilter_Base
// in order to perform their actual work.
///////////////////////////////////////////////////////////////////////////////////////////////////

/**
 *  Returns the number of inputs this filter will accept (some inputs can
 *  be NULL).
 */
int SkImageFilter::countInputs() const { … }

/**
 *  Returns the input filter at a given index, or NULL if no input is
 *  connected.  The indices used are filter-specific.
 */
const SkImageFilter* SkImageFilter::getInput(int i) const { … }

bool SkImageFilter::isColorFilterNode(SkColorFilter** filterPtr) const { … }

SkIRect SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm,
                                    MapDirection direction, const SkIRect* inputRect) const { … }

SkRect SkImageFilter::computeFastBounds(const SkRect& src) const { … }

bool SkImageFilter::canComputeFastBounds() const { … }

bool SkImageFilter_Base::affectsTransparentBlack() const { … }

bool SkImageFilter::asAColorFilter(SkColorFilter** filterPtr) const { … }

sk_sp<SkImageFilter> SkImageFilter::makeWithLocalMatrix(const SkMatrix& matrix) const { … }

///////////////////////////////////////////////////////////////////////////////////////////////////
// SkImageFilter_Base
///////////////////////////////////////////////////////////////////////////////////////////////////

static int32_t next_image_filter_unique_id() { … }

SkImageFilter_Base::SkImageFilter_Base(sk_sp<SkImageFilter> const* inputs,
                                       int inputCount,
                                       std::optional<bool> usesSrc)
        : … { … }

SkImageFilter_Base::~SkImageFilter_Base() { … }

std::pair<sk_sp<SkImageFilter>, std::optional<SkRect>>
SkImageFilter_Base::Unflatten(SkReadBuffer& buffer) { … }

bool SkImageFilter_Base::Common::unflatten(SkReadBuffer& buffer, int expectedCount) { … }

void SkImageFilter_Base::flatten(SkWriteBuffer& buffer) const { … }

skif::FilterResult SkImageFilter_Base::filterImage(const skif::Context& context) const { … }

sk_sp<SkImage> SkImageFilter_Base::makeImageWithFilter(sk_sp<skif::Backend> backend,
                                                       sk_sp<SkImage> src,
                                                       const SkIRect& subset,
                                                       const SkIRect& clipBounds,
                                                       SkIRect* outSubset,
                                                       SkIPoint* offset) const { … }

skif::LayerSpace<SkIRect> SkImageFilter_Base::getInputBounds(
        const skif::Mapping& mapping,
        const skif::DeviceSpace<SkIRect>& desiredOutput,
        std::optional<skif::ParameterSpace<SkRect>> knownContentBounds) const { … }

std::optional<skif::DeviceSpace<SkIRect>> SkImageFilter_Base::getOutputBounds(
        const skif::Mapping& mapping,
        const skif::ParameterSpace<SkRect>& contentBounds) const { … }

SkImageFilter_Base::MatrixCapability SkImageFilter_Base::getCTMCapability() const { … }

skif::LayerSpace<SkIRect> SkImageFilter_Base::getChildInputLayerBounds(
        int index,
        const skif::Mapping& mapping,
        const skif::LayerSpace<SkIRect>& desiredOutput,
        std::optional<skif::LayerSpace<SkIRect>> contentBounds) const { … }

std::optional<skif::LayerSpace<SkIRect>> SkImageFilter_Base::getChildOutputLayerBounds(
        int index,
        const skif::Mapping& mapping,
        std::optional<skif::LayerSpace<SkIRect>> contentBounds) const { … }

skif::FilterResult SkImageFilter_Base::getChildOutput(int index, const skif::Context& ctx) const { … }

void SkImageFilter_Base::PurgeCache() { … }