@shopify/react-native-skia 0.1.115

package/cpp/skia/include/private/SkFloatingPoint.h

@@ -0,0 +1,272 @@
+/*
+ * 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 SkFloatingPoint_DEFINED
+#define SkFloatingPoint_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/SkFloatBits.h"
+#include "include/private/SkSafe_math.h"
+#include <float.h>
+#include <math.h>
+#include <cmath>
+#include <cstring>
+#include <limits>
+
+
+#if defined(SK_LEGACY_FLOAT_RSQRT)
+#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
+    #include <xmmintrin.h>
+#elif defined(SK_ARM_HAS_NEON)
+    #include <arm_neon.h>
+#endif
+#endif
+
+constexpr float SK_FloatSqrt2 = 1.41421356f;
+constexpr float SK_FloatPI    = 3.14159265f;
+constexpr double SK_DoublePI  = 3.14159265358979323846264338327950288;
+
+// C++98 cmath std::pow seems to be the earliest portable way to get float pow.
+// However, on Linux including cmath undefines isfinite.
+// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14608
+static inline float sk_float_pow(float base, float exp) {
+    return powf(base, exp);
+}
+
+#define sk_float_sqrt(x)        sqrtf(x)
+#define sk_float_sin(x)         sinf(x)
+#define sk_float_cos(x)         cosf(x)
+#define sk_float_tan(x)         tanf(x)
+#define sk_float_floor(x)       floorf(x)
+#define sk_float_ceil(x)        ceilf(x)
+#define sk_float_trunc(x)       truncf(x)
+#ifdef SK_BUILD_FOR_MAC
+#    define sk_float_acos(x)    static_cast<float>(acos(x))
+#    define sk_float_asin(x)    static_cast<float>(asin(x))
+#else
+#    define sk_float_acos(x)    acosf(x)
+#    define sk_float_asin(x)    asinf(x)
+#endif
+#define sk_float_atan2(y,x)     atan2f(y,x)
+#define sk_float_abs(x)         fabsf(x)
+#define sk_float_copysign(x, y) copysignf(x, y)
+#define sk_float_mod(x,y)       fmodf(x,y)
+#define sk_float_exp(x)         expf(x)
+#define sk_float_log(x)         logf(x)
+
+constexpr float sk_float_degrees_to_radians(float degrees) {
+    return degrees * (SK_FloatPI / 180);
+}
+
+constexpr float sk_float_radians_to_degrees(float radians) {
+    return radians * (180 / SK_FloatPI);
+}
+
+#define sk_float_round(x) sk_float_floor((x) + 0.5f)
+
+// can't find log2f on android, but maybe that just a tool bug?
+#ifdef SK_BUILD_FOR_ANDROID
+    static inline float sk_float_log2(float x) {
+        const double inv_ln_2 = 1.44269504088896;
+        return (float)(log(x) * inv_ln_2);
+    }
+#else
+    #define sk_float_log2(x)        log2f(x)
+#endif
+
+static inline bool sk_float_isfinite(float x) {
+    return SkFloatBits_IsFinite(SkFloat2Bits(x));
+}
+
+static inline bool sk_floats_are_finite(float a, float b) {
+    return sk_float_isfinite(a) && sk_float_isfinite(b);
+}
+
+static inline bool sk_floats_are_finite(const float array[], int count) {
+    float prod = 0;
+    for (int i = 0; i < count; ++i) {
+        prod *= array[i];
+    }
+    // At this point, prod will either be NaN or 0
+    return prod == 0;   // if prod is NaN, this check will return false
+}
+
+static inline bool sk_float_isinf(float x) {
+    return SkFloatBits_IsInf(SkFloat2Bits(x));
+}
+
+static inline bool sk_float_isnan(float x) {
+    return !(x == x);
+}
+
+#define sk_double_isnan(a)          sk_float_isnan(a)
+
+#define SK_MaxS32FitsInFloat    2147483520
+#define SK_MinS32FitsInFloat    -SK_MaxS32FitsInFloat
+
+#define SK_MaxS64FitsInFloat    (SK_MaxS64 >> (63-24) << (63-24))   // 0x7fffff8000000000
+#define SK_MinS64FitsInFloat    -SK_MaxS64FitsInFloat
+
+/**
+ *  Return the closest int for the given float. Returns SK_MaxS32FitsInFloat for NaN.
+ */
+static inline int sk_float_saturate2int(float x) {
+    x = x < SK_MaxS32FitsInFloat ? x : SK_MaxS32FitsInFloat;
+    x = x > SK_MinS32FitsInFloat ? x : SK_MinS32FitsInFloat;
+    return (int)x;
+}
+
+/**
+ *  Return the closest int for the given double. Returns SK_MaxS32 for NaN.
+ */
+static inline int sk_double_saturate2int(double x) {
+    x = x < SK_MaxS32 ? x : SK_MaxS32;
+    x = x > SK_MinS32 ? x : SK_MinS32;
+    return (int)x;
+}
+
+/**
+ *  Return the closest int64_t for the given float. Returns SK_MaxS64FitsInFloat for NaN.
+ */
+static inline int64_t sk_float_saturate2int64(float x) {
+    x = x < SK_MaxS64FitsInFloat ? x : SK_MaxS64FitsInFloat;
+    x = x > SK_MinS64FitsInFloat ? x : SK_MinS64FitsInFloat;
+    return (int64_t)x;
+}
+
+#define sk_float_floor2int(x)   sk_float_saturate2int(sk_float_floor(x))
+#define sk_float_round2int(x)   sk_float_saturate2int(sk_float_floor((x) + 0.5f))
+#define sk_float_ceil2int(x)    sk_float_saturate2int(sk_float_ceil(x))
+
+#define sk_float_floor2int_no_saturate(x)   (int)sk_float_floor(x)
+#define sk_float_round2int_no_saturate(x)   (int)sk_float_floor((x) + 0.5f)
+#define sk_float_ceil2int_no_saturate(x)    (int)sk_float_ceil(x)
+
+#define sk_double_floor(x)          floor(x)
+#define sk_double_round(x)          floor((x) + 0.5)
+#define sk_double_ceil(x)           ceil(x)
+#define sk_double_floor2int(x)      (int)floor(x)
+#define sk_double_round2int(x)      (int)floor((x) + 0.5)
+#define sk_double_ceil2int(x)       (int)ceil(x)
+
+// Cast double to float, ignoring any warning about too-large finite values being cast to float.
+// Clang thinks this is undefined, but it's actually implementation defined to return either
+// the largest float or infinity (one of the two bracketing representable floats).  Good enough!
+SK_ATTRIBUTE(no_sanitize("float-cast-overflow"))
+static inline float sk_double_to_float(double x) {
+    return static_cast<float>(x);
+}
+
+#define SK_FloatNaN                 std::numeric_limits<float>::quiet_NaN()
+#define SK_FloatInfinity            (+std::numeric_limits<float>::infinity())
+#define SK_FloatNegativeInfinity    (-std::numeric_limits<float>::infinity())
+
+#define SK_DoubleNaN                std::numeric_limits<double>::quiet_NaN()
+
+// Returns false if any of the floats are outside of [0...1]
+// Returns true if count is 0
+bool sk_floats_are_unit(const float array[], size_t count);
+
+#if defined(SK_LEGACY_FLOAT_RSQRT)
+static inline float sk_float_rsqrt_portable(float x) {
+    // Get initial estimate.
+    int i;
+    memcpy(&i, &x, 4);
+    i = 0x5F1FFFF9 - (i>>1);
+    float estimate;
+    memcpy(&estimate, &i, 4);
+
+    // One step of Newton's method to refine.
+    const float estimate_sq = estimate*estimate;
+    estimate *= 0.703952253f*(2.38924456f-x*estimate_sq);
+    return estimate;
+}
+
+// Fast, approximate inverse square root.
+// Compare to name-brand "1.0f / sk_float_sqrt(x)".  Should be around 10x faster on SSE, 2x on NEON.
+static inline float sk_float_rsqrt(float x) {
+// We want all this inlined, so we'll inline SIMD and just take the hit when we don't know we've got
+// it at compile time.  This is going to be too fast to productively hide behind a function pointer.
+//
+// We do one step of Newton's method to refine the estimates in the NEON and portable paths.  No
+// refinement is faster, but very innacurate.  Two steps is more accurate, but slower than 1/sqrt.
+//
+// Optimized constants in the portable path courtesy of http://rrrola.wz.cz/inv_sqrt.html
+#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
+    return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x)));
+#elif defined(SK_ARM_HAS_NEON)
+    // Get initial estimate.
+    const float32x2_t xx = vdup_n_f32(x);  // Clever readers will note we're doing everything 2x.
+    float32x2_t estimate = vrsqrte_f32(xx);
+
+    // One step of Newton's method to refine.
+    const float32x2_t estimate_sq = vmul_f32(estimate, estimate);
+    estimate = vmul_f32(estimate, vrsqrts_f32(xx, estimate_sq));
+    return vget_lane_f32(estimate, 0);  // 1 will work fine too; the answer's in both places.
+#else
+    return sk_float_rsqrt_portable(x);
+#endif
+}
+#else
+
+static inline float sk_float_rsqrt_portable(float x) { return 1.0f / sk_float_sqrt(x); }
+static inline float sk_float_rsqrt         (float x) { return 1.0f / sk_float_sqrt(x); }
+
+#endif
+
+// Returns the log2 of the provided value, were that value to be rounded up to the next power of 2.
+// Returns 0 if value <= 0:
+// Never returns a negative number, even if value is NaN.
+//
+//     sk_float_nextlog2((-inf..1]) -> 0
+//     sk_float_nextlog2((1..2]) -> 1
+//     sk_float_nextlog2((2..4]) -> 2
+//     sk_float_nextlog2((4..8]) -> 3
+//     ...
+static inline int sk_float_nextlog2(float x) {
+    uint32_t bits = (uint32_t)SkFloat2Bits(x);
+    bits += (1u << 23) - 1u;  // Increment the exponent for non-powers-of-2.
+    int exp = ((int32_t)bits >> 23) - 127;
+    return exp & ~(exp >> 31);  // Return 0 for negative or denormalized floats, and exponents < 0.
+}
+
+// This is the number of significant digits we can print in a string such that when we read that
+// string back we get the floating point number we expect.  The minimum value C requires is 6, but
+// most compilers support 9
+#ifdef FLT_DECIMAL_DIG
+#define SK_FLT_DECIMAL_DIG FLT_DECIMAL_DIG
+#else
+#define SK_FLT_DECIMAL_DIG 9
+#endif
+
+// IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not
+// so we have a helper that suppresses the possible undefined-behavior warnings.
+
+SK_ATTRIBUTE(no_sanitize("float-divide-by-zero"))
+static inline float sk_ieee_float_divide(float numer, float denom) {
+    return numer / denom;
+}
+
+SK_ATTRIBUTE(no_sanitize("float-divide-by-zero"))
+static inline double sk_ieee_double_divide(double numer, double denom) {
+    return numer / denom;
+}
+
+// While we clean up divide by zero, we'll replace places that do divide by zero with this TODO.
+static inline float sk_ieee_float_divide_TODO_IS_DIVIDE_BY_ZERO_SAFE_HERE(float n, float d) {
+    return sk_ieee_float_divide(n,d);
+}
+
+static inline float sk_fmaf(float f, float m, float a) {
+#if defined(FP_FAST_FMA)
+    return std::fmaf(f,m,a);
+#else
+    return f*m+a;
+#endif
+}
+
+#endif

