@shopify/react-native-skia 0.0.135

package/cpp/skia/include/core/SkImageEncoder.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageEncoder_DEFINED
+#define SkImageEncoder_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkEncodedImageFormat.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkStream.h"
+
+class SkBitmap;
+
+/**
+ * Encode SkPixmap in the given binary image format.
+ *
+ * @param  dst     results are written to this stream.
+ * @param  src     source pixels.
+ * @param  format  image format, not all formats are supported.
+ * @param  quality range from 0-100, this is supported by jpeg and webp.
+ *                 higher values correspond to improved visual quality, but less compression.
+ *
+ * @return false iff input is bad or format is unsupported.
+ *
+ * Will always return false if Skia is compiled without image
+ * encoders.
+ *
+ * For SkEncodedImageFormat::kWEBP, if quality is 100, it will use lossless compression. Otherwise
+ * it will use lossy.
+ *
+ * For examples of encoding an image to a file or to a block of memory,
+ * see tools/ToolUtils.h.
+ */
+SK_API bool SkEncodeImage(SkWStream* dst, const SkPixmap& src,
+                          SkEncodedImageFormat format, int quality);
+
+/**
+ * The following helper function wraps SkEncodeImage().
+ */
+SK_API bool SkEncodeImage(SkWStream* dst, const SkBitmap& src, SkEncodedImageFormat f, int q);
+
+/**
+ * Encode SkPixmap in the given binary image format.
+ *
+ * @param  src     source pixels.
+ * @param  format  image format, not all formats are supported.
+ * @param  quality range from 0-100, this is supported by jpeg and webp.
+ *                 higher values correspond to improved visual quality, but less compression.
+ *
+ * @return encoded data or nullptr if input is bad or format is unsupported.
+ *
+ * Will always return nullptr if Skia is compiled without image
+ * encoders.
+ *
+ * For SkEncodedImageFormat::kWEBP, if quality is 100, it will use lossless compression. Otherwise
+ * it will use lossy.
+ */
+SK_API sk_sp<SkData> SkEncodePixmap(const SkPixmap& src, SkEncodedImageFormat format, int quality);
+
+/**
+ *  Helper that extracts the pixmap from the bitmap, and then calls SkEncodePixmap()
+ */
+SK_API sk_sp<SkData> SkEncodeBitmap(const SkBitmap& src, SkEncodedImageFormat format, int quality);
+
+#endif  // SkImageEncoder_DEFINED

