rngine 0.7.2 → 0.8.1

package/shared/skia/include/private/SkDeque.h

@@ -0,0 +1,138 @@
+
+/*
+ * Copyright 2006 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.
+ */
+
+
+#ifndef SkDeque_DEFINED
+#define SkDeque_DEFINED
+
+#include "include/private/SkAPI.h"
+
+#include <cstddef>
+
+/*
+ * The deque class works by blindly creating memory space of a specified element
+ * size. It manages the memory as a doubly linked list of blocks each of which
+ * can contain multiple elements. Pushes and pops add/remove blocks from the
+ * beginning/end of the list as necessary while each block tracks the used
+ * portion of its memory.
+ * One behavior to be aware of is that the pops do not immediately remove an
+ * empty block from the beginning/end of the list (Presumably so push/pop pairs
+ * on the block boundaries don't cause thrashing). This can result in the first/
+ * last element not residing in the first/last block.
+ */
+class SK_API SkDeque {
+public:
+    /**
+     * elemSize specifies the size of each individual element in the deque
+     * allocCount specifies how many elements are to be allocated as a block
+     */
+    explicit SkDeque(size_t elemSize, int allocCount = 1);
+    SkDeque(size_t elemSize, void* storage, size_t storageSize, int allocCount = 1);
+    ~SkDeque();
+
+    bool    empty() const { return 0 == fCount; }
+    int     count() const { return fCount; }
+    size_t  elemSize() const { return fElemSize; }
+
+    const void* front() const { return fFront; }
+    const void* back() const  { return fBack; }
+
+    void* front() { return fFront; }
+    void* back() { return fBack; }
+
+    /**
+     * push_front and push_back return a pointer to the memory space
+     * for the new element
+     */
+    void* push_front();
+    void* push_back();
+
+    void pop_front();
+    void pop_back();
+
+private:
+    struct Block;
+
+public:
+    class Iter {
+    public:
+        enum IterStart {
+            kFront_IterStart,
+            kBack_IterStart,
+        };
+
+        /**
+         * Creates an uninitialized iterator. Must be reset()
+         */
+        Iter();
+
+        Iter(const SkDeque& d, IterStart startLoc);
+        void* next();
+        void* prev();
+
+        void reset(const SkDeque& d, IterStart startLoc);
+
+    private:
+        SkDeque::Block* fCurBlock;
+        char*           fPos;
+        size_t          fElemSize;
+    };
+
+    // Inherit privately from Iter to prevent access to reverse iteration
+    class F2BIter : private Iter {
+    public:
+        F2BIter() {}
+
+        /**
+         * Wrap Iter's 2 parameter ctor to force initialization to the
+         * beginning of the deque
+         */
+        F2BIter(const SkDeque& d) : INHERITED(d, kFront_IterStart) {}
+
+        using Iter::next;
+
+        /**
+         * Wrap Iter::reset to force initialization to the beginning of the
+         * deque
+         */
+        void reset(const SkDeque& d) {
+            this->INHERITED::reset(d, kFront_IterStart);
+        }
+
+    private:
+        using INHERITED = Iter;
+    };
+
+private:
+    // allow unit test to call numBlocksAllocated
+    friend class DequeUnitTestHelper;
+
+    void*   fFront;
+    void*   fBack;
+
+    Block*  fFrontBlock;
+    Block*  fBackBlock;
+    size_t  fElemSize;
+    void*   fInitialStorage;
+    int     fCount;             // number of elements in the deque
+    int     fAllocCount;        // number of elements to allocate per block
+
+    Block*  allocateBlock(int allocCount);
+    void    freeBlock(Block* block);
+
+    /**
+     * This returns the number of chunk blocks allocated by the deque. It
+     * can be used to gauge the effectiveness of the selected allocCount.
+     */
+    int  numBlocksAllocated() const;
+
+    SkDeque(const SkDeque&) = delete;
+    SkDeque& operator=(const SkDeque&) = delete;
+};
+
+#endif

package/shared/skia/include/private/SkEncodedInfo.h