package/cpp/skia/include/private/SkHalf.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkHalf_DEFINED
+#define SkHalf_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/SkNx.h"
+
+// 16-bit floating point value
+// format is 1 bit sign, 5 bits exponent, 10 bits mantissa
+// only used for storage
+typedef uint16_t SkHalf;
+
+static constexpr uint16_t SK_HalfMin     = 0x0400; // 2^-14  (minimum positive normal value)
+static constexpr uint16_t SK_HalfMax     = 0x7bff; // 65504
+static constexpr uint16_t SK_HalfEpsilon = 0x1400; // 2^-10
+static constexpr uint16_t SK_Half1       = 0x3C00; // 1
+
+// convert between half and single precision floating point
+float SkHalfToFloat(SkHalf h);
+SkHalf SkFloatToHalf(float f);
+
+// Convert between half and single precision floating point,
+// assuming inputs and outputs are both finite, and may
+// flush values which would be denormal half floats to zero.
+static inline Sk4f SkHalfToFloat_finite_ftz(uint64_t);
+static inline Sk4h SkFloatToHalf_finite_ftz(const Sk4f&);
+
+// ~~~~~~~~~~~ impl ~~~~~~~~~~~~~~ //
+
+// Like the serial versions in SkHalf.cpp, these are based on
+// https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
+
+// GCC 4.9 lacks the intrinsics to use ARMv8 f16<->f32 instructions, so we use inline assembly.
+
+static inline Sk4f SkHalfToFloat_finite_ftz(uint64_t rgba) {
+    Sk4h hs = Sk4h::Load(&rgba);
+#if !defined(SKNX_NO_SIMD) && defined(SK_CPU_ARM64)
+    float32x4_t fs;
+    asm ("fcvtl %[fs].4s, %[hs].4h   \n"   // vcvt_f32_f16(...)
+        : [fs] "=w" (fs)                   // =w: write-only NEON register
+        : [hs] "w" (hs.fVec));             //  w: read-only NEON register
+    return fs;
+#else
+    Sk4i bits     = SkNx_cast<int>(hs),  // Expand to 32 bit.
+         sign     = bits & 0x00008000,   // Save the sign bit for later...
+         positive = bits ^ sign,         // ...but strip it off for now.
+         is_norm  = 0x03ff < positive;   // Exponent > 0?
+
+    // For normal half floats, extend the mantissa by 13 zero bits,
+    // then adjust the exponent from 15 bias to 127 bias.
+    Sk4i norm = (positive << 13) + ((127 - 15) << 23);
+
+    Sk4i merged = (sign << 16) | (norm & is_norm);
+    return Sk4f::Load(&merged);
+#endif
+}
+
+static inline Sk4h SkFloatToHalf_finite_ftz(const Sk4f& fs) {
+#if !defined(SKNX_NO_SIMD) && defined(SK_CPU_ARM64)
+    float32x4_t vec = fs.fVec;
+    asm ("fcvtn %[vec].4h, %[vec].4s  \n"   // vcvt_f16_f32(vec)
+        : [vec] "+w" (vec));                // +w: read-write NEON register
+    return vreinterpret_u16_f32(vget_low_f32(vec));
+#else
+    Sk4i bits         = Sk4i::Load(&fs),
+         sign         = bits & 0x80000000,      // Save the sign bit for later...
+         positive     = bits ^ sign,            // ...but strip it off for now.
+         will_be_norm = 0x387fdfff < positive;  // greater than largest denorm half?
+
+    // For normal half floats, adjust the exponent from 127 bias to 15 bias,
+    // then drop the bottom 13 mantissa bits.
+    Sk4i norm = (positive - ((127 - 15) << 23)) >> 13;
+
+    Sk4i merged = (sign >> 16) | (will_be_norm & norm);
+    return SkNx_cast<uint16_t>(merged);
+#endif
+}
+
+#endif

