@shopify/react-native-skia 0.1.115

package/cpp/skia/include/encode/SkEncoder.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncoder_DEFINED
+#define SkEncoder_DEFINED
+
+#include "include/core/SkPixmap.h"
+#include "include/private/SkNoncopyable.h"
+#include "include/private/SkTemplates.h"
+
+class SK_API SkEncoder : SkNoncopyable {
+public:
+
+    /**
+     *  Encode |numRows| rows of input.  If the caller requests more rows than are remaining
+     *  in the src, this will encode all of the remaining rows.  |numRows| must be greater
+     *  than zero.
+     */
+    bool encodeRows(int numRows);
+
+    virtual ~SkEncoder() {}
+
+protected:
+
+    virtual bool onEncodeRows(int numRows) = 0;
+
+    SkEncoder(const SkPixmap& src, size_t storageBytes)
+        : fSrc(src)
+        , fCurrRow(0)
+        , fStorage(storageBytes)
+    {}
+
+    const SkPixmap&        fSrc;
+    int                    fCurrRow;
+    SkAutoTMalloc<uint8_t> fStorage;
+};
+
+#endif

package/cpp/skia/include/encode/SkJpegEncoder.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegEncoder_DEFINED
+#define SkJpegEncoder_DEFINED
+
+#include "include/encode/SkEncoder.h"
+
+class SkJpegEncoderMgr;
+class SkWStream;
+
+class SK_API SkJpegEncoder : public SkEncoder {
+public:
+
+    enum class AlphaOption {
+        kIgnore,
+        kBlendOnBlack,
+    };
+
+    enum class Downsample {
+        /**
+         *  Reduction by a factor of two in both the horizontal and vertical directions.
+         */
+        k420,
+
+        /**
+         *  Reduction by a factor of two in the horizontal direction.
+         */
+        k422,
+
+        /**
+         *  No downsampling.
+         */
+        k444,
+    };
+
+    struct Options {
+        /**
+         *  |fQuality| must be in [0, 100] where 0 corresponds to the lowest quality.
+         */
+        int fQuality = 100;
+
+        /**
+         *  Choose the downsampling factor for the U and V components.  This is only
+         *  meaningful if the |src| is not kGray, since kGray will not be encoded as YUV.
+         *
+         *  Our default value matches the libjpeg-turbo default.
+         */
+        Downsample fDownsample = Downsample::k420;
+
+        /**
+         *  Jpegs must be opaque.  This instructs the encoder on how to handle input
+         *  images with alpha.
+         *
+         *  The default is to ignore the alpha channel and treat the image as opaque.
+         *  Another option is to blend the pixels onto a black background before encoding.
+         *  In the second case, the encoder supports linear or legacy blending.
+         */
+        AlphaOption fAlphaOption = AlphaOption::kIgnore;
+    };
+
+    /**
+     *  Encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    static bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+
+    /**
+     *  Create a jpeg encoder that will encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  |dst| is unowned but must remain valid for the lifetime of the object.
+     *
+     *  This returns nullptr on an invalid or unsupported |src|.
+     */
+    static std::unique_ptr<SkEncoder> Make(SkWStream* dst, const SkPixmap& src,
+                                           const Options& options);
+
+    ~SkJpegEncoder() override;
+
+protected:
+    bool onEncodeRows(int numRows) override;
+
+private:
+    SkJpegEncoder(std::unique_ptr<SkJpegEncoderMgr>, const SkPixmap& src);
+
+    std::unique_ptr<SkJpegEncoderMgr> fEncoderMgr;
+    using INHERITED = SkEncoder;
+};
+
+#endif

