public static byte4 bitmask8(byte4 numBits, byte4 index = default(byte4))
{
Assert.IsBetween(index.x, 0u, 8u);
Assert.IsBetween(index.y, 0u, 8u);
Assert.IsBetween(index.z, 0u, 8u);
Assert.IsBetween(index.w, 0u, 8u);
Assert.IsBetween(numBits.x, 0u, 8u - index.x);
Assert.IsBetween(numBits.y, 0u, 8u - index.y);
Assert.IsBetween(numBits.z, 0u, 8u - index.z);
Assert.IsBetween(numBits.w, 0u, 8u - index.w);
// mask
index = shl(byte.MaxValue, index);
if (Sse2.IsSse2Supported)
{
v128 isMaxBitsMask = Sse2.cmpeq_epi8(numBits, new byte4(8));
return(isMaxBitsMask | andnot(index, shl(index, numBits)));
}
else
{
return((byte4)(-toint16(numBits == 16)) | andnot(index, shl(index, numBits)));
}
}
public static byte4 tzcnt(byte4 x)
{
if (Ssse3.IsSsse3Supported)
{
v128 NIBBLE_MASK = new v128(0x0F0F_0F0F);
v128 SHUFFLE_MASK_LO = new v128(8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0);
v128 SHUFFLE_MASK_HI = new v128(8, 4, 5, 4, 6, 4, 5, 4, 7, 4, 5, 4, 6, 4, 5, 4);
return(Sse2.min_epu8(Ssse3.shuffle_epi8(SHUFFLE_MASK_LO, Sse2.and_si128(NIBBLE_MASK, x)),
Ssse3.shuffle_epi8(SHUFFLE_MASK_HI, Sse2.and_si128(NIBBLE_MASK, Sse2.srli_epi16(x, 4)))));
}
else if (Sse2.IsSse2Supported)
{
v128 compareMask = x & (byte4)(-(sbyte4)x);
byte4 first = Mask.BlendV(default(v128), new byte4(1), Sse2.cmpeq_epi8(compareMask, default(v128)));
byte4 second = Mask.BlendV(default(v128), new byte4(4), Sse2.cmpeq_epi8(compareMask & (byte4)0x0F, default(v128)));
byte4 third = Mask.BlendV(default(v128), new byte4(2), Sse2.cmpeq_epi8(compareMask & (byte4)0x33, default(v128)));
byte4 fourth = Mask.BlendV(default(v128), new byte4(1), Sse2.cmpeq_epi8(compareMask & (byte4)0x55, default(v128)));
return((first + second) + (third + fourth));
}
else
{
return(new byte4(tzcnt(x.x), tzcnt(x.y), tzcnt(x.z), tzcnt(x.w)));
}
}
public byte4x4(byte v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
public static byte4 lcm(sbyte4 x, sbyte4 y)
{
byte4 absX = (byte4)abs(x);
byte4 absY = (byte4)abs(y);
return((absX / gcd(absX, absY)) * absY);
}
public static byte4 reversebits(byte4 x)
{
x = ((x >> 1) & 0x55) | ((x & 0x55) << 1);
x = ((x >> 2) & 0x33) | ((x & 0x33) << 2);
return((x >> 4) | (x << 4));
}
public byte4x4(byte4 c0, byte4 c1, byte4 c2, byte4 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
static private void InsetYCoCgBBox(ref byte4 minColor, ref byte4 maxColor)
{
var inset = stackalloc int[4];
var mini = stackalloc int[4];
var maxi = stackalloc int[4];
inset[0] = (maxColor.V0 - minColor.V0) - ((1 << (INSET_COLOR_SHIFT - 1)) - 1);
inset[1] = (maxColor.V1 - minColor.V1) - ((1 << (INSET_COLOR_SHIFT - 1)) - 1);
inset[3] = (maxColor.V3 - minColor.V3) - ((1 << (INSET_ALPHA_SHIFT - 1)) - 1);
mini[0] = ((minColor.V0 << INSET_COLOR_SHIFT) + inset[0]) >> INSET_COLOR_SHIFT;
mini[1] = ((minColor.V1 << INSET_COLOR_SHIFT) + inset[1]) >> INSET_COLOR_SHIFT;
mini[3] = ((minColor.V3 << INSET_ALPHA_SHIFT) + inset[3]) >> INSET_ALPHA_SHIFT;
maxi[0] = ((maxColor.V0 << INSET_COLOR_SHIFT) - inset[0]) >> INSET_COLOR_SHIFT;
maxi[1] = ((maxColor.V1 << INSET_COLOR_SHIFT) - inset[1]) >> INSET_COLOR_SHIFT;
maxi[3] = ((maxColor.V3 << INSET_ALPHA_SHIFT) - inset[3]) >> INSET_ALPHA_SHIFT;
mini[0] = (mini[0] >= 0) ? mini[0] : 0;
mini[1] = (mini[1] >= 0) ? mini[1] : 0;
mini[3] = (mini[3] >= 0) ? mini[3] : 0;
maxi[0] = (maxi[0] <= 255) ? maxi[0] : 255;
maxi[1] = (maxi[1] <= 255) ? maxi[1] : 255;
maxi[3] = (maxi[3] <= 255) ? maxi[3] : 255;
minColor.V0 = (byte)((mini[0] & C565_5_MASK) | (mini[0] >> 5));
minColor.V1 = (byte)((mini[1] & C565_6_MASK) | (mini[1] >> 6));
minColor.V3 = (byte)(mini[3]);
maxColor.V0 = (byte)((maxi[0] & C565_5_MASK) | (maxi[0] >> 5));
maxColor.V1 = (byte)((maxi[1] & C565_6_MASK) | (maxi[1] >> 6));
maxColor.V3 = (byte)(maxi[3]);
}
static private void SelectYCoCgDiagonal(byte4[] colorBlock, ref byte4 MinColor, ref byte4 MaxColor)
{
int i;
byte c0, c1;
byte mid0 = (byte)(((int)MinColor.V0 + MaxColor.V0 + 1) >> 1);
byte mid1 = (byte)(((int)MinColor.V1 + MaxColor.V1 + 1) >> 1);
byte side = 0;
for (i = 0; i < 16; i++)
{
byte b0 = (byte)((colorBlock[i].V0 >= mid0) ? 1 : 0);
byte b1 = (byte)((colorBlock[i].V1 >= mid1) ? 1 : 0);
side += (byte)(b0 ^ b1);
}
byte mask = (byte)(-((side > 8) ? 1 : 0));
//if (NVIDIA_7X_HARDWARE_BUG_FIX) mask &= -( minColor[0] != maxColor[0] );
c0 = MinColor.V1;
c1 = MaxColor.V1;
c0 ^= c1 ^= mask &= c0 ^= c1;
MinColor.V1 = c0;
MaxColor.V1 = c1;
}
public byte4x2(byte m00, byte m01,
byte m10, byte m11,
byte m20, byte m21,
byte m30, byte m31)
{
this.c0 = new byte4(m00, m10, m20, m30);
this.c1 = new byte4(m01, m11, m21, m31);
}
public static byte4 floorpow2(byte4 x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
return(x - (x >> 1));
}
public void Byte4_ParseFromString(byte v0, byte v1, byte v2, byte v3)
{
string s = NormalFormat.F(v0, v1, v2, v3);
byte4 n = new byte4(v0, v1, v2, v3);
byte4 ns = byte4.Parse(s);
Assert.That(ns, Is.EqualTo(n));
}
public void Byte4_WriteToString(byte v0, byte v1, byte v2, byte v3)
{
string s = NormalFormat.F(v0, v1, v2, v3);
byte4 n = new byte4(v0, v1, v2, v3);
string sn = n.ToString();
Assert.That(sn, Is.EqualTo(s));
}
public static uint cprod(byte4 x)
{
uint4 cast = x;
cast *= cast.zwzw;
cast *= cast.yyyy;
return(cast.x);
}
public void Byte4_GetIndices(byte v0, byte v1, byte v2, byte v3)
{
byte4 n = new byte4(v0, v1, v2, v3);
Assert.That(n[0], Is.EqualTo(v0));
Assert.That(n[1], Is.EqualTo(v1));
Assert.That(n[2], Is.EqualTo(v2));
Assert.That(n[3], Is.EqualTo(v3));
}
public void Byte4_GetFields(byte v0, byte v1, byte v2, byte v3)
{
byte4 n = new byte4(v0, v1, v2, v3);
Assert.That(n.x, Is.EqualTo(v0));
Assert.That(n.y, Is.EqualTo(v1));
Assert.That(n.z, Is.EqualTo(v2));
Assert.That(n.w, Is.EqualTo(v3));
}
public void Byte4_TryParse(byte v0, byte v1, byte v2, byte v3)
{
string s = NormalFormat.F(v0, v1, v2, v3);
byte4 n = new byte4(v0, v1, v2, v3);
byte4 ns;
Assert.IsTrue(byte4.TryParse(s, out ns));
Assert.That(ns, Is.EqualTo(n));
}
public byte4x3(byte m00, byte m01, byte m02,
byte m10, byte m11, byte m12,
byte m20, byte m21, byte m22,
byte m30, byte m31, byte m32)
{
this.c0 = new byte4(m00, m10, m20, m30);
this.c1 = new byte4(m01, m11, m21, m31);
this.c2 = new byte4(m02, m12, m22, m32);
}
public static float4 mul(byte4 a, float b)
{
return(new float4(
a.x * b,
a.y * b,
a.z * b,
a.w * b
));
}
public static byte4 ceilpow2(byte4 x)
{
x -= 1;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
return(x + 1);
}
public static float4 mul(float a, byte4 b)
{
return(new float4(
a * b.x,
a * b.y,
a * b.z,
a * b.w
));
}
public void Byte4_ParseFromString_ArbitarySpace(byte v0, byte v1, byte v2, byte v3)
{
foreach (string fmt in ArbitaryWhiteSpaceFormat)
{
string s = fmt.F(v0, v1, v2, v3);
byte4 n = new byte4(v0, v1, v2, v3);
byte4 ns = byte4.Parse(s);
Assert.That(ns, Is.EqualTo(n));
}
}
public byte4x4(byte m00, byte m01, byte m02, byte m03,
byte m10, byte m11, byte m12, byte m13,
byte m20, byte m21, byte m22, byte m23,
byte m30, byte m31, byte m32, byte m33)
{
this.c0 = new byte4(m00, m10, m20, m30);
this.c1 = new byte4(m01, m11, m21, m31);
this.c2 = new byte4(m02, m12, m22, m32);
this.c3 = new byte4(m03, m13, m23, m33);
}
public static byte4 countbits(byte4 x)
{
if (Ssse3.IsSsse3Supported)
{
return((v128)countbits((byte16)(v128)x));
}
else
{
return(new byte4((byte)math.countbits((uint)x.x), (byte)math.countbits((uint)x.y), (byte)math.countbits((uint)x.z), (byte)math.countbits((uint)x.w)));
}
}
public static bool all(byte4 x)
{
if (Sse2.IsSse2Supported)
{
return(0 == Sse2.cmpeq_epi8(x, default(v128)).UInt0);
}
else
{
return(math.all(x != 0));
}
}
internal static byte4 vdiv_byte(byte4 dividend, byte4 divisor)
{
Assert.AreNotEqual(divisor.x, 0);
Assert.AreNotEqual(divisor.y, 0);
Assert.AreNotEqual(divisor.z, 0);
Assert.AreNotEqual(divisor.w, 0);
v128 floatResult = vdiv_byte_quotient((int4)dividend, (int4)divisor);
return((byte4)(*(float4 *)&floatResult));
}
public static byte4 andnot(byte4 left, byte4 right)
{
if (Sse2.IsSse2Supported)
{
return(Sse2.andnot_si128(right, left));
}
else
{
return(left & ~right);
}
}
public static void byte4()
{
Random8 rng = new Random8(135);
for (int i = 0; i < 64; i++)
{
byte4 x = rng.NextByte4();
Assert.AreEqual(new byte4((byte)_intsqrt(x.x), (byte)_intsqrt(x.y), (byte)_intsqrt(x.z), (byte)_intsqrt(x.w)), maxmath.intsqrt(x));
}
}
public static byte4 subadd(byte4 a, byte4 b)
{
if (Ssse3.IsSsse3Supported)
{
return(a + Ssse3.sign_epi8(b, new byte4(255, 1, 255, 1)));
}
else
{
return(a - select(b, (byte4)(-(sbyte4)b), new bool4(false, true, false, true)));
}
}
public static bool any(byte4 x)
{
if (Sse2.IsSse2Supported)
{
return(0 != ((v128)x).UInt0);
}
else
{
return(math.any(x != 0));
}
}
public static uint csum(byte4 x)
{
if (Sse2.IsSse2Supported)
{
return(sad(x, byte4.zero));
}
else
{
return((uint)((x.x + x.y) + (x.z + x.w)));
}
}