package/cpp/skia/include/private/SkIDChangeListener.h

@@ -0,0 +1,75 @@
+/*
+ * 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 SkIDChangeListener_DEFINED
+#define SkIDChangeListener_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkMutex.h"
+#include "include/private/SkTDArray.h"
+
+#include <atomic>
+
+/**
+ * Used to be notified when a gen/unique ID is invalidated, typically to preemptively purge
+ * associated items from a cache that are no longer reachable. The listener can
+ * be marked for deregistration if the cached item is remove before the listener is
+ * triggered. This prevents unbounded listener growth when cache items are routinely
+ * removed before the gen ID/unique ID is invalidated.
+ */
+class SkIDChangeListener : public SkRefCnt {
+public:
+    SkIDChangeListener();
+
+    ~SkIDChangeListener() override;
+
+    virtual void changed() = 0;
+
+    /**
+     * Mark the listener is no longer needed. It should be removed and changed() should not be
+     * called.
+     */
+    void markShouldDeregister() { fShouldDeregister.store(true, std::memory_order_relaxed); }
+
+    /** Indicates whether markShouldDeregister was called. */
+    bool shouldDeregister() { return fShouldDeregister.load(std::memory_order_acquire); }
+
+    /** Manages a list of SkIDChangeListeners. */
+    class List {
+    public:
+        List();
+
+        ~List();
+
+        /**
+         * Add a new listener to the list. It must not already be deregistered. Also clears out
+         * previously deregistered listeners.
+         */
+        void add(sk_sp<SkIDChangeListener> listener) SK_EXCLUDES(fMutex);
+
+        /**
+         * The number of registered listeners (including deregisterd listeners that are yet-to-be
+         * removed.
+         */
+        int count() const SK_EXCLUDES(fMutex);
+
+        /** Calls changed() on all listeners that haven't been deregistered and resets the list. */
+        void changed() SK_EXCLUDES(fMutex);
+
+        /** Resets without calling changed() on the listeners. */
+        void reset() SK_EXCLUDES(fMutex);
+
+    private:
+        mutable SkMutex fMutex;
+        SkTDArray<SkIDChangeListener*> fListeners SK_GUARDED_BY(fMutex);  // pointers are reffed
+    };
+
+private:
+    std::atomic<bool> fShouldDeregister;
+};
+
+#endif