package/cpp/skia/include/encode/SkPngEncoder.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPngEncoder_DEFINED
+#define SkPngEncoder_DEFINED
+
+#include "include/core/SkDataTable.h"
+#include "include/encode/SkEncoder.h"
+
+class SkPngEncoderMgr;
+class SkWStream;
+
+class SK_API SkPngEncoder : public SkEncoder {
+public:
+
+    enum class FilterFlag : int {
+        kZero  = 0x00,
+        kNone  = 0x08,
+        kSub   = 0x10,
+        kUp    = 0x20,
+        kAvg   = 0x40,
+        kPaeth = 0x80,
+        kAll   = kNone | kSub | kUp | kAvg | kPaeth,
+    };
+
+    struct Options {
+        /**
+         *  Selects which filtering strategies to use.
+         *
+         *  If a single filter is chosen, libpng will use that filter for every row.
+         *
+         *  If multiple filters are chosen, libpng will use a heuristic to guess which filter
+         *  will encode smallest, then apply that filter.  This happens on a per row basis,
+         *  different rows can use different filters.
+         *
+         *  Using a single filter (or less filters) is typically faster.  Trying all of the
+         *  filters may help minimize the output file size.
+         *
+         *  Our default value matches libpng's default.
+         */
+        FilterFlag fFilterFlags = FilterFlag::kAll;
+
+        /**
+         *  Must be in [0, 9] where 9 corresponds to maximal compression.  This value is passed
+         *  directly to zlib.  0 is a special case to skip zlib entirely, creating dramatically
+         *  larger pngs.
+         *
+         *  Our default value matches libpng's default.
+         */
+        int fZLibLevel = 6;
+
+        /**
+         *  Represents comments in the tEXt ancillary chunk of the png.
+         *  The 2i-th entry is the keyword for the i-th comment,
+         *  and the (2i + 1)-th entry is the text for the i-th comment.
+         */
+        sk_sp<SkDataTable> fComments;
+    };
+
+    /**
+     *  Encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    static bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+
+    /**
+     *  Create a png encoder that will encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  |dst| is unowned but must remain valid for the lifetime of the object.
+     *
+     *  This returns nullptr on an invalid or unsupported |src|.
+     */
+    static std::unique_ptr<SkEncoder> Make(SkWStream* dst, const SkPixmap& src,
+                                           const Options& options);
+
+    ~SkPngEncoder() override;
+
+protected:
+    bool onEncodeRows(int numRows) override;
+
+    SkPngEncoder(std::unique_ptr<SkPngEncoderMgr>, const SkPixmap& src);
+
+    std::unique_ptr<SkPngEncoderMgr> fEncoderMgr;
+    using INHERITED = SkEncoder;
+};
+
+static inline SkPngEncoder::FilterFlag operator|(SkPngEncoder::FilterFlag x,
+                                                 SkPngEncoder::FilterFlag y) {
+    return (SkPngEncoder::FilterFlag)((int)x | (int)y);
+}
+
+#endif

