src/core/Sk4px.h - skia - Git at Google

 /*
  * 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 Sk4px_DEFINED
 #define Sk4px_DEFINED

 #include "include/core/SkColor.h"
 #include "include/private/SkColorData.h"
 #include "include/private/SkNx.h"

 // This file may be included multiple times by .cpp files with different flags, leading
 // to different definitions.  Usually that doesn't matter because it's all inlined, but
 // in Debug modes the compilers may not inline everything.  So wrap everything in an
 // anonymous namespace to give each includer their own silo of this code (or the linker
 // will probably pick one randomly for us, which is rarely correct).
 namespace {  // NOLINT(google-build-namespaces)

 // 1, 2 or 4 SkPMColors, generally vectorized.
 class Sk4px : public Sk16b {
 public:
     Sk4px(const Sk16b& v) : INHERITED(v) {}

     static Sk4px DupPMColor(SkPMColor c) {
         Sk4u splat(c);

         Sk4px v;
         memcpy(&v, &splat, 16);
         return v;
     }

     Sk4px alphas() const;  // ARGB argb XYZW xyzw -> AAAA aaaa XXXX xxxx
     Sk4px inv() const { return Sk16b(255) - *this; }

     // When loading or storing fewer than 4 SkPMColors, we use the low lanes.
     static Sk4px Load4(const SkPMColor px[4]) {
         Sk4px v;
         memcpy(&v, px, 16);
         return v;
     }
     static Sk4px Load2(const SkPMColor px[2]) {
         Sk4px v;
         memcpy(&v, px, 8);
         return v;
     }
     static Sk4px Load1(const SkPMColor px[1]) {
         Sk4px v;
         memcpy(&v, px, 4);
         return v;
     }

     // Ditto for Alphas... Load2Alphas fills the low two lanes of Sk4px.
     static Sk4px Load4Alphas(const SkAlpha[4]);  // AaXx -> AAAA aaaa XXXX xxxx
     static Sk4px Load2Alphas(const SkAlpha[2]);  // Aa   -> AAAA aaaa ???? ????

     void store4(SkPMColor px[4]) const { memcpy(px, this, 16); }
     void store2(SkPMColor px[2]) const { memcpy(px, this,  8); }
     void store1(SkPMColor px[1]) const { memcpy(px, this,  4); }

     // 1, 2, or 4 SkPMColors with 16-bit components.
     // This is most useful as the result of a multiply, e.g. from mulWiden().
     class Wide : public Sk16h {
     public:
         Wide(const Sk16h& v) : Sk16h(v) {}

         // Add, then pack the top byte of each component back down into 4 SkPMColors.
         Sk4px addNarrowHi(const Sk16h&) const;

         // Rounds, i.e. (x+127) / 255.
         Sk4px div255() const;

         // These just keep the types as Wide so the user doesn't have to keep casting.
         Wide operator * (const Wide& o) const { return INHERITED::operator*(o); }
         Wide operator + (const Wide& o) const { return INHERITED::operator+(o); }
         Wide operator - (const Wide& o) const { return INHERITED::operator-(o); }
         Wide operator >> (int bits) const { return INHERITED::operator>>(bits); }
         Wide operator << (int bits) const { return INHERITED::operator<<(bits); }

     private:
         typedef Sk16h INHERITED;
     };

     Wide widen() const;               // Widen 8-bit values to low 8-bits of 16-bit lanes.
     Wide mulWiden(const Sk16b&) const;  // 8-bit x 8-bit -> 16-bit components.

     // The only 8-bit multiply we use is 8-bit x 8-bit -> 16-bit.  Might as well make it pithy.
     Wide operator * (const Sk4px& o) const { return this->mulWiden(o); }

     // These just keep the types as Sk4px so the user doesn't have to keep casting.
     Sk4px operator + (const Sk4px& o) const { return INHERITED::operator+(o); }
     Sk4px operator - (const Sk4px& o) const { return INHERITED::operator-(o); }
     Sk4px operator < (const Sk4px& o) const { return INHERITED::operator<(o); }
     Sk4px thenElse(const Sk4px& t, const Sk4px& e) const { return INHERITED::thenElse(t,e); }

     // Generally faster than (*this * o).div255().
     // May be incorrect by +-1, but is always exactly correct when *this or o is 0 or 255.
     Sk4px approxMulDiv255(const Sk16b& o) const {
         // (x*y + x) / 256 meets these criteria.  (As of course does (x*y + y) / 256 by symmetry.)
         // FYI: (x*y + 255) / 256 also meets these criteria.  In my brief testing, it was slower.
         return this->widen().addNarrowHi(*this * o);
     }

     // A generic driver that maps fn over a src array into a dst array.
     // fn should take an Sk4px (4 src pixels) and return an Sk4px (4 dst pixels).
     template <typename Fn>
     static void MapSrc(int n, SkPMColor* dst, const SkPMColor* src, const Fn& fn) {
         SkASSERT(dst);
         SkASSERT(src);
         // This looks a bit odd, but it helps loop-invariant hoisting across different calls to fn.
         // Basically, we need to make sure we keep things inside a single loop.
         while (n > 0) {
             if (n >= 8) {
                 Sk4px dst0 = fn(Load4(src+0)),
                       dst4 = fn(Load4(src+4));
                 dst0.store4(dst+0);
                 dst4.store4(dst+4);
                 dst += 8; src += 8; n -= 8;
                 continue;  // Keep our stride at 8 pixels as long as possible.
             }
             SkASSERT(n <= 7);
             if (n >= 4) {
                 fn(Load4(src)).store4(dst);
                 dst += 4; src += 4; n -= 4;
             }
             if (n >= 2) {
                 fn(Load2(src)).store2(dst);
                 dst += 2; src += 2; n -= 2;
             }
             if (n >= 1) {
                 fn(Load1(src)).store1(dst);
             }
             break;
         }
     }

     // As above, but with dst4' = fn(dst4, src4).
     template <typename Fn>
     static void MapDstSrc(int n, SkPMColor* dst, const SkPMColor* src, const Fn& fn) {
         SkASSERT(dst);
         SkASSERT(src);
         while (n > 0) {
             if (n >= 8) {
                 Sk4px dst0 = fn(Load4(dst+0), Load4(src+0)),
                       dst4 = fn(Load4(dst+4), Load4(src+4));
                 dst0.store4(dst+0);
                 dst4.store4(dst+4);
                 dst += 8; src += 8; n -= 8;
                 continue;  // Keep our stride at 8 pixels as long as possible.
             }
             SkASSERT(n <= 7);
             if (n >= 4) {
                 fn(Load4(dst), Load4(src)).store4(dst);
                 dst += 4; src += 4; n -= 4;
             }
             if (n >= 2) {
                 fn(Load2(dst), Load2(src)).store2(dst);
                 dst += 2; src += 2; n -= 2;
             }
             if (n >= 1) {
                 fn(Load1(dst), Load1(src)).store1(dst);
             }
             break;
         }
     }

     // As above, but with dst4' = fn(dst4, alpha4).
     template <typename Fn>
     static void MapDstAlpha(int n, SkPMColor* dst, const SkAlpha* a, const Fn& fn) {
         SkASSERT(dst);
         SkASSERT(a);
         while (n > 0) {
             if (n >= 8) {
                 Sk4px dst0 = fn(Load4(dst+0), Load4Alphas(a+0)),
                       dst4 = fn(Load4(dst+4), Load4Alphas(a+4));
                 dst0.store4(dst+0);
                 dst4.store4(dst+4);
                 dst += 8; a += 8; n -= 8;
                 continue;  // Keep our stride at 8 pixels as long as possible.
             }
             SkASSERT(n <= 7);
             if (n >= 4) {
                 fn(Load4(dst), Load4Alphas(a)).store4(dst);
                 dst += 4; a += 4; n -= 4;
             }
             if (n >= 2) {
                 fn(Load2(dst), Load2Alphas(a)).store2(dst);
                 dst += 2; a += 2; n -= 2;
             }
             if (n >= 1) {
                 fn(Load1(dst), Sk16b(*a)).store1(dst);
             }
             break;
         }
     }

     // As above, but with dst4' = fn(dst4, src4, alpha4).
     template <typename Fn>
     static void MapDstSrcAlpha(int n, SkPMColor* dst, const SkPMColor* src, const SkAlpha* a,
                                const Fn& fn) {
         SkASSERT(dst);
         SkASSERT(src);
         SkASSERT(a);
         while (n > 0) {
             if (n >= 8) {
                 Sk4px dst0 = fn(Load4(dst+0), Load4(src+0), Load4Alphas(a+0)),
                       dst4 = fn(Load4(dst+4), Load4(src+4), Load4Alphas(a+4));
                 dst0.store4(dst+0);
                 dst4.store4(dst+4);
                 dst += 8; src += 8; a += 8; n -= 8;
                 continue;  // Keep our stride at 8 pixels as long as possible.
             }
             SkASSERT(n <= 7);
             if (n >= 4) {
                 fn(Load4(dst), Load4(src), Load4Alphas(a)).store4(dst);
                 dst += 4; src += 4; a += 4; n -= 4;
             }
             if (n >= 2) {
                 fn(Load2(dst), Load2(src), Load2Alphas(a)).store2(dst);
                 dst += 2; src += 2; a += 2; n -= 2;
             }
             if (n >= 1) {
                 fn(Load1(dst), Load1(src), Sk16b(*a)).store1(dst);
             }
             break;
         }
     }

 private:
     Sk4px() = default;

     typedef Sk16b INHERITED;
 };

 }  // namespace

 #ifdef SKNX_NO_SIMD
     #include "src/opts/Sk4px_none.h"
 #else
     #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
         #include "src/opts/Sk4px_SSE2.h"
     #elif defined(SK_ARM_HAS_NEON)
         #include "src/opts/Sk4px_NEON.h"
     #else
         #include "src/opts/Sk4px_none.h"
     #endif
 #endif

 #endif//Sk4px_DEFINED
	/*
	* 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 Sk4px_DEFINED
	#define Sk4px_DEFINED

	#include "include/core/SkColor.h"
	#include "include/private/SkColorData.h"
	#include "include/private/SkNx.h"

	// This file may be included multiple times by .cpp files with different flags, leading
	// to different definitions. Usually that doesn't matter because it's all inlined, but
	// in Debug modes the compilers may not inline everything. So wrap everything in an
	// anonymous namespace to give each includer their own silo of this code (or the linker
	// will probably pick one randomly for us, which is rarely correct).
	namespace { // NOLINT(google-build-namespaces)

	// 1, 2 or 4 SkPMColors, generally vectorized.
	class Sk4px : public Sk16b {
	public:
	Sk4px(const Sk16b& v) : INHERITED(v) {}

	static Sk4px DupPMColor(SkPMColor c) {
	Sk4u splat(c);

	Sk4px v;
	memcpy(&v, &splat, 16);
	return v;
	}

	Sk4px alphas() const; // ARGB argb XYZW xyzw -> AAAA aaaa XXXX xxxx
	Sk4px inv() const { return Sk16b(255) - *this; }

	// When loading or storing fewer than 4 SkPMColors, we use the low lanes.
	static Sk4px Load4(const SkPMColor px[4]) {
	Sk4px v;
	memcpy(&v, px, 16);
	return v;
	}
	static Sk4px Load2(const SkPMColor px[2]) {
	Sk4px v;
	memcpy(&v, px, 8);
	return v;
	}
	static Sk4px Load1(const SkPMColor px[1]) {
	Sk4px v;
	memcpy(&v, px, 4);
	return v;
	}

	// Ditto for Alphas... Load2Alphas fills the low two lanes of Sk4px.
	static Sk4px Load4Alphas(const SkAlpha[4]); // AaXx -> AAAA aaaa XXXX xxxx
	static Sk4px Load2Alphas(const SkAlpha[2]); // Aa -> AAAA aaaa ???? ????

	void store4(SkPMColor px[4]) const { memcpy(px, this, 16); }
	void store2(SkPMColor px[2]) const { memcpy(px, this, 8); }
	void store1(SkPMColor px[1]) const { memcpy(px, this, 4); }

	// 1, 2, or 4 SkPMColors with 16-bit components.
	// This is most useful as the result of a multiply, e.g. from mulWiden().
	class Wide : public Sk16h {
	public:
	Wide(const Sk16h& v) : Sk16h(v) {}

	// Add, then pack the top byte of each component back down into 4 SkPMColors.
	Sk4px addNarrowHi(const Sk16h&) const;

	// Rounds, i.e. (x+127) / 255.
	Sk4px div255() const;

	// These just keep the types as Wide so the user doesn't have to keep casting.
	Wide operator * (const Wide& o) const { return INHERITED::operator*(o); }
	Wide operator + (const Wide& o) const { return INHERITED::operator+(o); }
	Wide operator - (const Wide& o) const { return INHERITED::operator-(o); }
	Wide operator >> (int bits) const { return INHERITED::operator>>(bits); }
	Wide operator << (int bits) const { return INHERITED::operator<<(bits); }

	private:
	typedef Sk16h INHERITED;
	};

	Wide widen() const; // Widen 8-bit values to low 8-bits of 16-bit lanes.
	Wide mulWiden(const Sk16b&) const; // 8-bit x 8-bit -> 16-bit components.

	// The only 8-bit multiply we use is 8-bit x 8-bit -> 16-bit. Might as well make it pithy.
	Wide operator * (const Sk4px& o) const { return this->mulWiden(o); }

	// These just keep the types as Sk4px so the user doesn't have to keep casting.
	Sk4px operator + (const Sk4px& o) const { return INHERITED::operator+(o); }
	Sk4px operator - (const Sk4px& o) const { return INHERITED::operator-(o); }
	Sk4px operator < (const Sk4px& o) const { return INHERITED::operator<(o); }
	Sk4px thenElse(const Sk4px& t, const Sk4px& e) const { return INHERITED::thenElse(t,e); }

	// Generally faster than (this o).div255().
	// May be incorrect by +-1, but is always exactly correct when *this or o is 0 or 255.
	Sk4px approxMulDiv255(const Sk16b& o) const {
	// (xy + x) / 256 meets these criteria. (As of course does (xy + y) / 256 by symmetry.)
	// FYI: (x*y + 255) / 256 also meets these criteria. In my brief testing, it was slower.
	return this->widen().addNarrowHi(this o);
	}

	// A generic driver that maps fn over a src array into a dst array.
	// fn should take an Sk4px (4 src pixels) and return an Sk4px (4 dst pixels).
	template <typename Fn>
	static void MapSrc(int n, SkPMColor* dst, const SkPMColor* src, const Fn& fn) {
	SkASSERT(dst);
	SkASSERT(src);
	// This looks a bit odd, but it helps loop-invariant hoisting across different calls to fn.
	// Basically, we need to make sure we keep things inside a single loop.
	while (n > 0) {
	if (n >= 8) {
	Sk4px dst0 = fn(Load4(src+0)),
	dst4 = fn(Load4(src+4));
	dst0.store4(dst+0);
	dst4.store4(dst+4);
	dst += 8; src += 8; n -= 8;
	continue; // Keep our stride at 8 pixels as long as possible.
	}
	SkASSERT(n <= 7);
	if (n >= 4) {
	fn(Load4(src)).store4(dst);
	dst += 4; src += 4; n -= 4;
	}
	if (n >= 2) {
	fn(Load2(src)).store2(dst);
	dst += 2; src += 2; n -= 2;
	}
	if (n >= 1) {
	fn(Load1(src)).store1(dst);
	}
	break;
	}
	}

	// As above, but with dst4' = fn(dst4, src4).
	template <typename Fn>
	static void MapDstSrc(int n, SkPMColor* dst, const SkPMColor* src, const Fn& fn) {
	SkASSERT(dst);
	SkASSERT(src);
	while (n > 0) {
	if (n >= 8) {
	Sk4px dst0 = fn(Load4(dst+0), Load4(src+0)),
	dst4 = fn(Load4(dst+4), Load4(src+4));
	dst0.store4(dst+0);
	dst4.store4(dst+4);
	dst += 8; src += 8; n -= 8;
	continue; // Keep our stride at 8 pixels as long as possible.
	}
	SkASSERT(n <= 7);
	if (n >= 4) {
	fn(Load4(dst), Load4(src)).store4(dst);
	dst += 4; src += 4; n -= 4;
	}
	if (n >= 2) {
	fn(Load2(dst), Load2(src)).store2(dst);
	dst += 2; src += 2; n -= 2;
	}
	if (n >= 1) {
	fn(Load1(dst), Load1(src)).store1(dst);
	}
	break;
	}
	}

	// As above, but with dst4' = fn(dst4, alpha4).
	template <typename Fn>
	static void MapDstAlpha(int n, SkPMColor* dst, const SkAlpha* a, const Fn& fn) {
	SkASSERT(dst);
	SkASSERT(a);
	while (n > 0) {
	if (n >= 8) {
	Sk4px dst0 = fn(Load4(dst+0), Load4Alphas(a+0)),
	dst4 = fn(Load4(dst+4), Load4Alphas(a+4));
	dst0.store4(dst+0);
	dst4.store4(dst+4);
	dst += 8; a += 8; n -= 8;
	continue; // Keep our stride at 8 pixels as long as possible.
	}
	SkASSERT(n <= 7);
	if (n >= 4) {
	fn(Load4(dst), Load4Alphas(a)).store4(dst);
	dst += 4; a += 4; n -= 4;
	}
	if (n >= 2) {
	fn(Load2(dst), Load2Alphas(a)).store2(dst);
	dst += 2; a += 2; n -= 2;
	}
	if (n >= 1) {
	fn(Load1(dst), Sk16b(*a)).store1(dst);
	}
	break;
	}
	}

	// As above, but with dst4' = fn(dst4, src4, alpha4).
	template <typename Fn>
	static void MapDstSrcAlpha(int n, SkPMColor* dst, const SkPMColor* src, const SkAlpha* a,
	const Fn& fn) {
	SkASSERT(dst);
	SkASSERT(src);
	SkASSERT(a);
	while (n > 0) {
	if (n >= 8) {
	Sk4px dst0 = fn(Load4(dst+0), Load4(src+0), Load4Alphas(a+0)),
	dst4 = fn(Load4(dst+4), Load4(src+4), Load4Alphas(a+4));
	dst0.store4(dst+0);
	dst4.store4(dst+4);
	dst += 8; src += 8; a += 8; n -= 8;
	continue; // Keep our stride at 8 pixels as long as possible.
	}
	SkASSERT(n <= 7);
	if (n >= 4) {
	fn(Load4(dst), Load4(src), Load4Alphas(a)).store4(dst);
	dst += 4; src += 4; a += 4; n -= 4;
	}
	if (n >= 2) {
	fn(Load2(dst), Load2(src), Load2Alphas(a)).store2(dst);
	dst += 2; src += 2; a += 2; n -= 2;
	}
	if (n >= 1) {
	fn(Load1(dst), Load1(src), Sk16b(*a)).store1(dst);
	}
	break;
	}
	}

	private:
	Sk4px() = default;

	typedef Sk16b INHERITED;
	};

	} // namespace

	#ifdef SKNX_NO_SIMD
	#include "src/opts/Sk4px_none.h"
	#else
	#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
	#include "src/opts/Sk4px_SSE2.h"
	#elif defined(SK_ARM_HAS_NEON)
	#include "src/opts/Sk4px_NEON.h"
	#else
	#include "src/opts/Sk4px_none.h"
	#endif
	#endif

	#endif//Sk4px_DEFINED