@@ -0,0 +1,249 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncodedInfo_DEFINED
+#define SkEncodedInfo_DEFINED
+
+#include "include/core/SkAlphaType.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkColorType.h"
+#include "include/core/SkData.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkHdrMetadata.h"
+#include "include/private/SkTo.h"
+#include "modules/skcms/skcms.h"
+
+#include <cstdint>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+namespace SkCodecs {
+class ColorProfile;
+}
+
+struct SK_API SkEncodedInfo {
+public:
+    enum Alpha {
+        kOpaque_Alpha,
+        kUnpremul_Alpha,
+
+        // Each pixel is either fully opaque or fully transparent.
+        // There is no difference between requesting kPremul or kUnpremul.
+        kBinary_Alpha,
+    };
+
+    /*
+     * We strive to make the number of components per pixel obvious through
+     * our naming conventions.
+     * Ex: kRGB has 3 components.  kRGBA has 4 components.
+     *
+     * This sometimes results in redundant Alpha and Color information.
+     * Ex: kRGB images must also be kOpaque.
+     */
+    enum Color {
+        // PNG, WBMP
+        kGray_Color,
+
+        // PNG
+        kGrayAlpha_Color,
+
+        // PNG with Skia-specific sBIT
+        // Like kGrayAlpha, except this expects to be treated as
+        // kAlpha_8_SkColorType, which ignores the gray component. If
+        // decoded to full color (e.g. kN32), the gray component is respected
+        // (so it can share code with kGrayAlpha).
+        kXAlpha_Color,
+
+        // PNG
+        // 565 images may be encoded to PNG by specifying the number of
+        // significant bits for each channel.  This is a strange 565
+        // representation because the image is still encoded with 8 bits per
+        // component.
+        k565_Color,
+
+        // PNG, GIF, BMP
+        kPalette_Color,
+
+        // PNG, RAW
+        kRGB_Color,
+        kRGBA_Color,
+
+        // BMP
+        kBGR_Color,
+        kBGRX_Color,
+        kBGRA_Color,
+
+        // JPEG, WEBP
+        kYUV_Color,
+
+        // WEBP
+        kYUVA_Color,
+
+        // JPEG
+        // Photoshop actually writes inverted CMYK data into JPEGs, where zero
+        // represents 100% ink coverage.  For this reason, we treat CMYK JPEGs
+        // as having inverted CMYK.  libjpeg-turbo warns that this may break
+        // other applications, but the CMYK JPEGs we see on the web expect to
+        // be treated as inverted CMYK.
+        kInvertedCMYK_Color,
+        kYCCK_Color,
+    };
+
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent);
+
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent,
+        std::unique_ptr<SkCodecs::ColorProfile> profile);
+
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent,
+        std::unique_ptr<SkCodecs::ColorProfile> profile, int colorDepth);
+
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent,
+        int colorDepth,
+        std::unique_ptr<SkCodecs::ColorProfile> profile, const skhdr::Metadata& hdrMetadata);
+
+    /*
+     * Returns a recommended SkImageInfo.
+     *
+     * TODO: Leave this up to the client.
+     */
+    SkImageInfo makeImageInfo() const;
+
+    int   width() const { return fWidth;  }
+    int  height() const { return fHeight; }
+    Color color() const { return fColor;  }
+    Alpha alpha() const { return fAlpha;  }
+    bool opaque() const { return fAlpha == kOpaque_Alpha; }
+
+    // TODO(https://issues.skia.org/issues/464217864): Remove direct access to the
+    // skcms_ICCProfile and change profileData() to serialize a new profile.
+    const skcms_ICCProfile* profile() const;
+    sk_sp<const SkData> profileData() const;
+    const SkCodecs::ColorProfile* colorProfile() const {
+        return fColorProfile.get();
+    }
+
+    uint8_t bitsPerComponent() const { return fBitsPerComponent; }
+
+    uint8_t bitsPerPixel() const {
+        switch (fColor) {
+            case kGray_Color:
+                return fBitsPerComponent;
+            case kXAlpha_Color:
+            case kGrayAlpha_Color:
+                return 2 * fBitsPerComponent;
+            case kPalette_Color:
+                return fBitsPerComponent;
+            case kRGB_Color:
+            case kBGR_Color:
+            case kYUV_Color:
+            case k565_Color:
+                return 3 * fBitsPerComponent;
+            case kRGBA_Color:
+            case kBGRA_Color:
+            case kBGRX_Color:
+            case kYUVA_Color:
+            case kInvertedCMYK_Color:
+            case kYCCK_Color:
+                return 4 * fBitsPerComponent;
+        }
+        SkASSERT(false);
+        return 0;
+    }
+
+    SkEncodedInfo(const SkEncodedInfo& orig) = delete;
+    SkEncodedInfo& operator=(const SkEncodedInfo&) = delete;
+
+    SkEncodedInfo(SkEncodedInfo&& orig);
+    SkEncodedInfo& operator=(SkEncodedInfo&&);
+
+    // Explicit copy method, to avoid accidental copying.
+    SkEncodedInfo copy() const;
+
+    // Return number of bits of R/G/B channel
+    uint8_t getColorDepth() const {
+        return fColorDepth;
+    }
+
+    // Return the HDR metadata associated with this image. Note that even SDR images can include
+    // HDR metadata (e.g, indicating how to inverse tone map when displayed on an HDR display).
+    const skhdr::Metadata& getHdrMetadata() const {
+        return fHdrMetadata;
+    }
+
+    ~SkEncodedInfo();
+
+private:
+    SkEncodedInfo(
+        int width, int height, Color color, Alpha alpha, uint8_t bitsPerComponent,
+        uint8_t colorDepth,
+        std::unique_ptr<SkCodecs::ColorProfile> profile, const skhdr::Metadata& hdrMetadata);
+
+    static void VerifyColor(Color color, Alpha alpha, int bitsPerComponent) {
+        // Avoid `-Wunused-parameter` warnings on non-debug builds.
+        std::ignore = alpha;
+        std::ignore = bitsPerComponent;
+
+        switch (color) {
+            case kGray_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                return;
+            case kGrayAlpha_Color:
+                SkASSERT(kOpaque_Alpha != alpha);
+                return;
+            case kPalette_Color:
+                SkASSERT(16 != bitsPerComponent);
+                return;
+            case kRGB_Color:
+            case kBGR_Color:
+            case kBGRX_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                SkASSERT(bitsPerComponent >= 8);
+                return;
+            case kYUV_Color:
+            case kInvertedCMYK_Color:
+            case kYCCK_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                SkASSERT(8 == bitsPerComponent);
+                return;
+            case kRGBA_Color:
+                SkASSERT(bitsPerComponent >= 8);
+                return;
+            case kBGRA_Color:
+            case kYUVA_Color:
+                SkASSERT(8 == bitsPerComponent);
+                return;
+            case kXAlpha_Color:
+                SkASSERT(kUnpremul_Alpha == alpha);
+                SkASSERT(8 == bitsPerComponent);
+                return;
+            case k565_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                SkASSERT(8 == bitsPerComponent);
+                return;
+        }
+        SkASSERT(false);  // Unrecognized `color` enum value.
+    }
+
+    int     fWidth;
+    int     fHeight;
+    Color   fColor;
+    Alpha   fAlpha;
+    uint8_t fBitsPerComponent;
+    uint8_t fColorDepth;
+    std::unique_ptr<const SkCodecs::ColorProfile> fColorProfile;
+    skhdr::Metadata                               fHdrMetadata;
+};
+
+#endif