package/cpp/skia/include/encode/SkWebpEncoder.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkWebpEncoder_DEFINED
+#define SkWebpEncoder_DEFINED
+
+#include "include/encode/SkEncoder.h"
+
+class SkWStream;
+
+namespace SkWebpEncoder {
+
+    enum class Compression {
+        kLossy,
+        kLossless,
+    };
+
+    struct SK_API Options {
+        /**
+         *  |fCompression| determines whether we will use webp lossy or lossless compression.
+         *
+         *  |fQuality| must be in [0.0f, 100.0f].
+         *  If |fCompression| is kLossy, |fQuality| corresponds to the visual quality of the
+         *  encoding.  Decreasing the quality will result in a smaller encoded image.
+         *  If |fCompression| is kLossless, |fQuality| corresponds to the amount of effort
+         *  put into the encoding.  Lower values will compress faster into larger files,
+         *  while larger values will compress slower into smaller files.
+         *
+         *  This scheme is designed to match the libwebp API.
+         */
+        Compression fCompression = Compression::kLossy;
+        float fQuality = 100.0f;
+    };
+
+    /**
+     *  Encode the |src| pixels to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+} // namespace SkWebpEncoder
+
+#endif

package/cpp/skia/include/gpu/GrBackendDrawableInfo.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBackendDrawableInfo_DEFINED
+#define GrBackendDrawableInfo_DEFINED
+
+#include "include/gpu/GrTypes.h"
+
+#include "include/gpu/vk/GrVkTypes.h"
+
+class SK_API GrBackendDrawableInfo {
+public:
+    // Creates an invalid backend drawable info.
+    GrBackendDrawableInfo() : fIsValid(false) {}
+
+    GrBackendDrawableInfo(const GrVkDrawableInfo& info)
+            : fIsValid(true)
+            , fBackend(GrBackendApi::kVulkan)
+            , fVkInfo(info) {}
+
+    // Returns true if the backend texture has been initialized.
+    bool isValid() const { return fIsValid; }
+
+    GrBackendApi backend() const { return fBackend; }
+
+    bool getVkDrawableInfo(GrVkDrawableInfo* outInfo) const {
+        if (this->isValid() && GrBackendApi::kVulkan == fBackend) {
+            *outInfo = fVkInfo;
+            return true;
+        }
+        return false;
+    }
+
+private:
+    bool             fIsValid;
+    GrBackendApi     fBackend;
+    GrVkDrawableInfo fVkInfo;
+};
+
+#endif

package/cpp/skia/include/gpu/GrBackendSemaphore.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBackendSemaphore_DEFINED
+#define GrBackendSemaphore_DEFINED
+
+#include "include/gpu/GrTypes.h"
+
+#include "include/gpu/gl/GrGLTypes.h"
+
+#ifdef SK_METAL
+#include "include/gpu/mtl/GrMtlTypes.h"
+#endif
+
+#ifdef SK_VULKAN
+#include "include/gpu/vk/GrVkTypes.h"
+#endif
+
+#ifdef SK_DIRECT3D
+#include "include/private/GrD3DTypesMinimal.h"
+#endif
+
+/**
+ * Wrapper class for passing into and receiving data from Ganesh about a backend semaphore object.
+ */
+class GrBackendSemaphore {
+public:
+    // For convenience we just set the backend here to OpenGL. The GrBackendSemaphore cannot be used
+    // until either init* is called, which will set the appropriate GrBackend.
+    GrBackendSemaphore()
+            : fBackend(GrBackendApi::kOpenGL), fGLSync(nullptr), fIsInitialized(false) {}
+
+#ifdef SK_DIRECT3D
+    // We only need to specify these if Direct3D is enabled, because it requires special copy
+    // characteristics.
+    ~GrBackendSemaphore();
+    GrBackendSemaphore(const GrBackendSemaphore&);
+    GrBackendSemaphore& operator=(const GrBackendSemaphore&);
+#endif
+
+    void initGL(GrGLsync sync) {
+        fBackend = GrBackendApi::kOpenGL;
+        fGLSync = sync;
+        fIsInitialized = true;
+    }
+
+#ifdef SK_VULKAN
+    void initVulkan(VkSemaphore semaphore) {
+        fBackend = GrBackendApi::kVulkan;
+        fVkSemaphore = semaphore;
+
+        fIsInitialized = true;
+    }
+
+    VkSemaphore vkSemaphore() const {
+        if (!fIsInitialized || GrBackendApi::kVulkan != fBackend) {
+            return VK_NULL_HANDLE;
+        }
+        return fVkSemaphore;
+    }
+#endif
+
+#ifdef SK_METAL
+    // It is the creator's responsibility to ref the MTLEvent passed in here, via __bridge_retained.
+    // The other end will wrap this BackendSemaphore and take the ref, via __bridge_transfer.
+    void initMetal(GrMTLHandle event, uint64_t value) {
+        fBackend = GrBackendApi::kMetal;
+        fMtlEvent = event;
+        fMtlValue = value;
+
+        fIsInitialized = true;
+    }
+
+    GrMTLHandle mtlSemaphore() const {
+        if (!fIsInitialized || GrBackendApi::kMetal != fBackend) {
+            return nullptr;
+        }
+        return fMtlEvent;
+    }
+
+    uint64_t mtlValue() const {
+        if (!fIsInitialized || GrBackendApi::kMetal != fBackend) {
+            return 0;
+        }
+        return fMtlValue;
+    }
+
+#endif
+
+#ifdef SK_DIRECT3D
+    void initDirect3D(const GrD3DFenceInfo& info) {
+        fBackend = GrBackendApi::kDirect3D;
+        this->assignD3DFenceInfo(info);
+        fIsInitialized = true;
+    }
+#endif
+
+    bool isInitialized() const { return fIsInitialized; }
+
+    GrGLsync glSync() const {
+        if (!fIsInitialized || GrBackendApi::kOpenGL != fBackend) {
+            return nullptr;
+        }
+        return fGLSync;
+    }
+
+
+#ifdef SK_DIRECT3D
+    bool getD3DFenceInfo(GrD3DFenceInfo* outInfo) const;
+#endif
+
+private:
+#ifdef SK_DIRECT3D
+    void assignD3DFenceInfo(const GrD3DFenceInfo& info);
+#endif
+
+    GrBackendApi fBackend;
+    union {
+        GrGLsync    fGLSync;
+#ifdef SK_VULKAN
+        VkSemaphore fVkSemaphore;
+#endif
+#ifdef SK_METAL
+        GrMTLHandle fMtlEvent;    // Expected to be an id<MTLEvent>
+#endif
+#ifdef SK_DIRECT3D
+        GrD3DFenceInfo* fD3DFenceInfo;
+#endif
+    };
+#ifdef SK_METAL
+    uint64_t fMtlValue;
+#endif
+    bool fIsInitialized;
+};
+
+#endif