rngine 0.7.2 → 0.8.1

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

@@ -0,0 +1,55 @@
+/*
+ * 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 SkOnce_DEFINED
+#define SkOnce_DEFINED
+
+#include "include/private/SkThreadAnnotations.h"
+
+#include <atomic>
+#include <cstdint>
+#include <utility>
+
+// SkOnce provides call-once guarantees for Skia, much like std::once_flag/std::call_once().
+//
+// There should be no particularly error-prone gotcha use cases when using SkOnce.
+// It works correctly as a class member, a local, a global, a function-scoped static, whatever.
+
+class SkOnce {
+public:
+    constexpr SkOnce() = default;
+
+    template <typename Fn, typename... Args>
+    void operator()(Fn&& fn, Args&&... args) {
+        auto state = fState.load(std::memory_order_acquire);
+
+        if (state == Done) {
+            return;
+        }
+
+        // If it looks like no one has started calling fn(), try to claim that job.
+        if (state == NotStarted && fState.compare_exchange_strong(state, Claimed,
+                                                                  std::memory_order_relaxed,
+                                                                  std::memory_order_relaxed)) {
+            // Great!  We'll run fn() then notify the other threads by releasing Done into fState.
+            fn(std::forward<Args>(args)...);
+            return fState.store(Done, std::memory_order_release);
+        }
+
+        // Some other thread is calling fn().
+        // We'll just spin here acquiring until it releases Done into fState.
+        SK_POTENTIALLY_BLOCKING_REGION_BEGIN;
+        while (fState.load(std::memory_order_acquire) != Done) { /*spin*/ }
+        SK_POTENTIALLY_BLOCKING_REGION_END;
+    }
+
+private:
+    enum State : uint8_t { NotStarted, Claimed, Done};
+    std::atomic<uint8_t> fState{NotStarted};
+};
+
+#endif  // SkOnce_DEFINED

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathRef_DEFINED
+#define SkPathRef_DEFINED
+
+#include "include/core/SkArc.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkPathTypes.h" // IWYU pragma: keep
+#include "include/core/SkPoint.h"
+#include "include/core/SkRRect.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkDebug.h"
+#include "include/private/SkIDChangeListener.h"
+#include "include/private/SkTArray.h"
+#include "include/private/SkTo.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <tuple>
+
+class SkMatrix;
+
+/*
+ *  These "info" structs are used to return identifying information, when a path
+ *  is queried if it is a special "shape". (e.g. isOval(), isRRect())
+ */
+
+struct SkPathRectInfo {
+    SkRect          fRect;
+    SkPathDirection fDirection;
+    uint8_t         fStartIndex;
+};
+
+struct SkPathOvalInfo {
+    SkRect          fBounds;
+    SkPathDirection fDirection;
+    uint8_t         fStartIndex;
+};
+
+struct SkPathRRectInfo {
+    SkRRect         fRRect;
+    SkPathDirection fDirection;
+    uint8_t         fStartIndex;
+};
+
+/*
+ *  Paths can be tagged with a "Type" -- the IsAType
+ *  This signals that it was built from a high-level shape: oval, rrect, arc, wedge.
+ *  We try to retain this tag, but still build the explicitly line/quad/conic/cubic
+ *  structure need to represent that shape. Thus a user of path can always just look
+ *  at the points and verbs, and draw it correctly.
+ *
+ *  The GPU backend sometimes will sniff the path for this tag/type, and may have a
+ *  more optimal way to draw the shape if they know its "really" an oval or whatever.
+ *
+ *  Path's can also identify as a "rect" -- but we don't store any special tag for this.
+ *
+ *  Here are the special "types" we have APIs for (e.g. isRRect()) and what we store:
+ *
+ *      kGeneral  : no identifying shape, no extra data
+ *      (Rect)    : no tag, but isRect() will examing the points/verbs, and try to
+ *                  deduce that it represents a rect.
+ *      kOval     : the path bounds is also the oval's bounds -- we store the direction
+ *                  and start_index (important for dashing). see SkPathMakers.h
+ *      kRRect    : same as kOval for implicit bounds, direction and start_index.
+ *                  Note: we don't store its radii -- we deduce those when isRRect() is
+ *                        called, by examining the points/verbs.
+ */
+enum class SkPathIsAType : uint8_t {
+    kGeneral,
+    kOval,
+    kRRect,
+};
+
+struct SkPathIsAData {
+    uint8_t         fStartIndex;
+    SkPathDirection fDirection;
+};
+
+#endif

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPixelStorage_DEFINED
+#define SkPixelStorage_DEFINED
+
+#include <cstdint>
+#include <atomic>
+#include "include/core/SkRefCnt.h"
+
+/**
+ * SkPixelStorage is the class representing the storage block for pixel data. It serves as the
+ * abstract source of pixel memory—the 2D array of data—that is read from and written to by
+ * higher-level Skia objects like SkImage and SkSurface.
+ */
+class SkPixelStorage : public SkRefCnt {
+public:
+    enum Type {
+        kTextureProxy,
+        kPixelRef,
+    };
+
+    SkPixelStorage(Type type);
+    ~SkPixelStorage() override = default;
+
+    uint32_t getPixelStorageId() const { return fID; }
+    Type type() const { return fType; }
+
+    uint32_t getContentId() const { return fContentID.load(std::memory_order_relaxed); }
+    uint32_t incrementContentId() { return fContentID.fetch_add(1, std::memory_order_relaxed) + 1; }
+
+private:
+    Type fType;
+    /**
+     * fID is a static identifier that differenciates PixelStorages. This is assigned at
+     * construciton and does not change.
+     */
+    uint32_t fID;
+    /**
+     * fContentID is an identifier that tracks the current state of a PixelStorage. Gets incremented
+     * and read from other objects that want to track the state of a PixelStorage at a given time.
+     */
+    std::atomic<uint32_t> fContentID = 0;
+
+    static uint32_t NextId();
+};
+
+#endif

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

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSLSampleUsage_DEFINED
+#define SkSLSampleUsage_DEFINED
+
+#include "include/core/SkTypes.h"
+
+namespace SkSL {
+
+/**
+ * Represents all of the ways that a fragment processor is sampled by its parent.
+ */
+class SampleUsage {
+public:
+    enum class Kind {
+        // Child is never sampled
+        kNone,
+        // Child is only sampled at the same coordinates as the parent
+        kPassThrough,
+        // Child is sampled with a matrix whose value is uniform
+        kUniformMatrix,
+        // Child is sampled with sk_FragCoord.xy
+        kFragCoord,
+        // Child is sampled using explicit coordinates
+        kExplicit,
+    };
+
+    // Make a SampleUsage that corresponds to no sampling of the child at all
+    SampleUsage() = default;
+
+    SampleUsage(Kind kind, bool hasPerspective) : fKind(kind), fHasPerspective(hasPerspective) {
+        if (kind != Kind::kUniformMatrix) {
+            SkASSERT(!fHasPerspective);
+        }
+    }
+
+    // Child is sampled with a matrix whose value is uniform. The name is fixed.
+    static SampleUsage UniformMatrix(bool hasPerspective) {
+        return SampleUsage(Kind::kUniformMatrix, hasPerspective);
+    }
+
+    static SampleUsage Explicit() {
+        return SampleUsage(Kind::kExplicit, false);
+    }
+
+    static SampleUsage PassThrough() {
+        return SampleUsage(Kind::kPassThrough, false);
+    }
+
+    static SampleUsage FragCoord() { return SampleUsage(Kind::kFragCoord, false); }
+
+    bool operator==(const SampleUsage& that) const {
+        return fKind == that.fKind && fHasPerspective == that.fHasPerspective;
+    }
+
+    bool operator!=(const SampleUsage& that) const { return !(*this == that); }
+
+    // Arbitrary name used by all uniform sampling matrices
+    static const char* MatrixUniformName() { return "matrix"; }
+
+    SampleUsage merge(const SampleUsage& other);
+
+    Kind kind() const { return fKind; }
+
+    bool hasPerspective() const { return fHasPerspective; }
+
+    bool isSampled()       const { return fKind != Kind::kNone; }
+    bool isPassThrough()   const { return fKind == Kind::kPassThrough; }
+    bool isExplicit()      const { return fKind == Kind::kExplicit; }
+    bool isUniformMatrix() const { return fKind == Kind::kUniformMatrix; }
+    bool isFragCoord()     const { return fKind == Kind::kFragCoord; }
+
+private:
+    Kind fKind = Kind::kNone;
+    bool fHasPerspective = false;  // Only valid if fKind is kUniformMatrix
+};
+
+}  // namespace SkSL
+
+#endif

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSafe32_DEFINED
+#define SkSafe32_DEFINED
+
+#include "include/private/SkAssert.h"
+#include "include/private/SkMath.h"
+
+#include <cstdint>
+
+static constexpr int32_t Sk64_pin_to_s32(int64_t x) {
+    return x < SK_MinS32 ? SK_MinS32 : (x > SK_MaxS32 ? SK_MaxS32 : (int32_t)x);
+}
+
+static constexpr int32_t Sk32_sat_add(int32_t a, int32_t b) {
+    return Sk64_pin_to_s32((int64_t)a + (int64_t)b);
+}
+
+static constexpr int32_t Sk32_sat_sub(int32_t a, int32_t b) {
+    return Sk64_pin_to_s32((int64_t)a - (int64_t)b);
+}
+
+// To avoid UBSAN complaints about 2's compliment overflows
+//
+static constexpr int32_t Sk32_can_overflow_add(int32_t a, int32_t b) {
+    return (int32_t)((uint32_t)a + (uint32_t)b);
+}
+static constexpr int32_t Sk32_can_overflow_sub(int32_t a, int32_t b) {
+    return (int32_t)((uint32_t)a - (uint32_t)b);
+}
+
+/**
+ * This is a 'safe' abs for 32-bit integers that asserts when undefined behavior would occur.
+ * SkTAbs (in SkTemplates.h) is a general purpose absolute-value function.
+ */
+static inline int32_t SkAbs32(int32_t value) {
+    SkASSERT(value != SK_NaN32);  // The most negative int32_t can't be negated.
+    if (value < 0) {
+        value = -value;
+    }
+    return value;
+}
+
+#endif

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

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSemaphore_DEFINED
+#define SkSemaphore_DEFINED
+
+#include "include/private/SkAPI.h"
+#include "include/private/SkOnce.h"
+#include "include/private/SkThreadAnnotations.h"
+
+#include <algorithm>
+#include <atomic>
+
+class SkSemaphore {
+public:
+    constexpr SkSemaphore(int count = 0) : fCount(count), fOSSemaphore(nullptr) {}
+
+    // Cleanup the underlying OS semaphore.
+    SK_SPI ~SkSemaphore();
+
+    // Increment the counter n times.
+    // Generally it's better to call signal(n) instead of signal() n times.
+    void signal(int n = 1);
+
+    // Decrement the counter by 1,
+    // then if the counter is < 0, sleep this thread until the counter is >= 0.
+    void wait();
+
+    // If the counter is positive, decrement it by 1 and return true, otherwise return false.
+    SK_SPI bool try_wait();
+
+private:
+    // This implementation follows the general strategy of
+    //     'A Lightweight Semaphore with Partial Spinning'
+    // found here
+    //     http://preshing.com/20150316/semaphores-are-surprisingly-versatile/
+    // That article (and entire blog) are very much worth reading.
+    //
+    // We wrap an OS-provided semaphore with a user-space atomic counter that
+    // lets us avoid interacting with the OS semaphore unless strictly required:
+    // moving the count from >=0 to <0 or vice-versa, i.e. sleeping or waking threads.
+    struct OSSemaphore;
+
+    SK_SPI void osSignal(int n);
+    SK_SPI void osWait();
+
+    std::atomic<int> fCount;
+    SkOnce           fOSSemaphoreOnce;
+    OSSemaphore*     fOSSemaphore;
+};
+
+inline void SkSemaphore::signal(int n) {
+    int prev = fCount.fetch_add(n, std::memory_order_release);
+
+    // We only want to call the OS semaphore when our logical count crosses
+    // from <0 to >=0 (when we need to wake sleeping threads).
+    //
+    // This is easiest to think about with specific examples of prev and n.
+    // If n == 5 and prev == -3, there are 3 threads sleeping and we signal
+    // std::min(-(-3), 5) == 3 times on the OS semaphore, leaving the count at 2.
+    //
+    // If prev >= 0, no threads are waiting, std::min(-prev, n) is always <= 0,
+    // so we don't call the OS semaphore, leaving the count at (prev + n).
+    int toSignal = std::min(-prev, n);
+    if (toSignal > 0) {
+        this->osSignal(toSignal);
+    }
+}
+
+inline void SkSemaphore::wait() {
+    // Since this fetches the value before the subtract, zero and below means that there are no
+    // resources left, so the thread needs to wait.
+    if (fCount.fetch_sub(1, std::memory_order_acquire) <= 0) {
+        SK_POTENTIALLY_BLOCKING_REGION_BEGIN;
+        this->osWait();
+        SK_POTENTIALLY_BLOCKING_REGION_END;
+    }
+}
+
+#endif//SkSemaphore_DEFINED