rngine 0.7.2 → 0.8.1

package/shared/skia/include/core/SkUnPreMultiply.h

@@ -0,0 +1,55 @@
+
+/*
+ * Copyright 2008 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 SkUnPreMultiply_DEFINED
+#define SkUnPreMultiply_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkCPUTypes.h"
+
+#include <cstdint>
+
+class SK_API SkUnPreMultiply {
+public:
+    typedef uint32_t Scale;
+
+    // index this table with alpha [0..255]
+    static const Scale* GetScaleTable() {
+        return gTable;
+    }
+
+    static Scale GetScale(U8CPU alpha) {
+        SkASSERT(alpha <= 255);
+        return gTable[alpha];
+    }
+
+    /** Usage:
+
+        const Scale* table = SkUnPreMultiply::GetScaleTable();
+
+        for (...) {
+            unsigned a = ...
+            SkUnPreMultiply::Scale scale = table[a];
+
+            red = SkUnPreMultiply::ApplyScale(scale, red);
+            ...
+            // now red is unpremultiplied
+        }
+    */
+    static U8CPU ApplyScale(Scale scale, U8CPU component) {
+        SkASSERT(component <= 255);
+        return (scale * component + (1 << 23)) >> 24;
+    }
+
+    static SkColor PMColorToColor(SkPMColor c);
+
+private:
+    static const uint32_t gTable[256];
+};
+
+#endif

package/shared/skia/include/core/SkVertices.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkVertices_DEFINED
+#define SkVertices_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+class SkVerticesPriv;
+
+/**
+ * An immutable set of vertex data that can be used with SkCanvas::drawVertices.
+ */
+class SK_API SkVertices : public SkNVRefCnt<SkVertices> {
+    struct Desc;
+    struct Sizes;
+public:
+    enum VertexMode {
+        kTriangles_VertexMode,
+        kTriangleStrip_VertexMode,
+        kTriangleFan_VertexMode,
+
+        kLast_VertexMode = kTriangleFan_VertexMode,
+    };
+
+    /**
+     *  Create a vertices by copying the specified arrays. texs, colors may be nullptr,
+     *  and indices is ignored if indexCount == 0.
+     */
+    static sk_sp<SkVertices> MakeCopy(VertexMode mode, int vertexCount,
+                                      const SkPoint positions[],
+                                      const SkPoint texs[],
+                                      const SkColor colors[],
+                                      int indexCount,
+                                      const uint16_t indices[]);
+
+    static sk_sp<SkVertices> MakeCopy(VertexMode mode, int vertexCount,
+                                      const SkPoint positions[],
+                                      const SkPoint texs[],
+                                      const SkColor colors[]) {
+        return MakeCopy(mode,
+                        vertexCount,
+                        positions,
+                        texs,
+                        colors,
+                        0,
+                        nullptr);
+    }
+
+    enum BuilderFlags {
+        kHasTexCoords_BuilderFlag   = 1 << 0,
+        kHasColors_BuilderFlag      = 1 << 1,
+    };
+    class SK_API Builder {
+    public:
+        Builder(VertexMode mode, int vertexCount, int indexCount, uint32_t flags);
+
+        bool isValid() const { return fVertices != nullptr; }
+
+        SkPoint* positions();
+        uint16_t* indices();        // returns null if there are no indices
+
+        // If we have custom attributes, these will always be null
+        SkPoint* texCoords();       // returns null if there are no texCoords
+        SkColor* colors();          // returns null if there are no colors
+
+        // Detach the built vertices object. After the first call, this will always return null.
+        sk_sp<SkVertices> detach();
+
+    private:
+        Builder(const Desc&);
+
+        void init(const Desc&);
+
+        // holds a partially complete object. only completed in detach()
+        sk_sp<SkVertices> fVertices;
+        // Extra storage for intermediate vertices in the case where the client specifies indexed
+        // triangle fans. These get converted to indexed triangles when the Builder is finalized.
+        std::unique_ptr<uint8_t[]> fIntermediateFanIndices;
+
+        friend class SkVertices;
+        friend class SkVerticesPriv;
+    };
+
+    uint32_t uniqueID() const { return fUniqueID; }
+    const SkRect& bounds() const { return fBounds; }
+
+    // returns approximate byte size of the vertices object
+    size_t approximateSize() const;
+
+    // Provides access to functions that aren't part of the public API.
+    SkVerticesPriv priv();
+    const SkVerticesPriv priv() const;  // NOLINT(readability-const-return-type)
+
+private:
+    SkVertices() {}
+
+    friend class SkVerticesPriv;
+
+    // these are needed since we've manually sized our allocation (see Builder::init)
+    friend class SkNVRefCnt<SkVertices>;
+    void operator delete(void* p);
+
+    Sizes getSizes() const;
+
+    // we store this first, to pair with the refcnt in our base-class, so we don't have an
+    // unnecessary pad between it and the (possibly 8-byte aligned) ptrs.
+    uint32_t fUniqueID;
+
+    // these point inside our allocation, so none of these can be "freed"
+    SkPoint*     fPositions;        // [vertexCount]
+    uint16_t*    fIndices;          // [indexCount] or null
+    SkPoint*     fTexs;             // [vertexCount] or null
+    SkColor*     fColors;           // [vertexCount] or null
+
+    SkRect  fBounds;    // computed to be the union of the fPositions[]
+    int     fVertexCount;
+    int     fIndexCount;
+
+    VertexMode fMode;
+    // below here is where the actual array data is stored.
+};
+
+#endif

