godot/thirdparty/etcpak/ProcessRGB.cpp

4184 lines
164 KiB
C++
Raw Normal View History

#include <array>
#include <string.h>
#include <limits>
#ifdef __ARM_NEON
# include <arm_neon.h>
#endif
#include "Dither.hpp"
#include "ForceInline.hpp"
#include "Math.hpp"
#include "ProcessCommon.hpp"
#include "ProcessRGB.hpp"
#include "Tables.hpp"
#include "Vector.hpp"
#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER
# ifdef _MSC_VER
# include <intrin.h>
# include <Windows.h>
# define _bswap(x) _byteswap_ulong(x)
# define _bswap64(x) _byteswap_uint64(x)
# else
# include <x86intrin.h>
# endif
#endif
#ifndef _bswap
# define _bswap(x) __builtin_bswap32(x)
# define _bswap64(x) __builtin_bswap64(x)
#endif
static const uint32_t MaxError = 1065369600; // ((38+76+14) * 255)^2
// common T-/H-mode table
static uint8_t tableTH[8] = { 3, 6, 11, 16, 23, 32, 41, 64 };
// thresholds for the early compression-mode decision scheme
// default: 0.03, 0.09, and 0.38
float ecmd_threshold[3] = { 0.03f, 0.09f, 0.38f };
static const uint8_t ModeUndecided = 0;
static const uint8_t ModePlanar = 0x1;
static const uint8_t ModeTH = 0x2;
const unsigned int R = 2;
const unsigned int G = 1;
const unsigned int B = 0;
struct Luma
{
#ifdef __AVX2__
float max, min;
uint8_t minIdx = 255, maxIdx = 255;
__m128i luma8;
#elif defined __ARM_NEON && defined __aarch64__
float max, min;
uint8_t minIdx = 255, maxIdx = 255;
uint8x16_t luma8;
#else
uint8_t max = 0, min = 255, maxIdx = 0, minIdx = 0;
uint8_t val[16];
#endif
};
#ifdef __AVX2__
struct Plane
{
uint64_t plane;
uint64_t error;
__m256i sum4;
};
#endif
#if defined __AVX2__ || (defined __ARM_NEON && defined __aarch64__)
struct Channels
{
#ifdef __AVX2__
__m128i r8, g8, b8;
#elif defined __ARM_NEON && defined __aarch64__
uint8x16x2_t r, g, b;
#endif
};
#endif
namespace
{
static etcpak_force_inline uint8_t clamp( uint8_t min, int16_t val, uint8_t max )
{
return val < min ? min : ( val > max ? max : val );
}
static etcpak_force_inline uint8_t clampMin( uint8_t min, int16_t val )
{
return val < min ? min : val;
}
static etcpak_force_inline uint8_t clampMax( int16_t val, uint8_t max )
{
return val > max ? max : val;
}
// slightly faster than std::sort
static void insertionSort( uint8_t* arr1, uint8_t* arr2 )
{
for( uint8_t i = 1; i < 16; ++i )
{
uint8_t value = arr1[i];
uint8_t hole = i;
for( ; hole > 0 && value < arr1[hole - 1]; --hole )
{
arr1[hole] = arr1[hole - 1];
arr2[hole] = arr2[hole - 1];
}
arr1[hole] = value;
arr2[hole] = i;
}
}
//converts indices from |a0|a1|e0|e1|i0|i1|m0|m1|b0|b1|f0|f1|j0|j1|n0|n1|c0|c1|g0|g1|k0|k1|o0|o1|d0|d1|h0|h1|l0|l1|p0|p1| previously used by T- and H-modes
// into |p0|o0|n0|m0|l0|k0|j0|i0|h0|g0|f0|e0|d0|c0|b0|a0|p1|o1|n1|m1|l1|k1|j1|i1|h1|g1|f1|e1|d1|c1|b1|a1| which should be used for all modes.
// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved.
static etcpak_force_inline int indexConversion( int pixelIndices )
{
int correctIndices = 0;
int LSB[4][4];
int MSB[4][4];
int shift = 0;
for( int y = 3; y >= 0; y-- )
{
for( int x = 3; x >= 0; x-- )
{
LSB[x][y] = ( pixelIndices >> shift ) & 1;
shift++;
MSB[x][y] = ( pixelIndices >> shift ) & 1;
shift++;
}
}
shift = 0;
for( int x = 0; x < 4; x++ )
{
for( int y = 0; y < 4; y++ )
{
correctIndices |= ( LSB[x][y] << shift );
correctIndices |= ( MSB[x][y] << ( 16 + shift ) );
shift++;
}
}
return correctIndices;
}
// Swapping two RGB-colors
// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved.
static etcpak_force_inline void swapColors( uint8_t( colors )[2][3] )
{
uint8_t temp = colors[0][R];
colors[0][R] = colors[1][R];
colors[1][R] = temp;
temp = colors[0][G];
colors[0][G] = colors[1][G];
colors[1][G] = temp;
temp = colors[0][B];
colors[0][B] = colors[1][B];
colors[1][B] = temp;
}
// calculates quantized colors for T or H modes
void compressColor( uint8_t( currColor )[2][3], uint8_t( quantColor )[2][3], bool t_mode )
{
if( t_mode )
{
quantColor[0][R] = clampMax( 15 * ( currColor[0][R] + 8 ) / 255, 15 );
quantColor[0][G] = clampMax( 15 * ( currColor[0][G] + 8 ) / 255, 15 );
quantColor[0][B] = clampMax( 15 * ( currColor[0][B] + 8 ) / 255, 15 );
}
else // clamped to [1,14] to get a wider range
{
quantColor[0][R] = clamp( 1, 15 * ( currColor[0][R] + 8 ) / 255, 14 );
quantColor[0][G] = clamp( 1, 15 * ( currColor[0][G] + 8 ) / 255, 14 );
quantColor[0][B] = clamp( 1, 15 * ( currColor[0][B] + 8 ) / 255, 14 );
}
// clamped to [1,14] to get a wider range
quantColor[1][R] = clamp( 1, 15 * ( currColor[1][R] + 8 ) / 255, 14 );
quantColor[1][G] = clamp( 1, 15 * ( currColor[1][G] + 8 ) / 255, 14 );
quantColor[1][B] = clamp( 1, 15 * ( currColor[1][B] + 8 ) / 255, 14 );
}
// three decoding functions come from ETCPACK v2.74 and are slightly changed.
static etcpak_force_inline void decompressColor( uint8_t( colorsRGB444 )[2][3], uint8_t( colors )[2][3] )
{
// The color should be retrieved as:
//
// c = round(255/(r_bits^2-1))*comp_color
//
// This is similar to bit replication
//
// Note -- this code only work for bit replication from 4 bits and up --- 3 bits needs
// two copy operations.
colors[0][R] = ( colorsRGB444[0][R] << 4 ) | colorsRGB444[0][R];
colors[0][G] = ( colorsRGB444[0][G] << 4 ) | colorsRGB444[0][G];
colors[0][B] = ( colorsRGB444[0][B] << 4 ) | colorsRGB444[0][B];
colors[1][R] = ( colorsRGB444[1][R] << 4 ) | colorsRGB444[1][R];
colors[1][G] = ( colorsRGB444[1][G] << 4 ) | colorsRGB444[1][G];
colors[1][B] = ( colorsRGB444[1][B] << 4 ) | colorsRGB444[1][B];
}
// calculates the paint colors from the block colors
// using a distance d and one of the H- or T-patterns.
static void calculatePaintColors59T( uint8_t d, uint8_t( colors )[2][3], uint8_t( pColors )[4][3] )
{
//////////////////////////////////////////////
//
// C3 C1 C4----C1---C2
// | | |
// | | |
// |-------| |
// | | |
// | | |
// C4 C2 C3
//
//////////////////////////////////////////////
// C4
pColors[3][R] = clampMin( 0, colors[1][R] - tableTH[d] );
pColors[3][G] = clampMin( 0, colors[1][G] - tableTH[d] );
pColors[3][B] = clampMin( 0, colors[1][B] - tableTH[d] );
// C3
pColors[0][R] = colors[0][R];
pColors[0][G] = colors[0][G];
pColors[0][B] = colors[0][B];
// C2
pColors[1][R] = clampMax( colors[1][R] + tableTH[d], 255 );
pColors[1][G] = clampMax( colors[1][G] + tableTH[d], 255 );
pColors[1][B] = clampMax( colors[1][B] + tableTH[d], 255 );
// C1
pColors[2][R] = colors[1][R];
pColors[2][G] = colors[1][G];
pColors[2][B] = colors[1][B];
}
static void calculatePaintColors58H( uint8_t d, uint8_t( colors )[2][3], uint8_t( pColors )[4][3] )
{
pColors[3][R] = clampMin( 0, colors[1][R] - tableTH[d] );
pColors[3][G] = clampMin( 0, colors[1][G] - tableTH[d] );
pColors[3][B] = clampMin( 0, colors[1][B] - tableTH[d] );
// C1
pColors[0][R] = clampMax( colors[0][R] + tableTH[d], 255 );
pColors[0][G] = clampMax( colors[0][G] + tableTH[d], 255 );
pColors[0][B] = clampMax( colors[0][B] + tableTH[d], 255 );
// C2
pColors[1][R] = clampMin( 0, colors[0][R] - tableTH[d] );
pColors[1][G] = clampMin( 0, colors[0][G] - tableTH[d] );
pColors[1][B] = clampMin( 0, colors[0][B] - tableTH[d] );
// C3
pColors[2][R] = clampMax( colors[1][R] + tableTH[d], 255 );
pColors[2][G] = clampMax( colors[1][G] + tableTH[d], 255 );
pColors[2][B] = clampMax( colors[1][B] + tableTH[d], 255 );
}
#if defined _MSC_VER && !defined __clang__
static etcpak_force_inline unsigned long _bit_scan_forward( unsigned long mask )
{
unsigned long ret;
_BitScanForward( &ret, mask );
return ret;
}
#endif
typedef std::array<uint16_t, 4> v4i;
#ifdef __AVX2__
static etcpak_force_inline __m256i Sum4_AVX2( const uint8_t* data) noexcept
{
__m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0);
__m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1);
__m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2);
__m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3);
__m128i dm0 = _mm_and_si128(d0, _mm_set1_epi32(0x00FFFFFF));
__m128i dm1 = _mm_and_si128(d1, _mm_set1_epi32(0x00FFFFFF));
__m128i dm2 = _mm_and_si128(d2, _mm_set1_epi32(0x00FFFFFF));
__m128i dm3 = _mm_and_si128(d3, _mm_set1_epi32(0x00FFFFFF));
__m256i t0 = _mm256_cvtepu8_epi16(dm0);
__m256i t1 = _mm256_cvtepu8_epi16(dm1);
__m256i t2 = _mm256_cvtepu8_epi16(dm2);
__m256i t3 = _mm256_cvtepu8_epi16(dm3);
__m256i sum0 = _mm256_add_epi16(t0, t1);
__m256i sum1 = _mm256_add_epi16(t2, t3);
__m256i s0 = _mm256_permute2x128_si256(sum0, sum1, (0) | (3 << 4)); // 0, 0, 3, 3
__m256i s1 = _mm256_permute2x128_si256(sum0, sum1, (1) | (2 << 4)); // 1, 1, 2, 2
__m256i s2 = _mm256_permute4x64_epi64(s0, _MM_SHUFFLE(1, 3, 0, 2));
__m256i s3 = _mm256_permute4x64_epi64(s0, _MM_SHUFFLE(0, 2, 1, 3));
__m256i s4 = _mm256_permute4x64_epi64(s1, _MM_SHUFFLE(3, 1, 0, 2));
__m256i s5 = _mm256_permute4x64_epi64(s1, _MM_SHUFFLE(2, 0, 1, 3));
__m256i sum5 = _mm256_add_epi16(s2, s3); // 3, 0, 3, 0
__m256i sum6 = _mm256_add_epi16(s4, s5); // 2, 1, 1, 2
return _mm256_add_epi16(sum5, sum6); // 3+2, 0+1, 3+1, 3+2
}
static etcpak_force_inline __m256i Average_AVX2( const __m256i data) noexcept
{
__m256i a = _mm256_add_epi16(data, _mm256_set1_epi16(4));
return _mm256_srli_epi16(a, 3);
}
static etcpak_force_inline __m128i CalcErrorBlock_AVX2( const __m256i data, const v4i a[8]) noexcept
{
//
__m256i a0 = _mm256_load_si256((__m256i*)a[0].data());
__m256i a1 = _mm256_load_si256((__m256i*)a[4].data());
// err = 8 * ( sq( average[0] ) + sq( average[1] ) + sq( average[2] ) );
__m256i a4 = _mm256_madd_epi16(a0, a0);
__m256i a5 = _mm256_madd_epi16(a1, a1);
__m256i a6 = _mm256_hadd_epi32(a4, a5);
__m256i a7 = _mm256_slli_epi32(a6, 3);
__m256i a8 = _mm256_add_epi32(a7, _mm256_set1_epi32(0x3FFFFFFF)); // Big value to prevent negative values, but small enough to prevent overflow
// average is not swapped
// err -= block[0] * 2 * average[0];
// err -= block[1] * 2 * average[1];
// err -= block[2] * 2 * average[2];
__m256i a2 = _mm256_slli_epi16(a0, 1);
__m256i a3 = _mm256_slli_epi16(a1, 1);
__m256i b0 = _mm256_madd_epi16(a2, data);
__m256i b1 = _mm256_madd_epi16(a3, data);
__m256i b2 = _mm256_hadd_epi32(b0, b1);
__m256i b3 = _mm256_sub_epi32(a8, b2);
__m256i b4 = _mm256_hadd_epi32(b3, b3);
__m256i b5 = _mm256_permutevar8x32_epi32(b4, _mm256_set_epi32(0, 0, 0, 0, 5, 1, 4, 0));
return _mm256_castsi256_si128(b5);
}
static etcpak_force_inline void ProcessAverages_AVX2(const __m256i d, v4i a[8] ) noexcept
{
__m256i t = _mm256_add_epi16(_mm256_mullo_epi16(d, _mm256_set1_epi16(31)), _mm256_set1_epi16(128));
__m256i c = _mm256_srli_epi16(_mm256_add_epi16(t, _mm256_srli_epi16(t, 8)), 8);
__m256i c1 = _mm256_shuffle_epi32(c, _MM_SHUFFLE(3, 2, 3, 2));
__m256i diff = _mm256_sub_epi16(c, c1);
diff = _mm256_max_epi16(diff, _mm256_set1_epi16(-4));
diff = _mm256_min_epi16(diff, _mm256_set1_epi16(3));
__m256i co = _mm256_add_epi16(c1, diff);
c = _mm256_blend_epi16(co, c, 0xF0);
__m256i a0 = _mm256_or_si256(_mm256_slli_epi16(c, 3), _mm256_srli_epi16(c, 2));
_mm256_store_si256((__m256i*)a[4].data(), a0);
__m256i t0 = _mm256_add_epi16(_mm256_mullo_epi16(d, _mm256_set1_epi16(15)), _mm256_set1_epi16(128));
__m256i t1 = _mm256_srli_epi16(_mm256_add_epi16(t0, _mm256_srli_epi16(t0, 8)), 8);
__m256i t2 = _mm256_or_si256(t1, _mm256_slli_epi16(t1, 4));
_mm256_store_si256((__m256i*)a[0].data(), t2);
}
static etcpak_force_inline uint64_t EncodeAverages_AVX2( const v4i a[8], size_t idx ) noexcept
{
uint64_t d = ( idx << 24 );
size_t base = idx << 1;
__m128i a0 = _mm_load_si128((const __m128i*)a[base].data());
__m128i r0, r1;
if( ( idx & 0x2 ) == 0 )
{
r0 = _mm_srli_epi16(a0, 4);
__m128i a1 = _mm_unpackhi_epi64(r0, r0);
r1 = _mm_slli_epi16(a1, 4);
}
else
{
__m128i a1 = _mm_and_si128(a0, _mm_set1_epi16(-8));
r0 = _mm_unpackhi_epi64(a1, a1);
__m128i a2 = _mm_sub_epi16(a1, r0);
__m128i a3 = _mm_srai_epi16(a2, 3);
r1 = _mm_and_si128(a3, _mm_set1_epi16(0x07));
}
__m128i r2 = _mm_or_si128(r0, r1);
// do missing swap for average values
__m128i r3 = _mm_shufflelo_epi16(r2, _MM_SHUFFLE(3, 0, 1, 2));
__m128i r4 = _mm_packus_epi16(r3, _mm_setzero_si128());
d |= _mm_cvtsi128_si32(r4);
return d;
}
static etcpak_force_inline uint64_t CheckSolid_AVX2( const uint8_t* src ) noexcept
{
__m256i d0 = _mm256_loadu_si256(((__m256i*)src) + 0);
__m256i d1 = _mm256_loadu_si256(((__m256i*)src) + 1);
__m256i c = _mm256_broadcastd_epi32(_mm256_castsi256_si128(d0));
__m256i c0 = _mm256_cmpeq_epi8(d0, c);
__m256i c1 = _mm256_cmpeq_epi8(d1, c);
__m256i m = _mm256_and_si256(c0, c1);
if (!_mm256_testc_si256(m, _mm256_set1_epi32(-1)))
{
return 0;
}
return 0x02000000 |
( (unsigned int)( src[0] & 0xF8 ) << 16 ) |
( (unsigned int)( src[1] & 0xF8 ) << 8 ) |
( (unsigned int)( src[2] & 0xF8 ) );
}
static etcpak_force_inline __m128i PrepareAverages_AVX2( v4i a[8], const uint8_t* src) noexcept
{
__m256i sum4 = Sum4_AVX2( src );
ProcessAverages_AVX2(Average_AVX2( sum4 ), a );
return CalcErrorBlock_AVX2( sum4, a);
}
static etcpak_force_inline __m128i PrepareAverages_AVX2( v4i a[8], const __m256i sum4) noexcept
{
ProcessAverages_AVX2(Average_AVX2( sum4 ), a );
return CalcErrorBlock_AVX2( sum4, a);
}
static etcpak_force_inline void FindBestFit_4x2_AVX2( uint32_t terr[2][8], uint32_t tsel[8], v4i a[8], const uint32_t offset, const uint8_t* data) noexcept
{
__m256i sel0 = _mm256_setzero_si256();
__m256i sel1 = _mm256_setzero_si256();
for (unsigned int j = 0; j < 2; ++j)
{
unsigned int bid = offset + 1 - j;
__m256i squareErrorSum = _mm256_setzero_si256();
__m128i a0 = _mm_loadl_epi64((const __m128i*)a[bid].data());
__m256i a1 = _mm256_broadcastq_epi64(a0);
// Processing one full row each iteration
for (size_t i = 0; i < 8; i += 4)
{
__m128i rgb = _mm_loadu_si128((const __m128i*)(data + i * 4));
__m256i rgb16 = _mm256_cvtepu8_epi16(rgb);
__m256i d = _mm256_sub_epi16(a1, rgb16);
// The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16
// This produces slightly different results, but is significant faster
__m256i pixel0 = _mm256_madd_epi16(d, _mm256_set_epi16(0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14));
__m256i pixel1 = _mm256_packs_epi32(pixel0, pixel0);
__m256i pixel2 = _mm256_hadd_epi16(pixel1, pixel1);
__m128i pixel3 = _mm256_castsi256_si128(pixel2);
__m128i pix0 = _mm_broadcastw_epi16(pixel3);
__m128i pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16));
__m256i pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1);
// Processing first two pixels of the row
{
__m256i pix = _mm256_abs_epi16(pixel);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
// Since the selector table is symmetrical, we need to calculate the difference only for half of the entries.
__m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0])));
__m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1])));
__m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1));
__m256i minError = _mm256_min_epi16(error0, error1);
// Exploiting symmetry of the selector table and use the sign bit
// This produces slightly different results, but is significant faster
__m256i minIndex1 = _mm256_srli_epi16(pixel, 15);
// Interleaving values so madd instruction can be used
__m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0));
__m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2));
__m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi);
// Squaring the minimum error to produce correct values when adding
__m256i squareError = _mm256_madd_epi16(minError2, minError2);
squareErrorSum = _mm256_add_epi32(squareErrorSum, squareError);
// Packing selector bits
__m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i + j * 8));
__m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i + j * 8));
sel0 = _mm256_or_si256(sel0, minIndexLo2);
sel1 = _mm256_or_si256(sel1, minIndexHi2);
}
pixel3 = _mm256_extracti128_si256(pixel2, 1);
pix0 = _mm_broadcastw_epi16(pixel3);
pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16));
pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1);
// Processing second two pixels of the row
{
__m256i pix = _mm256_abs_epi16(pixel);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
// Since the selector table is symmetrical, we need to calculate the difference only for half of the entries.
__m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0])));
__m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1])));
__m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1));
__m256i minError = _mm256_min_epi16(error0, error1);
// Exploiting symmetry of the selector table and use the sign bit
__m256i minIndex1 = _mm256_srli_epi16(pixel, 15);
// Interleaving values so madd instruction can be used
__m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0));
__m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2));
__m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi);
// Squaring the minimum error to produce correct values when adding
__m256i squareError = _mm256_madd_epi16(minError2, minError2);
squareErrorSum = _mm256_add_epi32(squareErrorSum, squareError);
// Packing selector bits
__m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i + j * 8));
__m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i + j * 8));
__m256i minIndexLo3 = _mm256_slli_epi16(minIndexLo2, 2);
__m256i minIndexHi3 = _mm256_slli_epi16(minIndexHi2, 2);
sel0 = _mm256_or_si256(sel0, minIndexLo3);
sel1 = _mm256_or_si256(sel1, minIndexHi3);
}
}
data += 8 * 4;
_mm256_store_si256((__m256i*)terr[1 - j], squareErrorSum);
}
// Interleave selector bits
__m256i minIndexLo0 = _mm256_unpacklo_epi16(sel0, sel1);
__m256i minIndexHi0 = _mm256_unpackhi_epi16(sel0, sel1);
__m256i minIndexLo1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (0) | (2 << 4));
__m256i minIndexHi1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (1) | (3 << 4));
__m256i minIndexHi2 = _mm256_slli_epi32(minIndexHi1, 1);
__m256i sel = _mm256_or_si256(minIndexLo1, minIndexHi2);
_mm256_store_si256((__m256i*)tsel, sel);
}
static etcpak_force_inline void FindBestFit_2x4_AVX2( uint32_t terr[2][8], uint32_t tsel[8], v4i a[8], const uint32_t offset, const uint8_t* data) noexcept
{
__m256i sel0 = _mm256_setzero_si256();
__m256i sel1 = _mm256_setzero_si256();
__m256i squareErrorSum0 = _mm256_setzero_si256();
__m256i squareErrorSum1 = _mm256_setzero_si256();
__m128i a0 = _mm_loadl_epi64((const __m128i*)a[offset + 1].data());
__m128i a1 = _mm_loadl_epi64((const __m128i*)a[offset + 0].data());
__m128i a2 = _mm_broadcastq_epi64(a0);
__m128i a3 = _mm_broadcastq_epi64(a1);
__m256i a4 = _mm256_insertf128_si256(_mm256_castsi128_si256(a2), a3, 1);
// Processing one full row each iteration
for (size_t i = 0; i < 16; i += 4)
{
__m128i rgb = _mm_loadu_si128((const __m128i*)(data + i * 4));
__m256i rgb16 = _mm256_cvtepu8_epi16(rgb);
__m256i d = _mm256_sub_epi16(a4, rgb16);
// The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16
// This produces slightly different results, but is significant faster
__m256i pixel0 = _mm256_madd_epi16(d, _mm256_set_epi16(0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14, 0, 38, 76, 14));
__m256i pixel1 = _mm256_packs_epi32(pixel0, pixel0);
__m256i pixel2 = _mm256_hadd_epi16(pixel1, pixel1);
__m128i pixel3 = _mm256_castsi256_si128(pixel2);
__m128i pix0 = _mm_broadcastw_epi16(pixel3);
__m128i pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16));
__m256i pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1);
// Processing first two pixels of the row
{
__m256i pix = _mm256_abs_epi16(pixel);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
// Since the selector table is symmetrical, we need to calculate the difference only for half of the entries.
__m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0])));
__m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1])));
__m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1));
__m256i minError = _mm256_min_epi16(error0, error1);
// Exploiting symmetry of the selector table and use the sign bit
__m256i minIndex1 = _mm256_srli_epi16(pixel, 15);
// Interleaving values so madd instruction can be used
__m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0));
__m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2));
__m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi);
// Squaring the minimum error to produce correct values when adding
__m256i squareError = _mm256_madd_epi16(minError2, minError2);
squareErrorSum0 = _mm256_add_epi32(squareErrorSum0, squareError);
// Packing selector bits
__m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i));
__m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i));
sel0 = _mm256_or_si256(sel0, minIndexLo2);
sel1 = _mm256_or_si256(sel1, minIndexHi2);
}
pixel3 = _mm256_extracti128_si256(pixel2, 1);
pix0 = _mm_broadcastw_epi16(pixel3);
pix1 = _mm_broadcastw_epi16(_mm_srli_epi32(pixel3, 16));
pixel = _mm256_insertf128_si256(_mm256_castsi128_si256(pix0), pix1, 1);
// Processing second two pixels of the row
{
__m256i pix = _mm256_abs_epi16(pixel);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
// Since the selector table is symmetrical, we need to calculate the difference only for half of the entries.
__m256i error0 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[0])));
__m256i error1 = _mm256_abs_epi16(_mm256_sub_epi16(pix, _mm256_broadcastsi128_si256(g_table128_SIMD[1])));
__m256i minIndex0 = _mm256_and_si256(_mm256_cmpgt_epi16(error0, error1), _mm256_set1_epi16(1));
__m256i minError = _mm256_min_epi16(error0, error1);
// Exploiting symmetry of the selector table and use the sign bit
__m256i minIndex1 = _mm256_srli_epi16(pixel, 15);
// Interleaving values so madd instruction can be used
__m256i minErrorLo = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(1, 1, 0, 0));
__m256i minErrorHi = _mm256_permute4x64_epi64(minError, _MM_SHUFFLE(3, 3, 2, 2));
__m256i minError2 = _mm256_unpacklo_epi16(minErrorLo, minErrorHi);
// Squaring the minimum error to produce correct values when adding
__m256i squareError = _mm256_madd_epi16(minError2, minError2);
squareErrorSum1 = _mm256_add_epi32(squareErrorSum1, squareError);
// Packing selector bits
__m256i minIndexLo2 = _mm256_sll_epi16(minIndex0, _mm_cvtsi64_si128(i));
__m256i minIndexHi2 = _mm256_sll_epi16(minIndex1, _mm_cvtsi64_si128(i));
__m256i minIndexLo3 = _mm256_slli_epi16(minIndexLo2, 2);
__m256i minIndexHi3 = _mm256_slli_epi16(minIndexHi2, 2);
sel0 = _mm256_or_si256(sel0, minIndexLo3);
sel1 = _mm256_or_si256(sel1, minIndexHi3);
}
}
_mm256_store_si256((__m256i*)terr[1], squareErrorSum0);
_mm256_store_si256((__m256i*)terr[0], squareErrorSum1);
// Interleave selector bits
__m256i minIndexLo0 = _mm256_unpacklo_epi16(sel0, sel1);
__m256i minIndexHi0 = _mm256_unpackhi_epi16(sel0, sel1);
__m256i minIndexLo1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (0) | (2 << 4));
__m256i minIndexHi1 = _mm256_permute2x128_si256(minIndexLo0, minIndexHi0, (1) | (3 << 4));
__m256i minIndexHi2 = _mm256_slli_epi32(minIndexHi1, 1);
__m256i sel = _mm256_or_si256(minIndexLo1, minIndexHi2);
_mm256_store_si256((__m256i*)tsel, sel);
}
static etcpak_force_inline uint64_t EncodeSelectors_AVX2( uint64_t d, const uint32_t terr[2][8], const uint32_t tsel[8], const bool rotate) noexcept
{
size_t tidx[2];
// Get index of minimum error (terr[0] and terr[1])
__m256i err0 = _mm256_load_si256((const __m256i*)terr[0]);
__m256i err1 = _mm256_load_si256((const __m256i*)terr[1]);
__m256i errLo = _mm256_permute2x128_si256(err0, err1, (0) | (2 << 4));
__m256i errHi = _mm256_permute2x128_si256(err0, err1, (1) | (3 << 4));
__m256i errMin0 = _mm256_min_epu32(errLo, errHi);
__m256i errMin1 = _mm256_shuffle_epi32(errMin0, _MM_SHUFFLE(2, 3, 0, 1));
__m256i errMin2 = _mm256_min_epu32(errMin0, errMin1);
__m256i errMin3 = _mm256_shuffle_epi32(errMin2, _MM_SHUFFLE(1, 0, 3, 2));
__m256i errMin4 = _mm256_min_epu32(errMin3, errMin2);
__m256i errMin5 = _mm256_permute2x128_si256(errMin4, errMin4, (0) | (0 << 4));
__m256i errMin6 = _mm256_permute2x128_si256(errMin4, errMin4, (1) | (1 << 4));
__m256i errMask0 = _mm256_cmpeq_epi32(errMin5, err0);
__m256i errMask1 = _mm256_cmpeq_epi32(errMin6, err1);
uint32_t mask0 = _mm256_movemask_epi8(errMask0);
uint32_t mask1 = _mm256_movemask_epi8(errMask1);
tidx[0] = _bit_scan_forward(mask0) >> 2;
tidx[1] = _bit_scan_forward(mask1) >> 2;
d |= tidx[0] << 26;
d |= tidx[1] << 29;
unsigned int t0 = tsel[tidx[0]];
unsigned int t1 = tsel[tidx[1]];
if (!rotate)
{
t0 &= 0xFF00FF00;
t1 &= 0x00FF00FF;
}
else
{
t0 &= 0xCCCCCCCC;
t1 &= 0x33333333;
}
// Flip selectors from sign bit
unsigned int t2 = (t0 | t1) ^ 0xFFFF0000;
return d | static_cast<uint64_t>(_bswap(t2)) << 32;
}
static etcpak_force_inline __m128i r6g7b6_AVX2(__m128 cof, __m128 chf, __m128 cvf) noexcept
{
__m128i co = _mm_cvttps_epi32(cof);
__m128i ch = _mm_cvttps_epi32(chf);
__m128i cv = _mm_cvttps_epi32(cvf);
__m128i coh = _mm_packus_epi32(co, ch);
__m128i cv0 = _mm_packus_epi32(cv, _mm_setzero_si128());
__m256i cohv0 = _mm256_inserti128_si256(_mm256_castsi128_si256(coh), cv0, 1);
__m256i cohv1 = _mm256_min_epu16(cohv0, _mm256_set1_epi16(1023));
__m256i cohv2 = _mm256_sub_epi16(cohv1, _mm256_set1_epi16(15));
__m256i cohv3 = _mm256_srai_epi16(cohv2, 1);
__m256i cohvrb0 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(11));
__m256i cohvrb1 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(4));
__m256i cohvg0 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(9));
__m256i cohvg1 = _mm256_add_epi16(cohv3, _mm256_set1_epi16(6));
__m256i cohvrb2 = _mm256_srai_epi16(cohvrb0, 7);
__m256i cohvrb3 = _mm256_srai_epi16(cohvrb1, 7);
__m256i cohvg2 = _mm256_srai_epi16(cohvg0, 8);
__m256i cohvg3 = _mm256_srai_epi16(cohvg1, 8);
__m256i cohvrb4 = _mm256_sub_epi16(cohvrb0, cohvrb2);
__m256i cohvrb5 = _mm256_sub_epi16(cohvrb4, cohvrb3);
__m256i cohvg4 = _mm256_sub_epi16(cohvg0, cohvg2);
__m256i cohvg5 = _mm256_sub_epi16(cohvg4, cohvg3);
__m256i cohvrb6 = _mm256_srai_epi16(cohvrb5, 3);
__m256i cohvg6 = _mm256_srai_epi16(cohvg5, 2);
__m256i cohv4 = _mm256_blend_epi16(cohvg6, cohvrb6, 0x55);
__m128i cohv5 = _mm_packus_epi16(_mm256_castsi256_si128(cohv4), _mm256_extracti128_si256(cohv4, 1));
return _mm_shuffle_epi8(cohv5, _mm_setr_epi8(6, 5, 4, -1, 2, 1, 0, -1, 10, 9, 8, -1, -1, -1, -1, -1));
}
static etcpak_force_inline Plane Planar_AVX2( const Channels& ch, uint8_t& mode, bool useHeuristics )
{
__m128i t0 = _mm_sad_epu8( ch.r8, _mm_setzero_si128() );
__m128i t1 = _mm_sad_epu8( ch.g8, _mm_setzero_si128() );
__m128i t2 = _mm_sad_epu8( ch.b8, _mm_setzero_si128() );
__m128i r8s = _mm_shuffle_epi8( ch.r8, _mm_set_epi8( 0xF, 0xE, 0xB, 0xA, 0x7, 0x6, 0x3, 0x2, 0xD, 0xC, 0x9, 0x8, 0x5, 0x4, 0x1, 0x0 ) );
__m128i g8s = _mm_shuffle_epi8( ch.g8, _mm_set_epi8( 0xF, 0xE, 0xB, 0xA, 0x7, 0x6, 0x3, 0x2, 0xD, 0xC, 0x9, 0x8, 0x5, 0x4, 0x1, 0x0 ) );
__m128i b8s = _mm_shuffle_epi8( ch.b8, _mm_set_epi8( 0xF, 0xE, 0xB, 0xA, 0x7, 0x6, 0x3, 0x2, 0xD, 0xC, 0x9, 0x8, 0x5, 0x4, 0x1, 0x0 ) );
__m128i s0 = _mm_sad_epu8( r8s, _mm_setzero_si128() );
__m128i s1 = _mm_sad_epu8( g8s, _mm_setzero_si128() );
__m128i s2 = _mm_sad_epu8( b8s, _mm_setzero_si128() );
__m256i sr0 = _mm256_insertf128_si256( _mm256_castsi128_si256( t0 ), s0, 1 );
__m256i sg0 = _mm256_insertf128_si256( _mm256_castsi128_si256( t1 ), s1, 1 );
__m256i sb0 = _mm256_insertf128_si256( _mm256_castsi128_si256( t2 ), s2, 1 );
__m256i sr1 = _mm256_slli_epi64( sr0, 32 );
__m256i sg1 = _mm256_slli_epi64( sg0, 16 );
__m256i srb = _mm256_or_si256( sr1, sb0 );
__m256i srgb = _mm256_or_si256( srb, sg1 );
if( mode != ModePlanar && useHeuristics )
{
Plane plane;
plane.sum4 = _mm256_permute4x64_epi64( srgb, _MM_SHUFFLE( 2, 3, 0, 1 ) );
return plane;
}
__m128i t3 = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps( t0 ), _mm_castsi128_ps( t1 ), _MM_SHUFFLE( 2, 0, 2, 0 ) ) );
__m128i t4 = _mm_shuffle_epi32( t2, _MM_SHUFFLE( 3, 1, 2, 0 ) );
__m128i t5 = _mm_hadd_epi32( t3, t4 );
__m128i t6 = _mm_shuffle_epi32( t5, _MM_SHUFFLE( 1, 1, 1, 1 ) );
__m128i t7 = _mm_shuffle_epi32( t5, _MM_SHUFFLE( 2, 2, 2, 2 ) );
__m256i sr = _mm256_broadcastw_epi16( t5 );
__m256i sg = _mm256_broadcastw_epi16( t6 );
__m256i sb = _mm256_broadcastw_epi16( t7 );
__m256i r08 = _mm256_cvtepu8_epi16( ch.r8 );
__m256i g08 = _mm256_cvtepu8_epi16( ch.g8 );
__m256i b08 = _mm256_cvtepu8_epi16( ch.b8 );
__m256i r16 = _mm256_slli_epi16( r08, 4 );
__m256i g16 = _mm256_slli_epi16( g08, 4 );
__m256i b16 = _mm256_slli_epi16( b08, 4 );
__m256i difR0 = _mm256_sub_epi16( r16, sr );
__m256i difG0 = _mm256_sub_epi16( g16, sg );
__m256i difB0 = _mm256_sub_epi16( b16, sb );
__m256i difRyz = _mm256_madd_epi16( difR0, _mm256_set_epi16( 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255 ) );
__m256i difGyz = _mm256_madd_epi16( difG0, _mm256_set_epi16( 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255 ) );
__m256i difByz = _mm256_madd_epi16( difB0, _mm256_set_epi16( 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255, 255, 85, -85, -255 ) );
__m256i difRxz = _mm256_madd_epi16( difR0, _mm256_set_epi16( 255, 255, 255, 255, 85, 85, 85, 85, -85, -85, -85, -85, -255, -255, -255, -255 ) );
__m256i difGxz = _mm256_madd_epi16( difG0, _mm256_set_epi16( 255, 255, 255, 255, 85, 85, 85, 85, -85, -85, -85, -85, -255, -255, -255, -255 ) );
__m256i difBxz = _mm256_madd_epi16( difB0, _mm256_set_epi16( 255, 255, 255, 255, 85, 85, 85, 85, -85, -85, -85, -85, -255, -255, -255, -255 ) );
__m256i difRGyz = _mm256_hadd_epi32( difRyz, difGyz );
__m256i difByzxz = _mm256_hadd_epi32( difByz, difBxz );
__m256i difRGxz = _mm256_hadd_epi32( difRxz, difGxz );
__m128i sumRGyz = _mm_add_epi32( _mm256_castsi256_si128( difRGyz ), _mm256_extracti128_si256( difRGyz, 1 ) );
__m128i sumByzxz = _mm_add_epi32( _mm256_castsi256_si128( difByzxz ), _mm256_extracti128_si256( difByzxz, 1 ) );
__m128i sumRGxz = _mm_add_epi32( _mm256_castsi256_si128( difRGxz ), _mm256_extracti128_si256( difRGxz, 1 ) );
__m128i sumRGByz = _mm_hadd_epi32( sumRGyz, sumByzxz );
__m128i sumRGByzxz = _mm_hadd_epi32( sumRGxz, sumByzxz );
__m128i sumRGBxz = _mm_shuffle_epi32( sumRGByzxz, _MM_SHUFFLE( 2, 3, 1, 0 ) );
__m128 sumRGByzf = _mm_cvtepi32_ps( sumRGByz );
__m128 sumRGBxzf = _mm_cvtepi32_ps( sumRGBxz );
const float value = ( 255 * 255 * 8.0f + 85 * 85 * 8.0f ) * 16.0f;
__m128 scale = _mm_set1_ps( -4.0f / value );
__m128 af = _mm_mul_ps( sumRGBxzf, scale );
__m128 bf = _mm_mul_ps( sumRGByzf, scale );
__m128 df = _mm_mul_ps( _mm_cvtepi32_ps( t5 ), _mm_set1_ps( 4.0f / 16.0f ) );
// calculating the three colors RGBO, RGBH, and RGBV. RGB = df - af * x - bf * y;
__m128 cof0 = _mm_fnmadd_ps( af, _mm_set1_ps( -255.0f ), _mm_fnmadd_ps( bf, _mm_set1_ps( -255.0f ), df ) );
__m128 chf0 = _mm_fnmadd_ps( af, _mm_set1_ps( 425.0f ), _mm_fnmadd_ps( bf, _mm_set1_ps( -255.0f ), df ) );
__m128 cvf0 = _mm_fnmadd_ps( af, _mm_set1_ps( -255.0f ), _mm_fnmadd_ps( bf, _mm_set1_ps( 425.0f ), df ) );
// convert to r6g7b6
__m128i cohv = r6g7b6_AVX2( cof0, chf0, cvf0 );
uint64_t rgbho = _mm_extract_epi64( cohv, 0 );
uint32_t rgbv0 = _mm_extract_epi32( cohv, 2 );
// Error calculation
uint64_t error = 0;
if( !useHeuristics )
{
auto ro0 = ( rgbho >> 48 ) & 0x3F;
auto go0 = ( rgbho >> 40 ) & 0x7F;
auto bo0 = ( rgbho >> 32 ) & 0x3F;
auto ro1 = ( ro0 >> 4 ) | ( ro0 << 2 );
auto go1 = ( go0 >> 6 ) | ( go0 << 1 );
auto bo1 = ( bo0 >> 4 ) | ( bo0 << 2 );
auto ro2 = ( ro1 << 2 ) + 2;
auto go2 = ( go1 << 2 ) + 2;
auto bo2 = ( bo1 << 2 ) + 2;
__m256i ro3 = _mm256_set1_epi16( ro2 );
__m256i go3 = _mm256_set1_epi16( go2 );
__m256i bo3 = _mm256_set1_epi16( bo2 );
auto rh0 = ( rgbho >> 16 ) & 0x3F;
auto gh0 = ( rgbho >> 8 ) & 0x7F;
auto bh0 = ( rgbho >> 0 ) & 0x3F;
auto rh1 = ( rh0 >> 4 ) | ( rh0 << 2 );
auto gh1 = ( gh0 >> 6 ) | ( gh0 << 1 );
auto bh1 = ( bh0 >> 4 ) | ( bh0 << 2 );
auto rh2 = rh1 - ro1;
auto gh2 = gh1 - go1;
auto bh2 = bh1 - bo1;
__m256i rh3 = _mm256_set1_epi16( rh2 );
__m256i gh3 = _mm256_set1_epi16( gh2 );
__m256i bh3 = _mm256_set1_epi16( bh2 );
auto rv0 = ( rgbv0 >> 16 ) & 0x3F;
auto gv0 = ( rgbv0 >> 8 ) & 0x7F;
auto bv0 = ( rgbv0 >> 0 ) & 0x3F;
auto rv1 = ( rv0 >> 4 ) | ( rv0 << 2 );
auto gv1 = ( gv0 >> 6 ) | ( gv0 << 1 );
auto bv1 = ( bv0 >> 4 ) | ( bv0 << 2 );
auto rv2 = rv1 - ro1;
auto gv2 = gv1 - go1;
auto bv2 = bv1 - bo1;
__m256i rv3 = _mm256_set1_epi16( rv2 );
__m256i gv3 = _mm256_set1_epi16( gv2 );
__m256i bv3 = _mm256_set1_epi16( bv2 );
__m256i x = _mm256_set_epi16( 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0 );
__m256i rh4 = _mm256_mullo_epi16( rh3, x );
__m256i gh4 = _mm256_mullo_epi16( gh3, x );
__m256i bh4 = _mm256_mullo_epi16( bh3, x );
__m256i y = _mm256_set_epi16( 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0 );
__m256i rv4 = _mm256_mullo_epi16( rv3, y );
__m256i gv4 = _mm256_mullo_epi16( gv3, y );
__m256i bv4 = _mm256_mullo_epi16( bv3, y );
__m256i rxy = _mm256_add_epi16( rh4, rv4 );
__m256i gxy = _mm256_add_epi16( gh4, gv4 );
__m256i bxy = _mm256_add_epi16( bh4, bv4 );
__m256i rp0 = _mm256_add_epi16( rxy, ro3 );
__m256i gp0 = _mm256_add_epi16( gxy, go3 );
__m256i bp0 = _mm256_add_epi16( bxy, bo3 );
__m256i rp1 = _mm256_srai_epi16( rp0, 2 );
__m256i gp1 = _mm256_srai_epi16( gp0, 2 );
__m256i bp1 = _mm256_srai_epi16( bp0, 2 );
__m256i rp2 = _mm256_max_epi16( _mm256_min_epi16( rp1, _mm256_set1_epi16( 255 ) ), _mm256_setzero_si256() );
__m256i gp2 = _mm256_max_epi16( _mm256_min_epi16( gp1, _mm256_set1_epi16( 255 ) ), _mm256_setzero_si256() );
__m256i bp2 = _mm256_max_epi16( _mm256_min_epi16( bp1, _mm256_set1_epi16( 255 ) ), _mm256_setzero_si256() );
__m256i rdif = _mm256_sub_epi16( r08, rp2 );
__m256i gdif = _mm256_sub_epi16( g08, gp2 );
__m256i bdif = _mm256_sub_epi16( b08, bp2 );
__m256i rerr = _mm256_mullo_epi16( rdif, _mm256_set1_epi16( 38 ) );
__m256i gerr = _mm256_mullo_epi16( gdif, _mm256_set1_epi16( 76 ) );
__m256i berr = _mm256_mullo_epi16( bdif, _mm256_set1_epi16( 14 ) );
__m256i sum0 = _mm256_add_epi16( rerr, gerr );
__m256i sum1 = _mm256_add_epi16( sum0, berr );
__m256i sum2 = _mm256_madd_epi16( sum1, sum1 );
__m128i sum3 = _mm_add_epi32( _mm256_castsi256_si128( sum2 ), _mm256_extracti128_si256( sum2, 1 ) );
uint32_t err0 = _mm_extract_epi32( sum3, 0 );
uint32_t err1 = _mm_extract_epi32( sum3, 1 );
uint32_t err2 = _mm_extract_epi32( sum3, 2 );
uint32_t err3 = _mm_extract_epi32( sum3, 3 );
error = err0 + err1 + err2 + err3;
}
/**/
uint32_t rgbv = ( rgbv0 & 0x3F ) | ( ( rgbv0 >> 2 ) & 0x1FC0 ) | ( ( rgbv0 >> 3 ) & 0x7E000 );
uint64_t rgbho0_ = ( rgbho & 0x3F0000003F ) | ( ( rgbho >> 2 ) & 0x1FC000001FC0 ) | ( ( rgbho >> 3 ) & 0x7E0000007E000 );
uint64_t rgbho0 = ( rgbho0_ & 0x7FFFF ) | ( ( rgbho0_ >> 13 ) & 0x3FFFF80000 );
uint32_t hi = rgbv | ((rgbho0 & 0x1FFF) << 19);
rgbho0 >>= 13;
uint32_t lo = ( rgbho0 & 0x1 ) | ( ( rgbho0 & 0x1FE ) << 1 ) | ( ( rgbho0 & 0x600 ) << 2 ) | ( ( rgbho0 & 0x3F800 ) << 5 ) | ( ( rgbho0 & 0x1FC0000 ) << 6 );
uint32_t idx = ( ( rgbho >> 33 ) & 0xF ) | ( ( rgbho >> 41 ) & 0x10 ) | ( ( rgbho >> 48 ) & 0x20 );
lo |= g_flags[idx];
uint64_t result = static_cast<uint32_t>(_bswap(lo));
result |= static_cast<uint64_t>(static_cast<uint32_t>(_bswap(hi))) << 32;
Plane plane;
plane.plane = result;
if( useHeuristics )
{
plane.error = 0;
mode = ModePlanar;
}
else
{
plane.error = error;
}
plane.sum4 = _mm256_permute4x64_epi64(srgb, _MM_SHUFFLE(2, 3, 0, 1));
return plane;
}
static etcpak_force_inline uint64_t EncodeSelectors_AVX2( uint64_t d, const uint32_t terr[2][8], const uint32_t tsel[8], const bool rotate, const uint64_t value, const uint32_t error) noexcept
{
size_t tidx[2];
// Get index of minimum error (terr[0] and terr[1])
__m256i err0 = _mm256_load_si256((const __m256i*)terr[0]);
__m256i err1 = _mm256_load_si256((const __m256i*)terr[1]);
__m256i errLo = _mm256_permute2x128_si256(err0, err1, (0) | (2 << 4));
__m256i errHi = _mm256_permute2x128_si256(err0, err1, (1) | (3 << 4));
__m256i errMin0 = _mm256_min_epu32(errLo, errHi);
__m256i errMin1 = _mm256_shuffle_epi32(errMin0, _MM_SHUFFLE(2, 3, 0, 1));
__m256i errMin2 = _mm256_min_epu32(errMin0, errMin1);
__m256i errMin3 = _mm256_shuffle_epi32(errMin2, _MM_SHUFFLE(1, 0, 3, 2));
__m256i errMin4 = _mm256_min_epu32(errMin3, errMin2);
__m256i errMin5 = _mm256_permute2x128_si256(errMin4, errMin4, (0) | (0 << 4));
__m256i errMin6 = _mm256_permute2x128_si256(errMin4, errMin4, (1) | (1 << 4));
__m256i errMask0 = _mm256_cmpeq_epi32(errMin5, err0);
__m256i errMask1 = _mm256_cmpeq_epi32(errMin6, err1);
uint32_t mask0 = _mm256_movemask_epi8(errMask0);
uint32_t mask1 = _mm256_movemask_epi8(errMask1);
tidx[0] = _bit_scan_forward(mask0) >> 2;
tidx[1] = _bit_scan_forward(mask1) >> 2;
if ((terr[0][tidx[0]] + terr[1][tidx[1]]) >= error)
{
return value;
}
d |= tidx[0] << 26;
d |= tidx[1] << 29;
unsigned int t0 = tsel[tidx[0]];
unsigned int t1 = tsel[tidx[1]];
if (!rotate)
{
t0 &= 0xFF00FF00;
t1 &= 0x00FF00FF;
}
else
{
t0 &= 0xCCCCCCCC;
t1 &= 0x33333333;
}
// Flip selectors from sign bit
unsigned int t2 = (t0 | t1) ^ 0xFFFF0000;
return d | static_cast<uint64_t>(_bswap(t2)) << 32;
}
#endif
static etcpak_force_inline void Average( const uint8_t* data, v4i* a )
{
#ifdef __SSE4_1__
__m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0);
__m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1);
__m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2);
__m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3);
__m128i d0l = _mm_unpacklo_epi8(d0, _mm_setzero_si128());
__m128i d0h = _mm_unpackhi_epi8(d0, _mm_setzero_si128());
__m128i d1l = _mm_unpacklo_epi8(d1, _mm_setzero_si128());
__m128i d1h = _mm_unpackhi_epi8(d1, _mm_setzero_si128());
__m128i d2l = _mm_unpacklo_epi8(d2, _mm_setzero_si128());
__m128i d2h = _mm_unpackhi_epi8(d2, _mm_setzero_si128());
__m128i d3l = _mm_unpacklo_epi8(d3, _mm_setzero_si128());
__m128i d3h = _mm_unpackhi_epi8(d3, _mm_setzero_si128());
__m128i sum0 = _mm_add_epi16(d0l, d1l);
__m128i sum1 = _mm_add_epi16(d0h, d1h);
__m128i sum2 = _mm_add_epi16(d2l, d3l);
__m128i sum3 = _mm_add_epi16(d2h, d3h);
__m128i sum0l = _mm_unpacklo_epi16(sum0, _mm_setzero_si128());
__m128i sum0h = _mm_unpackhi_epi16(sum0, _mm_setzero_si128());
__m128i sum1l = _mm_unpacklo_epi16(sum1, _mm_setzero_si128());
__m128i sum1h = _mm_unpackhi_epi16(sum1, _mm_setzero_si128());
__m128i sum2l = _mm_unpacklo_epi16(sum2, _mm_setzero_si128());
__m128i sum2h = _mm_unpackhi_epi16(sum2, _mm_setzero_si128());
__m128i sum3l = _mm_unpacklo_epi16(sum3, _mm_setzero_si128());
__m128i sum3h = _mm_unpackhi_epi16(sum3, _mm_setzero_si128());
__m128i b0 = _mm_add_epi32(sum0l, sum0h);
__m128i b1 = _mm_add_epi32(sum1l, sum1h);
__m128i b2 = _mm_add_epi32(sum2l, sum2h);
__m128i b3 = _mm_add_epi32(sum3l, sum3h);
__m128i a0 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b2, b3), _mm_set1_epi32(4)), 3);
__m128i a1 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b0, b1), _mm_set1_epi32(4)), 3);
__m128i a2 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b1, b3), _mm_set1_epi32(4)), 3);
__m128i a3 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b0, b2), _mm_set1_epi32(4)), 3);
_mm_storeu_si128((__m128i*)&a[0], _mm_packus_epi32(_mm_shuffle_epi32(a0, _MM_SHUFFLE(3, 0, 1, 2)), _mm_shuffle_epi32(a1, _MM_SHUFFLE(3, 0, 1, 2))));
_mm_storeu_si128((__m128i*)&a[2], _mm_packus_epi32(_mm_shuffle_epi32(a2, _MM_SHUFFLE(3, 0, 1, 2)), _mm_shuffle_epi32(a3, _MM_SHUFFLE(3, 0, 1, 2))));
#elif defined __ARM_NEON
uint8x16x2_t t0 = vzipq_u8(vld1q_u8(data + 0), uint8x16_t());
uint8x16x2_t t1 = vzipq_u8(vld1q_u8(data + 16), uint8x16_t());
uint8x16x2_t t2 = vzipq_u8(vld1q_u8(data + 32), uint8x16_t());
uint8x16x2_t t3 = vzipq_u8(vld1q_u8(data + 48), uint8x16_t());
uint16x8x2_t d0 = { vreinterpretq_u16_u8(t0.val[0]), vreinterpretq_u16_u8(t0.val[1]) };
uint16x8x2_t d1 = { vreinterpretq_u16_u8(t1.val[0]), vreinterpretq_u16_u8(t1.val[1]) };
uint16x8x2_t d2 = { vreinterpretq_u16_u8(t2.val[0]), vreinterpretq_u16_u8(t2.val[1]) };
uint16x8x2_t d3 = { vreinterpretq_u16_u8(t3.val[0]), vreinterpretq_u16_u8(t3.val[1]) };
uint16x8x2_t s0 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[0] ), vreinterpretq_s16_u16( d1.val[0] ) ) ), uint16x8_t());
uint16x8x2_t s1 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[1] ), vreinterpretq_s16_u16( d1.val[1] ) ) ), uint16x8_t());
uint16x8x2_t s2 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[0] ), vreinterpretq_s16_u16( d3.val[0] ) ) ), uint16x8_t());
uint16x8x2_t s3 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[1] ), vreinterpretq_s16_u16( d3.val[1] ) ) ), uint16x8_t());
uint32x4x2_t sum0 = { vreinterpretq_u32_u16(s0.val[0]), vreinterpretq_u32_u16(s0.val[1]) };
uint32x4x2_t sum1 = { vreinterpretq_u32_u16(s1.val[0]), vreinterpretq_u32_u16(s1.val[1]) };
uint32x4x2_t sum2 = { vreinterpretq_u32_u16(s2.val[0]), vreinterpretq_u32_u16(s2.val[1]) };
uint32x4x2_t sum3 = { vreinterpretq_u32_u16(s3.val[0]), vreinterpretq_u32_u16(s3.val[1]) };
uint32x4_t b0 = vaddq_u32(sum0.val[0], sum0.val[1]);
uint32x4_t b1 = vaddq_u32(sum1.val[0], sum1.val[1]);
uint32x4_t b2 = vaddq_u32(sum2.val[0], sum2.val[1]);
uint32x4_t b3 = vaddq_u32(sum3.val[0], sum3.val[1]);
uint32x4_t a0 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b2, b3), vdupq_n_u32(4)), 3);
uint32x4_t a1 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b0, b1), vdupq_n_u32(4)), 3);
uint32x4_t a2 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b1, b3), vdupq_n_u32(4)), 3);
uint32x4_t a3 = vshrq_n_u32(vqaddq_u32(vqaddq_u32(b0, b2), vdupq_n_u32(4)), 3);
uint16x8_t o0 = vcombine_u16(vqmovun_s32(vreinterpretq_s32_u32( a0 )), vqmovun_s32(vreinterpretq_s32_u32( a1 )));
uint16x8_t o1 = vcombine_u16(vqmovun_s32(vreinterpretq_s32_u32( a2 )), vqmovun_s32(vreinterpretq_s32_u32( a3 )));
a[0] = v4i{o0[2], o0[1], o0[0], 0};
a[1] = v4i{o0[6], o0[5], o0[4], 0};
a[2] = v4i{o1[2], o1[1], o1[0], 0};
a[3] = v4i{o1[6], o1[5], o1[4], 0};
#else
uint32_t r[4];
uint32_t g[4];
uint32_t b[4];
memset(r, 0, sizeof(r));
memset(g, 0, sizeof(g));
memset(b, 0, sizeof(b));
for( int j=0; j<4; j++ )
{
for( int i=0; i<4; i++ )
{
int index = (j & 2) + (i >> 1);
b[index] += *data++;
g[index] += *data++;
r[index] += *data++;
data++;
}
}
a[0] = v4i{ uint16_t( (r[2] + r[3] + 4) / 8 ), uint16_t( (g[2] + g[3] + 4) / 8 ), uint16_t( (b[2] + b[3] + 4) / 8 ), 0};
a[1] = v4i{ uint16_t( (r[0] + r[1] + 4) / 8 ), uint16_t( (g[0] + g[1] + 4) / 8 ), uint16_t( (b[0] + b[1] + 4) / 8 ), 0};
a[2] = v4i{ uint16_t( (r[1] + r[3] + 4) / 8 ), uint16_t( (g[1] + g[3] + 4) / 8 ), uint16_t( (b[1] + b[3] + 4) / 8 ), 0};
a[3] = v4i{ uint16_t( (r[0] + r[2] + 4) / 8 ), uint16_t( (g[0] + g[2] + 4) / 8 ), uint16_t( (b[0] + b[2] + 4) / 8 ), 0};
#endif
}
static etcpak_force_inline void CalcErrorBlock( const uint8_t* data, unsigned int err[4][4] )
{
#ifdef __SSE4_1__
__m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0);
__m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1);
__m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2);
__m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3);
__m128i dm0 = _mm_and_si128(d0, _mm_set1_epi32(0x00FFFFFF));
__m128i dm1 = _mm_and_si128(d1, _mm_set1_epi32(0x00FFFFFF));
__m128i dm2 = _mm_and_si128(d2, _mm_set1_epi32(0x00FFFFFF));
__m128i dm3 = _mm_and_si128(d3, _mm_set1_epi32(0x00FFFFFF));
__m128i d0l = _mm_unpacklo_epi8(dm0, _mm_setzero_si128());
__m128i d0h = _mm_unpackhi_epi8(dm0, _mm_setzero_si128());
__m128i d1l = _mm_unpacklo_epi8(dm1, _mm_setzero_si128());
__m128i d1h = _mm_unpackhi_epi8(dm1, _mm_setzero_si128());
__m128i d2l = _mm_unpacklo_epi8(dm2, _mm_setzero_si128());
__m128i d2h = _mm_unpackhi_epi8(dm2, _mm_setzero_si128());
__m128i d3l = _mm_unpacklo_epi8(dm3, _mm_setzero_si128());
__m128i d3h = _mm_unpackhi_epi8(dm3, _mm_setzero_si128());
__m128i sum0 = _mm_add_epi16(d0l, d1l);
__m128i sum1 = _mm_add_epi16(d0h, d1h);
__m128i sum2 = _mm_add_epi16(d2l, d3l);
__m128i sum3 = _mm_add_epi16(d2h, d3h);
__m128i sum0l = _mm_unpacklo_epi16(sum0, _mm_setzero_si128());
__m128i sum0h = _mm_unpackhi_epi16(sum0, _mm_setzero_si128());
__m128i sum1l = _mm_unpacklo_epi16(sum1, _mm_setzero_si128());
__m128i sum1h = _mm_unpackhi_epi16(sum1, _mm_setzero_si128());
__m128i sum2l = _mm_unpacklo_epi16(sum2, _mm_setzero_si128());
__m128i sum2h = _mm_unpackhi_epi16(sum2, _mm_setzero_si128());
__m128i sum3l = _mm_unpacklo_epi16(sum3, _mm_setzero_si128());
__m128i sum3h = _mm_unpackhi_epi16(sum3, _mm_setzero_si128());
__m128i b0 = _mm_add_epi32(sum0l, sum0h);
__m128i b1 = _mm_add_epi32(sum1l, sum1h);
__m128i b2 = _mm_add_epi32(sum2l, sum2h);
__m128i b3 = _mm_add_epi32(sum3l, sum3h);
__m128i a0 = _mm_add_epi32(b2, b3);
__m128i a1 = _mm_add_epi32(b0, b1);
__m128i a2 = _mm_add_epi32(b1, b3);
__m128i a3 = _mm_add_epi32(b0, b2);
_mm_storeu_si128((__m128i*)&err[0], a0);
_mm_storeu_si128((__m128i*)&err[1], a1);
_mm_storeu_si128((__m128i*)&err[2], a2);
_mm_storeu_si128((__m128i*)&err[3], a3);
#elif defined __ARM_NEON
uint8x16x2_t t0 = vzipq_u8(vld1q_u8(data + 0), uint8x16_t());
uint8x16x2_t t1 = vzipq_u8(vld1q_u8(data + 16), uint8x16_t());
uint8x16x2_t t2 = vzipq_u8(vld1q_u8(data + 32), uint8x16_t());
uint8x16x2_t t3 = vzipq_u8(vld1q_u8(data + 48), uint8x16_t());
uint16x8x2_t d0 = { vreinterpretq_u16_u8(t0.val[0]), vreinterpretq_u16_u8(t0.val[1]) };
uint16x8x2_t d1 = { vreinterpretq_u16_u8(t1.val[0]), vreinterpretq_u16_u8(t1.val[1]) };
uint16x8x2_t d2 = { vreinterpretq_u16_u8(t2.val[0]), vreinterpretq_u16_u8(t2.val[1]) };
uint16x8x2_t d3 = { vreinterpretq_u16_u8(t3.val[0]), vreinterpretq_u16_u8(t3.val[1]) };
uint16x8x2_t s0 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[0] ), vreinterpretq_s16_u16( d1.val[0] ))), uint16x8_t());
uint16x8x2_t s1 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d0.val[1] ), vreinterpretq_s16_u16( d1.val[1] ))), uint16x8_t());
uint16x8x2_t s2 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[0] ), vreinterpretq_s16_u16( d3.val[0] ))), uint16x8_t());
uint16x8x2_t s3 = vzipq_u16(vreinterpretq_u16_s16( vaddq_s16(vreinterpretq_s16_u16( d2.val[1] ), vreinterpretq_s16_u16( d3.val[1] ))), uint16x8_t());
uint32x4x2_t sum0 = { vreinterpretq_u32_u16(s0.val[0]), vreinterpretq_u32_u16(s0.val[1]) };
uint32x4x2_t sum1 = { vreinterpretq_u32_u16(s1.val[0]), vreinterpretq_u32_u16(s1.val[1]) };
uint32x4x2_t sum2 = { vreinterpretq_u32_u16(s2.val[0]), vreinterpretq_u32_u16(s2.val[1]) };
uint32x4x2_t sum3 = { vreinterpretq_u32_u16(s3.val[0]), vreinterpretq_u32_u16(s3.val[1]) };
uint32x4_t b0 = vaddq_u32(sum0.val[0], sum0.val[1]);
uint32x4_t b1 = vaddq_u32(sum1.val[0], sum1.val[1]);
uint32x4_t b2 = vaddq_u32(sum2.val[0], sum2.val[1]);
uint32x4_t b3 = vaddq_u32(sum3.val[0], sum3.val[1]);
uint32x4_t a0 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b2, b3) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) );
uint32x4_t a1 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b0, b1) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) );
uint32x4_t a2 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b1, b3) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) );
uint32x4_t a3 = vreinterpretq_u32_u8( vandq_u8(vreinterpretq_u8_u32( vqaddq_u32(b0, b2) ), vreinterpretq_u8_u32( vdupq_n_u32(0x00FFFFFF)) ) );
vst1q_u32(err[0], a0);
vst1q_u32(err[1], a1);
vst1q_u32(err[2], a2);
vst1q_u32(err[3], a3);
#else
unsigned int terr[4][4];
memset(terr, 0, 16 * sizeof(unsigned int));
for( int j=0; j<4; j++ )
{
for( int i=0; i<4; i++ )
{
int index = (j & 2) + (i >> 1);
unsigned int d = *data++;
terr[index][0] += d;
d = *data++;
terr[index][1] += d;
d = *data++;
terr[index][2] += d;
data++;
}
}
for( int i=0; i<3; i++ )
{
err[0][i] = terr[2][i] + terr[3][i];
err[1][i] = terr[0][i] + terr[1][i];
err[2][i] = terr[1][i] + terr[3][i];
err[3][i] = terr[0][i] + terr[2][i];
}
for( int i=0; i<4; i++ )
{
err[i][3] = 0;
}
#endif
}
static etcpak_force_inline unsigned int CalcError( const unsigned int block[4], const v4i& average )
{
unsigned int err = 0x3FFFFFFF; // Big value to prevent negative values, but small enough to prevent overflow
err -= block[0] * 2 * average[2];
err -= block[1] * 2 * average[1];
err -= block[2] * 2 * average[0];
err += 8 * ( sq( average[0] ) + sq( average[1] ) + sq( average[2] ) );
return err;
}
static etcpak_force_inline void ProcessAverages( v4i* a )
{
#ifdef __SSE4_1__
for( int i=0; i<2; i++ )
{
__m128i d = _mm_loadu_si128((__m128i*)a[i*2].data());
__m128i t = _mm_add_epi16(_mm_mullo_epi16(d, _mm_set1_epi16(31)), _mm_set1_epi16(128));
__m128i c = _mm_srli_epi16(_mm_add_epi16(t, _mm_srli_epi16(t, 8)), 8);
__m128i c1 = _mm_shuffle_epi32(c, _MM_SHUFFLE(3, 2, 3, 2));
__m128i diff = _mm_sub_epi16(c, c1);
diff = _mm_max_epi16(diff, _mm_set1_epi16(-4));
diff = _mm_min_epi16(diff, _mm_set1_epi16(3));
__m128i co = _mm_add_epi16(c1, diff);
c = _mm_blend_epi16(co, c, 0xF0);
__m128i a0 = _mm_or_si128(_mm_slli_epi16(c, 3), _mm_srli_epi16(c, 2));
_mm_storeu_si128((__m128i*)a[4+i*2].data(), a0);
}
for( int i=0; i<2; i++ )
{
__m128i d = _mm_loadu_si128((__m128i*)a[i*2].data());
__m128i t0 = _mm_add_epi16(_mm_mullo_epi16(d, _mm_set1_epi16(15)), _mm_set1_epi16(128));
__m128i t1 = _mm_srli_epi16(_mm_add_epi16(t0, _mm_srli_epi16(t0, 8)), 8);
__m128i t2 = _mm_or_si128(t1, _mm_slli_epi16(t1, 4));
_mm_storeu_si128((__m128i*)a[i*2].data(), t2);
}
#elif defined __ARM_NEON
for( int i=0; i<2; i++ )
{
int16x8_t d = vld1q_s16((int16_t*)&a[i*2]);
int16x8_t t = vaddq_s16(vmulq_s16(d, vdupq_n_s16(31)), vdupq_n_s16(128));
int16x8_t c = vshrq_n_s16(vaddq_s16(t, vshrq_n_s16(t, 8)), 8);
int16x8_t c1 = vcombine_s16(vget_high_s16(c), vget_high_s16(c));
int16x8_t diff = vsubq_s16(c, c1);
diff = vmaxq_s16(diff, vdupq_n_s16(-4));
diff = vminq_s16(diff, vdupq_n_s16(3));
int16x8_t co = vaddq_s16(c1, diff);
c = vcombine_s16(vget_low_s16(co), vget_high_s16(c));
int16x8_t a0 = vorrq_s16(vshlq_n_s16(c, 3), vshrq_n_s16(c, 2));
vst1q_s16((int16_t*)&a[4+i*2], a0);
}
for( int i=0; i<2; i++ )
{
int16x8_t d = vld1q_s16((int16_t*)&a[i*2]);
int16x8_t t0 = vaddq_s16(vmulq_s16(d, vdupq_n_s16(15)), vdupq_n_s16(128));
int16x8_t t1 = vshrq_n_s16(vaddq_s16(t0, vshrq_n_s16(t0, 8)), 8);
int16x8_t t2 = vorrq_s16(t1, vshlq_n_s16(t1, 4));
vst1q_s16((int16_t*)&a[i*2], t2);
}
#else
for( int i=0; i<2; i++ )
{
for( int j=0; j<3; j++ )
{
int32_t c1 = mul8bit( a[i*2+1][j], 31 );
int32_t c2 = mul8bit( a[i*2][j], 31 );
int32_t diff = c2 - c1;
if( diff > 3 ) diff = 3;
else if( diff < -4 ) diff = -4;
int32_t co = c1 + diff;
a[5+i*2][j] = ( c1 << 3 ) | ( c1 >> 2 );
a[4+i*2][j] = ( co << 3 ) | ( co >> 2 );
}
}
for( int i=0; i<4; i++ )
{
a[i][0] = g_avg2[mul8bit( a[i][0], 15 )];
a[i][1] = g_avg2[mul8bit( a[i][1], 15 )];
a[i][2] = g_avg2[mul8bit( a[i][2], 15 )];
}
#endif
}
static etcpak_force_inline void EncodeAverages( uint64_t& _d, const v4i* a, size_t idx )
{
auto d = _d;
d |= ( idx << 24 );
size_t base = idx << 1;
if( ( idx & 0x2 ) == 0 )
{
for( int i=0; i<3; i++ )
{
d |= uint64_t( a[base+0][i] >> 4 ) << ( i*8 );
d |= uint64_t( a[base+1][i] >> 4 ) << ( i*8 + 4 );
}
}
else
{
for( int i=0; i<3; i++ )
{
d |= uint64_t( a[base+1][i] & 0xF8 ) << ( i*8 );
int32_t c = ( ( a[base+0][i] & 0xF8 ) - ( a[base+1][i] & 0xF8 ) ) >> 3;
c &= ~0xFFFFFFF8;
d |= ((uint64_t)c) << ( i*8 );
}
}
_d = d;
}
static etcpak_force_inline uint64_t CheckSolid( const uint8_t* src )
{
#ifdef __SSE4_1__
__m128i d0 = _mm_loadu_si128(((__m128i*)src) + 0);
__m128i d1 = _mm_loadu_si128(((__m128i*)src) + 1);
__m128i d2 = _mm_loadu_si128(((__m128i*)src) + 2);
__m128i d3 = _mm_loadu_si128(((__m128i*)src) + 3);
__m128i c = _mm_shuffle_epi32(d0, _MM_SHUFFLE(0, 0, 0, 0));
__m128i c0 = _mm_cmpeq_epi8(d0, c);
__m128i c1 = _mm_cmpeq_epi8(d1, c);
__m128i c2 = _mm_cmpeq_epi8(d2, c);
__m128i c3 = _mm_cmpeq_epi8(d3, c);
__m128i m0 = _mm_and_si128(c0, c1);
__m128i m1 = _mm_and_si128(c2, c3);
__m128i m = _mm_and_si128(m0, m1);
if (!_mm_testc_si128(m, _mm_set1_epi32(-1)))
{
return 0;
}
#elif defined __ARM_NEON
int32x4_t d0 = vld1q_s32((int32_t*)src + 0);
int32x4_t d1 = vld1q_s32((int32_t*)src + 4);
int32x4_t d2 = vld1q_s32((int32_t*)src + 8);
int32x4_t d3 = vld1q_s32((int32_t*)src + 12);
int32x4_t c = vdupq_n_s32(d0[0]);
int32x4_t c0 = vreinterpretq_s32_u32(vceqq_s32(d0, c));
int32x4_t c1 = vreinterpretq_s32_u32(vceqq_s32(d1, c));
int32x4_t c2 = vreinterpretq_s32_u32(vceqq_s32(d2, c));
int32x4_t c3 = vreinterpretq_s32_u32(vceqq_s32(d3, c));
int32x4_t m0 = vandq_s32(c0, c1);
int32x4_t m1 = vandq_s32(c2, c3);
int64x2_t m = vreinterpretq_s64_s32(vandq_s32(m0, m1));
if (m[0] != -1 || m[1] != -1)
{
return 0;
}
#else
const uint8_t* ptr = src + 4;
for( int i=1; i<16; i++ )
{
if( memcmp( src, ptr, 4 ) != 0 )
{
return 0;
}
ptr += 4;
}
#endif
return 0x02000000 |
( (unsigned int)( src[0] & 0xF8 ) << 16 ) |
( (unsigned int)( src[1] & 0xF8 ) << 8 ) |
( (unsigned int)( src[2] & 0xF8 ) );
}
static etcpak_force_inline void PrepareAverages( v4i a[8], const uint8_t* src, unsigned int err[4] )
{
Average( src, a );
ProcessAverages( a );
unsigned int errblock[4][4];
CalcErrorBlock( src, errblock );
for( int i=0; i<4; i++ )
{
err[i/2] += CalcError( errblock[i], a[i] );
err[2+i/2] += CalcError( errblock[i], a[i+4] );
}
}
static etcpak_force_inline void FindBestFit( uint64_t terr[2][8], uint16_t tsel[16][8], v4i a[8], const uint32_t* id, const uint8_t* data )
{
for( size_t i=0; i<16; i++ )
{
uint16_t* sel = tsel[i];
unsigned int bid = id[i];
uint64_t* ter = terr[bid%2];
uint8_t b = *data++;
uint8_t g = *data++;
uint8_t r = *data++;
data++;
int dr = a[bid][0] - r;
int dg = a[bid][1] - g;
int db = a[bid][2] - b;
#ifdef __SSE4_1__
// Reference implementation
__m128i pix = _mm_set1_epi32(dr * 77 + dg * 151 + db * 28);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
__m128i error0 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[0]));
__m128i error1 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[1]));
__m128i error2 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[0]));
__m128i error3 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[1]));
__m128i index0 = _mm_and_si128(_mm_cmplt_epi32(error1, error0), _mm_set1_epi32(1));
__m128i minError0 = _mm_min_epi32(error0, error1);
__m128i index1 = _mm_sub_epi32(_mm_set1_epi32(2), _mm_cmplt_epi32(error3, error2));
__m128i minError1 = _mm_min_epi32(error2, error3);
__m128i minIndex0 = _mm_blendv_epi8(index0, index1, _mm_cmplt_epi32(minError1, minError0));
__m128i minError = _mm_min_epi32(minError0, minError1);
// Squaring the minimum error to produce correct values when adding
__m128i minErrorLow = _mm_shuffle_epi32(minError, _MM_SHUFFLE(1, 1, 0, 0));
__m128i squareErrorLow = _mm_mul_epi32(minErrorLow, minErrorLow);
squareErrorLow = _mm_add_epi64(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 0));
_mm_storeu_si128(((__m128i*)ter) + 0, squareErrorLow);
__m128i minErrorHigh = _mm_shuffle_epi32(minError, _MM_SHUFFLE(3, 3, 2, 2));
__m128i squareErrorHigh = _mm_mul_epi32(minErrorHigh, minErrorHigh);
squareErrorHigh = _mm_add_epi64(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 1));
_mm_storeu_si128(((__m128i*)ter) + 1, squareErrorHigh);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
error0 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[2]));
error1 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[3]));
error2 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[2]));
error3 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[3]));
index0 = _mm_and_si128(_mm_cmplt_epi32(error1, error0), _mm_set1_epi32(1));
minError0 = _mm_min_epi32(error0, error1);
index1 = _mm_sub_epi32(_mm_set1_epi32(2), _mm_cmplt_epi32(error3, error2));
minError1 = _mm_min_epi32(error2, error3);
__m128i minIndex1 = _mm_blendv_epi8(index0, index1, _mm_cmplt_epi32(minError1, minError0));
minError = _mm_min_epi32(minError0, minError1);
// Squaring the minimum error to produce correct values when adding
minErrorLow = _mm_shuffle_epi32(minError, _MM_SHUFFLE(1, 1, 0, 0));
squareErrorLow = _mm_mul_epi32(minErrorLow, minErrorLow);
squareErrorLow = _mm_add_epi64(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 2));
_mm_storeu_si128(((__m128i*)ter) + 2, squareErrorLow);
minErrorHigh = _mm_shuffle_epi32(minError, _MM_SHUFFLE(3, 3, 2, 2));
squareErrorHigh = _mm_mul_epi32(minErrorHigh, minErrorHigh);
squareErrorHigh = _mm_add_epi64(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 3));
_mm_storeu_si128(((__m128i*)ter) + 3, squareErrorHigh);
__m128i minIndex = _mm_packs_epi32(minIndex0, minIndex1);
_mm_storeu_si128((__m128i*)sel, minIndex);
#elif defined __ARM_NEON
int32x4_t pix = vdupq_n_s32(dr * 77 + dg * 151 + db * 28);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
uint32x4_t error0 = vreinterpretq_u32_s32(vabsq_s32(vaddq_s32(pix, g_table256_NEON[0])));
uint32x4_t error1 = vreinterpretq_u32_s32(vabsq_s32(vaddq_s32(pix, g_table256_NEON[1])));
uint32x4_t error2 = vreinterpretq_u32_s32(vabsq_s32(vsubq_s32(pix, g_table256_NEON[0])));
uint32x4_t error3 = vreinterpretq_u32_s32(vabsq_s32(vsubq_s32(pix, g_table256_NEON[1])));
uint32x4_t index0 = vandq_u32(vcltq_u32(error1, error0), vdupq_n_u32(1));
uint32x4_t minError0 = vminq_u32(error0, error1);
uint32x4_t index1 = vreinterpretq_u32_s32(vsubq_s32(vdupq_n_s32(2), vreinterpretq_s32_u32(vcltq_u32(error3, error2))));
uint32x4_t minError1 = vminq_u32(error2, error3);
uint32x4_t blendMask = vcltq_u32(minError1, minError0);
uint32x4_t minIndex0 = vorrq_u32(vbicq_u32(index0, blendMask), vandq_u32(index1, blendMask));
uint32x4_t minError = vminq_u32(minError0, minError1);
// Squaring the minimum error to produce correct values when adding
uint32x4_t squareErrorLow = vmulq_u32(minError, minError);
uint32x4_t squareErrorHigh = vshrq_n_u32(vreinterpretq_u32_s32(vqdmulhq_s32(vreinterpretq_s32_u32(minError), vreinterpretq_s32_u32(minError))), 1);
uint32x4x2_t squareErrorZip = vzipq_u32(squareErrorLow, squareErrorHigh);
uint64x2x2_t squareError = { vreinterpretq_u64_u32(squareErrorZip.val[0]), vreinterpretq_u64_u32(squareErrorZip.val[1]) };
squareError.val[0] = vaddq_u64(squareError.val[0], vld1q_u64(ter + 0));
squareError.val[1] = vaddq_u64(squareError.val[1], vld1q_u64(ter + 2));
vst1q_u64(ter + 0, squareError.val[0]);
vst1q_u64(ter + 2, squareError.val[1]);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
error0 = vreinterpretq_u32_s32( vabsq_s32(vaddq_s32(pix, g_table256_NEON[2])));
error1 = vreinterpretq_u32_s32( vabsq_s32(vaddq_s32(pix, g_table256_NEON[3])));
error2 = vreinterpretq_u32_s32( vabsq_s32(vsubq_s32(pix, g_table256_NEON[2])));
error3 = vreinterpretq_u32_s32( vabsq_s32(vsubq_s32(pix, g_table256_NEON[3])));
index0 = vandq_u32(vcltq_u32(error1, error0), vdupq_n_u32(1));
minError0 = vminq_u32(error0, error1);
index1 = vreinterpretq_u32_s32( vsubq_s32(vdupq_n_s32(2), vreinterpretq_s32_u32(vcltq_u32(error3, error2))) );
minError1 = vminq_u32(error2, error3);
blendMask = vcltq_u32(minError1, minError0);
uint32x4_t minIndex1 = vorrq_u32(vbicq_u32(index0, blendMask), vandq_u32(index1, blendMask));
minError = vminq_u32(minError0, minError1);
// Squaring the minimum error to produce correct values when adding
squareErrorLow = vmulq_u32(minError, minError);
squareErrorHigh = vshrq_n_u32(vreinterpretq_u32_s32( vqdmulhq_s32(vreinterpretq_s32_u32(minError), vreinterpretq_s32_u32(minError)) ), 1 );
squareErrorZip = vzipq_u32(squareErrorLow, squareErrorHigh);
squareError.val[0] = vaddq_u64(vreinterpretq_u64_u32( squareErrorZip.val[0] ), vld1q_u64(ter + 4));
squareError.val[1] = vaddq_u64(vreinterpretq_u64_u32( squareErrorZip.val[1] ), vld1q_u64(ter + 6));
vst1q_u64(ter + 4, squareError.val[0]);
vst1q_u64(ter + 6, squareError.val[1]);
uint16x8_t minIndex = vcombine_u16(vqmovn_u32(minIndex0), vqmovn_u32(minIndex1));
vst1q_u16(sel, minIndex);
#else
int pix = dr * 77 + dg * 151 + db * 28;
for( int t=0; t<8; t++ )
{
const int64_t* tab = g_table256[t];
unsigned int idx = 0;
uint64_t err = sq( tab[0] + pix );
for( int j=1; j<4; j++ )
{
uint64_t local = sq( tab[j] + pix );
if( local < err )
{
err = local;
idx = j;
}
}
*sel++ = idx;
*ter++ += err;
}
#endif
}
}
#if defined __SSE4_1__ || defined __ARM_NEON
// Non-reference implementation, but faster. Produces same results as the AVX2 version
static etcpak_force_inline void FindBestFit( uint32_t terr[2][8], uint16_t tsel[16][8], v4i a[8], const uint32_t* id, const uint8_t* data )
{
for( size_t i=0; i<16; i++ )
{
uint16_t* sel = tsel[i];
unsigned int bid = id[i];
uint32_t* ter = terr[bid%2];
uint8_t b = *data++;
uint8_t g = *data++;
uint8_t r = *data++;
data++;
int dr = a[bid][0] - r;
int dg = a[bid][1] - g;
int db = a[bid][2] - b;
#ifdef __SSE4_1__
// The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16
// This produces slightly different results, but is significant faster
__m128i pixel = _mm_set1_epi16(dr * 38 + dg * 76 + db * 14);
__m128i pix = _mm_abs_epi16(pixel);
// Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
// Since the selector table is symmetrical, we need to calculate the difference only for half of the entries.
__m128i error0 = _mm_abs_epi16(_mm_sub_epi16(pix, g_table128_SIMD[0]));
__m128i error1 = _mm_abs_epi16(_mm_sub_epi16(pix, g_table128_SIMD[1]));
__m128i index = _mm_and_si128(_mm_cmplt_epi16(error1, error0), _mm_set1_epi16(1));
__m128i minError = _mm_min_epi16(error0, error1);
// Exploiting symmetry of the selector table and use the sign bit
// This produces slightly different results, but is needed to produce same results as AVX2 implementation
__m128i indexBit = _mm_andnot_si128(_mm_srli_epi16(pixel, 15), _mm_set1_epi8(-1));
__m128i minIndex = _mm_or_si128(index, _mm_add_epi16(indexBit, indexBit));
// Squaring the minimum error to produce correct values when adding
__m128i squareErrorLo = _mm_mullo_epi16(minError, minError);
__m128i squareErrorHi = _mm_mulhi_epi16(minError, minError);
__m128i squareErrorLow = _mm_unpacklo_epi16(squareErrorLo, squareErrorHi);
__m128i squareErrorHigh = _mm_unpackhi_epi16(squareErrorLo, squareErrorHi);
squareErrorLow = _mm_add_epi32(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 0));
_mm_storeu_si128(((__m128i*)ter) + 0, squareErrorLow);
squareErrorHigh = _mm_add_epi32(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 1));
_mm_storeu_si128(((__m128i*)ter) + 1, squareErrorHigh);
_mm_storeu_si128((__m128i*)sel, minIndex);
#elif defined __ARM_NEON
int16x8_t pixel = vdupq_n_s16( dr * 38 + dg * 76 + db * 14 );
int16x8_t pix = vabsq_s16( pixel );
int16x8_t error0 = vabsq_s16( vsubq_s16( pix, g_table128_NEON[0] ) );
int16x8_t error1 = vabsq_s16( vsubq_s16( pix, g_table128_NEON[1] ) );
int16x8_t index = vandq_s16( vreinterpretq_s16_u16( vcltq_s16( error1, error0 ) ), vdupq_n_s16( 1 ) );
int16x8_t minError = vminq_s16( error0, error1 );
int16x8_t indexBit = vandq_s16( vmvnq_s16( vshrq_n_s16( pixel, 15 ) ), vdupq_n_s16( -1 ) );
int16x8_t minIndex = vorrq_s16( index, vaddq_s16( indexBit, indexBit ) );
int16x4_t minErrorLow = vget_low_s16( minError );
int16x4_t minErrorHigh = vget_high_s16( minError );
int32x4_t squareErrorLow = vmull_s16( minErrorLow, minErrorLow );
int32x4_t squareErrorHigh = vmull_s16( minErrorHigh, minErrorHigh );
int32x4_t squareErrorSumLow = vaddq_s32( squareErrorLow, vld1q_s32( (int32_t*)ter ) );
int32x4_t squareErrorSumHigh = vaddq_s32( squareErrorHigh, vld1q_s32( (int32_t*)ter + 4 ) );
vst1q_s32( (int32_t*)ter, squareErrorSumLow );
vst1q_s32( (int32_t*)ter + 4, squareErrorSumHigh );
vst1q_s16( (int16_t*)sel, minIndex );
#endif
}
}
#endif
static etcpak_force_inline uint8_t convert6(float f)
{
int i = (std::min(std::max(static_cast<int>(f), 0), 1023) - 15) >> 1;
return (i + 11 - ((i + 11) >> 7) - ((i + 4) >> 7)) >> 3;
}
static etcpak_force_inline uint8_t convert7(float f)
{
int i = (std::min(std::max(static_cast<int>(f), 0), 1023) - 15) >> 1;
return (i + 9 - ((i + 9) >> 8) - ((i + 6) >> 8)) >> 2;
}
static etcpak_force_inline std::pair<uint64_t, uint64_t> Planar( const uint8_t* src, const uint8_t mode, bool useHeuristics )
{
int32_t r = 0;
int32_t g = 0;
int32_t b = 0;
for( int i = 0; i < 16; ++i )
{
b += src[i * 4 + 0];
g += src[i * 4 + 1];
r += src[i * 4 + 2];
}
int32_t difRyz = 0;
int32_t difGyz = 0;
int32_t difByz = 0;
int32_t difRxz = 0;
int32_t difGxz = 0;
int32_t difBxz = 0;
const int32_t scaling[] = { -255, -85, 85, 255 };
for (int i = 0; i < 16; ++i)
{
int32_t difB = (static_cast<int>(src[i * 4 + 0]) << 4) - b;
int32_t difG = (static_cast<int>(src[i * 4 + 1]) << 4) - g;
int32_t difR = (static_cast<int>(src[i * 4 + 2]) << 4) - r;
difRyz += difR * scaling[i % 4];
difGyz += difG * scaling[i % 4];
difByz += difB * scaling[i % 4];
difRxz += difR * scaling[i / 4];
difGxz += difG * scaling[i / 4];
difBxz += difB * scaling[i / 4];
}
const float scale = -4.0f / ((255 * 255 * 8.0f + 85 * 85 * 8.0f) * 16.0f);
float aR = difRxz * scale;
float aG = difGxz * scale;
float aB = difBxz * scale;
float bR = difRyz * scale;
float bG = difGyz * scale;
float bB = difByz * scale;
float dR = r * (4.0f / 16.0f);
float dG = g * (4.0f / 16.0f);
float dB = b * (4.0f / 16.0f);
// calculating the three colors RGBO, RGBH, and RGBV. RGB = df - af * x - bf * y;
float cofR = std::fma(aR, 255.0f, std::fma(bR, 255.0f, dR));
float cofG = std::fma(aG, 255.0f, std::fma(bG, 255.0f, dG));
float cofB = std::fma(aB, 255.0f, std::fma(bB, 255.0f, dB));
float chfR = std::fma(aR, -425.0f, std::fma(bR, 255.0f, dR));
float chfG = std::fma(aG, -425.0f, std::fma(bG, 255.0f, dG));
float chfB = std::fma(aB, -425.0f, std::fma(bB, 255.0f, dB));
float cvfR = std::fma(aR, 255.0f, std::fma(bR, -425.0f, dR));
float cvfG = std::fma(aG, 255.0f, std::fma(bG, -425.0f, dG));
float cvfB = std::fma(aB, 255.0f, std::fma(bB, -425.0f, dB));
// convert to r6g7b6
int32_t coR = convert6(cofR);
int32_t coG = convert7(cofG);
int32_t coB = convert6(cofB);
int32_t chR = convert6(chfR);
int32_t chG = convert7(chfG);
int32_t chB = convert6(chfB);
int32_t cvR = convert6(cvfR);
int32_t cvG = convert7(cvfG);
int32_t cvB = convert6(cvfB);
// Error calculation
uint64_t error = 0;
if( ModePlanar != mode && useHeuristics )
{
auto ro0 = coR;
auto go0 = coG;
auto bo0 = coB;
auto ro1 = ( ro0 >> 4 ) | ( ro0 << 2 );
auto go1 = ( go0 >> 6 ) | ( go0 << 1 );
auto bo1 = ( bo0 >> 4 ) | ( bo0 << 2 );
auto ro2 = ( ro1 << 2 ) + 2;
auto go2 = ( go1 << 2 ) + 2;
auto bo2 = ( bo1 << 2 ) + 2;
auto rh0 = chR;
auto gh0 = chG;
auto bh0 = chB;
auto rh1 = ( rh0 >> 4 ) | ( rh0 << 2 );
auto gh1 = ( gh0 >> 6 ) | ( gh0 << 1 );
auto bh1 = ( bh0 >> 4 ) | ( bh0 << 2 );
auto rh2 = rh1 - ro1;
auto gh2 = gh1 - go1;
auto bh2 = bh1 - bo1;
auto rv0 = cvR;
auto gv0 = cvG;
auto bv0 = cvB;
auto rv1 = ( rv0 >> 4 ) | ( rv0 << 2 );
auto gv1 = ( gv0 >> 6 ) | ( gv0 << 1 );
auto bv1 = ( bv0 >> 4 ) | ( bv0 << 2 );
auto rv2 = rv1 - ro1;
auto gv2 = gv1 - go1;
auto bv2 = bv1 - bo1;
for( int i = 0; i < 16; ++i )
{
int32_t cR = clampu8( ( rh2 * ( i / 4 ) + rv2 * ( i % 4 ) + ro2 ) >> 2 );
int32_t cG = clampu8( ( gh2 * ( i / 4 ) + gv2 * ( i % 4 ) + go2 ) >> 2 );
int32_t cB = clampu8( ( bh2 * ( i / 4 ) + bv2 * ( i % 4 ) + bo2 ) >> 2 );
int32_t difB = static_cast<int>( src[i * 4 + 0] ) - cB;
int32_t difG = static_cast<int>( src[i * 4 + 1] ) - cG;
int32_t difR = static_cast<int>( src[i * 4 + 2] ) - cR;
int32_t dif = difR * 38 + difG * 76 + difB * 14;
error += dif * dif;
}
}
/**/
uint32_t rgbv = cvB | ( cvG << 6 ) | ( cvR << 13 );
uint32_t rgbh = chB | ( chG << 6 ) | ( chR << 13 );
uint32_t hi = rgbv | ( ( rgbh & 0x1FFF ) << 19 );
uint32_t lo = ( chR & 0x1 ) | 0x2 | ( ( chR << 1 ) & 0x7C );
lo |= ( ( coB & 0x07 ) << 7 ) | ( ( coB & 0x18 ) << 8 ) | ( ( coB & 0x20 ) << 11 );
lo |= ( ( coG & 0x3F ) << 17 ) | ( ( coG & 0x40 ) << 18 );
lo |= coR << 25;
const auto idx = ( coR & 0x20 ) | ( ( coG & 0x20 ) >> 1 ) | ( ( coB & 0x1E ) >> 1 );
lo |= g_flags[idx];
uint64_t result = static_cast<uint32_t>( _bswap( lo ) );
result |= static_cast<uint64_t>( static_cast<uint32_t>( _bswap( hi ) ) ) << 32;
return std::make_pair( result, error );
}
#ifdef __ARM_NEON
static etcpak_force_inline int32x2_t Planar_NEON_DifXZ( int16x8_t dif_lo, int16x8_t dif_hi )
{
int32x4_t dif0 = vmull_n_s16( vget_low_s16( dif_lo ), -255 );
int32x4_t dif1 = vmull_n_s16( vget_high_s16( dif_lo ), -85 );
int32x4_t dif2 = vmull_n_s16( vget_low_s16( dif_hi ), 85 );
int32x4_t dif3 = vmull_n_s16( vget_high_s16( dif_hi ), 255 );
int32x4_t dif4 = vaddq_s32( vaddq_s32( dif0, dif1 ), vaddq_s32( dif2, dif3 ) );
#ifndef __aarch64__
int32x2_t dif5 = vpadd_s32( vget_low_s32( dif4 ), vget_high_s32( dif4 ) );
return vpadd_s32( dif5, dif5 );
#else
return vdup_n_s32( vaddvq_s32( dif4 ) );
#endif
}
static etcpak_force_inline int32x2_t Planar_NEON_DifYZ( int16x8_t dif_lo, int16x8_t dif_hi )
{
int16x4_t scaling = { -255, -85, 85, 255 };
int32x4_t dif0 = vmull_s16( vget_low_s16( dif_lo ), scaling );
int32x4_t dif1 = vmull_s16( vget_high_s16( dif_lo ), scaling );
int32x4_t dif2 = vmull_s16( vget_low_s16( dif_hi ), scaling );
int32x4_t dif3 = vmull_s16( vget_high_s16( dif_hi ), scaling );
int32x4_t dif4 = vaddq_s32( vaddq_s32( dif0, dif1 ), vaddq_s32( dif2, dif3 ) );
#ifndef __aarch64__
int32x2_t dif5 = vpadd_s32( vget_low_s32( dif4 ), vget_high_s32( dif4 ) );
return vpadd_s32( dif5, dif5 );
#else
return vdup_n_s32( vaddvq_s32( dif4 ) );
#endif
}
static etcpak_force_inline int16x8_t Planar_NEON_SumWide( uint8x16_t src )
{
uint16x8_t accu8 = vpaddlq_u8( src );
#ifndef __aarch64__
uint16x4_t accu4 = vpadd_u16( vget_low_u16( accu8 ), vget_high_u16( accu8 ) );
uint16x4_t accu2 = vpadd_u16( accu4, accu4 );
uint16x4_t accu1 = vpadd_u16( accu2, accu2 );
return vreinterpretq_s16_u16( vcombine_u16( accu1, accu1 ) );
#else
return vdupq_n_s16( vaddvq_u16( accu8 ) );
#endif
}
static etcpak_force_inline int16x8_t convert6_NEON( int32x4_t lo, int32x4_t hi )
{
uint16x8_t x = vcombine_u16( vqmovun_s32( lo ), vqmovun_s32( hi ) );
int16x8_t i = vreinterpretq_s16_u16( vshrq_n_u16( vqshlq_n_u16( x, 6 ), 6) ); // clamp 0-1023
i = vhsubq_s16( i, vdupq_n_s16( 15 ) );
int16x8_t ip11 = vaddq_s16( i, vdupq_n_s16( 11 ) );
int16x8_t ip4 = vaddq_s16( i, vdupq_n_s16( 4 ) );
return vshrq_n_s16( vsubq_s16( vsubq_s16( ip11, vshrq_n_s16( ip11, 7 ) ), vshrq_n_s16( ip4, 7) ), 3 );
}
static etcpak_force_inline int16x4_t convert7_NEON( int32x4_t x )
{
int16x4_t i = vreinterpret_s16_u16( vshr_n_u16( vqshl_n_u16( vqmovun_s32( x ), 6 ), 6 ) ); // clamp 0-1023
i = vhsub_s16( i, vdup_n_s16( 15 ) );
int16x4_t p9 = vadd_s16( i, vdup_n_s16( 9 ) );
int16x4_t p6 = vadd_s16( i, vdup_n_s16( 6 ) );
return vshr_n_s16( vsub_s16( vsub_s16( p9, vshr_n_s16( p9, 8 ) ), vshr_n_s16( p6, 8 ) ), 2 );
}
static etcpak_force_inline std::pair<uint64_t, uint64_t> Planar_NEON( const uint8_t* src, const uint8_t mode, bool useHeuristics )
{
uint8x16x4_t srcBlock = vld4q_u8( src );
int16x8_t bSumWide = Planar_NEON_SumWide( srcBlock.val[0] );
int16x8_t gSumWide = Planar_NEON_SumWide( srcBlock.val[1] );
int16x8_t rSumWide = Planar_NEON_SumWide( srcBlock.val[2] );
int16x8_t dif_R_lo = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_low_u8( srcBlock.val[2] ), 4) ), rSumWide );
int16x8_t dif_R_hi = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_high_u8( srcBlock.val[2] ), 4) ), rSumWide );
int16x8_t dif_G_lo = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_low_u8( srcBlock.val[1] ), 4 ) ), gSumWide );
int16x8_t dif_G_hi = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_high_u8( srcBlock.val[1] ), 4 ) ), gSumWide );
int16x8_t dif_B_lo = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_low_u8( srcBlock.val[0] ), 4) ), bSumWide );
int16x8_t dif_B_hi = vsubq_s16( vreinterpretq_s16_u16( vshll_n_u8( vget_high_u8( srcBlock.val[0] ), 4) ), bSumWide );
int32x2x2_t dif_xz_z = vzip_s32( vzip_s32( Planar_NEON_DifXZ( dif_B_lo, dif_B_hi ), Planar_NEON_DifXZ( dif_R_lo, dif_R_hi ) ).val[0], Planar_NEON_DifXZ( dif_G_lo, dif_G_hi ) );
int32x4_t dif_xz = vcombine_s32( dif_xz_z.val[0], dif_xz_z.val[1] );
int32x2x2_t dif_yz_z = vzip_s32( vzip_s32( Planar_NEON_DifYZ( dif_B_lo, dif_B_hi ), Planar_NEON_DifYZ( dif_R_lo, dif_R_hi ) ).val[0], Planar_NEON_DifYZ( dif_G_lo, dif_G_hi ) );
int32x4_t dif_yz = vcombine_s32( dif_yz_z.val[0], dif_yz_z.val[1] );
const float fscale = -4.0f / ( (255 * 255 * 8.0f + 85 * 85 * 8.0f ) * 16.0f );
float32x4_t fa = vmulq_n_f32( vcvtq_f32_s32( dif_xz ), fscale );
float32x4_t fb = vmulq_n_f32( vcvtq_f32_s32( dif_yz ), fscale );
int16x4_t bgrgSum = vzip_s16( vzip_s16( vget_low_s16( bSumWide ), vget_low_s16( rSumWide ) ).val[0], vget_low_s16( gSumWide ) ).val[0];
float32x4_t fd = vmulq_n_f32( vcvtq_f32_s32( vmovl_s16( bgrgSum ) ), 4.0f / 16.0f);
float32x4_t cof = vmlaq_n_f32( vmlaq_n_f32( fd, fb, 255.0f ), fa, 255.0f );
float32x4_t chf = vmlaq_n_f32( vmlaq_n_f32( fd, fb, 255.0f ), fa, -425.0f );
float32x4_t cvf = vmlaq_n_f32( vmlaq_n_f32( fd, fb, -425.0f ), fa, 255.0f );
int32x4_t coi = vcvtq_s32_f32( cof );
int32x4_t chi = vcvtq_s32_f32( chf );
int32x4_t cvi = vcvtq_s32_f32( cvf );
int32x4x2_t tr_hv = vtrnq_s32( chi, cvi );
int32x4x2_t tr_o = vtrnq_s32( coi, coi );
int16x8_t c_hvoo_br_6 = convert6_NEON( tr_hv.val[0], tr_o.val[0] );
int16x4_t c_hvox_g_7 = convert7_NEON( vcombine_s32( vget_low_s32( tr_hv.val[1] ), vget_low_s32( tr_o.val[1] ) ) );
int16x8_t c_hvoo_br_8 = vorrq_s16( vshrq_n_s16( c_hvoo_br_6, 4 ), vshlq_n_s16( c_hvoo_br_6, 2 ) );
int16x4_t c_hvox_g_8 = vorr_s16( vshr_n_s16( c_hvox_g_7, 6 ), vshl_n_s16( c_hvox_g_7, 1 ) );
uint64_t error = 0;
if( mode != ModePlanar && useHeuristics )
{
int16x4_t rec_gxbr_o = vext_s16( c_hvox_g_8, vget_high_s16( c_hvoo_br_8 ), 3 );
rec_gxbr_o = vadd_s16( vshl_n_s16( rec_gxbr_o, 2 ), vdup_n_s16( 2 ) );
int16x8_t rec_ro_wide = vdupq_lane_s16( rec_gxbr_o, 3 );
int16x8_t rec_go_wide = vdupq_lane_s16( rec_gxbr_o, 0 );
int16x8_t rec_bo_wide = vdupq_lane_s16( rec_gxbr_o, 1 );
int16x4_t br_hv2 = vsub_s16( vget_low_s16( c_hvoo_br_8 ), vget_high_s16( c_hvoo_br_8 ) );
int16x4_t gg_hv2 = vsub_s16( c_hvox_g_8, vdup_lane_s16( c_hvox_g_8, 2 ) );
int16x8_t scaleh_lo = { 0, 0, 0, 0, 1, 1, 1, 1 };
int16x8_t scaleh_hi = { 2, 2, 2, 2, 3, 3, 3, 3 };
int16x8_t scalev = { 0, 1, 2, 3, 0, 1, 2, 3 };
int16x8_t rec_r_1 = vmlaq_lane_s16( rec_ro_wide, scalev, br_hv2, 3 );
int16x8_t rec_r_lo = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_r_1, scaleh_lo, br_hv2, 2 ), 2 ) ) );
int16x8_t rec_r_hi = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_r_1, scaleh_hi, br_hv2, 2 ), 2 ) ) );
int16x8_t rec_b_1 = vmlaq_lane_s16( rec_bo_wide, scalev, br_hv2, 1 );
int16x8_t rec_b_lo = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_b_1, scaleh_lo, br_hv2, 0 ), 2 ) ) );
int16x8_t rec_b_hi = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_b_1, scaleh_hi, br_hv2, 0 ), 2 ) ) );
int16x8_t rec_g_1 = vmlaq_lane_s16( rec_go_wide, scalev, gg_hv2, 1 );
int16x8_t rec_g_lo = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_g_1, scaleh_lo, gg_hv2, 0 ), 2 ) ) );
int16x8_t rec_g_hi = vreinterpretq_s16_u16( vmovl_u8( vqshrun_n_s16( vmlaq_lane_s16( rec_g_1, scaleh_hi, gg_hv2, 0 ), 2 ) ) );
int16x8_t dif_r_lo = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_low_u8( srcBlock.val[2] ) ) ), rec_r_lo );
int16x8_t dif_r_hi = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_high_u8( srcBlock.val[2] ) ) ), rec_r_hi );
int16x8_t dif_g_lo = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_low_u8( srcBlock.val[1] ) ) ), rec_g_lo );
int16x8_t dif_g_hi = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_high_u8( srcBlock.val[1] ) ) ), rec_g_hi );
int16x8_t dif_b_lo = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_low_u8( srcBlock.val[0] ) ) ), rec_b_lo );
int16x8_t dif_b_hi = vsubq_s16( vreinterpretq_s16_u16( vmovl_u8( vget_high_u8( srcBlock.val[0] ) ) ), rec_b_hi );
int16x8_t dif_lo = vmlaq_n_s16( vmlaq_n_s16( vmulq_n_s16( dif_r_lo, 38 ), dif_g_lo, 76 ), dif_b_lo, 14 );
int16x8_t dif_hi = vmlaq_n_s16( vmlaq_n_s16( vmulq_n_s16( dif_r_hi, 38 ), dif_g_hi, 76 ), dif_b_hi, 14 );
int16x4_t tmpDif = vget_low_s16( dif_lo );
int32x4_t difsq_0 = vmull_s16( tmpDif, tmpDif );
tmpDif = vget_high_s16( dif_lo );
int32x4_t difsq_1 = vmull_s16( tmpDif, tmpDif );
tmpDif = vget_low_s16( dif_hi );
int32x4_t difsq_2 = vmull_s16( tmpDif, tmpDif );
tmpDif = vget_high_s16( dif_hi );
int32x4_t difsq_3 = vmull_s16( tmpDif, tmpDif );
uint32x4_t difsq_5 = vaddq_u32( vreinterpretq_u32_s32( difsq_0 ), vreinterpretq_u32_s32( difsq_1 ) );
uint32x4_t difsq_6 = vaddq_u32( vreinterpretq_u32_s32( difsq_2 ), vreinterpretq_u32_s32( difsq_3 ) );
uint64x2_t difsq_7 = vaddl_u32( vget_low_u32( difsq_5 ), vget_high_u32( difsq_5 ) );
uint64x2_t difsq_8 = vaddl_u32( vget_low_u32( difsq_6 ), vget_high_u32( difsq_6 ) );
uint64x2_t difsq_9 = vaddq_u64( difsq_7, difsq_8 );
#ifdef __aarch64__
error = vaddvq_u64( difsq_9 );
#else
error = vgetq_lane_u64( difsq_9, 0 ) + vgetq_lane_u64( difsq_9, 1 );
#endif
}
int32_t coR = c_hvoo_br_6[6];
int32_t coG = c_hvox_g_7[2];
int32_t coB = c_hvoo_br_6[4];
int32_t chR = c_hvoo_br_6[2];
int32_t chG = c_hvox_g_7[0];
int32_t chB = c_hvoo_br_6[0];
int32_t cvR = c_hvoo_br_6[3];
int32_t cvG = c_hvox_g_7[1];
int32_t cvB = c_hvoo_br_6[1];
uint32_t rgbv = cvB | ( cvG << 6 ) | ( cvR << 13 );
uint32_t rgbh = chB | ( chG << 6 ) | ( chR << 13 );
uint32_t hi = rgbv | ( ( rgbh & 0x1FFF ) << 19 );
uint32_t lo = ( chR & 0x1 ) | 0x2 | ( ( chR << 1 ) & 0x7C );
lo |= ( ( coB & 0x07 ) << 7 ) | ( ( coB & 0x18 ) << 8 ) | ( ( coB & 0x20 ) << 11 );
lo |= ( ( coG & 0x3F) << 17) | ( (coG & 0x40 ) << 18 );
lo |= coR << 25;
const auto idx = ( coR & 0x20 ) | ( ( coG & 0x20 ) >> 1 ) | ( ( coB & 0x1E ) >> 1 );
lo |= g_flags[idx];
uint64_t result = static_cast<uint32_t>( _bswap(lo) );
result |= static_cast<uint64_t>( static_cast<uint32_t>( _bswap( hi ) ) ) << 32;
return std::make_pair( result, error );
}
#endif
#ifdef __AVX2__
uint32_t calculateErrorTH( bool tMode, uint8_t( colorsRGB444 )[2][3], uint8_t& dist, uint32_t& pixIndices, uint8_t startDist, __m128i r8, __m128i g8, __m128i b8 )
#else
uint32_t calculateErrorTH( bool tMode, uint8_t* src, uint8_t( colorsRGB444 )[2][3], uint8_t& dist, uint32_t& pixIndices, uint8_t startDist )
#endif
{
uint32_t blockErr = 0, bestBlockErr = MaxError;
uint32_t pixColors;
uint8_t possibleColors[4][3];
uint8_t colors[2][3];
decompressColor( colorsRGB444, colors );
#ifdef __AVX2__
__m128i reverseMask = _mm_set_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 );
#endif
// test distances
for( uint8_t d = startDist; d < 8; ++d )
{
if( d >= 2 && dist == d - 2 ) break;
blockErr = 0;
pixColors = 0;
if( tMode )
{
calculatePaintColors59T( d, colors, possibleColors );
}
else
{
calculatePaintColors58H( d, colors, possibleColors );
}
#ifdef __AVX2__
// RGB ordering
__m128i b8Rev = _mm_shuffle_epi8( b8, reverseMask );
__m128i g8Rev = _mm_shuffle_epi8( g8, reverseMask );
__m128i r8Rev = _mm_shuffle_epi8( r8, reverseMask );
// extends 3x128 bits RGB into 3x256 bits RGB for error comparisions
static const __m128i zero = _mm_setzero_si128();
__m128i b8Lo = _mm_unpacklo_epi8( b8Rev, zero );
__m128i g8Lo = _mm_unpacklo_epi8( g8Rev, zero );
__m128i r8Lo = _mm_unpacklo_epi8( r8Rev, zero );
__m128i b8Hi = _mm_unpackhi_epi8( b8Rev, zero );
__m128i g8Hi = _mm_unpackhi_epi8( g8Rev, zero );
__m128i r8Hi = _mm_unpackhi_epi8( r8Rev, zero );
__m256i b8 = _mm256_set_m128i( b8Hi, b8Lo );
__m256i g8 = _mm256_set_m128i( g8Hi, g8Lo );
__m256i r8 = _mm256_set_m128i( r8Hi, r8Lo );
// caculates differences between the pixel colrs and the palette colors
__m256i diffb = _mm256_abs_epi16( _mm256_sub_epi16( b8, _mm256_set1_epi16( possibleColors[0][B] ) ) );
__m256i diffg = _mm256_abs_epi16( _mm256_sub_epi16( g8, _mm256_set1_epi16( possibleColors[0][G] ) ) );
__m256i diffr = _mm256_abs_epi16( _mm256_sub_epi16( r8, _mm256_set1_epi16( possibleColors[0][R] ) ) );
// luma-based error calculations
static const __m256i bWeight = _mm256_set1_epi16( 14 );
static const __m256i gWeight = _mm256_set1_epi16( 76 );
static const __m256i rWeight = _mm256_set1_epi16( 38 );
diffb = _mm256_mullo_epi16( diffb, bWeight );
diffg = _mm256_mullo_epi16( diffg, gWeight );
diffr = _mm256_mullo_epi16( diffr, rWeight );
// obtains the error with the current palette color
__m256i lowestPixErr = _mm256_add_epi16( _mm256_add_epi16( diffb, diffg ), diffr );
// error calucations with the remaining three palette colors
static const uint32_t masks[4] = { 0, 0x55555555, 0xAAAAAAAA, 0xFFFFFFFF };
for( uint8_t c = 1; c < 4; c++ )
{
__m256i diffb = _mm256_abs_epi16( _mm256_sub_epi16( b8, _mm256_set1_epi16( possibleColors[c][B] ) ) );
__m256i diffg = _mm256_abs_epi16( _mm256_sub_epi16( g8, _mm256_set1_epi16( possibleColors[c][G] ) ) );
__m256i diffr = _mm256_abs_epi16( _mm256_sub_epi16( r8, _mm256_set1_epi16( possibleColors[c][R] ) ) );
diffb = _mm256_mullo_epi16( diffb, bWeight );
diffg = _mm256_mullo_epi16( diffg, gWeight );
diffr = _mm256_mullo_epi16( diffr, rWeight );
// error comparison with the previous best color
__m256i pixErrors = _mm256_add_epi16( _mm256_add_epi16( diffb, diffg ), diffr );
__m256i minErr = _mm256_min_epu16( lowestPixErr, pixErrors );
__m256i cmpRes = _mm256_cmpeq_epi16( pixErrors, minErr );
lowestPixErr = minErr;
// update pixel colors
uint32_t updPixColors = _mm256_movemask_epi8( cmpRes );
uint32_t prevPixColors = pixColors & ~updPixColors;
uint32_t mskPixColors = masks[c] & updPixColors;
pixColors = prevPixColors | mskPixColors;
}
// accumulate the block error
alignas( 32 ) uint16_t pixErr16[16] = { 0, };
_mm256_storeu_si256( (__m256i*)pixErr16, lowestPixErr );
for( uint8_t p = 0; p < 16; p++ )
{
blockErr += (int)( pixErr16[p] ) * pixErr16[p];
}
#else
for( size_t y = 0; y < 4; ++y )
{
for( size_t x = 0; x < 4; ++x )
{
uint32_t bestPixErr = MaxError;
pixColors <<= 2; // Make room for next value
// Loop possible block colors
for( uint8_t c = 0; c < 4; ++c )
{
int diff[3];
diff[R] = src[4 * ( x * 4 + y ) + R] - possibleColors[c][R];
diff[G] = src[4 * ( x * 4 + y ) + G] - possibleColors[c][G];
diff[B] = src[4 * ( x * 4 + y ) + B] - possibleColors[c][B];
const uint32_t err = 38 * abs( diff[R] ) + 76 * abs( diff[G] ) + 14 * abs( diff[B] );
uint32_t pixErr = err * err;
// Choose best error
if( pixErr < bestPixErr )
{
bestPixErr = pixErr;
pixColors ^= ( pixColors & 3 ); // Reset the two first bits
pixColors |= c;
}
}
blockErr += bestPixErr;
}
}
#endif
if( blockErr < bestBlockErr )
{
bestBlockErr = blockErr;
dist = d;
pixIndices = pixColors;
}
}
return bestBlockErr;
}
// main T-/H-mode compression function
#ifdef __AVX2__
uint32_t compressBlockTH( uint8_t* src, Luma& l, uint32_t& compressed1, uint32_t& compressed2, bool& tMode, __m128i r8, __m128i g8, __m128i b8 )
#else
uint32_t compressBlockTH( uint8_t *src, Luma& l, uint32_t& compressed1, uint32_t& compressed2, bool &tMode )
#endif
{
#ifdef __AVX2__
alignas( 8 ) uint8_t luma[16] = { 0, };
_mm_storeu_si128 ( (__m128i* )luma, l.luma8 );
#elif defined __ARM_NEON && defined __aarch64__
alignas( 8 ) uint8_t luma[16] = { 0 };
vst1q_u8( luma, l.luma8 );
#else
uint8_t* luma = l.val;
#endif
uint8_t pixIdx[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
// 1) sorts the pairs of (luma, pix_idx)
insertionSort( luma, pixIdx );
// 2) finds the min (left+right)
uint8_t minSumRangeIdx = 0;
uint16_t minSumRangeValue;
uint16_t sum;
static const uint8_t diffBonus[15] = {8, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 8};
const int16_t temp = luma[15] - luma[0];
minSumRangeValue = luma[15] - luma[1] + diffBonus[0];
for( uint8_t i = 1; i < 14; i++ )
{
sum = temp - luma[i+1] + luma[i] + diffBonus[i];
if( minSumRangeValue > sum )
{
minSumRangeValue = sum;
minSumRangeIdx = i;
}
}
sum = luma[14] - luma[0] + diffBonus[14];
if( minSumRangeValue > sum )
{
minSumRangeValue = sum;
minSumRangeIdx = 14;
}
uint8_t lRange, rRange;
lRange = luma[minSumRangeIdx] - luma[0];
rRange = luma[15] - luma[minSumRangeIdx + 1];
// 3) sets a proper mode
bool swap = false;
if( lRange >= rRange )
{
if( lRange >= rRange * 2 )
{
swap = true;
tMode = true;
}
}
else
{
if( lRange * 2 <= rRange ) tMode = true;
}
// 4) calculates the two base colors
uint8_t rangeIdx[4] = { pixIdx[0], pixIdx[minSumRangeIdx], pixIdx[minSumRangeIdx + 1], pixIdx[15] };
uint16_t r[4], g[4], b[4];
for( uint8_t i = 0; i < 4; ++i )
{
uint8_t idx = rangeIdx[i] * 4;
b[i] = src[idx];
g[i] = src[idx + 1];
r[i] = src[idx + 2];
}
uint8_t mid_rgb[2][3];
if( swap )
{
mid_rgb[1][B] = ( b[0] + b[1] ) / 2;
mid_rgb[1][G] = ( g[0] + g[1] ) / 2;
mid_rgb[1][R] = ( r[0] + r[1] ) / 2;
uint16_t sum_rgb[3] = { 0, 0, 0 };
for( uint8_t i = minSumRangeIdx + 1; i < 16; i++ )
{
uint8_t idx = pixIdx[i] * 4;
sum_rgb[B] += src[idx];
sum_rgb[G] += src[idx + 1];
sum_rgb[R] += src[idx + 2];
}
const uint8_t temp = 15 - minSumRangeIdx;
mid_rgb[0][B] = sum_rgb[B] / temp;
mid_rgb[0][G] = sum_rgb[G] / temp;
mid_rgb[0][R] = sum_rgb[R] / temp;
}
else
{
mid_rgb[0][B] = (b[0] + b[1]) / 2;
mid_rgb[0][G] = (g[0] + g[1]) / 2;
mid_rgb[0][R] = (r[0] + r[1]) / 2;
if( tMode )
{
uint16_t sum_rgb[3] = { 0, 0, 0 };
for( uint8_t i = minSumRangeIdx + 1; i < 16; i++ )
{
uint8_t idx = pixIdx[i] * 4;
sum_rgb[B] += src[idx];
sum_rgb[G] += src[idx + 1];
sum_rgb[R] += src[idx + 2];
}
const uint8_t temp = 15 - minSumRangeIdx;
mid_rgb[1][B] = sum_rgb[B] / temp;
mid_rgb[1][G] = sum_rgb[G] / temp;
mid_rgb[1][R] = sum_rgb[R] / temp;
}
else
{
mid_rgb[1][B] = (b[2] + b[3]) / 2;
mid_rgb[1][G] = (g[2] + g[3]) / 2;
mid_rgb[1][R] = (r[2] + r[3]) / 2;
}
}
// 5) sets the start distance index
uint32_t startDistCandidate;
uint32_t avgDist;
if( tMode )
{
if( swap )
{
avgDist = ( b[1] - b[0] + g[1] - g[0] + r[1] - r[0] ) / 6;
}
else
{
avgDist = ( b[3] - b[2] + g[3] - g[2] + r[3] - r[2] ) / 6;
}
}
else
{
avgDist = ( b[1] - b[0] + g[1] - g[0] + r[1] - r[0] + b[3] - b[2] + g[3] - g[2] + r[3] - r[2] ) / 12;
}
if( avgDist <= 16)
{
startDistCandidate = 0;
}
else if( avgDist <= 23 )
{
startDistCandidate = 1;
}
else if( avgDist <= 32 )
{
startDistCandidate = 2;
}
else if( avgDist <= 41 )
{
startDistCandidate = 3;
}
else
{
startDistCandidate = 4;
}
uint32_t bestErr = MaxError;
uint32_t bestPixIndices;
uint8_t bestDist = 10;
uint8_t colorsRGB444[2][3];
compressColor( mid_rgb, colorsRGB444, tMode );
compressed1 = 0;
// 6) finds the best candidate with the lowest error
#ifdef __AVX2__
// Vectorized ver
bestErr = calculateErrorTH( tMode, colorsRGB444, bestDist, bestPixIndices, startDistCandidate, r8, g8, b8 );
#else
// Scalar ver
bestErr = calculateErrorTH( tMode, src, colorsRGB444, bestDist, bestPixIndices, startDistCandidate );
#endif
// 7) outputs the final T or H block
if( tMode )
{
// Put the compress params into the compression block
compressed1 |= ( colorsRGB444[0][R] & 0xf ) << 23;
compressed1 |= ( colorsRGB444[0][G] & 0xf ) << 19;
compressed1 |= ( colorsRGB444[0][B] ) << 15;
compressed1 |= ( colorsRGB444[1][R] ) << 11;
compressed1 |= ( colorsRGB444[1][G] ) << 7;
compressed1 |= ( colorsRGB444[1][B] ) << 3;
compressed1 |= bestDist & 0x7;
}
else
{
int bestRGB444ColPacked[2];
bestRGB444ColPacked[0] = (colorsRGB444[0][R] << 8) + (colorsRGB444[0][G] << 4) + colorsRGB444[0][B];
bestRGB444ColPacked[1] = (colorsRGB444[1][R] << 8) + (colorsRGB444[1][G] << 4) + colorsRGB444[1][B];
if( ( bestRGB444ColPacked[0] >= bestRGB444ColPacked[1] ) ^ ( ( bestDist & 1 ) == 1 ) )
{
swapColors( colorsRGB444 );
// Reshuffle pixel indices to to exchange C1 with C3, and C2 with C4
bestPixIndices = ( 0x55555555 & bestPixIndices ) | ( 0xaaaaaaaa & ( ~bestPixIndices ) );
}
// Put the compress params into the compression block
compressed1 |= ( colorsRGB444[0][R] & 0xf ) << 22;
compressed1 |= ( colorsRGB444[0][G] & 0xf ) << 18;
compressed1 |= ( colorsRGB444[0][B] & 0xf ) << 14;
compressed1 |= ( colorsRGB444[1][R] & 0xf ) << 10;
compressed1 |= ( colorsRGB444[1][G] & 0xf ) << 6;
compressed1 |= ( colorsRGB444[1][B] & 0xf ) << 2;
compressed1 |= ( bestDist >> 1 ) & 0x3;
}
bestPixIndices = indexConversion( bestPixIndices );
compressed2 = 0;
compressed2 = ( compressed2 & ~( ( 0x2 << 31 ) - 1 ) ) | ( bestPixIndices & ( ( 2 << 31 ) - 1 ) );
return bestErr;
}
//#endif
template<class T, class S>
static etcpak_force_inline uint64_t EncodeSelectors( uint64_t d, const T terr[2][8], const S tsel[16][8], const uint32_t* id, const uint64_t value, const uint64_t error)
{
size_t tidx[2];
tidx[0] = GetLeastError( terr[0], 8 );
tidx[1] = GetLeastError( terr[1], 8 );
if ((terr[0][tidx[0]] + terr[1][tidx[1]]) >= error)
{
return value;
}
d |= tidx[0] << 26;
d |= tidx[1] << 29;
for( int i=0; i<16; i++ )
{
uint64_t t = tsel[i][tidx[id[i]%2]];
d |= ( t & 0x1 ) << ( i + 32 );
d |= ( t & 0x2 ) << ( i + 47 );
}
return FixByteOrder(d);
}
}
static etcpak_force_inline uint64_t ProcessRGB( const uint8_t* src )
{
#ifdef __AVX2__
uint64_t d = CheckSolid_AVX2( src );
if( d != 0 ) return d;
alignas(32) v4i a[8];
__m128i err0 = PrepareAverages_AVX2( a, src );
// Get index of minimum error (err0)
__m128i err1 = _mm_shuffle_epi32(err0, _MM_SHUFFLE(2, 3, 0, 1));
__m128i errMin0 = _mm_min_epu32(err0, err1);
__m128i errMin1 = _mm_shuffle_epi32(errMin0, _MM_SHUFFLE(1, 0, 3, 2));
__m128i errMin2 = _mm_min_epu32(errMin1, errMin0);
__m128i errMask = _mm_cmpeq_epi32(errMin2, err0);
uint32_t mask = _mm_movemask_epi8(errMask);
uint32_t idx = _bit_scan_forward(mask) >> 2;
d |= EncodeAverages_AVX2( a, idx );
alignas(32) uint32_t terr[2][8] = {};
alignas(32) uint32_t tsel[8];
if ((idx == 0) || (idx == 2))
{
FindBestFit_4x2_AVX2( terr, tsel, a, idx * 2, src );
}
else
{
FindBestFit_2x4_AVX2( terr, tsel, a, idx * 2, src );
}
return EncodeSelectors_AVX2( d, terr, tsel, (idx % 2) == 1 );
#else
uint64_t d = CheckSolid( src );
if( d != 0 ) return d;
v4i a[8];
unsigned int err[4] = {};
PrepareAverages( a, src, err );
size_t idx = GetLeastError( err, 4 );
EncodeAverages( d, a, idx );
#if ( defined __SSE4_1__ || defined __ARM_NEON ) && !defined REFERENCE_IMPLEMENTATION
uint32_t terr[2][8] = {};
#else
uint64_t terr[2][8] = {};
#endif
uint16_t tsel[16][8];
auto id = g_id[idx];
FindBestFit( terr, tsel, a, id, src );
return FixByteOrder( EncodeSelectors( d, terr, tsel, id ) );
#endif
}
#ifdef __AVX2__
// horizontal min/max functions. https://stackoverflow.com/questions/22256525/horizontal-minimum-and-maximum-using-sse
// if an error occurs in GCC, please change the value of -march in CFLAGS to a specific value for your CPU (e.g., skylake).
static inline int16_t hMax( __m128i buffer, uint8_t& idx )
{
__m128i tmp1 = _mm_sub_epi8( _mm_set1_epi8( (char)( 255 ) ), buffer );
__m128i tmp2 = _mm_min_epu8( tmp1, _mm_srli_epi16( tmp1, 8 ) );
__m128i tmp3 = _mm_minpos_epu16( tmp2 );
uint8_t result = 255 - (uint8_t)_mm_cvtsi128_si32( tmp3 );
__m128i mask = _mm_cmpeq_epi8( buffer, _mm_set1_epi8( result ) );
idx = _tzcnt_u32( _mm_movemask_epi8( mask ) );
return result;
}
#elif defined __ARM_NEON && defined __aarch64__
static inline int16_t hMax( uint8x16_t buffer, uint8_t& idx )
{
const uint8_t max = vmaxvq_u8( buffer );
const uint16x8_t vmax = vdupq_n_u16( max );
uint8x16x2_t buff_wide = vzipq_u8( buffer, uint8x16_t() );
uint16x8_t lowbuf16 = vreinterpretq_u16_u8( buff_wide.val[0] );
uint16x8_t hibuf16 = vreinterpretq_u16_u8( buff_wide.val[1] );
uint16x8_t low_eqmask = vceqq_u16( lowbuf16, vmax );
uint16x8_t hi_eqmask = vceqq_u16( hibuf16, vmax );
static const uint16_t mask_lsb[] = {
0x1, 0x2, 0x4, 0x8,
0x10, 0x20, 0x40, 0x80 };
static const uint16_t mask_msb[] = {
0x100, 0x200, 0x400, 0x800,
0x1000, 0x2000, 0x4000, 0x8000 };
uint16x8_t vmask_lsb = vld1q_u16( mask_lsb );
uint16x8_t vmask_msb = vld1q_u16( mask_msb );
uint16x8_t pos_lsb = vandq_u16( vmask_lsb, low_eqmask );
uint16x8_t pos_msb = vandq_u16( vmask_msb, hi_eqmask );
pos_lsb = vpaddq_u16( pos_lsb, pos_lsb );
pos_lsb = vpaddq_u16( pos_lsb, pos_lsb );
pos_lsb = vpaddq_u16( pos_lsb, pos_lsb );
uint64_t idx_lane1 = vgetq_lane_u64( vreinterpretq_u64_u16( pos_lsb ), 0 );
pos_msb = vpaddq_u16( pos_msb, pos_msb );
pos_msb = vpaddq_u16( pos_msb, pos_msb );
pos_msb = vpaddq_u16( pos_msb, pos_msb );
uint32_t idx_lane2 = vgetq_lane_u32( vreinterpretq_u32_u16( pos_msb ), 0 );
idx = idx_lane1 != 0 ? __builtin_ctz( idx_lane1 ) : __builtin_ctz( idx_lane2 );
return max;
}
#endif
#ifdef __AVX2__
static inline int16_t hMin( __m128i buffer, uint8_t& idx )
{
__m128i tmp2 = _mm_min_epu8( buffer, _mm_srli_epi16( buffer, 8 ) );
__m128i tmp3 = _mm_minpos_epu16( tmp2 );
uint8_t result = (uint8_t)_mm_cvtsi128_si32( tmp3 );
__m128i mask = _mm_cmpeq_epi8( buffer, _mm_set1_epi8( result ) );
idx = _tzcnt_u32( _mm_movemask_epi8( mask ) );
return result;
}
#elif defined __ARM_NEON && defined __aarch64__
static inline int16_t hMin( uint8x16_t buffer, uint8_t& idx )
{
const uint8_t min = vminvq_u8( buffer );
const uint16x8_t vmin = vdupq_n_u16( min );
uint8x16x2_t buff_wide = vzipq_u8( buffer, uint8x16_t() );
uint16x8_t lowbuf16 = vreinterpretq_u16_u8( buff_wide.val[0] );
uint16x8_t hibuf16 = vreinterpretq_u16_u8( buff_wide.val[1] );
uint16x8_t low_eqmask = vceqq_u16( lowbuf16, vmin );
uint16x8_t hi_eqmask = vceqq_u16( hibuf16, vmin );
static const uint16_t mask_lsb[] = {
0x1, 0x2, 0x4, 0x8,
0x10, 0x20, 0x40, 0x80 };
static const uint16_t mask_msb[] = {
0x100, 0x200, 0x400, 0x800,
0x1000, 0x2000, 0x4000, 0x8000 };
uint16x8_t vmask_lsb = vld1q_u16( mask_lsb );
uint16x8_t vmask_msb = vld1q_u16( mask_msb );
uint16x8_t pos_lsb = vandq_u16( vmask_lsb, low_eqmask );
uint16x8_t pos_msb = vandq_u16( vmask_msb, hi_eqmask );
pos_lsb = vpaddq_u16( pos_lsb, pos_lsb );
pos_lsb = vpaddq_u16( pos_lsb, pos_lsb );
pos_lsb = vpaddq_u16( pos_lsb, pos_lsb );
uint64_t idx_lane1 = vgetq_lane_u64( vreinterpretq_u64_u16( pos_lsb ), 0 );
pos_msb = vpaddq_u16( pos_msb, pos_msb );
pos_msb = vpaddq_u16( pos_msb, pos_msb );
pos_msb = vpaddq_u16( pos_msb, pos_msb );
uint32_t idx_lane2 = vgetq_lane_u32( vreinterpretq_u32_u16( pos_msb ), 0 );
idx = idx_lane1 != 0 ? __builtin_ctz( idx_lane1 ) : __builtin_ctz( idx_lane2 );
return min;
}
#endif
// During search it is not convenient to store the bits the way they are stored in the
// file format. Hence, after search, it is converted to this format.
// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved.
static inline void stuff59bits( unsigned int thumbT59W1, unsigned int thumbT59W2, unsigned int& thumbTW1, unsigned int& thumbTW2 )
{
// Put bits in twotimer configuration for 59 (red overflows)
//
// Go from this bit layout:
//
// |63 62 61 60 59|58 57 56 55|54 53 52 51|50 49 48 47|46 45 44 43|42 41 40 39|38 37 36 35|34 33 32|
// |----empty-----|---red 0---|--green 0--|--blue 0---|---red 1---|--green 1--|--blue 1---|--dist--|
//
// |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00|
// |----------------------------------------index bits---------------------------------------------|
//
//
// To this:
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32
// -----------------------------------------------------------------------------------------------
// |// // //|R0a |//|R0b |G0 |B0 |R1 |G1 |B1 |da |df|db|
// -----------------------------------------------------------------------------------------------
//
// |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00|
// |----------------------------------------index bits---------------------------------------------|
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32
// -----------------------------------------------------------------------------------------------
// | base col1 | dcol 2 | base col1 | dcol 2 | base col 1 | dcol 2 | table | table |df|fp|
// | R1' (5 bits) | dR2 | G1' (5 bits) | dG2 | B1' (5 bits) | dB2 | cw 1 | cw 2 |bt|bt|
// ------------------------------------------------------------------------------------------------
uint8_t R0a;
uint8_t bit, a, b, c, d, bits;
R0a = ( thumbT59W1 >> 25 ) & 0x3;
// Fix middle part
thumbTW1 = thumbT59W1 << 1;
// Fix R0a (top two bits of R0)
thumbTW1 = ( thumbTW1 & ~( 0x3 << 27 ) ) | ( ( R0a & 0x3 ) << 27 );
// Fix db (lowest bit of d)
thumbTW1 = ( thumbTW1 & ~0x1 ) | ( thumbT59W1 & 0x1 );
// Make sure that red overflows:
a = ( thumbTW1 >> 28 ) & 0x1;
b = ( thumbTW1 >> 27 ) & 0x1;
c = ( thumbTW1 >> 25 ) & 0x1;
d = ( thumbTW1 >> 24 ) & 0x1;
// The following bit abcd bit sequences should be padded with ones: 0111, 1010, 1011, 1101, 1110, 1111
// The following logical expression checks for the presence of any of those:
bit = ( a & c ) | ( !a & b & c & d ) | ( a & b & !c & d );
bits = 0xf * bit;
thumbTW1 = ( thumbTW1 & ~( 0x7 << 29 ) ) | ( bits & 0x7 ) << 29;
thumbTW1 = ( thumbTW1 & ~( 0x1 << 26 ) ) | ( !bit & 0x1 ) << 26;
// Set diffbit
thumbTW1 = ( thumbTW1 & ~0x2 ) | 0x2;
thumbTW2 = thumbT59W2;
}
// During search it is not convenient to store the bits the way they are stored in the
// file format. Hence, after search, it is converted to this format.
// NO WARRANTY --- SEE STATEMENT IN TOP OF FILE (C) Ericsson AB 2005-2013. All Rights Reserved.
static inline void stuff58bits( unsigned int thumbH58W1, unsigned int thumbH58W2, unsigned int& thumbHW1, unsigned int& thumbHW2 )
{
// Put bits in twotimer configuration for 58 (red doesn't overflow, green does)
//
// Go from this bit layout:
//
//
// |63 62 61 60 59 58|57 56 55 54|53 52 51 50|49 48 47 46|45 44 43 42|41 40 39 38|37 36 35 34|33 32|
// |-------empty-----|---red 0---|--green 0--|--blue 0---|---red 1---|--green 1--|--blue 1---|d2 d1|
//
// |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00|
// |---------------------------------------index bits----------------------------------------------|
//
// To this:
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32
// -----------------------------------------------------------------------------------------------
// |//|R0 |G0 |// // //|G0|B0|//|B0b |R1 |G1 |B0 |d2|df|d1|
// -----------------------------------------------------------------------------------------------
//
// |31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00|
// |---------------------------------------index bits----------------------------------------------|
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32
// -----------------------------------------------------------------------------------------------
// | base col1 | dcol 2 | base col1 | dcol 2 | base col 1 | dcol 2 | table | table |df|fp|
// | R1' (5 bits) | dR2 | G1' (5 bits) | dG2 | B1' (5 bits) | dB2 | cw 1 | cw 2 |bt|bt|
// -----------------------------------------------------------------------------------------------
//
//
// Thus, what we are really doing is going from this bit layout:
//
//
// |63 62 61 60 59 58|57 56 55 54 53 52 51|50 49|48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33|32 |
// |-------empty-----|part0---------------|part1|part2------------------------------------------|part3|
//
// To this:
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32
// --------------------------------------------------------------------------------------------------|
// |//|part0 |// // //|part1|//|part2 |df|part3|
// --------------------------------------------------------------------------------------------------|
unsigned int part0, part1, part2, part3;
uint8_t bit, a, b, c, d, bits;
// move parts
part0 = ( thumbH58W1 >> 19 ) & 0x7f;
part1 = ( thumbH58W1 >> 17 ) & 0x3;
part2 = ( thumbH58W1 >> 1 ) & 0xffff;
part3 = thumbH58W1 & 0x1;
thumbHW1 = 0;
thumbHW1 = ( thumbHW1 & ~( 0x7f << 24 ) ) | ( ( part0 & 0x7f ) << 24 );
thumbHW1 = ( thumbHW1 & ~( 0x3 << 19 ) ) | ( ( part1 & 0x3 ) << 19 );
thumbHW1 = ( thumbHW1 & ~( 0xffff << 2 ) ) | ( ( part2 & 0xffff ) << 2 );
thumbHW1 = ( thumbHW1 & ~0x1 ) | ( part3 & 0x1 );
// Make sure that red does not overflow:
bit = ( thumbHW1 >> 30 ) & 0x1;
thumbHW1 = ( thumbHW1 & ~( 0x1 << 31 ) ) | ( ( !bit & 0x1 ) << 31 );
// Make sure that green overflows:
a = ( thumbHW1 >> 20 ) & 0x1;
b = ( thumbHW1 >> 19 ) & 0x1;
c = ( thumbHW1 >> 17 ) & 0x1;
d = ( thumbHW1 >> 16 ) & 0x1;
// The following bit abcd bit sequences should be padded with ones: 0111, 1010, 1011, 1101, 1110, 1111
// The following logical expression checks for the presence of any of those:
bit = ( a & c ) | ( !a & b & c & d ) | ( a & b & !c & d );
bits = 0xf * bit;
thumbHW1 = ( thumbHW1 & ~( 0x7 << 21 ) ) | ( ( bits & 0x7 ) << 21 );
thumbHW1 = ( thumbHW1 & ~( 0x1 << 18 ) ) | ( ( !bit & 0x1 ) << 18 );
// Set diffbit
thumbHW1 = ( thumbHW1 & ~0x2 ) | 0x2;
thumbHW2 = thumbH58W2;
}
#if defined __AVX2__ || (defined __ARM_NEON && defined __aarch64__)
static etcpak_force_inline Channels GetChannels( const uint8_t* src )
{
Channels ch;
#ifdef __AVX2__
__m128i d0 = _mm_loadu_si128( ( (__m128i*)src ) + 0 );
__m128i d1 = _mm_loadu_si128( ( (__m128i*)src ) + 1 );
__m128i d2 = _mm_loadu_si128( ( (__m128i*)src ) + 2 );
__m128i d3 = _mm_loadu_si128( ( (__m128i*)src ) + 3 );
__m128i rgb0 = _mm_shuffle_epi8( d0, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) );
__m128i rgb1 = _mm_shuffle_epi8( d1, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) );
__m128i rgb2 = _mm_shuffle_epi8( d2, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) );
__m128i rgb3 = _mm_shuffle_epi8( d3, _mm_setr_epi8( 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, -1, -1, -1, -1 ) );
__m128i rg0 = _mm_unpacklo_epi32( rgb0, rgb1 );
__m128i rg1 = _mm_unpacklo_epi32( rgb2, rgb3 );
__m128i b0 = _mm_unpackhi_epi32( rgb0, rgb1 );
__m128i b1 = _mm_unpackhi_epi32( rgb2, rgb3 );
// swap channels
ch.b8 = _mm_unpacklo_epi64( rg0, rg1 );
ch.g8 = _mm_unpackhi_epi64( rg0, rg1 );
ch.r8 = _mm_unpacklo_epi64( b0, b1 );
#elif defined __ARM_NEON && defined __aarch64__
//load pixel data into 4 rows
uint8x16_t px0 = vld1q_u8( src + 0 );
uint8x16_t px1 = vld1q_u8( src + 16 );
uint8x16_t px2 = vld1q_u8( src + 32 );
uint8x16_t px3 = vld1q_u8( src + 48 );
uint8x16x2_t px0z1 = vzipq_u8( px0, px1 );
uint8x16x2_t px2z3 = vzipq_u8( px2, px3 );
uint8x16x2_t px01 = vzipq_u8( px0z1.val[0], px0z1.val[1] );
uint8x16x2_t rgb01 = vzipq_u8( px01.val[0], px01.val[1] );
uint8x16x2_t px23 = vzipq_u8( px2z3.val[0], px2z3.val[1] );
uint8x16x2_t rgb23 = vzipq_u8( px23.val[0], px23.val[1] );
uint8x16_t rr = vreinterpretq_u8_u64( vzip1q_u64( vreinterpretq_u64_u8( rgb01.val[0] ), vreinterpretq_u64_u8( rgb23.val[0] ) ) );
uint8x16_t gg = vreinterpretq_u8_u64( vzip2q_u64( vreinterpretq_u64_u8( rgb01.val[0] ), vreinterpretq_u64_u8( rgb23.val[0] ) ) );
uint8x16_t bb = vreinterpretq_u8_u64( vzip1q_u64( vreinterpretq_u64_u8( rgb01.val[1] ), vreinterpretq_u64_u8( rgb23.val[1] ) ) );
uint8x16x2_t red = vzipq_u8( rr, uint8x16_t() );
uint8x16x2_t grn = vzipq_u8( gg, uint8x16_t() );
uint8x16x2_t blu = vzipq_u8( bb, uint8x16_t() );
ch.r = red;
ch.b = blu;
ch.g = grn;
#endif
return ch;
}
#endif
#if defined __AVX2__ || (defined __ARM_NEON && defined __aarch64__)
static etcpak_force_inline void CalculateLuma( Channels& ch, Luma& luma )
#else
static etcpak_force_inline void CalculateLuma( const uint8_t* src, Luma& luma )
#endif
{
#ifdef __AVX2__
__m256i b16_luma = _mm256_mullo_epi16( _mm256_cvtepu8_epi16( ch.b8 ), _mm256_set1_epi16( 14 ) );
__m256i g16_luma = _mm256_mullo_epi16( _mm256_cvtepu8_epi16( ch.g8 ), _mm256_set1_epi16( 76 ) );
__m256i r16_luma = _mm256_mullo_epi16( _mm256_cvtepu8_epi16( ch.r8 ), _mm256_set1_epi16( 38 ) );
__m256i luma_16bit = _mm256_add_epi16( _mm256_add_epi16( g16_luma, r16_luma ), b16_luma );
__m256i luma_8bit_m256i = _mm256_srli_epi16( luma_16bit, 7 );
__m128i luma_8bit_lo = _mm256_extractf128_si256( luma_8bit_m256i, 0 );
__m128i luma_8bit_hi = _mm256_extractf128_si256( luma_8bit_m256i, 1 );
static const __m128i interleaving_mask_lo = _mm_set_epi8( 15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0 );
static const __m128i interleaving_mask_hi = _mm_set_epi8( 14, 12, 10, 8, 6, 4, 2, 0, 15, 13, 11, 9, 7, 5, 3, 1 );
__m128i luma_8bit_lo_moved = _mm_shuffle_epi8( luma_8bit_lo, interleaving_mask_lo );
__m128i luma_8bit_hi_moved = _mm_shuffle_epi8( luma_8bit_hi, interleaving_mask_hi );
__m128i luma_8bit = _mm_or_si128( luma_8bit_hi_moved, luma_8bit_lo_moved );
luma.luma8 = luma_8bit;
// min/max calculation
luma.min = hMin( luma_8bit, luma.minIdx ) * 0.00392156f;
luma.max = hMax( luma_8bit, luma.maxIdx ) * 0.00392156f;
#elif defined __ARM_NEON && defined __aarch64__
//load pixel data into 4 rows
uint16x8_t red0 = vmulq_n_u16( vreinterpretq_u16_u8( ch.r.val[0] ), 14 );
uint16x8_t red1 = vmulq_n_u16( vreinterpretq_u16_u8( ch.r.val[1] ), 14 );
uint16x8_t grn0 = vmulq_n_u16( vreinterpretq_u16_u8( ch.g.val[0] ), 76 );
uint16x8_t grn1 = vmulq_n_u16( vreinterpretq_u16_u8( ch.g.val[1] ), 76 );
uint16x8_t blu0 = vmulq_n_u16( vreinterpretq_u16_u8( ch.b.val[0] ), 38 );
uint16x8_t blu1 = vmulq_n_u16( vreinterpretq_u16_u8( ch.b.val[1] ), 38 );
//calculate luma for rows 0,1 and 2,3
uint16x8_t lum_r01 = vaddq_u16( vaddq_u16( red0, grn0 ), blu0 );
uint16x8_t lum_r23 = vaddq_u16( vaddq_u16( red1, grn1 ), blu1 );
//divide luma values with right shift and narrow results to 8bit
uint8x8_t lum_r01_d = vshrn_n_u16( lum_r01, 7 );
uint8x8_t lum_r02_d = vshrn_n_u16( lum_r23, 7 );
luma.luma8 = vcombine_u8( lum_r01_d, lum_r02_d );
//find min and max luma value
luma.min = hMin( luma.luma8, luma.minIdx ) * 0.00392156f;
luma.max = hMax( luma.luma8, luma.maxIdx ) * 0.00392156f;
#else
for( int i = 0; i < 16; ++i )
{
luma.val[i] = ( src[i * 4 + 2] * 76 + src[i * 4 + 1] * 150 + src[i * 4] * 28 ) / 254; // luma calculation
if( luma.min > luma.val[i] )
{
luma.min = luma.val[i];
luma.minIdx = i;
}
if( luma.max < luma.val[i] )
{
luma.max = luma.val[i];
luma.maxIdx = i;
}
}
#endif
}
static etcpak_force_inline uint8_t SelectModeETC2( const Luma& luma )
{
#if defined __AVX2__ || defined __ARM_NEON
const float lumaRange = ( luma.max - luma.min );
#else
const float lumaRange = ( luma.max - luma.min ) * ( 1.f / 255.f );
#endif
// filters a very-low-contrast block
if( lumaRange <= ecmd_threshold[0] )
{
return ModePlanar;
}
// checks whether a pair of the corner pixels in a block has the min/max luma values;
// if so, the ETC2 planar mode is enabled, and otherwise, the ETC1 mode is enabled
else if( lumaRange <= ecmd_threshold[1] )
{
#ifdef __AVX2__
static const __m128i corner_pair = _mm_set_epi8( 1, 1, 1, 1, 1, 1, 1, 1, 0, 15, 3, 12, 12, 3, 15, 0 );
__m128i current_max_min = _mm_set_epi8( 0, 0, 0, 0, 0, 0, 0, 0, luma.minIdx, luma.maxIdx, luma.minIdx, luma.maxIdx, luma.minIdx, luma.maxIdx, luma.minIdx, luma.maxIdx );
__m128i max_min_result = _mm_cmpeq_epi16( corner_pair, current_max_min );
int mask = _mm_movemask_epi8( max_min_result );
if( mask )
{
return ModePlanar;
}
#else
// check whether a pair of the corner pixels in a block has the min/max luma values;
// if so, the ETC2 planar mode is enabled.
if( ( luma.minIdx == 0 && luma.maxIdx == 15 ) ||
( luma.minIdx == 15 && luma.maxIdx == 0 ) ||
( luma.minIdx == 3 && luma.maxIdx == 12 ) ||
( luma.minIdx == 12 && luma.maxIdx == 3 ) )
{
return ModePlanar;
}
#endif
}
// filters a high-contrast block for checking both ETC1 mode and the ETC2 T/H mode
else if( lumaRange >= ecmd_threshold[2] )
{
return ModeTH;
}
return ModeUndecided;
}
static etcpak_force_inline uint64_t ProcessRGB_ETC2( const uint8_t* src, bool useHeuristics )
{
#ifdef __AVX2__
uint64_t d = CheckSolid_AVX2( src );
if( d != 0 ) return d;
#else
uint64_t d = CheckSolid( src );
if (d != 0) return d;
#endif
uint8_t mode = ModeUndecided;
Luma luma;
#ifdef __AVX2__
Channels ch = GetChannels( src );
if( useHeuristics )
{
CalculateLuma( ch, luma );
mode = SelectModeETC2( luma );
}
auto plane = Planar_AVX2( ch, mode, useHeuristics );
if( useHeuristics && mode == ModePlanar ) return plane.plane;
alignas( 32 ) v4i a[8];
__m128i err0 = PrepareAverages_AVX2( a, plane.sum4 );
// Get index of minimum error (err0)
__m128i err1 = _mm_shuffle_epi32( err0, _MM_SHUFFLE( 2, 3, 0, 1 ) );
__m128i errMin0 = _mm_min_epu32(err0, err1);
__m128i errMin1 = _mm_shuffle_epi32( errMin0, _MM_SHUFFLE( 1, 0, 3, 2 ) );
__m128i errMin2 = _mm_min_epu32( errMin1, errMin0 );
__m128i errMask = _mm_cmpeq_epi32( errMin2, err0 );
uint32_t mask = _mm_movemask_epi8( errMask );
size_t idx = _bit_scan_forward( mask ) >> 2;
d = EncodeAverages_AVX2( a, idx );
alignas(32) uint32_t terr[2][8] = {};
alignas(32) uint32_t tsel[8];
if ((idx == 0) || (idx == 2))
{
FindBestFit_4x2_AVX2( terr, tsel, a, idx * 2, src );
}
else
{
FindBestFit_2x4_AVX2( terr, tsel, a, idx * 2, src );
}
if( useHeuristics )
{
if( mode == ModeTH )
{
uint64_t result = 0;
uint64_t error = 0;
uint32_t compressed[4] = { 0, 0, 0, 0 };
bool tMode = false;
error = compressBlockTH( (uint8_t*)src, luma, compressed[0], compressed[1], tMode, ch.r8, ch.g8, ch.b8 );
if( tMode )
{
stuff59bits( compressed[0], compressed[1], compressed[2], compressed[3] );
}
else
{
stuff58bits( compressed[0], compressed[1], compressed[2], compressed[3] );
}
result = (uint32_t)_bswap( compressed[2] );
result |= static_cast<uint64_t>( _bswap( compressed[3] ) ) << 32;
plane.plane = result;
plane.error = error;
}
else
{
plane.plane = 0;
plane.error = MaxError;
}
}
return EncodeSelectors_AVX2( d, terr, tsel, ( idx % 2 ) == 1, plane.plane, plane.error );
#else
if( useHeuristics )
{
#if defined __ARM_NEON && defined __aarch64__
Channels ch = GetChannels( src );
CalculateLuma( ch, luma );
#else
CalculateLuma( src, luma );
#endif
mode = SelectModeETC2( luma );
}
#ifdef __ARM_NEON
auto result = Planar_NEON( src, mode, useHeuristics );
#else
auto result = Planar( src, mode, useHeuristics );
#endif
if( result.second == 0 ) return result.first;
v4i a[8];
unsigned int err[4] = {};
PrepareAverages( a, src, err );
size_t idx = GetLeastError( err, 4 );
EncodeAverages( d, a, idx );
#if ( defined __SSE4_1__ || defined __ARM_NEON ) && !defined REFERENCE_IMPLEMENTATION
uint32_t terr[2][8] = {};
#else
uint64_t terr[2][8] = {};
#endif
uint16_t tsel[16][8];
auto id = g_id[idx];
FindBestFit( terr, tsel, a, id, src );
if( useHeuristics )
{
if( mode == ModeTH )
{
uint32_t compressed[4] = { 0, 0, 0, 0 };
bool tMode = false;
result.second = compressBlockTH( (uint8_t*)src, luma, compressed[0], compressed[1], tMode );
if( tMode )
{
stuff59bits( compressed[0], compressed[1], compressed[2], compressed[3] );
}
else
{
stuff58bits( compressed[0], compressed[1], compressed[2], compressed[3] );
}
result.first = (uint32_t)_bswap( compressed[2] );
result.first |= static_cast<uint64_t>( _bswap( compressed[3] ) ) << 32;
}
else
{
result.first = 0;
result.second = MaxError;
}
}
return EncodeSelectors( d, terr, tsel, id, result.first, result.second );
#endif
}
#ifdef __SSE4_1__
template<int K>
static etcpak_force_inline __m128i Widen( const __m128i src )
{
static_assert( K >= 0 && K <= 7, "Index out of range" );
__m128i tmp;
switch( K )
{
case 0:
tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 0, 0, 0, 0 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) );
case 1:
tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 1, 1, 1, 1 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) );
case 2:
tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 2, 2, 2, 2 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) );
case 3:
tmp = _mm_shufflelo_epi16( src, _MM_SHUFFLE( 3, 3, 3, 3 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 0, 0, 0, 0 ) );
case 4:
tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 0, 0, 0, 0 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) );
case 5:
tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 1, 1, 1, 1 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) );
case 6:
tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 2, 2, 2, 2 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) );
case 7:
tmp = _mm_shufflehi_epi16( src, _MM_SHUFFLE( 3, 3, 3, 3 ) );
return _mm_shuffle_epi32( tmp, _MM_SHUFFLE( 2, 2, 2, 2 ) );
}
}
static etcpak_force_inline int GetMulSel( int sel )
{
switch( sel )
{
case 0:
return 0;
case 1:
case 2:
case 3:
return 1;
case 4:
return 2;
case 5:
case 6:
case 7:
return 3;
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
return 4;
case 14:
case 15:
return 5;
}
}
#endif
#ifdef __ARM_NEON
static constexpr etcpak_force_inline int GetMulSel(int sel)
{
return ( sel < 1 ) ? 0 : ( sel < 4 ) ? 1 : ( sel < 5 ) ? 2 : ( sel < 8 ) ? 3 : ( sel < 14 ) ? 4 : 5;
}
static constexpr int ClampConstant( int x, int min, int max )
{
return x < min ? min : x > max ? max : x;
}
template <int Index>
etcpak_force_inline static uint16x8_t ErrorProbe_EAC_NEON( uint8x8_t recVal, uint8x16_t alphaBlock )
{
uint8x8_t srcValWide;
#ifndef __aarch64__
if( Index < 8 )
srcValWide = vdup_lane_u8( vget_low_u8( alphaBlock ), ClampConstant( Index, 0, 8 ) );
else
srcValWide = vdup_lane_u8( vget_high_u8( alphaBlock ), ClampConstant( Index - 8, 0, 8 ) );
#else
srcValWide = vdup_laneq_u8( alphaBlock, Index );
#endif
uint8x8_t deltaVal = vabd_u8( srcValWide, recVal );
return vmull_u8( deltaVal, deltaVal );
}
etcpak_force_inline static uint16_t MinError_EAC_NEON( uint16x8_t errProbe )
{
#ifndef __aarch64__
uint16x4_t tmpErr = vpmin_u16( vget_low_u16( errProbe ), vget_high_u16( errProbe ) );
tmpErr = vpmin_u16( tmpErr, tmpErr );
return vpmin_u16( tmpErr, tmpErr )[0];
#else
return vminvq_u16( errProbe );
#endif
}
template <int Index>
etcpak_force_inline static uint64_t MinErrorIndex_EAC_NEON( uint8x8_t recVal, uint8x16_t alphaBlock )
{
uint16x8_t errProbe = ErrorProbe_EAC_NEON<Index>( recVal, alphaBlock );
uint16x8_t minErrMask = vceqq_u16( errProbe, vdupq_n_u16( MinError_EAC_NEON( errProbe ) ) );
uint64_t idx = __builtin_ctzll( vget_lane_u64( vreinterpret_u64_u8( vqmovn_u16( minErrMask ) ), 0 ) );
idx >>= 3;
idx <<= 45 - Index * 3;
return idx;
}
template <int Index>
etcpak_force_inline static int16x8_t WidenMultiplier_EAC_NEON( int16x8_t multipliers )
{
constexpr int Lane = GetMulSel( Index );
#ifndef __aarch64__
if( Lane < 4 )
return vdupq_lane_s16( vget_low_s16( multipliers ), ClampConstant( Lane, 0, 4 ) );
else
return vdupq_lane_s16( vget_high_s16( multipliers ), ClampConstant( Lane - 4, 0, 4 ) );
#else
return vdupq_laneq_s16( multipliers, Lane );
#endif
}
#endif
static etcpak_force_inline uint64_t ProcessAlpha_ETC2( const uint8_t* src )
{
#if defined __SSE4_1__
// Check solid
__m128i s = _mm_loadu_si128( (__m128i*)src );
__m128i solidCmp = _mm_set1_epi8( src[0] );
__m128i cmpRes = _mm_cmpeq_epi8( s, solidCmp );
if( _mm_testc_si128( cmpRes, _mm_set1_epi32( -1 ) ) )
{
return src[0];
}
// Calculate min, max
__m128i s1 = _mm_shuffle_epi32( s, _MM_SHUFFLE( 2, 3, 0, 1 ) );
__m128i max1 = _mm_max_epu8( s, s1 );
__m128i min1 = _mm_min_epu8( s, s1 );
__m128i smax2 = _mm_shuffle_epi32( max1, _MM_SHUFFLE( 0, 0, 2, 2 ) );
__m128i smin2 = _mm_shuffle_epi32( min1, _MM_SHUFFLE( 0, 0, 2, 2 ) );
__m128i max2 = _mm_max_epu8( max1, smax2 );
__m128i min2 = _mm_min_epu8( min1, smin2 );
__m128i smax3 = _mm_alignr_epi8( max2, max2, 2 );
__m128i smin3 = _mm_alignr_epi8( min2, min2, 2 );
__m128i max3 = _mm_max_epu8( max2, smax3 );
__m128i min3 = _mm_min_epu8( min2, smin3 );
__m128i smax4 = _mm_alignr_epi8( max3, max3, 1 );
__m128i smin4 = _mm_alignr_epi8( min3, min3, 1 );
__m128i max = _mm_max_epu8( max3, smax4 );
__m128i min = _mm_min_epu8( min3, smin4 );
__m128i max16 = _mm_unpacklo_epi8( max, _mm_setzero_si128() );
__m128i min16 = _mm_unpacklo_epi8( min, _mm_setzero_si128() );
// src range, mid
__m128i srcRange = _mm_sub_epi16( max16, min16 );
__m128i srcRangeHalf = _mm_srli_epi16( srcRange, 1 );
__m128i srcMid = _mm_add_epi16( min16, srcRangeHalf );
// multiplier
__m128i mul1 = _mm_mulhi_epi16( srcRange, g_alphaRange_SIMD );
__m128i mul = _mm_add_epi16( mul1, _mm_set1_epi16( 1 ) );
// wide source
__m128i s16_1 = _mm_shuffle_epi32( s, _MM_SHUFFLE( 3, 2, 3, 2 ) );
__m128i s16[2] = { _mm_unpacklo_epi8( s, _mm_setzero_si128() ), _mm_unpacklo_epi8( s16_1, _mm_setzero_si128() ) };
__m128i sr[16] = {
Widen<0>( s16[0] ),
Widen<1>( s16[0] ),
Widen<2>( s16[0] ),
Widen<3>( s16[0] ),
Widen<4>( s16[0] ),
Widen<5>( s16[0] ),
Widen<6>( s16[0] ),
Widen<7>( s16[0] ),
Widen<0>( s16[1] ),
Widen<1>( s16[1] ),
Widen<2>( s16[1] ),
Widen<3>( s16[1] ),
Widen<4>( s16[1] ),
Widen<5>( s16[1] ),
Widen<6>( s16[1] ),
Widen<7>( s16[1] )
};
#ifdef __AVX2__
__m256i srcRangeWide = _mm256_broadcastsi128_si256( srcRange );
__m256i srcMidWide = _mm256_broadcastsi128_si256( srcMid );
__m256i mulWide1 = _mm256_mulhi_epi16( srcRangeWide, g_alphaRange_AVX );
__m256i mulWide = _mm256_add_epi16( mulWide1, _mm256_set1_epi16( 1 ) );
__m256i modMul[8] = {
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[0] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[0] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[1] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[1] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[2] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[2] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[3] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[3] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[4] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[4] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[5] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[5] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[6] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[6] ) ) ), _mm256_setzero_si256() ),
_mm256_unpacklo_epi8( _mm256_packus_epi16( _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[7] ) ), _mm256_add_epi16( srcMidWide, _mm256_mullo_epi16( mulWide, g_alpha_AVX[7] ) ) ), _mm256_setzero_si256() ),
};
// find selector
__m256i mulErr = _mm256_setzero_si256();
for( int j=0; j<16; j++ )
{
__m256i s16Wide = _mm256_broadcastsi128_si256( sr[j] );
__m256i err1, err2;
err1 = _mm256_sub_epi16( s16Wide, modMul[0] );
__m256i localErr = _mm256_mullo_epi16( err1, err1 );
err1 = _mm256_sub_epi16( s16Wide, modMul[1] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
err1 = _mm256_sub_epi16( s16Wide, modMul[2] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
err1 = _mm256_sub_epi16( s16Wide, modMul[3] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
err1 = _mm256_sub_epi16( s16Wide, modMul[4] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
err1 = _mm256_sub_epi16( s16Wide, modMul[5] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
err1 = _mm256_sub_epi16( s16Wide, modMul[6] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
err1 = _mm256_sub_epi16( s16Wide, modMul[7] );
err2 = _mm256_mullo_epi16( err1, err1 );
localErr = _mm256_min_epu16( localErr, err2 );
// note that this can overflow, but since we're looking for the smallest error, it shouldn't matter
mulErr = _mm256_adds_epu16( mulErr, localErr );
}
uint64_t minPos1 = _mm_cvtsi128_si64( _mm_minpos_epu16( _mm256_castsi256_si128( mulErr ) ) );
uint64_t minPos2 = _mm_cvtsi128_si64( _mm_minpos_epu16( _mm256_extracti128_si256( mulErr, 1 ) ) );
int sel = ( ( minPos1 & 0xFFFF ) < ( minPos2 & 0xFFFF ) ) ? ( minPos1 >> 16 ) : ( 8 + ( minPos2 >> 16 ) );
__m128i recVal16;
switch( sel )
{
case 0:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ) ), _mm_setzero_si128() );
break;
case 1:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ) ), _mm_setzero_si128() );
break;
case 2:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ) ), _mm_setzero_si128() );
break;
case 3:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ) ), _mm_setzero_si128() );
break;
case 4:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ) ), _mm_setzero_si128() );
break;
case 5:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ) ), _mm_setzero_si128() );
break;
case 6:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ) ), _mm_setzero_si128() );
break;
case 7:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ) ), _mm_setzero_si128() );
break;
case 8:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ) ), _mm_setzero_si128() );
break;
case 9:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ) ), _mm_setzero_si128() );
break;
case 10:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ) ), _mm_setzero_si128() );
break;
case 11:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ) ), _mm_setzero_si128() );
break;
case 12:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ) ), _mm_setzero_si128() );
break;
case 13:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ) ), _mm_setzero_si128() );
break;
case 14:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ) ), _mm_setzero_si128() );
break;
case 15:
recVal16 = _mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ) ), _mm_setzero_si128() );
break;
default:
assert( false );
break;
}
#else
// wide multiplier
__m128i rangeMul[16] = {
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<0>( mul ), g_alpha_SIMD[0] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[1] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[2] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<1>( mul ), g_alpha_SIMD[3] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<2>( mul ), g_alpha_SIMD[4] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[5] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[6] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<3>( mul ), g_alpha_SIMD[7] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[8] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[9] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[10] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[11] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[12] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<4>( mul ), g_alpha_SIMD[13] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[14] ) ) ), _mm_setzero_si128() ),
_mm_unpacklo_epi8( _mm_packus_epi16( _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ), _mm_add_epi16( srcMid, _mm_mullo_epi16( Widen<5>( mul ), g_alpha_SIMD[15] ) ) ), _mm_setzero_si128() )
};
// find selector
int err = std::numeric_limits<int>::max();
int sel;
for( int r=0; r<16; r++ )
{
__m128i err1, err2, minerr;
__m128i recVal16 = rangeMul[r];
int rangeErr;
err1 = _mm_sub_epi16( sr[0], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr = _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[1], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[2], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[3], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[4], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[5], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[6], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[7], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[8], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[9], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[10], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[11], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[12], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[13], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[14], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
err1 = _mm_sub_epi16( sr[15], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
rangeErr += _mm_cvtsi128_si64( minerr ) & 0xFFFF;
if( rangeErr < err )
{
err = rangeErr;
sel = r;
if( err == 0 ) break;
}
}
__m128i recVal16 = rangeMul[sel];
#endif
// find indices
__m128i err1, err2, minerr;
uint64_t idx = 0, tmp;
err1 = _mm_sub_epi16( sr[0], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 15*3;
err1 = _mm_sub_epi16( sr[1], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 14*3;
err1 = _mm_sub_epi16( sr[2], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 13*3;
err1 = _mm_sub_epi16( sr[3], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 12*3;
err1 = _mm_sub_epi16( sr[4], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 11*3;
err1 = _mm_sub_epi16( sr[5], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 10*3;
err1 = _mm_sub_epi16( sr[6], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 9*3;
err1 = _mm_sub_epi16( sr[7], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 8*3;
err1 = _mm_sub_epi16( sr[8], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 7*3;
err1 = _mm_sub_epi16( sr[9], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 6*3;
err1 = _mm_sub_epi16( sr[10], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 5*3;
err1 = _mm_sub_epi16( sr[11], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 4*3;
err1 = _mm_sub_epi16( sr[12], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 3*3;
err1 = _mm_sub_epi16( sr[13], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 2*3;
err1 = _mm_sub_epi16( sr[14], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 1*3;
err1 = _mm_sub_epi16( sr[15], recVal16 );
err2 = _mm_mullo_epi16( err1, err1 );
minerr = _mm_minpos_epu16( err2 );
tmp = _mm_cvtsi128_si64( minerr );
idx |= ( tmp >> 16 ) << 0*3;
uint16_t rm[8];
_mm_storeu_si128( (__m128i*)rm, mul );
uint16_t sm = _mm_cvtsi128_si64( srcMid );
uint64_t d = ( uint64_t( sm ) << 56 ) |
( uint64_t( rm[GetMulSel( sel )] ) << 52 ) |
( uint64_t( sel ) << 48 ) |
idx;
return _bswap64( d );
#elif defined __ARM_NEON
int16x8_t srcMidWide, multipliers;
int srcMid;
uint8x16_t srcAlphaBlock = vld1q_u8( src );
{
uint8_t ref = src[0];
uint8x16_t a0 = vdupq_n_u8( ref );
uint8x16_t r = vceqq_u8( srcAlphaBlock, a0 );
int64x2_t m = vreinterpretq_s64_u8( r );
if( m[0] == -1 && m[1] == -1 )
return ref;
// srcRange
#ifdef __aarch64__
uint8_t min = vminvq_u8( srcAlphaBlock );
uint8_t max = vmaxvq_u8( srcAlphaBlock );
uint8_t srcRange = max - min;
multipliers = vqaddq_s16( vshrq_n_s16( vqdmulhq_n_s16( g_alphaRange_NEON, srcRange ), 1 ), vdupq_n_s16( 1 ) );
srcMid = min + srcRange / 2;
srcMidWide = vdupq_n_s16( srcMid );
#else
uint8x8_t vmin = vpmin_u8( vget_low_u8( srcAlphaBlock ), vget_high_u8( srcAlphaBlock ) );
vmin = vpmin_u8( vmin, vmin );
vmin = vpmin_u8( vmin, vmin );
vmin = vpmin_u8( vmin, vmin );
uint8x8_t vmax = vpmax_u8( vget_low_u8( srcAlphaBlock ), vget_high_u8( srcAlphaBlock ) );
vmax = vpmax_u8( vmax, vmax );
vmax = vpmax_u8( vmax, vmax );
vmax = vpmax_u8( vmax, vmax );
int16x8_t srcRangeWide = vreinterpretq_s16_u16( vsubl_u8( vmax, vmin ) );
multipliers = vqaddq_s16( vshrq_n_s16( vqdmulhq_s16( g_alphaRange_NEON, srcRangeWide ), 1 ), vdupq_n_s16( 1 ) );
srcMidWide = vsraq_n_s16( vreinterpretq_s16_u16(vmovl_u8(vmin)), srcRangeWide, 1);
srcMid = vgetq_lane_s16( srcMidWide, 0 );
#endif
}
// calculate reconstructed values
#define EAC_APPLY_16X( m ) m( 0 ) m( 1 ) m( 2 ) m( 3 ) m( 4 ) m( 5 ) m( 6 ) m( 7 ) m( 8 ) m( 9 ) m( 10 ) m( 11 ) m( 12 ) m( 13 ) m( 14 ) m( 15 )
#define EAC_RECONSTRUCT_VALUE( n ) vqmovun_s16( vmlaq_s16( srcMidWide, g_alpha_NEON[n], WidenMultiplier_EAC_NEON<n>( multipliers ) ) ),
uint8x8_t recVals[16] = { EAC_APPLY_16X( EAC_RECONSTRUCT_VALUE ) };
// find selector
int err = std::numeric_limits<int>::max();
int sel = 0;
for( int r = 0; r < 16; r++ )
{
uint8x8_t recVal = recVals[r];
int rangeErr = 0;
#define EAC_ACCUMULATE_ERROR( n ) rangeErr += MinError_EAC_NEON( ErrorProbe_EAC_NEON<n>( recVal, srcAlphaBlock ) );
EAC_APPLY_16X( EAC_ACCUMULATE_ERROR )
if( rangeErr < err )
{
err = rangeErr;
sel = r;
if ( err == 0 ) break;
}
}
// combine results
uint64_t d = ( uint64_t( srcMid ) << 56 ) |
( uint64_t( multipliers[GetMulSel( sel )] ) << 52 ) |
( uint64_t( sel ) << 48);
// generate indices
uint8x8_t recVal = recVals[sel];
#define EAC_INSERT_INDEX(n) d |= MinErrorIndex_EAC_NEON<n>( recVal, srcAlphaBlock );
EAC_APPLY_16X( EAC_INSERT_INDEX )
return _bswap64( d );
#undef EAC_APPLY_16X
#undef EAC_INSERT_INDEX
#undef EAC_ACCUMULATE_ERROR
#undef EAC_RECONSTRUCT_VALUE
#else
{
bool solid = true;
const uint8_t* ptr = src + 1;
const uint8_t ref = *src;
for( int i=1; i<16; i++ )
{
if( ref != *ptr++ )
{
solid = false;
break;
}
}
if( solid )
{
return ref;
}
}
uint8_t min = src[0];
uint8_t max = src[0];
for( int i=1; i<16; i++ )
{
if( min > src[i] ) min = src[i];
else if( max < src[i] ) max = src[i];
}
int srcRange = max - min;
int srcMid = min + srcRange / 2;
uint8_t buf[16][16];
int err = std::numeric_limits<int>::max();
int sel;
int selmul;
for( int r=0; r<16; r++ )
{
int mul = ( ( srcRange * g_alphaRange[r] ) >> 16 ) + 1;
int rangeErr = 0;
for( int i=0; i<16; i++ )
{
const auto srcVal = src[i];
int idx = 0;
const auto modVal = g_alpha[r][0] * mul;
const auto recVal = clampu8( srcMid + modVal );
int localErr = sq( srcVal - recVal );
if( localErr != 0 )
{
for( int j=1; j<8; j++ )
{
const auto modVal = g_alpha[r][j] * mul;
const auto recVal = clampu8( srcMid + modVal );
const auto errProbe = sq( srcVal - recVal );
if( errProbe < localErr )
{
localErr = errProbe;
idx = j;
}
}
}
buf[r][i] = idx;
rangeErr += localErr;
}
if( rangeErr < err )
{
err = rangeErr;
sel = r;
selmul = mul;
if( err == 0 ) break;
}
}
uint64_t d = ( uint64_t( srcMid ) << 56 ) |
( uint64_t( selmul ) << 52 ) |
( uint64_t( sel ) << 48 );
int offset = 45;
auto ptr = buf[sel];
for( int i=0; i<16; i++ )
{
d |= uint64_t( *ptr++ ) << offset;
offset -= 3;
}
return _bswap64( d );
#endif
}
void CompressEtc1Alpha( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width )
{
int w = 0;
uint32_t buf[4*4];
do
{
#ifdef __SSE4_1__
__m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) );
__m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) );
__m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) );
__m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) );
_MM_TRANSPOSE4_PS( px0, px1, px2, px3 );
__m128i c0 = _mm_castps_si128( px0 );
__m128i c1 = _mm_castps_si128( px1 );
__m128i c2 = _mm_castps_si128( px2 );
__m128i c3 = _mm_castps_si128( px3 );
__m128i mask = _mm_setr_epi32( 0x03030303, 0x07070707, 0x0b0b0b0b, 0x0f0f0f0f );
__m128i p0 = _mm_shuffle_epi8( c0, mask );
__m128i p1 = _mm_shuffle_epi8( c1, mask );
__m128i p2 = _mm_shuffle_epi8( c2, mask );
__m128i p3 = _mm_shuffle_epi8( c3, mask );
_mm_store_si128( (__m128i*)(buf + 0), p0 );
_mm_store_si128( (__m128i*)(buf + 4), p1 );
_mm_store_si128( (__m128i*)(buf + 8), p2 );
_mm_store_si128( (__m128i*)(buf + 12), p3 );
src += 4;
#else
auto ptr = buf;
for( int x=0; x<4; x++ )
{
unsigned int a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src += width;
a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src += width;
a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src += width;
a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src -= width * 3 - 1;
}
#endif
if( ++w == width/4 )
{
src += width * 3;
w = 0;
}
*dst++ = ProcessRGB( (uint8_t*)buf );
}
while( --blocks );
}
void CompressEtc2Alpha( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics )
{
int w = 0;
uint32_t buf[4*4];
do
{
#ifdef __SSE4_1__
__m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) );
__m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) );
__m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) );
__m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) );
_MM_TRANSPOSE4_PS( px0, px1, px2, px3 );
__m128i c0 = _mm_castps_si128( px0 );
__m128i c1 = _mm_castps_si128( px1 );
__m128i c2 = _mm_castps_si128( px2 );
__m128i c3 = _mm_castps_si128( px3 );
__m128i mask = _mm_setr_epi32( 0x03030303, 0x07070707, 0x0b0b0b0b, 0x0f0f0f0f );
__m128i p0 = _mm_shuffle_epi8( c0, mask );
__m128i p1 = _mm_shuffle_epi8( c1, mask );
__m128i p2 = _mm_shuffle_epi8( c2, mask );
__m128i p3 = _mm_shuffle_epi8( c3, mask );
_mm_store_si128( (__m128i*)(buf + 0), p0 );
_mm_store_si128( (__m128i*)(buf + 4), p1 );
_mm_store_si128( (__m128i*)(buf + 8), p2 );
_mm_store_si128( (__m128i*)(buf + 12), p3 );
src += 4;
#else
auto ptr = buf;
for( int x=0; x<4; x++ )
{
unsigned int a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src += width;
a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src += width;
a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src += width;
a = *src >> 24;
*ptr++ = a | ( a << 8 ) | ( a << 16 );
src -= width * 3 - 1;
}
#endif
if( ++w == width/4 )
{
src += width * 3;
w = 0;
}
*dst++ = ProcessRGB_ETC2( (uint8_t*)buf, useHeuristics );
}
while( --blocks );
}
#include <chrono>
#include <thread>
void CompressEtc1Rgb( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width )
{
int w = 0;
uint32_t buf[4*4];
do
{
#ifdef __SSE4_1__
__m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) );
__m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) );
__m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) );
__m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) );
_MM_TRANSPOSE4_PS( px0, px1, px2, px3 );
_mm_store_si128( (__m128i*)(buf + 0), _mm_castps_si128( px0 ) );
_mm_store_si128( (__m128i*)(buf + 4), _mm_castps_si128( px1 ) );
_mm_store_si128( (__m128i*)(buf + 8), _mm_castps_si128( px2 ) );
_mm_store_si128( (__m128i*)(buf + 12), _mm_castps_si128( px3 ) );
src += 4;
#else
auto ptr = buf;
for( int x=0; x<4; x++ )
{
*ptr++ = *src;
src += width;
*ptr++ = *src;
src += width;
*ptr++ = *src;
src += width;
*ptr++ = *src;
src -= width * 3 - 1;
}
#endif
if( ++w == width/4 )
{
src += width * 3;
w = 0;
}
*dst++ = ProcessRGB( (uint8_t*)buf );
}
while( --blocks );
}
void CompressEtc1RgbDither( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width )
{
int w = 0;
uint32_t buf[4*4];
do
{
#ifdef __SSE4_1__
__m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) );
__m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) );
__m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) );
__m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) );
_MM_TRANSPOSE4_PS( px0, px1, px2, px3 );
# ifdef __AVX2__
DitherAvx2( (uint8_t*)buf, _mm_castps_si128( px0 ), _mm_castps_si128( px1 ), _mm_castps_si128( px2 ), _mm_castps_si128( px3 ) );
# else
_mm_store_si128( (__m128i*)(buf + 0), _mm_castps_si128( px0 ) );
_mm_store_si128( (__m128i*)(buf + 4), _mm_castps_si128( px1 ) );
_mm_store_si128( (__m128i*)(buf + 8), _mm_castps_si128( px2 ) );
_mm_store_si128( (__m128i*)(buf + 12), _mm_castps_si128( px3 ) );
Dither( (uint8_t*)buf );
# endif
src += 4;
#else
auto ptr = buf;
for( int x=0; x<4; x++ )
{
*ptr++ = *src;
src += width;
*ptr++ = *src;
src += width;
*ptr++ = *src;
src += width;
*ptr++ = *src;
src -= width * 3 - 1;
}
#endif
if( ++w == width/4 )
{
src += width * 3;
w = 0;
}
*dst++ = ProcessRGB( (uint8_t*)buf );
}
while( --blocks );
}
void CompressEtc2Rgb( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics )
{
int w = 0;
uint32_t buf[4*4];
do
{
#ifdef __SSE4_1__
__m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) );
__m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) );
__m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) );
__m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) );
_MM_TRANSPOSE4_PS( px0, px1, px2, px3 );
_mm_store_si128( (__m128i*)(buf + 0), _mm_castps_si128( px0 ) );
_mm_store_si128( (__m128i*)(buf + 4), _mm_castps_si128( px1 ) );
_mm_store_si128( (__m128i*)(buf + 8), _mm_castps_si128( px2 ) );
_mm_store_si128( (__m128i*)(buf + 12), _mm_castps_si128( px3 ) );
src += 4;
#else
auto ptr = buf;
for( int x=0; x<4; x++ )
{
*ptr++ = *src;
src += width;
*ptr++ = *src;
src += width;
*ptr++ = *src;
src += width;
*ptr++ = *src;
src -= width * 3 - 1;
}
#endif
if( ++w == width/4 )
{
src += width * 3;
w = 0;
}
*dst++ = ProcessRGB_ETC2( (uint8_t*)buf, useHeuristics );
}
while( --blocks );
}
void CompressEtc2Rgba( const uint32_t* src, uint64_t* dst, uint32_t blocks, size_t width, bool useHeuristics )
{
int w = 0;
uint32_t rgba[4*4];
uint8_t alpha[4*4];
do
{
#ifdef __SSE4_1__
__m128 px0 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 0 ) ) );
__m128 px1 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 1 ) ) );
__m128 px2 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 2 ) ) );
__m128 px3 = _mm_castsi128_ps( _mm_loadu_si128( (__m128i*)( src + width * 3 ) ) );
_MM_TRANSPOSE4_PS( px0, px1, px2, px3 );
__m128i c0 = _mm_castps_si128( px0 );
__m128i c1 = _mm_castps_si128( px1 );
__m128i c2 = _mm_castps_si128( px2 );
__m128i c3 = _mm_castps_si128( px3 );
_mm_store_si128( (__m128i*)(rgba + 0), c0 );
_mm_store_si128( (__m128i*)(rgba + 4), c1 );
_mm_store_si128( (__m128i*)(rgba + 8), c2 );
_mm_store_si128( (__m128i*)(rgba + 12), c3 );
__m128i mask = _mm_setr_epi32( 0x0f0b0703, -1, -1, -1 );
__m128i a0 = _mm_shuffle_epi8( c0, mask );
__m128i a1 = _mm_shuffle_epi8( c1, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 3, 0, 3 ) ) );
__m128i a2 = _mm_shuffle_epi8( c2, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 3, 0, 3, 3 ) ) );
__m128i a3 = _mm_shuffle_epi8( c3, _mm_shuffle_epi32( mask, _MM_SHUFFLE( 0, 3, 3, 3 ) ) );
__m128i s0 = _mm_or_si128( a0, a1 );
__m128i s1 = _mm_or_si128( a2, a3 );
__m128i s2 = _mm_or_si128( s0, s1 );
_mm_store_si128( (__m128i*)alpha, s2 );
src += 4;
#else
auto ptr = rgba;
auto ptr8 = alpha;
for( int x=0; x<4; x++ )
{
auto v = *src;
*ptr++ = v;
*ptr8++ = v >> 24;
src += width;
v = *src;
*ptr++ = v;
*ptr8++ = v >> 24;
src += width;
v = *src;
*ptr++ = v;
*ptr8++ = v >> 24;
src += width;
v = *src;
*ptr++ = v;
*ptr8++ = v >> 24;
src -= width * 3 - 1;
}
#endif
if( ++w == width/4 )
{
src += width * 3;
w = 0;
}
*dst++ = ProcessAlpha_ETC2( alpha );
*dst++ = ProcessRGB_ETC2( (uint8_t*)rgba, useHeuristics );
}
while( --blocks );
}