package/cpp/skia/include/core/SkImageFilter.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageFilter_DEFINED
+#define SkImageFilter_DEFINED
+
+#include "include/core/SkFlattenable.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkRect.h"
+
+class SkColorFilter;
+
+/**
+ *  Base class for image filters. If one is installed in the paint, then all drawing occurs as
+ *  usual, but it is as if the drawing happened into an offscreen (before the xfermode is applied).
+ *  This offscreen bitmap will then be handed to the imagefilter, who in turn creates a new bitmap
+ *  which is what will finally be drawn to the device (using the original xfermode).
+ *
+ *  The local space of image filters matches the local space of the drawn geometry. For instance if
+ *  there is rotation on the canvas, the blur will be computed along those rotated axes and not in
+ *  the device space. In order to achieve this result, the actual drawing of the geometry may happen
+ *  in an unrotated coordinate system so that the filtered image can be computed more easily, and
+ *  then it will be post transformed to match what would have been produced if the geometry were
+ *  drawn with the total canvas matrix to begin with.
+ */
+class SK_API SkImageFilter : public SkFlattenable {
+public:
+    enum MapDirection {
+        kForward_MapDirection,
+        kReverse_MapDirection,
+    };
+    /**
+     * Map a device-space rect recursively forward or backward through the filter DAG.
+     * kForward_MapDirection is used to determine which pixels of the destination canvas a source
+     * image rect would touch after filtering. kReverse_MapDirection is used to determine which rect
+     * of the source image would be required to fill the given rect (typically, clip bounds). Used
+     * for clipping and temp-buffer allocations, so the result need not be exact, but should never
+     * be smaller than the real answer. The default implementation recursively unions all input
+     * bounds, or returns the source rect if no inputs.
+     *
+     * In kReverse mode, 'inputRect' is the device-space bounds of the input pixels. In kForward
+     * mode it should always be null. If 'inputRect' is null in kReverse mode the resulting answer
+     * may be incorrect.
+     */
+    SkIRect filterBounds(const SkIRect& src, const SkMatrix& ctm,
+                         MapDirection, const SkIRect* inputRect = nullptr) const;
+
+    /**
+     *  Returns whether this image filter is a color filter and puts the color filter into the
+     *  "filterPtr" parameter if it can. Does nothing otherwise.
+     *  If this returns false, then the filterPtr is unchanged.
+     *  If this returns true, then if filterPtr is not null, it must be set to a ref'd colorfitler
+     *  (i.e. it may not be set to NULL).
+     */
+    bool isColorFilterNode(SkColorFilter** filterPtr) const;
+
+    // DEPRECATED : use isColorFilterNode() instead
+    bool asColorFilter(SkColorFilter** filterPtr) const {
+        return this->isColorFilterNode(filterPtr);
+    }
+
+    /**
+     *  Returns true (and optionally returns a ref'd filter) if this imagefilter can be completely
+     *  replaced by the returned colorfilter. i.e. the two effects will affect drawing in the same
+     *  way.
+     */
+    bool asAColorFilter(SkColorFilter** filterPtr) const;
+
+    /**
+     *  Returns the number of inputs this filter will accept (some inputs can be NULL).
+     */
+    int 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* getInput(int i) const;
+
+    // Default impl returns union of all input bounds.
+    virtual SkRect computeFastBounds(const SkRect& bounds) const;
+
+    // Can this filter DAG compute the resulting bounds of an object-space rectangle?
+    bool canComputeFastBounds() const;
+
+    /**
+     *  If this filter can be represented by another filter + a localMatrix, return that filter,
+     *  else return null.
+     */
+    sk_sp<SkImageFilter> makeWithLocalMatrix(const SkMatrix& matrix) const;
+
+    static sk_sp<SkImageFilter> Deserialize(const void* data, size_t size,
+                                          const SkDeserialProcs* procs = nullptr) {
+        return sk_sp<SkImageFilter>(static_cast<SkImageFilter*>(
+                SkFlattenable::Deserialize(kSkImageFilter_Type, data, size, procs).release()));
+    }
+
+protected:
+
+    sk_sp<SkImageFilter> refMe() const {
+        return sk_ref_sp(const_cast<SkImageFilter*>(this));
+    }
+
+private:
+    friend class SkImageFilter_Base;
+
+    using INHERITED = SkFlattenable;
+};
+
+#endif

package/cpp/skia/include/core/SkImageGenerator.h