package/shared/skia/include/core/SkYUVAInfo.h

@@ -0,0 +1,311 @@
+/*
+ * 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 SkYUVAInfo_DEFINED
+#define SkYUVAInfo_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <tuple>
+
+/**
+ * Specifies the structure of planes for a YUV image with optional alpha. The actual planar data
+ * is not part of this structure and depending on usage is in external textures or pixmaps.
+ */
+class SK_API SkYUVAInfo {
+public:
+    enum YUVAChannels { kY, kU, kV, kA, kLast = kA };
+    static constexpr int kYUVAChannelCount = static_cast<int>(YUVAChannels::kLast + 1);
+
+    struct YUVALocation;  // For internal use.
+    using YUVALocations = std::array<YUVALocation, kYUVAChannelCount>;
+
+    /**
+     * Specifies how YUV (and optionally A) are divided among planes. Planes are separated by
+     * underscores in the enum value names. Within each plane the pixmap/texture channels are
+     * mapped to the YUVA channels in the order specified, e.g. for kY_UV Y is in channel 0 of plane
+     * 0, U is in channel 0 of plane 1, and V is in channel 1 of plane 1. Channel ordering
+     * within a pixmap/texture given the channels it contains:
+     * A:                       0:A
+     * Luminance/Gray:          0:Gray
+     * Luminance/Gray + Alpha:  0:Gray, 1:A
+     * RG                       0:R,    1:G
+     * RGB                      0:R,    1:G, 2:B
+     * RGBA                     0:R,    1:G, 2:B, 3:A
+     */
+    enum class PlaneConfig {
+        kUnknown,
+
+        kY_U_V,    ///< Plane 0: Y, Plane 1: U,  Plane 2: V
+        kY_V_U,    ///< Plane 0: Y, Plane 1: V,  Plane 2: U
+        kY_UV,     ///< Plane 0: Y, Plane 1: UV
+        kY_VU,     ///< Plane 0: Y, Plane 1: VU
+        kYUV,      ///< Plane 0: YUV
+        kUYV,      ///< Plane 0: UYV
+
+        kY_U_V_A,  ///< Plane 0: Y, Plane 1: U,  Plane 2: V, Plane 3: A
+        kY_V_U_A,  ///< Plane 0: Y, Plane 1: V,  Plane 2: U, Plane 3: A
+        kY_UV_A,   ///< Plane 0: Y, Plane 1: UV, Plane 2: A
+        kY_VU_A,   ///< Plane 0: Y, Plane 1: VU, Plane 2: A
+        kYUVA,     ///< Plane 0: YUVA
+        kUYVA,     ///< Plane 0: UYVA
+
+        kLast = kUYVA
+    };
+
+    /**
+     * UV subsampling is also specified in the enum value names using J:a:b notation (e.g. 4:2:0 is
+     * 1/2 horizontal and 1/2 vertical resolution for U and V). If alpha is present it is not sub-
+     * sampled. Note that Subsampling values other than k444 are only valid with PlaneConfig values
+     * that have U and V in different planes than Y (and A, if present).
+     */
+    enum class Subsampling {
+        kUnknown,
+
+        k444,    ///< No subsampling. UV values for each Y.
+        k422,    ///< 1 set of UV values for each 2x1 block of Y values.
+        k420,    ///< 1 set of UV values for each 2x2 block of Y values.
+        k440,    ///< 1 set of UV values for each 1x2 block of Y values.
+        k411,    ///< 1 set of UV values for each 4x1 block of Y values.
+        k410,    ///< 1 set of UV values for each 4x2 block of Y values.
+
+        kLast = k410
+    };
+
+    /**
+     * Describes how subsampled chroma values are sited relative to luma values.
+     *
+     * Currently only centered siting is supported but will expand to support additional sitings.
+     */
+    enum class Siting {
+        /**
+         * Subsampled chroma value is sited at the center of the block of corresponding luma values.
+         */
+        kCentered,
+    };
+
+    static constexpr int kMaxPlanes = 4;
+
+    /** ratio of Y/A values to U/V values in x and y. */
+    static std::tuple<int, int> SubsamplingFactors(Subsampling);
+
+    /**
+     * SubsamplingFactors(Subsampling) if planedIdx refers to a U/V plane and otherwise {1, 1} if
+     * inputs are valid. Invalid inputs consist of incompatible PlaneConfig/Subsampling/planeIdx
+     * combinations. {0, 0} is returned for invalid inputs.
+     */
+    static std::tuple<int, int> PlaneSubsamplingFactors(PlaneConfig, Subsampling, int planeIdx);
+
+    /**
+     * Given image dimensions, a planer configuration, subsampling, and origin, determine the
+     * expected size of each plane. Returns the number of expected planes. planeDimensions[0]
+     * through planeDimensions[<ret>] are written. The input image dimensions are as displayed
+     * (after the planes have been transformed to the intended display orientation). The plane
+     * dimensions are output as the planes are stored in memory (may be rotated from image
+     * dimensions).
+     */
+    static int PlaneDimensions(SkISize imageDimensions,
+                               PlaneConfig,
+                               Subsampling,
+                               SkEncodedOrigin,
+                               SkISize planeDimensions[kMaxPlanes]);
+
+    /** Number of planes for a given PlaneConfig. */
+    static constexpr int NumPlanes(PlaneConfig);
+
+    /**
+     * Number of Y, U, V, A channels in the ith plane for a given PlaneConfig (or 0 if i is
+     * invalid).
+     */
+    static constexpr int NumChannelsInPlane(PlaneConfig, int i);
+
+    /**
+     * Given a PlaneConfig and a set of channel flags for each plane, convert to YUVALocations
+     * representation. Fails if channel flags aren't valid for the PlaneConfig (i.e. don't have
+     * enough channels in a plane) by returning an invalid set of locations (plane indices are -1).
+     */
+    static YUVALocations GetYUVALocations(PlaneConfig, const uint32_t* planeChannelFlags);
+
+    /** Does the PlaneConfig have alpha values? */
+    static bool HasAlpha(PlaneConfig);
+
+    SkYUVAInfo() = default;
+    SkYUVAInfo(const SkYUVAInfo&) = default;
+
+    /**
+     * 'dimensions' should specify the size of the full resolution image (after planes have been
+     * oriented to how the image is displayed as indicated by 'origin').
+     */
+    SkYUVAInfo(SkISize dimensions,
+               PlaneConfig,
+               Subsampling,
+               SkYUVColorSpace,
+               SkEncodedOrigin origin = kTopLeft_SkEncodedOrigin,
+               Siting sitingX = Siting::kCentered,
+               Siting sitingY = Siting::kCentered);
+
+    SkYUVAInfo& operator=(const SkYUVAInfo& that) = default;
+
+    PlaneConfig planeConfig() const { return fPlaneConfig; }
+    Subsampling subsampling() const { return fSubsampling; }
+
+    std::tuple<int, int> planeSubsamplingFactors(int planeIdx) const {
+        return PlaneSubsamplingFactors(fPlaneConfig, fSubsampling, planeIdx);
+    }
+
+    /**
+     * Dimensions of the full resolution image (after planes have been oriented to how the image
+     * is displayed as indicated by fOrigin).
+     */
+    SkISize dimensions() const { return fDimensions; }
+    int width() const { return fDimensions.width(); }
+    int height() const { return fDimensions.height(); }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVColorSpace; }
+    Siting sitingX() const { return fSitingX; }
+    Siting sitingY() const { return fSitingY; }
+
+    SkEncodedOrigin origin() const { return fOrigin; }
+
+    SkMatrix originMatrix() const {
+        return SkEncodedOriginToMatrix(fOrigin, this->width(), this->height());
+    }
+    SkMatrix inverseOriginMatrix() const {
+        return SkEncodedOriginToMatrixInverse(fOrigin, this->width(), this->height());
+    }
+
+    bool hasAlpha() const { return HasAlpha(fPlaneConfig); }
+
+    /**
+     * Returns the number of planes and initializes planeDimensions[0]..planeDimensions[<ret>] to
+     * the expected dimensions for each plane. Dimensions are as stored in memory, before
+     * transformation to image display space as indicated by origin().
+     */
+    int planeDimensions(SkISize planeDimensions[kMaxPlanes]) const {
+        return PlaneDimensions(fDimensions, fPlaneConfig, fSubsampling, fOrigin, planeDimensions);
+    }
+
+    /**
+     * Given a per-plane row bytes, determine size to allocate for all planes. Optionally retrieves
+     * the per-plane byte sizes in planeSizes if not null. If total size overflows will return
+     * SIZE_MAX and set all planeSizes to SIZE_MAX.
+     */
+    size_t computeTotalBytes(const size_t rowBytes[kMaxPlanes],
+                             size_t planeSizes[kMaxPlanes] = nullptr) const;
+
+    int numPlanes() const { return NumPlanes(fPlaneConfig); }
+
+    int numChannelsInPlane(int i) const { return NumChannelsInPlane(fPlaneConfig, i); }
+
+    /**
+     * Given a set of channel flags for each plane, converts this->planeConfig() to YUVALocations
+     * representation. Fails if the channel flags aren't valid for the PlaneConfig (i.e. don't have
+     * enough channels in a plane) by returning default initialized locations (all plane indices are
+     * -1).
+     */
+    YUVALocations toYUVALocations(const uint32_t* channelFlags) const;
+
+    /**
+     * Makes a SkYUVAInfo that is identical to this one but with the passed Subsampling. If the
+     * passed Subsampling is not k444 and this info's PlaneConfig is not compatible with chroma
+     * subsampling (because Y is in the same plane as UV) then the result will be an invalid
+     * SkYUVAInfo.
+     */
+    SkYUVAInfo makeSubsampling(SkYUVAInfo::Subsampling) const;
+
+    /**
+     * Makes a SkYUVAInfo that is identical to this one but with the passed dimensions. If the
+     * passed dimensions is empty then the result will be an invalid SkYUVAInfo.
+     */
+    SkYUVAInfo makeDimensions(SkISize) const;
+
+    bool operator==(const SkYUVAInfo& that) const;
+    bool operator!=(const SkYUVAInfo& that) const { return !(*this == that); }
+
+    bool isValid() const { return fPlaneConfig != PlaneConfig::kUnknown; }
+
+private:
+    SkISize fDimensions = {0, 0};
+
+    PlaneConfig fPlaneConfig = PlaneConfig::kUnknown;
+    Subsampling fSubsampling = Subsampling::kUnknown;
+
+    SkYUVColorSpace fYUVColorSpace = SkYUVColorSpace::kIdentity_SkYUVColorSpace;
+
+    /**
+     * YUVA data often comes from formats like JPEG that support EXIF orientation.
+     * Code that operates on the raw YUV data often needs to know that orientation.
+     */
+    SkEncodedOrigin fOrigin = kTopLeft_SkEncodedOrigin;
+
+    Siting fSitingX = Siting::kCentered;
+    Siting fSitingY = Siting::kCentered;
+};
+
+constexpr int SkYUVAInfo::NumPlanes(PlaneConfig planeConfig) {
+    switch (planeConfig) {
+        case PlaneConfig::kUnknown: return 0;
+        case PlaneConfig::kY_U_V:   return 3;
+        case PlaneConfig::kY_V_U:   return 3;
+        case PlaneConfig::kY_UV:    return 2;
+        case PlaneConfig::kY_VU:    return 2;
+        case PlaneConfig::kYUV:     return 1;
+        case PlaneConfig::kUYV:     return 1;
+        case PlaneConfig::kY_U_V_A: return 4;
+        case PlaneConfig::kY_V_U_A: return 4;
+        case PlaneConfig::kY_UV_A:  return 3;
+        case PlaneConfig::kY_VU_A:  return 3;
+        case PlaneConfig::kYUVA:    return 1;
+        case PlaneConfig::kUYVA:    return 1;
+    }
+    SkUNREACHABLE;
+}
+
+constexpr int SkYUVAInfo::NumChannelsInPlane(PlaneConfig config, int i) {
+    switch (config) {
+        case PlaneConfig::kUnknown:
+            return 0;
+
+        case SkYUVAInfo::PlaneConfig::kY_U_V:
+        case SkYUVAInfo::PlaneConfig::kY_V_U:
+            return i >= 0 && i < 3 ? 1 : 0;
+        case SkYUVAInfo::PlaneConfig::kY_UV:
+        case SkYUVAInfo::PlaneConfig::kY_VU:
+            switch (i) {
+                case 0:  return 1;
+                case 1:  return 2;
+                default: return 0;
+            }
+        case SkYUVAInfo::PlaneConfig::kYUV:
+        case SkYUVAInfo::PlaneConfig::kUYV:
+            return i == 0 ? 3 : 0;
+        case SkYUVAInfo::PlaneConfig::kY_U_V_A:
+        case SkYUVAInfo::PlaneConfig::kY_V_U_A:
+            return i >= 0 && i < 4 ? 1 : 0;
+        case SkYUVAInfo::PlaneConfig::kY_UV_A:
+        case SkYUVAInfo::PlaneConfig::kY_VU_A:
+            switch (i) {
+                case 0:  return 1;
+                case 1:  return 2;
+                case 2:  return 1;
+                default: return 0;
+            }
+        case SkYUVAInfo::PlaneConfig::kYUVA:
+        case SkYUVAInfo::PlaneConfig::kUYVA:
+            return i == 0 ? 4 : 0;
+    }
+    return 0;
+}
+
+#endif