package/shared/skia/include/private/SkEnumBitMask.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEnumBitMask_DEFINED
+#define SkEnumBitMask_DEFINED
+
+#include "include/private/SkAttributes.h"
+
+#include <type_traits>
+
+/**
+ * Wraps an enum that is used for flags, and enables masking with type safety. Example:
+ *
+ *   enum class MyFlags {
+ *       kNone = 0,
+ *       kA = 1,
+ *       kB = 2,
+ *       kC = 4,
+ *   };
+ *
+ *   SK_MAKE_BITMASK_OPS(MyFlags)
+ *
+ *   ...
+ *
+ *       SkEnumBitMask<MyFlags> flags = MyFlags::kA | MyFlags::kB;
+ *
+ *       if (flags & MyFlags::kB) {}
+ *
+ *   ...
+ */
+template<typename E>
+class SkEnumBitMask {
+    using I = std::underlying_type_t<E>;
+public:
+    SK_ALWAYS_INLINE constexpr SkEnumBitMask() : SkEnumBitMask(I(0)) {}
+    SK_ALWAYS_INLINE constexpr SkEnumBitMask(E e) : SkEnumBitMask(static_cast<I>(e)) {}
+
+    SK_ALWAYS_INLINE constexpr explicit operator bool() const { return fValue; }
+    SK_ALWAYS_INLINE constexpr I value() const                { return fValue; }
+
+    SK_ALWAYS_INLINE constexpr bool operator==(SkEnumBitMask m) const { return fValue == m.fValue; }
+    SK_ALWAYS_INLINE constexpr bool operator!=(SkEnumBitMask m) const { return fValue != m.fValue; }
+
+    SK_ALWAYS_INLINE constexpr SkEnumBitMask operator|(SkEnumBitMask m) const {
+        return SkEnumBitMask(fValue | m.fValue);
+    }
+    SK_ALWAYS_INLINE constexpr SkEnumBitMask operator&(SkEnumBitMask m) const {
+        return SkEnumBitMask(fValue & m.fValue);
+    }
+    SK_ALWAYS_INLINE constexpr SkEnumBitMask operator^(SkEnumBitMask m) const {
+        return SkEnumBitMask(fValue ^ m.fValue);
+    }
+    SK_ALWAYS_INLINE constexpr SkEnumBitMask operator~() const { return SkEnumBitMask(~fValue); }
+
+    SK_ALWAYS_INLINE SkEnumBitMask& operator|=(SkEnumBitMask m) { return *this = *this | m; }
+    SK_ALWAYS_INLINE SkEnumBitMask& operator&=(SkEnumBitMask m) { return *this = *this & m; }
+    SK_ALWAYS_INLINE SkEnumBitMask& operator^=(SkEnumBitMask m) { return *this = *this ^ m; }
+
+private:
+    SK_ALWAYS_INLINE constexpr explicit SkEnumBitMask(I value) : fValue(value) {}
+
+    I fValue;
+};
+
+/**
+ * Defines functions that make it possible to use bitwise operators on an enum.
+ */
+#define SK_MAKE_BITMASK_OPS(E)                                        \
+    [[maybe_unused]] constexpr SkEnumBitMask<E> operator|(E a, E b) { \
+        return SkEnumBitMask<E>(a) | b;                               \
+    }                                                                 \
+    [[maybe_unused]] constexpr SkEnumBitMask<E> operator&(E a, E b) { \
+        return SkEnumBitMask<E>(a) & b;                               \
+    }                                                                 \
+    [[maybe_unused]] constexpr SkEnumBitMask<E> operator^(E a, E b) { \
+        return SkEnumBitMask<E>(a) ^ b;                               \
+    }                                                                 \
+    [[maybe_unused]] constexpr SkEnumBitMask<E> operator~(E e) {      \
+        return ~SkEnumBitMask<E>(e);                                  \
+    }
+
+#define SK_DECL_BITMASK_OPS_FRIENDS(E)                 \
+    friend constexpr SkEnumBitMask<E> operator|(E, E); \
+    friend constexpr SkEnumBitMask<E> operator&(E, E); \
+    friend constexpr SkEnumBitMask<E> operator^(E, E); \
+    friend constexpr SkEnumBitMask<E> operator~(E);
+
+#endif  // SkEnumBitMask_DEFINED