@@ -0,0 +1,216 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageGenerator_DEFINED
+#define SkImageGenerator_DEFINED
+
+#include "include/core/SkBitmap.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkYUVAPixmaps.h"
+
+#include <optional>
+
+class GrRecordingContext;
+class GrSurfaceProxyView;
+class GrSamplerState;
+class SkBitmap;
+class SkData;
+class SkMatrix;
+class SkPaint;
+class SkPicture;
+
+enum class GrImageTexGenPolicy : int;
+
+class SK_API SkImageGenerator {
+public:
+    /**
+     *  The PixelRef which takes ownership of this SkImageGenerator
+     *  will call the image generator's destructor.
+     */
+    virtual ~SkImageGenerator() { }
+
+    uint32_t uniqueID() const { return fUniqueID; }
+
+    /**
+     *  Return a ref to the encoded (i.e. compressed) representation
+     *  of this data.
+     *
+     *  If non-NULL is returned, the caller is responsible for calling
+     *  unref() on the data when it is finished.
+     */
+    sk_sp<SkData> refEncodedData() {
+        return this->onRefEncodedData();
+    }
+
+    /**
+     *  Return the ImageInfo associated with this generator.
+     */
+    const SkImageInfo& getInfo() const { return fInfo; }
+
+    /**
+     *  Can this generator be used to produce images that will be drawable to the specified context
+     *  (or to CPU, if context is nullptr)?
+     */
+    bool isValid(GrRecordingContext* context) const {
+        return this->onIsValid(context);
+    }
+
+    /**
+     *  Decode into the given pixels, a block of memory of size at
+     *  least (info.fHeight - 1) * rowBytes + (info.fWidth *
+     *  bytesPerPixel)
+     *
+     *  Repeated calls to this function should give the same results,
+     *  allowing the PixelRef to be immutable.
+     *
+     *  @param info A description of the format
+     *         expected by the caller.  This can simply be identical
+     *         to the info returned by getInfo().
+     *
+     *         This contract also allows the caller to specify
+     *         different output-configs, which the implementation can
+     *         decide to support or not.
+     *
+     *         A size that does not match getInfo() implies a request
+     *         to scale. If the generator cannot perform this scale,
+     *         it will return false.
+     *
+     *  @return true on success.
+     */
+    bool getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes);
+
+    bool getPixels(const SkPixmap& pm) {
+        return this->getPixels(pm.info(), pm.writable_addr(), pm.rowBytes());
+    }
+
+    /**
+     *  If decoding to YUV is supported, this returns true. Otherwise, this
+     *  returns false and the caller will ignore output parameter yuvaPixmapInfo.
+     *
+     * @param  supportedDataTypes Indicates the data type/planar config combinations that are
+     *                            supported by the caller. If the generator supports decoding to
+     *                            YUV(A), but not as a type in supportedDataTypes, this method
+     *                            returns false.
+     *  @param yuvaPixmapInfo Output parameter that specifies the planar configuration, subsampling,
+     *                        orientation, chroma siting, plane color types, and row bytes.
+     */
+    bool queryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes& supportedDataTypes,
+                       SkYUVAPixmapInfo* yuvaPixmapInfo) const;
+
+    /**
+     *  Returns true on success and false on failure.
+     *  This always attempts to perform a full decode. To get the planar
+     *  configuration without decoding use queryYUVAInfo().
+     *
+     *  @param yuvaPixmaps  Contains preallocated pixmaps configured according to a successful call
+     *                      to queryYUVAInfo().
+     */
+    bool getYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps);
+
+#if SK_SUPPORT_GPU
+    /**
+     *  If the generator can natively/efficiently return its pixels as a GPU image (backed by a
+     *  texture) this will return that image. If not, this will return NULL.
+     *
+     *  This routine also supports retrieving only a subset of the pixels. That subset is specified
+     *  by the following rectangle:
+     *
+     *      subset = SkIRect::MakeXYWH(origin.x(), origin.y(), info.width(), info.height())
+     *
+     *  If subset is not contained inside the generator's bounds, this returns false.
+     *
+     *      whole = SkIRect::MakeWH(getInfo().width(), getInfo().height())
+     *      if (!whole.contains(subset)) {
+     *          return false;
+     *      }
+     *
+     *  Regarding the GrRecordingContext parameter:
+     *
+     *  It must be non-NULL. The generator should only succeed if:
+     *  - its internal context is the same
+     *  - it can somehow convert its texture into one that is valid for the provided context.
+     *
+     *  If the willNeedMipMaps flag is true, the generator should try to create a TextureProxy that
+     *  at least has the mip levels allocated and the base layer filled in. If this is not possible,
+     *  the generator is allowed to return a non mipped proxy, but this will have some additional
+     *  overhead in later allocating mips and copying of the base layer.
+     *
+     *  GrImageTexGenPolicy determines whether or not a new texture must be created (and its budget
+     *  status) or whether this may (but is not required to) return a pre-existing texture that is
+     *  retained by the generator (kDraw).
+     */
+    GrSurfaceProxyView generateTexture(GrRecordingContext*, const SkImageInfo& info,
+                                       const SkIPoint& origin, GrMipmapped, GrImageTexGenPolicy);
+
+#endif
+
+    /**
+     *  If the default image decoder system can interpret the specified (encoded) data, then
+     *  this returns a new ImageGenerator for it. Otherwise this returns NULL. Either way
+     *  the caller is still responsible for managing their ownership of the data.
+     *  By default, images will be converted to premultiplied pixels. The alpha type can be
+     *  overridden by specifying kPremul_SkAlphaType or kUnpremul_SkAlphaType. Specifying
+     *  kOpaque_SkAlphaType is not supported, and will return NULL.
+     */
+    static std::unique_ptr<SkImageGenerator> MakeFromEncoded(
+            sk_sp<SkData>, std::optional<SkAlphaType> = std::nullopt);
+
+    /** Return a new image generator backed by the specified picture.  If the size is empty or
+     *  the picture is NULL, this returns NULL.
+     *  The optional matrix and paint arguments are passed to drawPicture() at rasterization
+     *  time.
+     */
+    static std::unique_ptr<SkImageGenerator> MakeFromPicture(const SkISize&, sk_sp<SkPicture>,
+                                                             const SkMatrix*, const SkPaint*,
+                                                             SkImage::BitDepth,
+                                                             sk_sp<SkColorSpace>);
+
+protected:
+    static constexpr int kNeedNewImageUniqueID = 0;
+
+    SkImageGenerator(const SkImageInfo& info, uint32_t uniqueId = kNeedNewImageUniqueID);
+
+    virtual sk_sp<SkData> onRefEncodedData() { return nullptr; }
+    struct Options {};
+    virtual bool onGetPixels(const SkImageInfo&, void*, size_t, const Options&) { return false; }
+    virtual bool onIsValid(GrRecordingContext*) const { return true; }
+    virtual bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
+                                 SkYUVAPixmapInfo*) const { return false; }
+    virtual bool onGetYUVAPlanes(const SkYUVAPixmaps&) { return false; }
+#if SK_SUPPORT_GPU
+    // returns nullptr
+    virtual GrSurfaceProxyView onGenerateTexture(GrRecordingContext*, const SkImageInfo&,
+                                                 const SkIPoint&, GrMipmapped, GrImageTexGenPolicy);
+
+    // Most internal SkImageGenerators produce textures and views that use kTopLeft_GrSurfaceOrigin.
+    // If the generator may produce textures with different origins (e.g.
+    // GrAHardwareBufferImageGenerator) it should override this function to return the correct
+    // origin.
+    virtual GrSurfaceOrigin origin() const { return kTopLeft_GrSurfaceOrigin; }
+#endif
+
+private:
+    const SkImageInfo fInfo;
+    const uint32_t fUniqueID;
+
+    friend class SkImage_Lazy;
+
+    // This is our default impl, which may be different on different platforms.
+    // It is called from NewFromEncoded() after it has checked for any runtime factory.
+    // The SkData will never be NULL, as that will have been checked by NewFromEncoded.
+    static std::unique_ptr<SkImageGenerator> MakeFromEncodedImpl(sk_sp<SkData>,
+                                                                 std::optional<SkAlphaType>);
+
+    SkImageGenerator(SkImageGenerator&&) = delete;
+    SkImageGenerator(const SkImageGenerator&) = delete;
+    SkImageGenerator& operator=(SkImageGenerator&&) = delete;
+    SkImageGenerator& operator=(const SkImageGenerator&) = delete;
+};
+
+#endif  // SkImageGenerator_DEFINED