package/cpp/skia/include/private/SkImageInfoPriv.h

@@ -0,0 +1,193 @@
+/*
+ * 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 SkImageInfoPriv_DEFINED
+#define SkImageInfoPriv_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkImageInfo.h"
+
+static inline uint32_t SkColorTypeChannelFlags(SkColorType ct) {
+    switch (ct) {
+        case kUnknown_SkColorType:            return 0;
+        case kAlpha_8_SkColorType:            return kAlpha_SkColorChannelFlag;
+        case kRGB_565_SkColorType:            return kRGB_SkColorChannelFlags;
+        case kARGB_4444_SkColorType:          return kRGBA_SkColorChannelFlags;
+        case kRGBA_8888_SkColorType:          return kRGBA_SkColorChannelFlags;
+        case kRGB_888x_SkColorType:           return kRGB_SkColorChannelFlags;
+        case kBGRA_8888_SkColorType:          return kRGBA_SkColorChannelFlags;
+        case kRGBA_1010102_SkColorType:       return kRGBA_SkColorChannelFlags;
+        case kRGB_101010x_SkColorType:        return kRGB_SkColorChannelFlags;
+        case kBGRA_1010102_SkColorType:       return kRGBA_SkColorChannelFlags;
+        case kBGR_101010x_SkColorType:        return kRGB_SkColorChannelFlags;
+        case kGray_8_SkColorType:             return kGray_SkColorChannelFlag;
+        case kRGBA_F16Norm_SkColorType:       return kRGBA_SkColorChannelFlags;
+        case kRGBA_F16_SkColorType:           return kRGBA_SkColorChannelFlags;
+        case kRGBA_F32_SkColorType:           return kRGBA_SkColorChannelFlags;
+        case kR8G8_unorm_SkColorType:         return kRG_SkColorChannelFlags;
+        case kA16_unorm_SkColorType:          return kAlpha_SkColorChannelFlag;
+        case kR16G16_unorm_SkColorType:       return kRG_SkColorChannelFlags;
+        case kA16_float_SkColorType:          return kAlpha_SkColorChannelFlag;
+        case kR16G16_float_SkColorType:       return kRG_SkColorChannelFlags;
+        case kR16G16B16A16_unorm_SkColorType: return kRGBA_SkColorChannelFlags;
+        case kSRGBA_8888_SkColorType:         return kRGBA_SkColorChannelFlags;
+    }
+    SkUNREACHABLE;
+}
+
+static inline bool SkColorTypeIsAlphaOnly(SkColorType ct) {
+    return SkColorTypeChannelFlags(ct) == kAlpha_SkColorChannelFlag;
+}
+
+static inline bool SkAlphaTypeIsValid(unsigned value) {
+    return value <= kLastEnum_SkAlphaType;
+}
+
+static int SkColorTypeShiftPerPixel(SkColorType ct) {
+    switch (ct) {
+        case kUnknown_SkColorType:            return 0;
+        case kAlpha_8_SkColorType:            return 0;
+        case kRGB_565_SkColorType:            return 1;
+        case kARGB_4444_SkColorType:          return 1;
+        case kRGBA_8888_SkColorType:          return 2;
+        case kRGB_888x_SkColorType:           return 2;
+        case kBGRA_8888_SkColorType:          return 2;
+        case kRGBA_1010102_SkColorType:       return 2;
+        case kRGB_101010x_SkColorType:        return 2;
+        case kBGRA_1010102_SkColorType:       return 2;
+        case kBGR_101010x_SkColorType:        return 2;
+        case kGray_8_SkColorType:             return 0;
+        case kRGBA_F16Norm_SkColorType:       return 3;
+        case kRGBA_F16_SkColorType:           return 3;
+        case kRGBA_F32_SkColorType:           return 4;
+        case kR8G8_unorm_SkColorType:         return 1;
+        case kA16_unorm_SkColorType:          return 1;
+        case kR16G16_unorm_SkColorType:       return 2;
+        case kA16_float_SkColorType:          return 1;
+        case kR16G16_float_SkColorType:       return 2;
+        case kR16G16B16A16_unorm_SkColorType: return 3;
+        case kSRGBA_8888_SkColorType:         return 2;
+    }
+    SkUNREACHABLE;
+}
+
+static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) {
+    return (size_t)(width * SkColorTypeBytesPerPixel(ct));
+}
+
+static inline bool SkColorTypeIsValid(unsigned value) {
+    return value <= kLastEnum_SkColorType;
+}
+
+static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) {
+    if (kUnknown_SkColorType == ct) {
+        return 0;
+    }
+    return (size_t)y * rowBytes + ((size_t)x << SkColorTypeShiftPerPixel(ct));
+}
+
+static inline bool SkColorTypeIsNormalized(SkColorType ct) {
+    switch (ct) {
+        case kUnknown_SkColorType:
+        case kAlpha_8_SkColorType:
+        case kRGB_565_SkColorType:
+        case kARGB_4444_SkColorType:
+        case kRGBA_8888_SkColorType:
+        case kRGB_888x_SkColorType:
+        case kBGRA_8888_SkColorType:
+        case kRGBA_1010102_SkColorType:
+        case kRGB_101010x_SkColorType:
+        case kBGRA_1010102_SkColorType:
+        case kBGR_101010x_SkColorType:
+        case kGray_8_SkColorType:
+        case kRGBA_F16Norm_SkColorType:
+        case kR8G8_unorm_SkColorType:
+        case kA16_unorm_SkColorType:
+        case kA16_float_SkColorType:          /*subtle... alpha is always [0,1]*/
+        case kR16G16_unorm_SkColorType:
+        case kR16G16B16A16_unorm_SkColorType:
+        case kSRGBA_8888_SkColorType: return true;
+
+        case kRGBA_F16_SkColorType:
+        case kRGBA_F32_SkColorType:
+        case kR16G16_float_SkColorType:       return false;
+    }
+    SkUNREACHABLE;
+}
+
+static inline int SkColorTypeMaxBitsPerChannel(SkColorType ct) {
+    switch (ct) {
+        case kUnknown_SkColorType:
+            return 0;
+
+        case kARGB_4444_SkColorType:
+            return 4;
+
+        case kRGB_565_SkColorType:
+            return 6;
+
+        case kAlpha_8_SkColorType:
+        case kRGBA_8888_SkColorType:
+        case kRGB_888x_SkColorType:
+        case kBGRA_8888_SkColorType:
+        case kGray_8_SkColorType:
+        case kR8G8_unorm_SkColorType:
+        case kSRGBA_8888_SkColorType:
+            return 8;
+
+        case kRGBA_1010102_SkColorType:
+        case kRGB_101010x_SkColorType:
+        case kBGRA_1010102_SkColorType:
+        case kBGR_101010x_SkColorType:
+            return 10;
+
+        case kRGBA_F16Norm_SkColorType:
+        case kA16_unorm_SkColorType:
+        case kA16_float_SkColorType:
+        case kR16G16_unorm_SkColorType:
+        case kR16G16B16A16_unorm_SkColorType:
+        case kRGBA_F16_SkColorType:
+        case kR16G16_float_SkColorType:
+            return 16;
+
+        case kRGBA_F32_SkColorType:
+            return 32;
+    }
+    SkUNREACHABLE;
+}
+
+/**
+ *  Returns true if |info| contains a valid colorType and alphaType.
+ */
+static inline bool SkColorInfoIsValid(const SkColorInfo& info) {
+    return info.colorType() != kUnknown_SkColorType && info.alphaType() != kUnknown_SkAlphaType;
+}
+
+/**
+ *  Returns true if |info| contains a valid combination of width, height and colorInfo.
+ */
+static inline bool SkImageInfoIsValid(const SkImageInfo& info) {
+    if (info.width() <= 0 || info.height() <= 0) {
+        return false;
+    }
+
+    const int kMaxDimension = SK_MaxS32 >> 2;
+    if (info.width() > kMaxDimension || info.height() > kMaxDimension) {
+        return false;
+    }
+
+    return SkColorInfoIsValid(info.colorInfo());
+}
+
+/**
+ *  Returns true if Skia has defined a pixel conversion from the |src| to the |dst|.
+ *  Returns false otherwise.
+ */
+static inline bool SkImageInfoValidConversion(const SkImageInfo& dst, const SkImageInfo& src) {
+    return SkImageInfoIsValid(dst) && SkImageInfoIsValid(src);
+}
+#endif  // SkImageInfoPriv_DEFINED