#ifndef FilterEffect_h
#define FilterEffect_h
#include "ColorSpace.h"
#include "FloatRect.h"
#include "IntRect.h"
#include <runtime/Uint8ClampedArray.h>
#include <wtf/HashSet.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
#if ENABLE(OPENCL)
#include "FilterContextOpenCL.h"
#endif
namespace WebCore {
class Filter;
class FilterEffect;
class ImageBuffer;
class TextStream;
typedef Vector<RefPtr<FilterEffect>> FilterEffectVector;
enum FilterEffectType {
FilterEffectTypeUnknown,
FilterEffectTypeImage,
FilterEffectTypeTile,
FilterEffectTypeSourceInput
};
class FilterEffect : public RefCounted<FilterEffect> {
public:
virtual ~FilterEffect();
void clearResult();
void clearResultsRecursive();
ImageBuffer* asImageBuffer();
PassRefPtr<Uint8ClampedArray> asUnmultipliedImage(const IntRect&);
PassRefPtr<Uint8ClampedArray> asPremultipliedImage(const IntRect&);
void copyUnmultipliedImage(Uint8ClampedArray* destination, const IntRect&);
void copyPremultipliedImage(Uint8ClampedArray* destination, const IntRect&);
#if ENABLE(OPENCL)
OpenCLHandle openCLImage() { return m_openCLImageResult; }
void setOpenCLImage(OpenCLHandle openCLImage) { m_openCLImageResult = openCLImage; }
ImageBuffer* openCLImageToImageBuffer();
#endif
FilterEffectVector& inputEffects() { return m_inputEffects; }
FilterEffect* inputEffect(unsigned) const;
unsigned numberOfEffectInputs() const { return m_inputEffects.size(); }
unsigned totalNumberOfEffectInputs() const;
inline bool hasResult() const
{
return m_imageBufferResult
#if ENABLE(OPENCL)
|| m_openCLImageResult
#endif
|| m_unmultipliedImageResult
|| m_premultipliedImageResult;
}
FloatRect drawingRegionOfInputImage(const IntRect&) const;
IntRect requestedRegionOfInputImageData(const IntRect&) const;
bool isAlphaImage() const { return m_alphaImage; }
void setIsAlphaImage(bool alphaImage) { m_alphaImage = alphaImage; }
IntRect absolutePaintRect() const { return m_absolutePaintRect; }
void setAbsolutePaintRect(const IntRect& absolutePaintRect) { m_absolutePaintRect = absolutePaintRect; }
FloatRect maxEffectRect() const { return m_maxEffectRect; }
void setMaxEffectRect(const FloatRect& maxEffectRect) { m_maxEffectRect = maxEffectRect; }
void apply();
#if ENABLE(OPENCL)
void applyAll();
#else
inline void applyAll() { apply(); }
#endif
virtual void correctFilterResultIfNeeded() { }
virtual void platformApplySoftware() = 0;
#if ENABLE(OPENCL)
virtual bool platformApplyOpenCL();
#endif
virtual void dump() = 0;
virtual void determineAbsolutePaintRect();
virtual FilterEffectType filterEffectType() const { return FilterEffectTypeUnknown; }
virtual TextStream& externalRepresentation(TextStream&, int indention = 0) const;
public:
bool hasX() const { return m_hasX; }
void setHasX(bool value) { m_hasX = value; }
bool hasY() const { return m_hasY; }
void setHasY(bool value) { m_hasY = value; }
bool hasWidth() const { return m_hasWidth; }
void setHasWidth(bool value) { m_hasWidth = value; }
bool hasHeight() const { return m_hasHeight; }
void setHasHeight(bool value) { m_hasHeight = value; }
FloatRect filterPrimitiveSubregion() const { return m_filterPrimitiveSubregion; }
void setFilterPrimitiveSubregion(const FloatRect& filterPrimitiveSubregion) { m_filterPrimitiveSubregion = filterPrimitiveSubregion; }
FloatRect effectBoundaries() const { return m_effectBoundaries; }
void setEffectBoundaries(const FloatRect& effectBoundaries) { m_effectBoundaries = effectBoundaries; }
Filter& filter() { return m_filter; }
bool clipsToBounds() const { return m_clipsToBounds; }
void setClipsToBounds(bool value) { m_clipsToBounds = value; }
ColorSpace operatingColorSpace() const { return m_operatingColorSpace; }
virtual void setOperatingColorSpace(ColorSpace colorSpace) { m_operatingColorSpace = colorSpace; }
ColorSpace resultColorSpace() const { return m_resultColorSpace; }
virtual void setResultColorSpace(ColorSpace colorSpace) { m_resultColorSpace = colorSpace; }
virtual void transformResultColorSpace(FilterEffect* in, const int) { in->transformResultColorSpace(m_operatingColorSpace); }
void transformResultColorSpace(ColorSpace);
protected:
FilterEffect(Filter&);
ImageBuffer* createImageBufferResult();
Uint8ClampedArray* createUnmultipliedImageResult();
Uint8ClampedArray* createPremultipliedImageResult();
#if ENABLE(OPENCL)
OpenCLHandle createOpenCLImageResult(uint8_t* = 0);
#endif
virtual bool requiresValidPreMultipliedPixels() { return true; }
void forceValidPreMultipliedPixels();
void clipAbsolutePaintRect();
private:
std::unique_ptr<ImageBuffer> m_imageBufferResult;
RefPtr<Uint8ClampedArray> m_unmultipliedImageResult;
RefPtr<Uint8ClampedArray> m_premultipliedImageResult;
FilterEffectVector m_inputEffects;
#if ENABLE(OPENCL)
OpenCLHandle m_openCLImageResult;
#endif
bool m_alphaImage;
IntRect m_absolutePaintRect;
FloatRect m_maxEffectRect;
Filter& m_filter;
private:
inline void copyImageBytes(Uint8ClampedArray* source, Uint8ClampedArray* destination, const IntRect&);
FloatRect m_filterPrimitiveSubregion;
FloatRect m_effectBoundaries;
bool m_hasX;
bool m_hasY;
bool m_hasWidth;
bool m_hasHeight;
bool m_clipsToBounds;
ColorSpace m_operatingColorSpace;
ColorSpace m_resultColorSpace;
};
}
#endif // FilterEffect_h