package/shared/skia/include/private/SkExif.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkExif_DEFINED
+#define SkExif_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <cstdint>
+#include <optional>
+
+class SkData;
+
+namespace SkExif {
+
+// Tag values that are parsed by Parse and stored in Metadata.
+static constexpr uint16_t kOriginTag = 0x112;
+static constexpr uint16_t kResolutionUnitTag = 0x0128;
+static constexpr uint16_t kXResolutionTag = 0x011a;
+static constexpr uint16_t kYResolutionTag = 0x011b;
+static constexpr uint16_t kPixelXDimensionTag = 0xa002;
+static constexpr uint16_t kPixelYDimensionTag = 0xa003;
+
+struct Metadata {
+    // The image orientation.
+    std::optional<SkEncodedOrigin> fOrigin;
+
+    // The HDR headroom property.
+    // https://developer.apple.com/documentation/appkit/images_and_pdf/applying_apple_hdr_effect_to_your_photos
+    std::optional<float> fHdrHeadroom;
+
+    // Resolution.
+    std::optional<uint16_t> fResolutionUnit;
+    std::optional<float> fXResolution;
+    std::optional<float> fYResolution;
+
+    // Size in pixels.
+    std::optional<uint32_t> fPixelXDimension;
+    std::optional<uint32_t> fPixelYDimension;
+};
+
+/*
+ * Parse the metadata specified in |data| and write them to |metadata|. Stop only at an
+ * unrecoverable error (allow truncated input).
+ */
+void SK_API Parse(Metadata& metadata, const SkData* data);
+
+/*
+ * Write exif data that includes the values in |metadata| and returns it as SkData
+ * untruncated. Return nullptr if a write to the data stream fails or if
+ * |metadata.fHdrHeadroom| has value.
+ * This function cannot write an IFD entry based on the HdrHeadroom value because
+ * the information of maker33 and maker48 are lost in decoding.
+ * For metadata that belongs in a subIFD the function will write it to one and
+ * store it after the root IFD.
+ * Data that does not fit within kSizeEntry, is appended to the end of the data,
+ * after the subIFD if it exists.
+ */
+sk_sp<SkData> WriteExif(Metadata& metadata);
+
+}  // namespace SkExif
+
+#endif