Sk4px

src/core/SkNx.h

 /*
  * 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 SkNx_DEFINED
 #define SkNx_DEFINED
 
@@ skipping 12 matching lines @@
 // We pass along the byte size of the compared types (Bytes) to help platform specializations.
 template <int N, int Bytes>
 class SkNb {
 public:
     SkNb() {}
     SkNb(const SkNb<N/2, Bytes>& lo, const SkNb<N/2, Bytes>& hi) : fLo(lo), fHi(hi) {}
 
     bool allTrue() const { return fLo.allTrue() && fHi.allTrue(); }
     bool anyTrue() const { return fLo.anyTrue() || fHi.anyTrue(); }
 
-private:
+protected:
     REQUIRE(0 == (N & (N-1)));
     SkNb<N/2, Bytes> fLo, fHi;
 };
 
 template <int N, typename T>
 class SkNi {
 public:
     SkNi() {}
     SkNi(const SkNi<N/2, T>& lo, const SkNi<N/2, T>& hi) : fLo(lo), fHi(hi) {}
     explicit SkNi(T val) : fLo(val), fHi(val) {}
     static SkNi Load(const T vals[N]) {
         return SkNi(SkNi<N/2,T>::Load(vals), SkNi<N/2,T>::Load(vals+N/2));
     }
 
-    SkNi(T a, T b)                               : fLo(a),       fHi(b)       { REQUIRE(N==2); }
-    SkNi(T a, T b, T c, T d)                     : fLo(a,b),     fHi(c,d)     { REQUIRE(N==4); }
-    SkNi(T a, T b, T c, T d, T e, T f, T g, T h) : fLo(a,b,c,d), fHi(e,f,g,h) { REQUIRE(N==8); }
+    SkNi(T a, T b)                                : fLo(a),       fHi(b)       { REQUIRE(N==2); }
+    SkNi(T a, T b, T c, T d)                      : fLo(a,b),     fHi(c,d)     { REQUIRE(N==4); }
+    SkNi(T a, T b, T c, T d,  T e, T f, T g, T h) : fLo(a,b,c,d), fHi(e,f,g,h) { REQUIRE(N==8); }
+    SkNi(T a, T b, T c, T d,  T e, T f, T g, T h,
+         T i, T j, T k, T l,  T m, T n, T o, T p)
+        : fLo(a,b,c,d, e,f,g,h), fHi(i,j,k,l, m,n,o,p) { REQUIRE(N==16); }
 
     void store(T vals[N]) const {
         fLo.store(vals);
         fHi.store(vals+N/2);
     }
 
     SkNi operator + (const SkNi& o) const { return SkNi(fLo + o.fLo, fHi + o.fHi); }
     SkNi operator - (const SkNi& o) const { return SkNi(fLo - o.fLo, fHi - o.fHi); }
     SkNi operator * (const SkNi& o) const { return SkNi(fLo * o.fLo, fHi * o.fHi); }
 
     SkNi operator << (int bits) const { return SkNi(fLo << bits, fHi << bits); }
     SkNi operator >> (int bits) const { return SkNi(fLo >> bits, fHi >> bits); }
 
     // TODO: comparisons, min, max?
 
     template <int k> T kth() const {
         SkASSERT(0 <= k && k < N);
         return k < N/2 ? fLo.template kth<k>() : fHi.template kth<k-N/2>();
     }
 
-private:
+protected:
     REQUIRE(0 == (N & (N-1)));
 
     SkNi<N/2, T> fLo, fHi;
 };
 
 template <int N, typename T>
 class SkNf {
     typedef SkNb<N, sizeof(T)> Nb;
 
     static int32_t MyNi(float);
@@ skipping 44 matching lines @@
     SkNf rsqrt2() const { return SkNf(fLo.rsqrt2(), fHi.rsqrt2()); }
 
     SkNf       invert() const { return SkNf(fLo.      invert(), fHi.      invert()); }
     SkNf approxInvert() const { return SkNf(fLo.approxInvert(), fHi.approxInvert()); }
 
     template <int k> T kth() const {
         SkASSERT(0 <= k && k < N);
         return k < N/2 ? fLo.template kth<k>() : fHi.template kth<k-N/2>();
     }
 
-private:
+protected:
     REQUIRE(0 == (N & (N-1)));
     SkNf(const SkNf<N/2, T>& lo, const SkNf<N/2, T>& hi) : fLo(lo), fHi(hi) {}
 
     SkNf<N/2, T> fLo, fHi;
 };
 
 
 // Bottom out the default implementations with scalars when nothing's been specialized.
 
 template <int Bytes>
 class SkNb<1, Bytes> {
 public:
     SkNb() {}
     explicit SkNb(bool val) : fVal(val) {}
     bool allTrue() const { return fVal; }
     bool anyTrue() const { return fVal; }
-private:
+protected:
     bool fVal;
 };
 
 template <typename T>
 class SkNi<1,T> {
 public:
     SkNi() {}
     explicit SkNi(T val) : fVal(val) {}
     static SkNi Load(const T vals[1]) { return SkNi(vals[0]); }
 
     void store(T vals[1]) const { vals[0] = fVal; }
 
     SkNi operator + (const SkNi& o) const { return SkNi(fVal + o.fVal); }
     SkNi operator - (const SkNi& o) const { return SkNi(fVal - o.fVal); }
     SkNi operator * (const SkNi& o) const { return SkNi(fVal * o.fVal); }
 
     SkNi operator << (int bits) const { return SkNi(fVal << bits); }
     SkNi operator >> (int bits) const { return SkNi(fVal >> bits); }
 
     template <int k> T kth() const {
         SkASSERT(0 == k);
         return fVal;
     }
 
-private:
+protected:
     T fVal;
 };
 
 template <typename T>
 class SkNf<1,T> {
     typedef SkNb<1, sizeof(T)> Nb;
 
     static int32_t MyNi(float);
     static int64_t MyNi(double);
     typedef SkNi<1, decltype(MyNi(T()))> Ni;
@@ skipping 27 matching lines @@
     SkNf rsqrt2() const { return this->rsqrt1(); }
 
     SkNf       invert() const { return SkNf((T)1 / fVal); }
     SkNf approxInvert() const { return this->invert();    }
 
     template <int k> T kth() const {
         SkASSERT(k == 0);
         return fVal;
     }
 
-private:
+protected:
     // We do double sqrts natively, or via floats for any other type.
     template <typename U>
     static U      Sqrt(U      val) { return (U) ::sqrtf((float)val); }
     static double Sqrt(double val) { return     ::sqrt (       val); }
 
     T fVal;
 };
 
 
 // Generic syntax sugar that should work equally well for all implementations.
@@ skipping 19 matching lines @@
 #undef REQUIRE
 
 typedef SkNf<2,    float> Sk2f;
 typedef SkNf<2,   double> Sk2d;
 typedef SkNf<2, SkScalar> Sk2s;
 
 typedef SkNf<4,    float> Sk4f;
 typedef SkNf<4,   double> Sk4d;
 typedef SkNf<4, SkScalar> Sk4s;
 
-typedef SkNi<4, uint16_t> Sk4h;
-typedef SkNi<8, uint16_t> Sk8h;
+typedef SkNi<4,  uint16_t> Sk4h;
+typedef SkNi<8,  uint16_t> Sk8h;
+typedef SkNi<16, uint16_t> Sk16h;
 
-typedef SkNi<4, int> Sk4i;
+typedef SkNi<16, uint8_t> Sk16b;
+
+typedef SkNi<4,  int32_t> Sk4i;
+typedef SkNi<4, uint32_t> Sk4u;
 
 #endif//SkNx_DEFINED