static void SkMorph_SSE2(const SkPMColor* src, SkPMColor* dst, int radius,
int width, int height, int srcStride, int dstStride)
{
const int srcStrideX = direction == kX ? 1 : srcStride;
const int dstStrideX = direction == kX ? 1 : dstStride;
const int srcStrideY = direction == kX ? srcStride : 1;
const int dstStrideY = direction == kX ? dstStride : 1;
radius = SkMin32(radius, width - 1);
const SkPMColor* upperSrc = src + radius * srcStrideX;
for (int x = 0; x < width; ++x) {
const SkPMColor* lp = src;
const SkPMColor* up = upperSrc;
SkPMColor* dptr = dst;
for (int y = 0; y < height; ++y) {
__m128i max = type == kDilate ? _mm_setzero_si128() : _mm_set1_epi32(0xFFFFFFFF);
for (const SkPMColor* p = lp; p <= up; p += srcStrideX) {
__m128i src_pixel = _mm_cvtsi32_si128(*p);
max = type == kDilate ? _mm_max_epu8(src_pixel, max) : _mm_min_epu8(src_pixel, max);
}
*dptr = _mm_cvtsi128_si32(max);
dptr += dstStrideY;
lp += srcStrideY;
up += srcStrideY;
}
if (x >= radius) {
src += srcStrideX;
}
if (x + radius < width - 1) {
upperSrc += srcStrideX;
}
dst += dstStrideX;
}
}
static void
clamplow_u8_sse (uint8_t *dest, const uint8_t *src1, int n,
const uint8_t *src2_1)
{
__m128i xmm1;
uint8_t min = *src2_1;
/* Initial operations to align the destination pointer */
for (; ((long)dest & 15) && (n > 0); n--) {
uint8_t x = *src1++;
if (x < min)
x = min;
*dest++ = x;
}
xmm1 = _mm_set1_epi8(min);
for (; n >= 16; n -= 16) {
__m128i xmm0;
xmm0 = _mm_loadu_si128((__m128i *)src1);
xmm0 = _mm_max_epu8(xmm0, xmm1);
_mm_store_si128((__m128i *)dest, xmm0);
dest += 16;
src1 += 16;
}
for (; n > 0; n--) {
uint8_t x = *src1++;
if (x < min)
x = min;
*dest++ = x;
}
}
__m128i test_mm_max_epu8(__m128i A, __m128i B) {
// DAG-LABEL: test_mm_max_epu8
// DAG: call <16 x i8> @llvm.x86.sse2.pmaxu.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
//
// ASM-LABEL: test_mm_max_epu8
// ASM: pmaxub
return _mm_max_epu8(A, B);
}
SIMDValue SIMDUint8x16Operation::OpMax(const SIMDValue& aValue, const SIMDValue& bValue)
{
X86SIMDValue x86Result;
X86SIMDValue tmpaValue = X86SIMDValue::ToX86SIMDValue(aValue);
X86SIMDValue tmpbValue = X86SIMDValue::ToX86SIMDValue(bValue);
x86Result.m128i_value = _mm_max_epu8(tmpaValue.m128i_value, tmpbValue.m128i_value);
return X86SIMDValue::ToSIMDValue(x86Result);
}
// SSE
__m64 _m_pmaxub(__m64 _MM1, __m64 _MM2)
{
__m128i lhs = {0}, rhs = {0};
lhs.m128i_i64[0] = _MM1.m64_i64;
rhs.m128i_i64[0] = _MM2.m64_i64;
lhs = _mm_max_epu8(lhs, rhs);
_MM1.m64_i64 = lhs.m128i_i64[0];
return _MM1;
}
static FORCE_INLINE __m128i mm_max_epu(const __m128i &a, const __m128i &b) {
if (sizeof(PixelType) == 1)
return _mm_max_epu8(a, b);
else {
__m128i word_32768 = _mm_set1_epi16(32768);
__m128i a_minus = _mm_sub_epi16(a, word_32768);
__m128i b_minus = _mm_sub_epi16(b, word_32768);
return _mm_add_epi16(_mm_max_epi16(a_minus, b_minus), word_32768);
}
}
static void GF_FUNC_ALIGN VS_CC
proc_8bit_sse2(uint8_t *buff, int bstride, int width, int height, int stride,
uint8_t *dstp, const uint8_t *srcp, int th)
{
uint8_t *p0 = buff + 16;
uint8_t *p1 = p0 + bstride;
uint8_t *p2 = p1 + bstride;
uint8_t *orig = p0, *end = p2;
line_copy8(p0, srcp + stride, width, 1);
line_copy8(p1, srcp, width, 1);
uint8_t threshold = (uint8_t)th;
__m128i zero = _mm_setzero_si128();
__m128i xth = _mm_set1_epi8((int8_t)threshold);
for (int y = 0; y < height; y++) {
srcp += stride * (y < height - 1 ? 1 : -1);
line_copy8(p2, srcp, width, 1);
uint8_t *coordinates[] = COORDINATES;
for (int x = 0; x < width; x += 16) {
__m128i sumlo = zero;
__m128i sumhi = zero;
for (int i = 0; i < 8; i++) {
__m128i target = _mm_loadu_si128((__m128i *)(coordinates[i] + x));
sumlo = _mm_add_epi16(sumlo, _mm_unpacklo_epi8(target, zero));
sumhi = _mm_add_epi16(sumhi, _mm_unpackhi_epi8(target, zero));
}
sumlo = _mm_srai_epi16(sumlo, 3);
sumhi = _mm_srai_epi16(sumhi, 3);
sumlo = _mm_packus_epi16(sumlo, sumhi);
__m128i src = _mm_load_si128((__m128i *)(p1 + x));
__m128i limit = _mm_adds_epu8(src, xth);
sumlo = _mm_max_epu8(sumlo, src);
sumlo = _mm_min_epu8(sumlo, limit);
_mm_store_si128((__m128i *)(dstp + x), sumlo);
}
dstp += stride;
p0 = p1;
p1 = p2;
p2 = (p2 == end) ? orig : p2 + bstride;
}
}
static void GF_FUNC_ALIGN VS_CC
proc_8bit_sse2(uint8_t *buff, int bstride, int width, int height, int stride,
uint8_t *dstp, const uint8_t *srcp, int th, int *enable)
{
uint8_t *p0 = buff + 16;
uint8_t *p1 = p0 + bstride;
uint8_t *p2 = p1 + bstride;
uint8_t *orig = p0, *end = p2;
uint8_t threshold = th > 255 ? 255 : (uint8_t)th;
line_copy8(p0, srcp, width, 1);
line_copy8(p1, srcp, width, 1);
__m128i xth = _mm_set1_epi8((int8_t)threshold);
for (int y = 0; y < height; y++) {
srcp += stride * (y < height - 1 ? 1 : -1);
line_copy8(p2, srcp, width, 1);
uint8_t *coordinates[] = {p0 - 1, p0, p0 + 1,
p1 - 1, p1 + 1,
p2 - 1, p2, p2 + 1};
for (int x = 0; x < width; x += 16) {
__m128i src = _mm_load_si128((__m128i *)(p1 + x));
__m128i min = src;
for (int i = 0; i < 8; i++) {
if (enable[i]) {
__m128i target = _mm_loadu_si128((__m128i *)(coordinates[i] + x));
min = _mm_min_epu8(target, min);
}
}
__m128i limit = _mm_subs_epu8(src, xth);
min = _mm_max_epu8(min, limit);
_mm_store_si128((__m128i *)(dstp + x), min);
}
dstp += stride;
p0 = p1;
p1 = p2;
p2 = (p2 == end) ? orig : p2 + bstride;
}
}
/**
* Calculate output of given chromosome and inputs using SSE instructions
* @param chr
* @param inputs
* @param outputs
*/
void cgp_get_output_sse(ga_chr_t chromosome,
__m128i_aligned inputs[CGP_INPUTS], __m128i_aligned outputs[CGP_OUTPUTS])
{
#ifdef SSE2
assert(CGP_OUTPUTS == 1);
assert(CGP_ROWS == 4);
assert(CGP_LBACK == 1);
// previous and currently computed column
register __m128i prev0, prev1, prev2, prev3;
register __m128i current0, current1, current2, current3;
// 0xFF constant
static __m128i_aligned FF;
FF = _mm_set1_epi8(0xFF);
cgp_genome_t genome = (cgp_genome_t) chromosome->genome;
/* if primary output is connected to primary input, skip evaluation
This cannot happen - CGP does not generate circuits like that
if (genome->outputs[0] < CGP_INPUTS) {
int i = genome->outputs[0];
_mm_store_si128(&outputs[0], inputs[i]);
return;
}
*/
#ifdef TEST_EVAL_SSE2
for (int i = 0; i < CGP_INPUTS; i++) {
unsigned char *_tmp = (unsigned char*) &inputs[i];
printf("I: %2d = " UCFMT16 "\n", i, UCVAL16(0));
}
#endif
int offset = -CGP_ROWS;
for (int x = 0; x < CGP_COLS; x++) {
for (int y = 0; y < CGP_ROWS; y++) {
int idx = cgp_node_index(x, y);
cgp_node_t *n = &(genome->nodes[idx]);
// skip inactive blocks
if (!n->is_active) continue;
register __m128i A;
register __m128i B;
register __m128i Y;
register __m128i TMP;
register __m128i mask;
LOAD_INPUT(A, n->inputs[0]);
LOAD_INPUT(B, n->inputs[1]);
switch (n->function) {
case c255:
Y = FF;
break;
case identity:
Y = A;
break;
case inversion:
Y = _mm_sub_epi8(FF, A);
break;
case b_or:
Y = _mm_or_si128(A, B);
break;
case b_not1or2:
// we don't have NOT instruction, we need to XOR with FF
Y = _mm_xor_si128(FF, A);
Y = _mm_or_si128(Y, B);
break;
case b_and:
Y = _mm_and_si128(A, B);
break;
case b_nand:
Y = _mm_and_si128(A, B);
Y = _mm_xor_si128(FF, Y);
break;
case b_xor:
Y = _mm_xor_si128(A, B);
break;
case rshift1:
// no SR instruction for 8bit data, we need to shift
// 16 bits and apply mask
// IN : [ 1 2 3 4 5 6 7 8 | A B C D E F G H]
// SHR: [ 0 1 2 3 4 5 6 7 | 8 A B C D E F G]
// MSK: [ 0 1 2 3 4 5 6 7 | 0 A B C D E F G]
mask = _mm_set1_epi8(0x7F);
Y = _mm_srli_epi16(A, 1);
Y = _mm_and_si128(Y, mask);
break;
case rshift2:
// similar to rshift1
// IN : [ 1 2 3 4 5 6 7 8 | A B C D E F G H]
// SHR: [ 0 0 1 2 3 4 5 6 | 7 8 A B C D E F]
// MSK: [ 0 0 1 2 3 4 5 6 | 0 0 A B C D E F]
mask = _mm_set1_epi8(0x3F);
Y = _mm_srli_epi16(A, 2);
Y = _mm_and_si128(Y, mask);
break;
case swap:
// SWAP(A, B) (((A & 0x0F) << 4) | ((B & 0x0F)))
// Shift A left by 4 bits
// IN : [ 1 2 3 4 5 6 7 8 | A B C D E F G H]
// SHL: [ 5 6 7 8 A B C D | E F G H 0 0 0 0]
// MSK: [ 5 6 7 8 0 0 0 0 | E F G H 0 0 0 0]
mask = _mm_set1_epi8(0xF0);
TMP = _mm_slli_epi16(A, 4);
TMP = _mm_and_si128(TMP, mask);
// Mask B
// IN : [ 1 2 3 4 5 6 7 8 | A B C D E F G H]
// MSK: [ 0 0 0 0 5 6 7 8 | 0 0 0 0 E F G H]
mask = _mm_set1_epi8(0x0F);
Y = _mm_and_si128(B, mask);
// Combine
Y = _mm_or_si128(Y, TMP);
break;
case add:
Y = _mm_add_epi8(A, B);
break;
case add_sat:
Y = _mm_adds_epu8(A, B);
break;
case avg:
// shift right first, then add, to avoid overflow
mask = _mm_set1_epi8(0x7F);
TMP = _mm_srli_epi16(A, 1);
TMP = _mm_and_si128(TMP, mask);
Y = _mm_srli_epi16(B, 1);
Y = _mm_and_si128(Y, mask);
Y = _mm_add_epi8(Y, TMP);
break;
case max:
Y = _mm_max_epu8(A, B);
break;
case min:
Y = _mm_min_epu8(A, B);
break;
}
#ifdef TEST_EVAL_SSE2
__m128i _tmpval = Y;
unsigned char *_tmp = (unsigned char*) &_tmpval;
printf("N: %2d = " UCFMT16 "\n", idx + CGP_INPUTS, UCVAL16(0));
bool mismatch = false;
for (int i = 1; i < 16; i++) {
if (_tmp[i] != _tmp[0]) {
fprintf(stderr,
"Value mismatch on index %2d (%u instead of %u)\n",
i, _tmp[i], _tmp[0]);
mismatch = true;
}
}
if (mismatch) {
abort();
}
#endif
if (idx + CGP_INPUTS == genome->outputs[0]) {
_mm_store_si128(&outputs[0], Y);
#ifndef TEST_EVAL_SSE2
return;
#endif
}
ASSIGN_CURRENT(y, Y);
} // end of column
offset += CGP_ROWS;
prev0 = current0;
prev1 = current1;
prev2 = current2;
prev3 = current3;
} // end of row
#ifdef TEST_EVAL_SSE2
for (int i = 0; i < CGP_OUTPUTS; i++) {
unsigned char *_tmp = (unsigned char*) &outputs[i];
printf("O: %2d = " UCFMT16 "\n", i, UCVAL16(0));
}
#endif
#endif
}
static void GF_FUNC_ALIGN VS_CC
proc_8bit_sse2(uint8_t *buff, int bstride, int width, int height, int stride,
uint8_t *dstp, const uint8_t *srcp, edge_t *eh,
uint16_t plane_max)
{
uint8_t* p0 = buff + 16;
uint8_t* p1 = p0 + bstride;
uint8_t* p2 = p1 + bstride;
uint8_t* p3 = p2 + bstride;
uint8_t* p4 = p3 + bstride;
uint8_t* orig = p0;
uint8_t* end = p4;
line_copy8(p0, srcp + 2 * stride, width, 2);
line_copy8(p1, srcp + stride, width, 2);
line_copy8(p2, srcp, width, 2);
srcp += stride;
line_copy8(p3, srcp, width, 2);
uint8_t th_min = eh->min > 0xFF ? 0xFF : (uint8_t)eh->min;
uint8_t th_max = eh->max > 0xFF ? 0xFF : (uint8_t)eh->max;
__m128i zero = _mm_setzero_si128();
__m128i ab = _mm_set1_epi16(15);
__m128i max = _mm_set1_epi8((int8_t)th_max);
__m128i min = _mm_set1_epi8((int8_t)th_min);
for (int y = 0; y < height; y++) {
srcp += stride * (y < height - 2 ? 1 : -1);
line_copy8(p4, srcp, width, 2);
uint8_t* posh[] = {p2 - 2, p2 - 1, p2 + 1, p2 + 2};
uint8_t* posv[] = {p0, p1, p3, p4};
for (int x = 0; x < width; x += 16) {
__m128i sumx[2] = {zero, zero};
__m128i sumy[2] = {zero, zero};
for (int i = 0; i < 4; i++) {
__m128i xmm0, xmm1, xmul;
xmul = _mm_load_si128((__m128i *)ar_mulx[i]);
xmm0 = _mm_loadu_si128((__m128i *)(posh[i] + x));
xmm1 = _mm_unpackhi_epi8(xmm0, zero);
xmm0 = _mm_unpacklo_epi8(xmm0, zero);
sumx[0] = _mm_add_epi16(sumx[0], _mm_mullo_epi16(xmm0, xmul));
sumx[1] = _mm_add_epi16(sumx[1], _mm_mullo_epi16(xmm1, xmul));
xmul = _mm_load_si128((__m128i *)ar_muly[i]);
xmm0 = _mm_load_si128((__m128i *)(posv[i] + x));
xmm1 = _mm_unpackhi_epi8(xmm0, zero);
xmm0 = _mm_unpacklo_epi8(xmm0, zero);
sumy[0] = _mm_add_epi16(sumy[0], _mm_mullo_epi16(xmm0, xmul));
sumy[1] = _mm_add_epi16(sumy[1], _mm_mullo_epi16(xmm1, xmul));
}
for (int i = 0; i < 2; i++) {
__m128i xmax, xmin, mull, mulh;
sumx[i] = mm_abs_epi16(sumx[i]);
sumy[i] = mm_abs_epi16(sumy[i]);
xmax = _mm_max_epi16(sumx[i], sumy[i]);
xmin = _mm_min_epi16(sumx[i], sumy[i]);
mull = _mm_srli_epi32(_mm_madd_epi16(ab, _mm_unpacklo_epi16(xmax, zero)), 4);
mulh = _mm_srli_epi32(_mm_madd_epi16(ab, _mm_unpackhi_epi16(xmax, zero)), 4);
xmax = mm_cast_epi32(mull, mulh);
mull = _mm_srli_epi32(_mm_madd_epi16(ab, _mm_unpacklo_epi16(xmin, zero)), 5);
mulh = _mm_srli_epi32(_mm_madd_epi16(ab, _mm_unpackhi_epi16(xmin, zero)), 5);
xmin = mm_cast_epi32(mull, mulh);
sumx[i] = _mm_adds_epu16(xmax, xmin);
sumx[i] = _mm_srli_epi16(sumx[i], eh->rshift);
}
__m128i out = _mm_packus_epi16(sumx[0], sumx[1]);
__m128i temp = _mm_min_epu8(out, max);
temp = _mm_cmpeq_epi8(temp, max);
out = _mm_or_si128(temp, out);
temp = _mm_max_epu8(out, min);
temp = _mm_cmpeq_epi8(temp, min);
out = _mm_andnot_si128(temp, out);
_mm_store_si128((__m128i*)(dstp + x), out);
}
dstp += stride;
p0 = p1;
p1 = p2;
p2 = p3;
p3 = p4;
p4 = (p4 == end) ? orig : p4 + bstride;
}
}
void GetMinMaxColors_Intrinsics( const byte *colorBlock, byte *minColor, byte *maxColor )
{
__m128i t0, t1, t3, t4, t6, t7;
// get bounding box
// ----------------
// load the first row
t0 = _mm_load_si128 ( (__m128i*) colorBlock );
t1 = _mm_load_si128 ( (__m128i*) colorBlock );
__m128i t16 = _mm_load_si128 ( (__m128i*) (colorBlock+16) );
// Minimum of Packed Unsigned Byte Integers
t0 = _mm_min_epu8 ( t0, t16);
// Maximum of Packed Unsigned Byte Integers
t1 = _mm_max_epu8 ( t1, t16);
__m128i t32 = _mm_load_si128 ( (__m128i*) (colorBlock+32) );
t0 = _mm_min_epu8 ( t0, t32);
t1 = _mm_max_epu8 ( t1, t32);
__m128i t48 = _mm_load_si128 ( (__m128i*) (colorBlock+48) );
t0 = _mm_min_epu8 ( t0, t48);
t1 = _mm_max_epu8 ( t1, t48);
// Shuffle Packed Doublewords
t3 = _mm_shuffle_epi32( t0, R_SHUFFLE_D( 2, 3, 2, 3 ) );
t4 = _mm_shuffle_epi32( t1, R_SHUFFLE_D( 2, 3, 2, 3 ) );
t0 = _mm_min_epu8 ( t0, t3);
t1 = _mm_max_epu8 ( t1, t4);
// Shuffle Packed Low Words
t6 = _mm_shufflelo_epi16( t0, R_SHUFFLE_D( 2, 3, 2, 3 ) );
t7 = _mm_shufflelo_epi16( t1, R_SHUFFLE_D( 2, 3, 2, 3 ) );
t0 = _mm_min_epu8 ( t0, t6);
t1 = _mm_max_epu8 ( t1, t7);
// inset the bounding box
// ----------------------
// Unpack Low Data
//__m128i t66 = _mm_set1_epi8( 0 );
__m128i t66 = _mm_load_si128 ( (__m128i*) SIMD_SSE2_byte_0 );
t0 = _mm_unpacklo_epi8(t0, t66);
t1 = _mm_unpacklo_epi8(t1, t66);
// copy (movdqa)
//__m128i t2 = _mm_load_si128 ( &t1 );
__m128i t2 = t1;
// Subtract Packed Integers
t2 = _mm_sub_epi16(t2, t0);
// Shift Packed Data Right Logical
t2 = _mm_srli_epi16(t2, INSET_SHIFT);
// Add Packed Integers
t0 = _mm_add_epi16(t0, t2);
t1 = _mm_sub_epi16(t1, t2);
// Pack with Unsigned Saturation
t0 = _mm_packus_epi16(t0, t0);
t1 = _mm_packus_epi16(t1, t1);
// store bounding box extents
// --------------------------
_mm_store_si128 ( (__m128i*) minColor, t0 );
_mm_store_si128 ( (__m128i*) maxColor, t1 );
}
int
smith_waterman_sse2_byte(const unsigned char * query_sequence,
unsigned char * query_profile_byte,
const int query_length,
const unsigned char * db_sequence,
const int db_length,
unsigned char bias,
unsigned char gap_open,
unsigned char gap_extend,
struct f_struct * f_str)
{
int i, j, k;
int score;
int dup;
int cmp;
int iter = (query_length + 15) / 16;
__m128i *p;
__m128i *workspace = (__m128i *) f_str->workspace;
__m128i E, F, H;
__m128i v_maxscore;
__m128i v_bias;
__m128i v_gapopen;
__m128i v_gapextend;
__m128i v_temp;
__m128i v_zero;
__m128i *pHLoad, *pHStore;
__m128i *pE;
__m128i *pScore;
/* Load the bias to all elements of a constant */
dup = ((short) bias << 8) | bias;
v_bias = _mm_setzero_si128();
v_bias = _mm_insert_epi16 (v_bias, dup, 0);
v_bias = _mm_shufflelo_epi16 (v_bias, 0);
v_bias = _mm_shuffle_epi32 (v_bias, 0);
/* Load gap opening penalty to all elements of a constant */
dup = ((short) gap_open << 8) | gap_open;
v_gapopen = _mm_setzero_si128();
v_gapopen = _mm_insert_epi16 (v_gapopen, dup, 0);
v_gapopen = _mm_shufflelo_epi16 (v_gapopen, 0);
v_gapopen = _mm_shuffle_epi32 (v_gapopen, 0);
/* Load gap extension penalty to all elements of a constant */
dup = ((short) gap_extend << 8) | gap_extend;
v_gapextend = _mm_setzero_si128();
v_gapextend = _mm_insert_epi16 (v_gapextend, dup, 0);
v_gapextend = _mm_shufflelo_epi16 (v_gapextend, 0);
v_gapextend = _mm_shuffle_epi32 (v_gapextend, 0);
/* initialize the max score */
/* v_maxscore = _mm_xor_si128 (v_maxscore, v_maxscore); - Apple Devel*/
v_maxscore = _mm_setzero_si128(); /* Apple Devel */
/* create a constant of all zeros for comparison */
/* v_zero = _mm_xor_si128 (v_zero, v_zero); - Apple Devel */
v_zero = _mm_setzero_si128(); /* Apple Devel */
/* Zero out the storage vector */
k = iter * 2;
p = workspace;
for (i = 0; i < k; i++)
{
_mm_store_si128 (p++, v_maxscore);
}
pE = workspace;
pHStore = pE + iter;
pHLoad = pHStore + iter;
for (i = 0; i < db_length; ++i)
{
/* fetch first data asap. */
pScore = (__m128i *) query_profile_byte + db_sequence[i] * iter;
/* zero out F value. */
/* F = _mm_xor_si128 (F, F); -Apple Devel */
F = _mm_setzero_si128(); /* Apple Devel */
/* load the next h value */
H = _mm_load_si128 (pHStore + iter - 1);
H = _mm_slli_si128 (H, 1);
p = pHLoad;
pHLoad = pHStore;
pHStore = p;
for (j = 0; j < iter; j++)
{
/* load values E. */
E = _mm_load_si128 (pE + j);
/* add score to H */
H = _mm_adds_epu8 (H, *pScore++);
H = _mm_subs_epu8 (H, v_bias);
/* Update highest score encountered this far */
v_maxscore = _mm_max_epu8 (v_maxscore, H);
/* get max from H, E and F */
H = _mm_max_epu8 (H, E);
H = _mm_max_epu8 (H, F);
/* save H values */
_mm_store_si128 (pHStore + j, H);
/* subtract the gap open penalty from H */
H = _mm_subs_epu8 (H, v_gapopen);
/* update E value */
E = _mm_subs_epu8 (E, v_gapextend);
E = _mm_max_epu8 (E, H);
/* update F value */
F = _mm_subs_epu8 (F, v_gapextend);
F = _mm_max_epu8 (F, H);
/* save E values */
_mm_store_si128 (pE + j, E);
/* load the next h value */
H = _mm_load_si128 (pHLoad + j);
}
/* reset pointers to the start of the saved data */
j = 0;
H = _mm_load_si128 (pHStore + j);
/* the computed F value is for the given column. since */
/* we are at the end, we need to shift the F value over */
/* to the next column. */
F = _mm_slli_si128 (F, 1);
v_temp = _mm_subs_epu8 (H, v_gapopen);
v_temp = _mm_subs_epu8 (F, v_temp);
v_temp = _mm_cmpeq_epi8 (v_temp, v_zero);
cmp = _mm_movemask_epi8 (v_temp);
while (cmp != 0xffff)
{
E = _mm_load_si128 (pE + j);
H = _mm_max_epu8 (H, F);
/* save H values */
_mm_store_si128 (pHStore + j, H);
/* update E in case the new H value would change it */
H = _mm_subs_epu8 (H, v_gapopen);
E = _mm_max_epu8 (E, H);
_mm_store_si128 (pE + j, E);
/* update F value */
F = _mm_subs_epu8 (F, v_gapextend);
j++;
if (j >= iter)
{
j = 0;
F = _mm_slli_si128 (F, 1);
}
H = _mm_load_si128 (pHStore + j);
v_temp = _mm_subs_epu8 (H, v_gapopen);
v_temp = _mm_subs_epu8 (F, v_temp);
v_temp = _mm_cmpeq_epi8 (v_temp, v_zero);
cmp = _mm_movemask_epi8 (v_temp);
}
}
/* find largest score in the v_maxscore vector */
v_temp = _mm_srli_si128 (v_maxscore, 8);
v_maxscore = _mm_max_epu8 (v_maxscore, v_temp);
v_temp = _mm_srli_si128 (v_maxscore, 4);
v_maxscore = _mm_max_epu8 (v_maxscore, v_temp);
v_temp = _mm_srli_si128 (v_maxscore, 2);
v_maxscore = _mm_max_epu8 (v_maxscore, v_temp);
v_temp = _mm_srli_si128 (v_maxscore, 1);
v_maxscore = _mm_max_epu8 (v_maxscore, v_temp);
/* store in temporary variable */
score = _mm_extract_epi16 (v_maxscore, 0);
score = score & 0x00ff;
/* check if we might have overflowed */
if (score + bias >= 255)
{
score = 255;
}
/* return largest score */
return score;
}
void SGMStereo::calcPixelwiseSAD(const unsigned char* leftSobelRow, const unsigned char* rightSobelRow) {
calcHalfPixelRight(rightSobelRow);
for (int x = 0; x < 16; ++x) {
int leftCenterValue = leftSobelRow[x];
int leftHalfLeftValue = x > 0 ? (leftCenterValue + leftSobelRow[x - 1])/2 : leftCenterValue;
int leftHalfRightValue = x < width_ - 1 ? (leftCenterValue + leftSobelRow[x + 1])/2 : leftCenterValue;
int leftMinValue = std::min(leftHalfLeftValue, leftHalfRightValue);
leftMinValue = std::min(leftMinValue, leftCenterValue);
int leftMaxValue = std::max(leftHalfLeftValue, leftHalfRightValue);
leftMaxValue = std::max(leftMaxValue, leftCenterValue);
for (int d = 0; d <= x; ++d) {
int rightCenterValue = rightSobelRow[width_ - 1 - x + d];
int rightMinValue = halfPixelRightMin_[width_ - 1 - x + d];
int rightMaxValue = halfPixelRightMax_[width_ - 1 - x + d];
int costLtoR = std::max(0, leftCenterValue - rightMaxValue);
costLtoR = std::max(costLtoR, rightMinValue - leftCenterValue);
int costRtoL = std::max(0, rightCenterValue - leftMaxValue);
costRtoL = std::max(costRtoL, leftMinValue - rightCenterValue);
int costValue = std::min(costLtoR, costRtoL);
pixelwiseCostRow_[disparityTotal_*x + d] = costValue;
}
for (int d = x + 1; d < disparityTotal_; ++d) {
pixelwiseCostRow_[disparityTotal_*x + d] = pixelwiseCostRow_[disparityTotal_*x + d - 1];
}
}
for (int x = 16; x < disparityTotal_; ++x) {
int leftCenterValue = leftSobelRow[x];
int leftHalfLeftValue = x > 0 ? (leftCenterValue + leftSobelRow[x - 1])/2 : leftCenterValue;
int leftHalfRightValue = x < width_ - 1 ? (leftCenterValue + leftSobelRow[x + 1])/2 : leftCenterValue;
int leftMinValue = std::min(leftHalfLeftValue, leftHalfRightValue);
leftMinValue = std::min(leftMinValue, leftCenterValue);
int leftMaxValue = std::max(leftHalfLeftValue, leftHalfRightValue);
leftMaxValue = std::max(leftMaxValue, leftCenterValue);
__m128i registerLeftCenterValue = _mm_set1_epi8(static_cast<char>(leftCenterValue));
__m128i registerLeftMinValue = _mm_set1_epi8(static_cast<char>(leftMinValue));
__m128i registerLeftMaxValue = _mm_set1_epi8(static_cast<char>(leftMaxValue));
for (int d = 0; d < x/16; d += 16) {
__m128i registerRightCenterValue = _mm_loadu_si128(reinterpret_cast<const __m128i*>(rightSobelRow + width_ - 1 - x + d));
__m128i registerRightMinValue = _mm_loadu_si128(reinterpret_cast<const __m128i*>(halfPixelRightMin_ + width_ - 1 - x + d));
__m128i registerRightMaxValue = _mm_loadu_si128(reinterpret_cast<const __m128i*>(halfPixelRightMax_ + width_ - 1 - x + d));
__m128i registerCostLtoR = _mm_max_epu8(_mm_subs_epu8(registerLeftCenterValue, registerRightMaxValue),
_mm_subs_epu8(registerRightMinValue, registerLeftCenterValue));
__m128i registerCostRtoL = _mm_max_epu8(_mm_subs_epu8(registerRightCenterValue, registerLeftMaxValue),
_mm_subs_epu8(registerLeftMinValue, registerRightCenterValue));
__m128i registerCost = _mm_min_epu8(registerCostLtoR, registerCostRtoL);
_mm_store_si128(reinterpret_cast<__m128i*>(pixelwiseCostRow_ + disparityTotal_*x + d), registerCost);
}
for (int d = x/16; d <= x; ++d) {
int rightCenterValue = rightSobelRow[width_ - 1 - x + d];
int rightMinValue = halfPixelRightMin_[width_ - 1 - x + d];
int rightMaxValue = halfPixelRightMax_[width_ - 1 - x + d];
int costLtoR = std::max(0, leftCenterValue - rightMaxValue);
costLtoR = std::max(costLtoR, rightMinValue - leftCenterValue);
int costRtoL = std::max(0, rightCenterValue - leftMaxValue);
costRtoL = std::max(costRtoL, leftMinValue - rightCenterValue);
int costValue = std::min(costLtoR, costRtoL);
pixelwiseCostRow_[disparityTotal_*x + d] = costValue;
}
for (int d = x + 1; d < disparityTotal_; ++d) {
pixelwiseCostRow_[disparityTotal_*x + d] = pixelwiseCostRow_[disparityTotal_*x + d - 1];
}
}
for (int x = disparityTotal_; x < width_; ++x) {
int leftCenterValue = leftSobelRow[x];
int leftHalfLeftValue = x > 0 ? (leftCenterValue + leftSobelRow[x - 1])/2 : leftCenterValue;
int leftHalfRightValue = x < width_ - 1 ? (leftCenterValue + leftSobelRow[x + 1])/2 : leftCenterValue;
int leftMinValue = std::min(leftHalfLeftValue, leftHalfRightValue);
leftMinValue = std::min(leftMinValue, leftCenterValue);
int leftMaxValue = std::max(leftHalfLeftValue, leftHalfRightValue);
leftMaxValue = std::max(leftMaxValue, leftCenterValue);
__m128i registerLeftCenterValue = _mm_set1_epi8(static_cast<char>(leftCenterValue));
__m128i registerLeftMinValue = _mm_set1_epi8(static_cast<char>(leftMinValue));
__m128i registerLeftMaxValue = _mm_set1_epi8(static_cast<char>(leftMaxValue));
for (int d = 0; d < disparityTotal_; d += 16) {
__m128i registerRightCenterValue = _mm_loadu_si128(reinterpret_cast<const __m128i*>(rightSobelRow + width_ - 1 - x + d));
__m128i registerRightMinValue = _mm_loadu_si128(reinterpret_cast<const __m128i*>(halfPixelRightMin_ + width_ - 1 - x + d));
__m128i registerRightMaxValue = _mm_loadu_si128(reinterpret_cast<const __m128i*>(halfPixelRightMax_ + width_ - 1 - x + d));
__m128i registerCostLtoR = _mm_max_epu8(_mm_subs_epu8(registerLeftCenterValue, registerRightMaxValue),
_mm_subs_epu8(registerRightMinValue, registerLeftCenterValue));
__m128i registerCostRtoL = _mm_max_epu8(_mm_subs_epu8(registerRightCenterValue, registerLeftMaxValue),
_mm_subs_epu8(registerLeftMinValue, registerRightCenterValue));
__m128i registerCost = _mm_min_epu8(registerCostLtoR, registerCostRtoL);
_mm_store_si128(reinterpret_cast<__m128i*>(pixelwiseCostRow_ + disparityTotal_*x + d), registerCost);
}
}
}
static void mb_lpf_horizontal_edge_w_avx2_16(unsigned char *s, int p,
const unsigned char *_blimit,
const unsigned char *_limit,
const unsigned char *_thresh) {
__m128i mask, hev, flat, flat2;
const __m128i zero = _mm_set1_epi16(0);
const __m128i one = _mm_set1_epi8(1);
__m128i p7, p6, p5;
__m128i p4, p3, p2, p1, p0, q0, q1, q2, q3, q4;
__m128i q5, q6, q7;
__m256i p256_7, q256_7, p256_6, q256_6, p256_5, q256_5, p256_4, q256_4,
p256_3, q256_3, p256_2, q256_2, p256_1, q256_1, p256_0, q256_0;
const __m128i thresh =
_mm_broadcastb_epi8(_mm_cvtsi32_si128((int)_thresh[0]));
const __m128i limit = _mm_broadcastb_epi8(_mm_cvtsi32_si128((int)_limit[0]));
const __m128i blimit =
_mm_broadcastb_epi8(_mm_cvtsi32_si128((int)_blimit[0]));
p256_4 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s - 5 * p)));
p256_3 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s - 4 * p)));
p256_2 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s - 3 * p)));
p256_1 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s - 2 * p)));
p256_0 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s - 1 * p)));
q256_0 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s - 0 * p)));
q256_1 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s + 1 * p)));
q256_2 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s + 2 * p)));
q256_3 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s + 3 * p)));
q256_4 =
_mm256_castpd_si256(_mm256_broadcast_pd((__m128d const *)(s + 4 * p)));
p4 = _mm256_castsi256_si128(p256_4);
p3 = _mm256_castsi256_si128(p256_3);
p2 = _mm256_castsi256_si128(p256_2);
p1 = _mm256_castsi256_si128(p256_1);
p0 = _mm256_castsi256_si128(p256_0);
q0 = _mm256_castsi256_si128(q256_0);
q1 = _mm256_castsi256_si128(q256_1);
q2 = _mm256_castsi256_si128(q256_2);
q3 = _mm256_castsi256_si128(q256_3);
q4 = _mm256_castsi256_si128(q256_4);
{
const __m128i abs_p1p0 =
_mm_or_si128(_mm_subs_epu8(p1, p0), _mm_subs_epu8(p0, p1));
const __m128i abs_q1q0 =
_mm_or_si128(_mm_subs_epu8(q1, q0), _mm_subs_epu8(q0, q1));
const __m128i fe = _mm_set1_epi8(0xfe);
const __m128i ff = _mm_cmpeq_epi8(abs_p1p0, abs_p1p0);
__m128i abs_p0q0 =
_mm_or_si128(_mm_subs_epu8(p0, q0), _mm_subs_epu8(q0, p0));
__m128i abs_p1q1 =
_mm_or_si128(_mm_subs_epu8(p1, q1), _mm_subs_epu8(q1, p1));
__m128i work;
flat = _mm_max_epu8(abs_p1p0, abs_q1q0);
hev = _mm_subs_epu8(flat, thresh);
hev = _mm_xor_si128(_mm_cmpeq_epi8(hev, zero), ff);
abs_p0q0 = _mm_adds_epu8(abs_p0q0, abs_p0q0);
abs_p1q1 = _mm_srli_epi16(_mm_and_si128(abs_p1q1, fe), 1);
mask = _mm_subs_epu8(_mm_adds_epu8(abs_p0q0, abs_p1q1), blimit);
mask = _mm_xor_si128(_mm_cmpeq_epi8(mask, zero), ff);
// mask |= (abs(p0 - q0) * 2 + abs(p1 - q1) / 2 > blimit) * -1;
mask = _mm_max_epu8(flat, mask);
// mask |= (abs(p1 - p0) > limit) * -1;
// mask |= (abs(q1 - q0) > limit) * -1;
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p2, p1), _mm_subs_epu8(p1, p2)),
_mm_or_si128(_mm_subs_epu8(p3, p2), _mm_subs_epu8(p2, p3)));
mask = _mm_max_epu8(work, mask);
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(q2, q1), _mm_subs_epu8(q1, q2)),
_mm_or_si128(_mm_subs_epu8(q3, q2), _mm_subs_epu8(q2, q3)));
mask = _mm_max_epu8(work, mask);
mask = _mm_subs_epu8(mask, limit);
mask = _mm_cmpeq_epi8(mask, zero);
}
// lp filter
{
const __m128i t4 = _mm_set1_epi8(4);
const __m128i t3 = _mm_set1_epi8(3);
const __m128i t80 = _mm_set1_epi8(0x80);
const __m128i te0 = _mm_set1_epi8(0xe0);
const __m128i t1f = _mm_set1_epi8(0x1f);
const __m128i t1 = _mm_set1_epi8(0x1);
const __m128i t7f = _mm_set1_epi8(0x7f);
__m128i ps1 = _mm_xor_si128(p1, t80);
__m128i ps0 = _mm_xor_si128(p0, t80);
__m128i qs0 = _mm_xor_si128(q0, t80);
__m128i qs1 = _mm_xor_si128(q1, t80);
__m128i filt;
__m128i work_a;
__m128i filter1, filter2;
__m128i flat2_p6, flat2_p5, flat2_p4, flat2_p3, flat2_p2, flat2_p1,
flat2_p0, flat2_q0, flat2_q1, flat2_q2, flat2_q3, flat2_q4, flat2_q5,
flat2_q6, flat_p2, flat_p1, flat_p0, flat_q0, flat_q1, flat_q2;
filt = _mm_and_si128(_mm_subs_epi8(ps1, qs1), hev);
work_a = _mm_subs_epi8(qs0, ps0);
filt = _mm_adds_epi8(filt, work_a);
filt = _mm_adds_epi8(filt, work_a);
filt = _mm_adds_epi8(filt, work_a);
/* (vpx_filter + 3 * (qs0 - ps0)) & mask */
filt = _mm_and_si128(filt, mask);
filter1 = _mm_adds_epi8(filt, t4);
filter2 = _mm_adds_epi8(filt, t3);
/* Filter1 >> 3 */
work_a = _mm_cmpgt_epi8(zero, filter1);
filter1 = _mm_srli_epi16(filter1, 3);
work_a = _mm_and_si128(work_a, te0);
filter1 = _mm_and_si128(filter1, t1f);
filter1 = _mm_or_si128(filter1, work_a);
qs0 = _mm_xor_si128(_mm_subs_epi8(qs0, filter1), t80);
/* Filter2 >> 3 */
work_a = _mm_cmpgt_epi8(zero, filter2);
filter2 = _mm_srli_epi16(filter2, 3);
work_a = _mm_and_si128(work_a, te0);
filter2 = _mm_and_si128(filter2, t1f);
filter2 = _mm_or_si128(filter2, work_a);
ps0 = _mm_xor_si128(_mm_adds_epi8(ps0, filter2), t80);
/* filt >> 1 */
filt = _mm_adds_epi8(filter1, t1);
work_a = _mm_cmpgt_epi8(zero, filt);
filt = _mm_srli_epi16(filt, 1);
work_a = _mm_and_si128(work_a, t80);
filt = _mm_and_si128(filt, t7f);
filt = _mm_or_si128(filt, work_a);
filt = _mm_andnot_si128(hev, filt);
ps1 = _mm_xor_si128(_mm_adds_epi8(ps1, filt), t80);
qs1 = _mm_xor_si128(_mm_subs_epi8(qs1, filt), t80);
// loopfilter done
{
__m128i work;
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p2, p0), _mm_subs_epu8(p0, p2)),
_mm_or_si128(_mm_subs_epu8(q2, q0), _mm_subs_epu8(q0, q2)));
flat = _mm_max_epu8(work, flat);
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p3, p0), _mm_subs_epu8(p0, p3)),
_mm_or_si128(_mm_subs_epu8(q3, q0), _mm_subs_epu8(q0, q3)));
flat = _mm_max_epu8(work, flat);
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p4, p0), _mm_subs_epu8(p0, p4)),
_mm_or_si128(_mm_subs_epu8(q4, q0), _mm_subs_epu8(q0, q4)));
flat = _mm_subs_epu8(flat, one);
flat = _mm_cmpeq_epi8(flat, zero);
flat = _mm_and_si128(flat, mask);
p256_5 = _mm256_castpd_si256(
_mm256_broadcast_pd((__m128d const *)(s - 6 * p)));
q256_5 = _mm256_castpd_si256(
_mm256_broadcast_pd((__m128d const *)(s + 5 * p)));
p5 = _mm256_castsi256_si128(p256_5);
q5 = _mm256_castsi256_si128(q256_5);
flat2 = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p5, p0), _mm_subs_epu8(p0, p5)),
_mm_or_si128(_mm_subs_epu8(q5, q0), _mm_subs_epu8(q0, q5)));
flat2 = _mm_max_epu8(work, flat2);
p256_6 = _mm256_castpd_si256(
_mm256_broadcast_pd((__m128d const *)(s - 7 * p)));
q256_6 = _mm256_castpd_si256(
_mm256_broadcast_pd((__m128d const *)(s + 6 * p)));
p6 = _mm256_castsi256_si128(p256_6);
q6 = _mm256_castsi256_si128(q256_6);
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p6, p0), _mm_subs_epu8(p0, p6)),
_mm_or_si128(_mm_subs_epu8(q6, q0), _mm_subs_epu8(q0, q6)));
flat2 = _mm_max_epu8(work, flat2);
p256_7 = _mm256_castpd_si256(
_mm256_broadcast_pd((__m128d const *)(s - 8 * p)));
q256_7 = _mm256_castpd_si256(
_mm256_broadcast_pd((__m128d const *)(s + 7 * p)));
p7 = _mm256_castsi256_si128(p256_7);
q7 = _mm256_castsi256_si128(q256_7);
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(p7, p0), _mm_subs_epu8(p0, p7)),
_mm_or_si128(_mm_subs_epu8(q7, q0), _mm_subs_epu8(q0, q7)));
flat2 = _mm_max_epu8(work, flat2);
flat2 = _mm_subs_epu8(flat2, one);
flat2 = _mm_cmpeq_epi8(flat2, zero);
flat2 = _mm_and_si128(flat2, flat); // flat2 & flat & mask
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// flat and wide flat calculations
{
const __m256i eight = _mm256_set1_epi16(8);
const __m256i four = _mm256_set1_epi16(4);
__m256i pixelFilter_p, pixelFilter_q, pixetFilter_p2p1p0,
pixetFilter_q2q1q0, sum_p7, sum_q7, sum_p3, sum_q3, res_p, res_q;
const __m256i filter =
_mm256_load_si256((__m256i const *)filt_loopfilter_avx2);
p256_7 = _mm256_shuffle_epi8(p256_7, filter);
p256_6 = _mm256_shuffle_epi8(p256_6, filter);
p256_5 = _mm256_shuffle_epi8(p256_5, filter);
p256_4 = _mm256_shuffle_epi8(p256_4, filter);
p256_3 = _mm256_shuffle_epi8(p256_3, filter);
p256_2 = _mm256_shuffle_epi8(p256_2, filter);
p256_1 = _mm256_shuffle_epi8(p256_1, filter);
p256_0 = _mm256_shuffle_epi8(p256_0, filter);
q256_0 = _mm256_shuffle_epi8(q256_0, filter);
q256_1 = _mm256_shuffle_epi8(q256_1, filter);
q256_2 = _mm256_shuffle_epi8(q256_2, filter);
q256_3 = _mm256_shuffle_epi8(q256_3, filter);
q256_4 = _mm256_shuffle_epi8(q256_4, filter);
q256_5 = _mm256_shuffle_epi8(q256_5, filter);
q256_6 = _mm256_shuffle_epi8(q256_6, filter);
q256_7 = _mm256_shuffle_epi8(q256_7, filter);
pixelFilter_p = _mm256_add_epi16(_mm256_add_epi16(p256_6, p256_5),
_mm256_add_epi16(p256_4, p256_3));
pixelFilter_q = _mm256_add_epi16(_mm256_add_epi16(q256_6, q256_5),
_mm256_add_epi16(q256_4, q256_3));
pixetFilter_p2p1p0 =
_mm256_add_epi16(p256_0, _mm256_add_epi16(p256_2, p256_1));
pixelFilter_p = _mm256_add_epi16(pixelFilter_p, pixetFilter_p2p1p0);
pixetFilter_q2q1q0 =
_mm256_add_epi16(q256_0, _mm256_add_epi16(q256_2, q256_1));
pixelFilter_q = _mm256_add_epi16(pixelFilter_q, pixetFilter_q2q1q0);
pixelFilter_p = _mm256_add_epi16(
eight, _mm256_add_epi16(pixelFilter_p, pixelFilter_q));
pixetFilter_p2p1p0 = _mm256_add_epi16(
four, _mm256_add_epi16(pixetFilter_p2p1p0, pixetFilter_q2q1q0));
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(p256_7, p256_0)), 4);
flat2_p0 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(q256_7, q256_0)), 4);
flat2_q0 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
res_p =
_mm256_srli_epi16(_mm256_add_epi16(pixetFilter_p2p1p0,
_mm256_add_epi16(p256_3, p256_0)),
3);
flat_p0 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q =
_mm256_srli_epi16(_mm256_add_epi16(pixetFilter_p2p1p0,
_mm256_add_epi16(q256_3, q256_0)),
3);
flat_q0 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
sum_p7 = _mm256_add_epi16(p256_7, p256_7);
sum_q7 = _mm256_add_epi16(q256_7, q256_7);
sum_p3 = _mm256_add_epi16(p256_3, p256_3);
sum_q3 = _mm256_add_epi16(q256_3, q256_3);
pixelFilter_q = _mm256_sub_epi16(pixelFilter_p, p256_6);
pixelFilter_p = _mm256_sub_epi16(pixelFilter_p, q256_6);
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(sum_p7, p256_1)), 4);
flat2_p1 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_q, _mm256_add_epi16(sum_q7, q256_1)), 4);
flat2_q1 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
pixetFilter_q2q1q0 = _mm256_sub_epi16(pixetFilter_p2p1p0, p256_2);
pixetFilter_p2p1p0 = _mm256_sub_epi16(pixetFilter_p2p1p0, q256_2);
res_p =
_mm256_srli_epi16(_mm256_add_epi16(pixetFilter_p2p1p0,
_mm256_add_epi16(sum_p3, p256_1)),
3);
flat_p1 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q =
_mm256_srli_epi16(_mm256_add_epi16(pixetFilter_q2q1q0,
_mm256_add_epi16(sum_q3, q256_1)),
3);
flat_q1 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
sum_p7 = _mm256_add_epi16(sum_p7, p256_7);
sum_q7 = _mm256_add_epi16(sum_q7, q256_7);
sum_p3 = _mm256_add_epi16(sum_p3, p256_3);
sum_q3 = _mm256_add_epi16(sum_q3, q256_3);
pixelFilter_p = _mm256_sub_epi16(pixelFilter_p, q256_5);
pixelFilter_q = _mm256_sub_epi16(pixelFilter_q, p256_5);
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(sum_p7, p256_2)), 4);
flat2_p2 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_q, _mm256_add_epi16(sum_q7, q256_2)), 4);
flat2_q2 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
pixetFilter_p2p1p0 = _mm256_sub_epi16(pixetFilter_p2p1p0, q256_1);
pixetFilter_q2q1q0 = _mm256_sub_epi16(pixetFilter_q2q1q0, p256_1);
res_p =
_mm256_srli_epi16(_mm256_add_epi16(pixetFilter_p2p1p0,
_mm256_add_epi16(sum_p3, p256_2)),
3);
flat_p2 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q =
_mm256_srli_epi16(_mm256_add_epi16(pixetFilter_q2q1q0,
_mm256_add_epi16(sum_q3, q256_2)),
3);
flat_q2 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
sum_p7 = _mm256_add_epi16(sum_p7, p256_7);
sum_q7 = _mm256_add_epi16(sum_q7, q256_7);
pixelFilter_p = _mm256_sub_epi16(pixelFilter_p, q256_4);
pixelFilter_q = _mm256_sub_epi16(pixelFilter_q, p256_4);
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(sum_p7, p256_3)), 4);
flat2_p3 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_q, _mm256_add_epi16(sum_q7, q256_3)), 4);
flat2_q3 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
sum_p7 = _mm256_add_epi16(sum_p7, p256_7);
sum_q7 = _mm256_add_epi16(sum_q7, q256_7);
pixelFilter_p = _mm256_sub_epi16(pixelFilter_p, q256_3);
pixelFilter_q = _mm256_sub_epi16(pixelFilter_q, p256_3);
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(sum_p7, p256_4)), 4);
flat2_p4 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_q, _mm256_add_epi16(sum_q7, q256_4)), 4);
flat2_q4 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
sum_p7 = _mm256_add_epi16(sum_p7, p256_7);
sum_q7 = _mm256_add_epi16(sum_q7, q256_7);
pixelFilter_p = _mm256_sub_epi16(pixelFilter_p, q256_2);
pixelFilter_q = _mm256_sub_epi16(pixelFilter_q, p256_2);
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(sum_p7, p256_5)), 4);
flat2_p5 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_q, _mm256_add_epi16(sum_q7, q256_5)), 4);
flat2_q5 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
sum_p7 = _mm256_add_epi16(sum_p7, p256_7);
sum_q7 = _mm256_add_epi16(sum_q7, q256_7);
pixelFilter_p = _mm256_sub_epi16(pixelFilter_p, q256_1);
pixelFilter_q = _mm256_sub_epi16(pixelFilter_q, p256_1);
res_p = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_p, _mm256_add_epi16(sum_p7, p256_6)), 4);
flat2_p6 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_p, res_p), 168));
res_q = _mm256_srli_epi16(
_mm256_add_epi16(pixelFilter_q, _mm256_add_epi16(sum_q7, q256_6)), 4);
flat2_q6 = _mm256_castsi256_si128(
_mm256_permute4x64_epi64(_mm256_packus_epi16(res_q, res_q), 168));
}
// wide flat
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p2 = _mm_andnot_si128(flat, p2);
flat_p2 = _mm_and_si128(flat, flat_p2);
p2 = _mm_or_si128(flat_p2, p2);
p1 = _mm_andnot_si128(flat, ps1);
flat_p1 = _mm_and_si128(flat, flat_p1);
p1 = _mm_or_si128(flat_p1, p1);
p0 = _mm_andnot_si128(flat, ps0);
flat_p0 = _mm_and_si128(flat, flat_p0);
p0 = _mm_or_si128(flat_p0, p0);
q0 = _mm_andnot_si128(flat, qs0);
flat_q0 = _mm_and_si128(flat, flat_q0);
q0 = _mm_or_si128(flat_q0, q0);
q1 = _mm_andnot_si128(flat, qs1);
flat_q1 = _mm_and_si128(flat, flat_q1);
q1 = _mm_or_si128(flat_q1, q1);
q2 = _mm_andnot_si128(flat, q2);
flat_q2 = _mm_and_si128(flat, flat_q2);
q2 = _mm_or_si128(flat_q2, q2);
p6 = _mm_andnot_si128(flat2, p6);
flat2_p6 = _mm_and_si128(flat2, flat2_p6);
p6 = _mm_or_si128(flat2_p6, p6);
_mm_storeu_si128((__m128i *)(s - 7 * p), p6);
p5 = _mm_andnot_si128(flat2, p5);
flat2_p5 = _mm_and_si128(flat2, flat2_p5);
p5 = _mm_or_si128(flat2_p5, p5);
_mm_storeu_si128((__m128i *)(s - 6 * p), p5);
p4 = _mm_andnot_si128(flat2, p4);
flat2_p4 = _mm_and_si128(flat2, flat2_p4);
p4 = _mm_or_si128(flat2_p4, p4);
_mm_storeu_si128((__m128i *)(s - 5 * p), p4);
p3 = _mm_andnot_si128(flat2, p3);
flat2_p3 = _mm_and_si128(flat2, flat2_p3);
p3 = _mm_or_si128(flat2_p3, p3);
_mm_storeu_si128((__m128i *)(s - 4 * p), p3);
p2 = _mm_andnot_si128(flat2, p2);
flat2_p2 = _mm_and_si128(flat2, flat2_p2);
p2 = _mm_or_si128(flat2_p2, p2);
_mm_storeu_si128((__m128i *)(s - 3 * p), p2);
p1 = _mm_andnot_si128(flat2, p1);
flat2_p1 = _mm_and_si128(flat2, flat2_p1);
p1 = _mm_or_si128(flat2_p1, p1);
_mm_storeu_si128((__m128i *)(s - 2 * p), p1);
p0 = _mm_andnot_si128(flat2, p0);
flat2_p0 = _mm_and_si128(flat2, flat2_p0);
p0 = _mm_or_si128(flat2_p0, p0);
_mm_storeu_si128((__m128i *)(s - 1 * p), p0);
q0 = _mm_andnot_si128(flat2, q0);
flat2_q0 = _mm_and_si128(flat2, flat2_q0);
q0 = _mm_or_si128(flat2_q0, q0);
_mm_storeu_si128((__m128i *)(s - 0 * p), q0);
q1 = _mm_andnot_si128(flat2, q1);
flat2_q1 = _mm_and_si128(flat2, flat2_q1);
q1 = _mm_or_si128(flat2_q1, q1);
_mm_storeu_si128((__m128i *)(s + 1 * p), q1);
q2 = _mm_andnot_si128(flat2, q2);
flat2_q2 = _mm_and_si128(flat2, flat2_q2);
q2 = _mm_or_si128(flat2_q2, q2);
_mm_storeu_si128((__m128i *)(s + 2 * p), q2);
q3 = _mm_andnot_si128(flat2, q3);
flat2_q3 = _mm_and_si128(flat2, flat2_q3);
q3 = _mm_or_si128(flat2_q3, q3);
_mm_storeu_si128((__m128i *)(s + 3 * p), q3);
q4 = _mm_andnot_si128(flat2, q4);
flat2_q4 = _mm_and_si128(flat2, flat2_q4);
q4 = _mm_or_si128(flat2_q4, q4);
_mm_storeu_si128((__m128i *)(s + 4 * p), q4);
q5 = _mm_andnot_si128(flat2, q5);
flat2_q5 = _mm_and_si128(flat2, flat2_q5);
q5 = _mm_or_si128(flat2_q5, q5);
_mm_storeu_si128((__m128i *)(s + 5 * p), q5);
q6 = _mm_andnot_si128(flat2, q6);
flat2_q6 = _mm_and_si128(flat2, flat2_q6);
q6 = _mm_or_si128(flat2_q6, q6);
_mm_storeu_si128((__m128i *)(s + 6 * p), q6);
}
}
static void mb_lpf_horizontal_edge_w_avx2_8(unsigned char *s, int p,
const unsigned char *_blimit,
const unsigned char *_limit,
const unsigned char *_thresh) {
__m128i mask, hev, flat, flat2;
const __m128i zero = _mm_set1_epi16(0);
const __m128i one = _mm_set1_epi8(1);
__m128i q7p7, q6p6, q5p5, q4p4, q3p3, q2p2, q1p1, q0p0, p0q0, p1q1;
__m128i abs_p1p0;
const __m128i thresh =
_mm_broadcastb_epi8(_mm_cvtsi32_si128((int)_thresh[0]));
const __m128i limit = _mm_broadcastb_epi8(_mm_cvtsi32_si128((int)_limit[0]));
const __m128i blimit =
_mm_broadcastb_epi8(_mm_cvtsi32_si128((int)_blimit[0]));
q4p4 = _mm_loadl_epi64((__m128i *)(s - 5 * p));
q4p4 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q4p4), (__m64 *)(s + 4 * p)));
q3p3 = _mm_loadl_epi64((__m128i *)(s - 4 * p));
q3p3 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q3p3), (__m64 *)(s + 3 * p)));
q2p2 = _mm_loadl_epi64((__m128i *)(s - 3 * p));
q2p2 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q2p2), (__m64 *)(s + 2 * p)));
q1p1 = _mm_loadl_epi64((__m128i *)(s - 2 * p));
q1p1 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q1p1), (__m64 *)(s + 1 * p)));
p1q1 = _mm_shuffle_epi32(q1p1, 78);
q0p0 = _mm_loadl_epi64((__m128i *)(s - 1 * p));
q0p0 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q0p0), (__m64 *)(s - 0 * p)));
p0q0 = _mm_shuffle_epi32(q0p0, 78);
{
__m128i abs_p1q1, abs_p0q0, abs_q1q0, fe, ff, work;
abs_p1p0 =
_mm_or_si128(_mm_subs_epu8(q1p1, q0p0), _mm_subs_epu8(q0p0, q1p1));
abs_q1q0 = _mm_srli_si128(abs_p1p0, 8);
fe = _mm_set1_epi8(0xfe);
ff = _mm_cmpeq_epi8(abs_p1p0, abs_p1p0);
abs_p0q0 =
_mm_or_si128(_mm_subs_epu8(q0p0, p0q0), _mm_subs_epu8(p0q0, q0p0));
abs_p1q1 =
_mm_or_si128(_mm_subs_epu8(q1p1, p1q1), _mm_subs_epu8(p1q1, q1p1));
flat = _mm_max_epu8(abs_p1p0, abs_q1q0);
hev = _mm_subs_epu8(flat, thresh);
hev = _mm_xor_si128(_mm_cmpeq_epi8(hev, zero), ff);
abs_p0q0 = _mm_adds_epu8(abs_p0q0, abs_p0q0);
abs_p1q1 = _mm_srli_epi16(_mm_and_si128(abs_p1q1, fe), 1);
mask = _mm_subs_epu8(_mm_adds_epu8(abs_p0q0, abs_p1q1), blimit);
mask = _mm_xor_si128(_mm_cmpeq_epi8(mask, zero), ff);
// mask |= (abs(p0 - q0) * 2 + abs(p1 - q1) / 2 > blimit) * -1;
mask = _mm_max_epu8(abs_p1p0, mask);
// mask |= (abs(p1 - p0) > limit) * -1;
// mask |= (abs(q1 - q0) > limit) * -1;
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(q2p2, q1p1), _mm_subs_epu8(q1p1, q2p2)),
_mm_or_si128(_mm_subs_epu8(q3p3, q2p2), _mm_subs_epu8(q2p2, q3p3)));
mask = _mm_max_epu8(work, mask);
mask = _mm_max_epu8(mask, _mm_srli_si128(mask, 8));
mask = _mm_subs_epu8(mask, limit);
mask = _mm_cmpeq_epi8(mask, zero);
}
// lp filter
{
const __m128i t4 = _mm_set1_epi8(4);
const __m128i t3 = _mm_set1_epi8(3);
const __m128i t80 = _mm_set1_epi8(0x80);
const __m128i t1 = _mm_set1_epi16(0x1);
__m128i qs1ps1 = _mm_xor_si128(q1p1, t80);
__m128i qs0ps0 = _mm_xor_si128(q0p0, t80);
__m128i qs0 = _mm_xor_si128(p0q0, t80);
__m128i qs1 = _mm_xor_si128(p1q1, t80);
__m128i filt;
__m128i work_a;
__m128i filter1, filter2;
__m128i flat2_q6p6, flat2_q5p5, flat2_q4p4, flat2_q3p3, flat2_q2p2;
__m128i flat2_q1p1, flat2_q0p0, flat_q2p2, flat_q1p1, flat_q0p0;
filt = _mm_and_si128(_mm_subs_epi8(qs1ps1, qs1), hev);
work_a = _mm_subs_epi8(qs0, qs0ps0);
filt = _mm_adds_epi8(filt, work_a);
filt = _mm_adds_epi8(filt, work_a);
filt = _mm_adds_epi8(filt, work_a);
/* (vpx_filter + 3 * (qs0 - ps0)) & mask */
filt = _mm_and_si128(filt, mask);
filter1 = _mm_adds_epi8(filt, t4);
filter2 = _mm_adds_epi8(filt, t3);
filter1 = _mm_unpacklo_epi8(zero, filter1);
filter1 = _mm_srai_epi16(filter1, 0xB);
filter2 = _mm_unpacklo_epi8(zero, filter2);
filter2 = _mm_srai_epi16(filter2, 0xB);
/* Filter1 >> 3 */
filt = _mm_packs_epi16(filter2, _mm_subs_epi16(zero, filter1));
qs0ps0 = _mm_xor_si128(_mm_adds_epi8(qs0ps0, filt), t80);
/* filt >> 1 */
filt = _mm_adds_epi16(filter1, t1);
filt = _mm_srai_epi16(filt, 1);
filt = _mm_andnot_si128(_mm_srai_epi16(_mm_unpacklo_epi8(zero, hev), 0x8),
filt);
filt = _mm_packs_epi16(filt, _mm_subs_epi16(zero, filt));
qs1ps1 = _mm_xor_si128(_mm_adds_epi8(qs1ps1, filt), t80);
// loopfilter done
{
__m128i work;
flat = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(q2p2, q0p0), _mm_subs_epu8(q0p0, q2p2)),
_mm_or_si128(_mm_subs_epu8(q3p3, q0p0), _mm_subs_epu8(q0p0, q3p3)));
flat = _mm_max_epu8(abs_p1p0, flat);
flat = _mm_max_epu8(flat, _mm_srli_si128(flat, 8));
flat = _mm_subs_epu8(flat, one);
flat = _mm_cmpeq_epi8(flat, zero);
flat = _mm_and_si128(flat, mask);
q5p5 = _mm_loadl_epi64((__m128i *)(s - 6 * p));
q5p5 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q5p5), (__m64 *)(s + 5 * p)));
q6p6 = _mm_loadl_epi64((__m128i *)(s - 7 * p));
q6p6 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q6p6), (__m64 *)(s + 6 * p)));
flat2 = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(q4p4, q0p0), _mm_subs_epu8(q0p0, q4p4)),
_mm_or_si128(_mm_subs_epu8(q5p5, q0p0), _mm_subs_epu8(q0p0, q5p5)));
q7p7 = _mm_loadl_epi64((__m128i *)(s - 8 * p));
q7p7 = _mm_castps_si128(
_mm_loadh_pi(_mm_castsi128_ps(q7p7), (__m64 *)(s + 7 * p)));
work = _mm_max_epu8(
_mm_or_si128(_mm_subs_epu8(q6p6, q0p0), _mm_subs_epu8(q0p0, q6p6)),
_mm_or_si128(_mm_subs_epu8(q7p7, q0p0), _mm_subs_epu8(q0p0, q7p7)));
flat2 = _mm_max_epu8(work, flat2);
flat2 = _mm_max_epu8(flat2, _mm_srli_si128(flat2, 8));
flat2 = _mm_subs_epu8(flat2, one);
flat2 = _mm_cmpeq_epi8(flat2, zero);
flat2 = _mm_and_si128(flat2, flat); // flat2 & flat & mask
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// flat and wide flat calculations
{
const __m128i eight = _mm_set1_epi16(8);
const __m128i four = _mm_set1_epi16(4);
__m128i p7_16, p6_16, p5_16, p4_16, p3_16, p2_16, p1_16, p0_16;
__m128i q7_16, q6_16, q5_16, q4_16, q3_16, q2_16, q1_16, q0_16;
__m128i pixelFilter_p, pixelFilter_q;
__m128i pixetFilter_p2p1p0, pixetFilter_q2q1q0;
__m128i sum_p7, sum_q7, sum_p3, sum_q3, res_p, res_q;
p7_16 = _mm_unpacklo_epi8(q7p7, zero);
p6_16 = _mm_unpacklo_epi8(q6p6, zero);
p5_16 = _mm_unpacklo_epi8(q5p5, zero);
p4_16 = _mm_unpacklo_epi8(q4p4, zero);
p3_16 = _mm_unpacklo_epi8(q3p3, zero);
p2_16 = _mm_unpacklo_epi8(q2p2, zero);
p1_16 = _mm_unpacklo_epi8(q1p1, zero);
p0_16 = _mm_unpacklo_epi8(q0p0, zero);
q0_16 = _mm_unpackhi_epi8(q0p0, zero);
q1_16 = _mm_unpackhi_epi8(q1p1, zero);
q2_16 = _mm_unpackhi_epi8(q2p2, zero);
q3_16 = _mm_unpackhi_epi8(q3p3, zero);
q4_16 = _mm_unpackhi_epi8(q4p4, zero);
q5_16 = _mm_unpackhi_epi8(q5p5, zero);
q6_16 = _mm_unpackhi_epi8(q6p6, zero);
q7_16 = _mm_unpackhi_epi8(q7p7, zero);
pixelFilter_p = _mm_add_epi16(_mm_add_epi16(p6_16, p5_16),
_mm_add_epi16(p4_16, p3_16));
pixelFilter_q = _mm_add_epi16(_mm_add_epi16(q6_16, q5_16),
_mm_add_epi16(q4_16, q3_16));
pixetFilter_p2p1p0 = _mm_add_epi16(p0_16, _mm_add_epi16(p2_16, p1_16));
pixelFilter_p = _mm_add_epi16(pixelFilter_p, pixetFilter_p2p1p0);
pixetFilter_q2q1q0 = _mm_add_epi16(q0_16, _mm_add_epi16(q2_16, q1_16));
pixelFilter_q = _mm_add_epi16(pixelFilter_q, pixetFilter_q2q1q0);
pixelFilter_p =
_mm_add_epi16(eight, _mm_add_epi16(pixelFilter_p, pixelFilter_q));
pixetFilter_p2p1p0 = _mm_add_epi16(
four, _mm_add_epi16(pixetFilter_p2p1p0, pixetFilter_q2q1q0));
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(p7_16, p0_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(q7_16, q0_16)), 4);
flat2_q0p0 = _mm_packus_epi16(res_p, res_q);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixetFilter_p2p1p0, _mm_add_epi16(p3_16, p0_16)), 3);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixetFilter_p2p1p0, _mm_add_epi16(q3_16, q0_16)), 3);
flat_q0p0 = _mm_packus_epi16(res_p, res_q);
sum_p7 = _mm_add_epi16(p7_16, p7_16);
sum_q7 = _mm_add_epi16(q7_16, q7_16);
sum_p3 = _mm_add_epi16(p3_16, p3_16);
sum_q3 = _mm_add_epi16(q3_16, q3_16);
pixelFilter_q = _mm_sub_epi16(pixelFilter_p, p6_16);
pixelFilter_p = _mm_sub_epi16(pixelFilter_p, q6_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(sum_p7, p1_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_q, _mm_add_epi16(sum_q7, q1_16)), 4);
flat2_q1p1 = _mm_packus_epi16(res_p, res_q);
pixetFilter_q2q1q0 = _mm_sub_epi16(pixetFilter_p2p1p0, p2_16);
pixetFilter_p2p1p0 = _mm_sub_epi16(pixetFilter_p2p1p0, q2_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixetFilter_p2p1p0, _mm_add_epi16(sum_p3, p1_16)), 3);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixetFilter_q2q1q0, _mm_add_epi16(sum_q3, q1_16)), 3);
flat_q1p1 = _mm_packus_epi16(res_p, res_q);
sum_p7 = _mm_add_epi16(sum_p7, p7_16);
sum_q7 = _mm_add_epi16(sum_q7, q7_16);
sum_p3 = _mm_add_epi16(sum_p3, p3_16);
sum_q3 = _mm_add_epi16(sum_q3, q3_16);
pixelFilter_p = _mm_sub_epi16(pixelFilter_p, q5_16);
pixelFilter_q = _mm_sub_epi16(pixelFilter_q, p5_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(sum_p7, p2_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_q, _mm_add_epi16(sum_q7, q2_16)), 4);
flat2_q2p2 = _mm_packus_epi16(res_p, res_q);
pixetFilter_p2p1p0 = _mm_sub_epi16(pixetFilter_p2p1p0, q1_16);
pixetFilter_q2q1q0 = _mm_sub_epi16(pixetFilter_q2q1q0, p1_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixetFilter_p2p1p0, _mm_add_epi16(sum_p3, p2_16)), 3);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixetFilter_q2q1q0, _mm_add_epi16(sum_q3, q2_16)), 3);
flat_q2p2 = _mm_packus_epi16(res_p, res_q);
sum_p7 = _mm_add_epi16(sum_p7, p7_16);
sum_q7 = _mm_add_epi16(sum_q7, q7_16);
pixelFilter_p = _mm_sub_epi16(pixelFilter_p, q4_16);
pixelFilter_q = _mm_sub_epi16(pixelFilter_q, p4_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(sum_p7, p3_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_q, _mm_add_epi16(sum_q7, q3_16)), 4);
flat2_q3p3 = _mm_packus_epi16(res_p, res_q);
sum_p7 = _mm_add_epi16(sum_p7, p7_16);
sum_q7 = _mm_add_epi16(sum_q7, q7_16);
pixelFilter_p = _mm_sub_epi16(pixelFilter_p, q3_16);
pixelFilter_q = _mm_sub_epi16(pixelFilter_q, p3_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(sum_p7, p4_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_q, _mm_add_epi16(sum_q7, q4_16)), 4);
flat2_q4p4 = _mm_packus_epi16(res_p, res_q);
sum_p7 = _mm_add_epi16(sum_p7, p7_16);
sum_q7 = _mm_add_epi16(sum_q7, q7_16);
pixelFilter_p = _mm_sub_epi16(pixelFilter_p, q2_16);
pixelFilter_q = _mm_sub_epi16(pixelFilter_q, p2_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(sum_p7, p5_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_q, _mm_add_epi16(sum_q7, q5_16)), 4);
flat2_q5p5 = _mm_packus_epi16(res_p, res_q);
sum_p7 = _mm_add_epi16(sum_p7, p7_16);
sum_q7 = _mm_add_epi16(sum_q7, q7_16);
pixelFilter_p = _mm_sub_epi16(pixelFilter_p, q1_16);
pixelFilter_q = _mm_sub_epi16(pixelFilter_q, p1_16);
res_p = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_p, _mm_add_epi16(sum_p7, p6_16)), 4);
res_q = _mm_srli_epi16(
_mm_add_epi16(pixelFilter_q, _mm_add_epi16(sum_q7, q6_16)), 4);
flat2_q6p6 = _mm_packus_epi16(res_p, res_q);
}
// wide flat
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
flat = _mm_shuffle_epi32(flat, 68);
flat2 = _mm_shuffle_epi32(flat2, 68);
q2p2 = _mm_andnot_si128(flat, q2p2);
flat_q2p2 = _mm_and_si128(flat, flat_q2p2);
q2p2 = _mm_or_si128(q2p2, flat_q2p2);
qs1ps1 = _mm_andnot_si128(flat, qs1ps1);
flat_q1p1 = _mm_and_si128(flat, flat_q1p1);
q1p1 = _mm_or_si128(qs1ps1, flat_q1p1);
qs0ps0 = _mm_andnot_si128(flat, qs0ps0);
flat_q0p0 = _mm_and_si128(flat, flat_q0p0);
q0p0 = _mm_or_si128(qs0ps0, flat_q0p0);
q6p6 = _mm_andnot_si128(flat2, q6p6);
flat2_q6p6 = _mm_and_si128(flat2, flat2_q6p6);
q6p6 = _mm_or_si128(q6p6, flat2_q6p6);
_mm_storel_epi64((__m128i *)(s - 7 * p), q6p6);
_mm_storeh_pi((__m64 *)(s + 6 * p), _mm_castsi128_ps(q6p6));
q5p5 = _mm_andnot_si128(flat2, q5p5);
flat2_q5p5 = _mm_and_si128(flat2, flat2_q5p5);
q5p5 = _mm_or_si128(q5p5, flat2_q5p5);
_mm_storel_epi64((__m128i *)(s - 6 * p), q5p5);
_mm_storeh_pi((__m64 *)(s + 5 * p), _mm_castsi128_ps(q5p5));
q4p4 = _mm_andnot_si128(flat2, q4p4);
flat2_q4p4 = _mm_and_si128(flat2, flat2_q4p4);
q4p4 = _mm_or_si128(q4p4, flat2_q4p4);
_mm_storel_epi64((__m128i *)(s - 5 * p), q4p4);
_mm_storeh_pi((__m64 *)(s + 4 * p), _mm_castsi128_ps(q4p4));
q3p3 = _mm_andnot_si128(flat2, q3p3);
flat2_q3p3 = _mm_and_si128(flat2, flat2_q3p3);
q3p3 = _mm_or_si128(q3p3, flat2_q3p3);
_mm_storel_epi64((__m128i *)(s - 4 * p), q3p3);
_mm_storeh_pi((__m64 *)(s + 3 * p), _mm_castsi128_ps(q3p3));
q2p2 = _mm_andnot_si128(flat2, q2p2);
flat2_q2p2 = _mm_and_si128(flat2, flat2_q2p2);
q2p2 = _mm_or_si128(q2p2, flat2_q2p2);
_mm_storel_epi64((__m128i *)(s - 3 * p), q2p2);
_mm_storeh_pi((__m64 *)(s + 2 * p), _mm_castsi128_ps(q2p2));
q1p1 = _mm_andnot_si128(flat2, q1p1);
flat2_q1p1 = _mm_and_si128(flat2, flat2_q1p1);
q1p1 = _mm_or_si128(q1p1, flat2_q1p1);
_mm_storel_epi64((__m128i *)(s - 2 * p), q1p1);
_mm_storeh_pi((__m64 *)(s + 1 * p), _mm_castsi128_ps(q1p1));
q0p0 = _mm_andnot_si128(flat2, q0p0);
flat2_q0p0 = _mm_and_si128(flat2, flat2_q0p0);
q0p0 = _mm_or_si128(q0p0, flat2_q0p0);
_mm_storel_epi64((__m128i *)(s - 1 * p), q0p0);
_mm_storeh_pi((__m64 *)(s - 0 * p), _mm_castsi128_ps(q0p0));
}
}
/* Striped Smith-Waterman
Record the highest score of each reference position.
Return the alignment score and ending position of the best alignment, 2nd best alignment, etc.
Gap begin and gap extension are different.
wight_match > 0, all other weights < 0.
The returned positions are 0-based.
*/
static alignment_end* sw_sse2_byte (const int8_t* ref,
int8_t ref_dir, // 0: forward ref; 1: reverse ref
int32_t refLen,
int32_t readLen,
const uint8_t weight_gapO, /* will be used as - */
const uint8_t weight_gapE, /* will be used as - */
const __m128i* vProfile,
uint8_t terminate, /* the best alignment score: used to terminate
the matrix calculation when locating the
alignment beginning point. If this score
is set to 0, it will not be used */
uint8_t bias, /* Shift 0 point to a positive value. */
int32_t maskLen) {
#define max16(m, vm) (vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 8)); \
(vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 4)); \
(vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 2)); \
(vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 1)); \
(m) = _mm_extract_epi16((vm), 0)
uint8_t max = 0; /* the max alignment score */
int32_t end_read = readLen - 1;
int32_t end_ref = -1; /* 0_based best alignment ending point; Initialized as isn't aligned -1. */
int32_t segLen = (readLen + 15) / 16; /* number of segment */
/* array to record the largest score of each reference position */
uint8_t* maxColumn = (uint8_t*) calloc(refLen, 1);
/* array to record the alignment read ending position of the largest score of each reference position */
int32_t* end_read_column = (int32_t*) calloc(refLen, sizeof(int32_t));
/* Define 16 byte 0 vector. */
__m128i vZero = _mm_set1_epi32(0);
__m128i* pvHStore = (__m128i*) calloc(segLen, sizeof(__m128i));
__m128i* pvHLoad = (__m128i*) calloc(segLen, sizeof(__m128i));
__m128i* pvE = (__m128i*) calloc(segLen, sizeof(__m128i));
__m128i* pvHmax = (__m128i*) calloc(segLen, sizeof(__m128i));
int32_t i, j;
/* 16 byte insertion begin vector */
__m128i vGapO = _mm_set1_epi8(weight_gapO);
/* 16 byte insertion extension vector */
__m128i vGapE = _mm_set1_epi8(weight_gapE);
/* 16 byte bias vector */
__m128i vBias = _mm_set1_epi8(bias);
__m128i vMaxScore = vZero; /* Trace the highest score of the whole SW matrix. */
__m128i vMaxMark = vZero; /* Trace the highest score till the previous column. */
__m128i vTemp;
int32_t edge, begin = 0, end = refLen, step = 1;
// int32_t distance = readLen * 2 / 3;
// int32_t distance = readLen / 2;
// int32_t distance = readLen;
/* outer loop to process the reference sequence */
if (ref_dir == 1) {
begin = refLen - 1;
end = -1;
step = -1;
}
for (i = begin; LIKELY(i != end); i += step) {
int32_t cmp;
__m128i e, vF = vZero, vMaxColumn = vZero; /* Initialize F value to 0.
Any errors to vH values will be corrected in the Lazy_F loop.
*/
// max16(maxColumn[i], vMaxColumn);
// fprintf(stderr, "middle[%d]: %d\n", i, maxColumn[i]);
__m128i vH = pvHStore[segLen - 1];
vH = _mm_slli_si128 (vH, 1); /* Shift the 128-bit value in vH left by 1 byte. */
const __m128i* vP = vProfile + ref[i] * segLen; /* Right part of the vProfile */
/* Swap the 2 H buffers. */
__m128i* pv = pvHLoad;
pvHLoad = pvHStore;
pvHStore = pv;
/* inner loop to process the query sequence */
for (j = 0; LIKELY(j < segLen); ++j) {
vH = _mm_adds_epu8(vH, _mm_load_si128(vP + j));
vH = _mm_subs_epu8(vH, vBias); /* vH will be always > 0 */
// max16(maxColumn[i], vH);
// fprintf(stderr, "H[%d]: %d\n", i, maxColumn[i]);
// int8_t* t;
// int32_t ti;
//for (t = (int8_t*)&vH, ti = 0; ti < 16; ++ti) fprintf(stderr, "%d\t", *t++);
/* Get max from vH, vE and vF. */
e = _mm_load_si128(pvE + j);
vH = _mm_max_epu8(vH, e);
vH = _mm_max_epu8(vH, vF);
vMaxColumn = _mm_max_epu8(vMaxColumn, vH);
// max16(maxColumn[i], vMaxColumn);
// fprintf(stderr, "middle[%d]: %d\n", i, maxColumn[i]);
// for (t = (int8_t*)&vMaxColumn, ti = 0; ti < 16; ++ti) fprintf(stderr, "%d\t", *t++);
/* Save vH values. */
_mm_store_si128(pvHStore + j, vH);
/* Update vE value. */
vH = _mm_subs_epu8(vH, vGapO); /* saturation arithmetic, result >= 0 */
e = _mm_max_epu8(e, vH);
e = _mm_subs_epu8(e, vGapE);
_mm_store_si128(pvE + j, e);
/* Update vF value. */
vF = _mm_max_epu8(vF, vH);
vF = _mm_subs_epu8(vF, vGapE);
/* Load the next vH. */
vH = _mm_load_si128(pvHLoad + j);
}
/* Lazy_F loop: has been revised to disallow adjecent insertion and then deletion, so don't update E(i, j), learn from SWPS3 */
/* reset pointers to the start of the saved data */
j = 0;
vH = _mm_load_si128 (pvHStore + j);
/* the computed vF value is for the given column. since */
/* we are at the end, we need to shift the vF value over */
/* to the next column. */
vF = _mm_slli_si128 (vF, 1);
vTemp = _mm_subs_epu8 (vH, vGapO);
vTemp = _mm_subs_epu8 (vF, vTemp);
vTemp = _mm_cmpeq_epi8 (vTemp, vZero);
cmp = _mm_movemask_epi8 (vTemp);
while (cmp != 0xffff)
{
vH = _mm_max_epu8 (vH, vF);
vMaxColumn = _mm_max_epu8(vMaxColumn, vH);
_mm_store_si128 (pvHStore + j, vH);
vF = _mm_subs_epu8 (vF, vGapE);
j++;
if (j >= segLen)
{
j = 0;
vF = _mm_slli_si128 (vF, 1);
}
vH = _mm_load_si128 (pvHStore + j);
vTemp = _mm_subs_epu8 (vH, vGapO);
vTemp = _mm_subs_epu8 (vF, vTemp);
vTemp = _mm_cmpeq_epi8 (vTemp, vZero);
cmp = _mm_movemask_epi8 (vTemp);
}
vMaxScore = _mm_max_epu8(vMaxScore, vMaxColumn);
vTemp = _mm_cmpeq_epi8(vMaxMark, vMaxScore);
cmp = _mm_movemask_epi8(vTemp);
if (cmp != 0xffff) {
uint8_t temp;
vMaxMark = vMaxScore;
max16(temp, vMaxScore);
vMaxScore = vMaxMark;
if (LIKELY(temp > max)) {
max = temp;
if (max + bias >= 255) break; //overflow
end_ref = i;
/* Store the column with the highest alignment score in order to trace the alignment ending position on read. */
for (j = 0; LIKELY(j < segLen); ++j) pvHmax[j] = pvHStore[j];
}
}
/* Record the max score of current column. */
max16(maxColumn[i], vMaxColumn);
// fprintf(stderr, "maxColumn[%d]: %d\n", i, maxColumn[i]);
if (maxColumn[i] == terminate) break;
}
/* Trace the alignment ending position on read. */
uint8_t *t = (uint8_t*)pvHmax;
int32_t column_len = segLen * 16;
for (i = 0; LIKELY(i < column_len); ++i, ++t) {
int32_t temp;
if (*t == max) {
temp = i / 16 + i % 16 * segLen;
if (temp < end_read) end_read = temp;
}
}
free(pvHmax);
free(pvE);
free(pvHLoad);
free(pvHStore);
/* Find the most possible 2nd best alignment. */
alignment_end* bests = (alignment_end*) calloc(2, sizeof(alignment_end));
bests[0].score = max + bias >= 255 ? 255 : max;
bests[0].ref = end_ref;
bests[0].read = end_read;
bests[1].score = 0;
bests[1].ref = 0;
bests[1].read = 0;
edge = (end_ref - maskLen) > 0 ? (end_ref - maskLen) : 0;
for (i = 0; i < edge; i ++) {
// fprintf (stderr, "maxColumn[%d]: %d\n", i, maxColumn[i]);
if (maxColumn[i] > bests[1].score) {
bests[1].score = maxColumn[i];
bests[1].ref = i;
}
}
edge = (end_ref + maskLen) > refLen ? refLen : (end_ref + maskLen);
for (i = edge + 1; i < refLen; i ++) {
// fprintf (stderr, "refLen: %d\tmaxColumn[%d]: %d\n", refLen, i, maxColumn[i]);
if (maxColumn[i] > bests[1].score) {
bests[1].score = maxColumn[i];
bests[1].ref = i;
}
}
free(maxColumn);
free(end_read_column);
return bests;
}
int
global_sse2_byte(int queryLength,
unsigned char *profile,
const unsigned char *dbSeq,
int dbLength,
unsigned short gapOpen,
unsigned short gapExtend,
unsigned short ceiling,
unsigned short bias,
struct f_struct *f_str)
{
int i, j;
int score;
int scale;
int distance;
int offset;
int position;
int dup;
int cmp;
int iter;
__m128i *pvH;
__m128i *pvE;
__m128i vE, vF, vH;
__m128i vHInit;
__m128i vHNext;
__m128i vFPrev;
__m128i vBias;
__m128i vGapOpen;
__m128i vGapExtend;
__m128i vCeiling;
__m128i vScale;
__m128i vScaleAmt;
__m128i vScaleTmp;
__m128i vTemp;
__m128i vNull;
__m128i *pvScore;
scale = 0;
iter = (queryLength + 15) / 16;
offset = (queryLength - 1) % iter;
position = 15 - (queryLength - 1) / iter;
pvH = (__m128i *)f_str->workspace;
pvE = pvH + iter;
/* Load the bias to all elements of a constant */
dup = (bias << 8) | (bias & 0x00ff);
vBias = _mm_setzero_si128(); /* initialize cf Apple Devel smith_waterman_sse2.c */
vBias = _mm_insert_epi16 (vBias, dup, 0);
vBias = _mm_shufflelo_epi16 (vBias, 0);
vBias = _mm_shuffle_epi32 (vBias, 0);
/* Load gap opening penalty to all elements of a constant */
dup = (gapOpen << 8) | (gapOpen & 0x00ff);
vGapOpen = _mm_setzero_si128(); /* initialize cf Apple Devel smith_waterman_sse2.c */
vGapOpen = _mm_insert_epi16 (vGapOpen, dup, 0);
vGapOpen = _mm_shufflelo_epi16 (vGapOpen, 0);
vGapOpen = _mm_shuffle_epi32 (vGapOpen, 0);
/* Load gap extension penalty to all elements of a constant */
dup = (gapExtend << 8) | (gapExtend & 0x00ff);
vGapExtend = _mm_setzero_si128(); /* initialize cf Apple Devel smith_waterman_sse2.c */
vGapExtend = _mm_insert_epi16 (vGapExtend, dup, 0);
vGapExtend = _mm_shufflelo_epi16 (vGapExtend, 0);
vGapExtend = _mm_shuffle_epi32 (vGapExtend, 0);
/* Generate the ceiling before scaling */
dup = (ceiling << 8) | (ceiling & 0x00ff);
vTemp = _mm_setzero_si128(); /* initialize cf Apple Devel smith_waterman_sse2.c */
vTemp = _mm_insert_epi16 (vTemp, dup, 0);
vTemp = _mm_shufflelo_epi16 (vTemp, 0);
vTemp = _mm_shuffle_epi32 (vTemp, 0);
vCeiling = _mm_cmpeq_epi8 (vTemp, vTemp);
vCeiling = _mm_subs_epu8 (vCeiling, vTemp);
vCeiling = _mm_subs_epu8 (vCeiling, vGapOpen);
/* since we want to use the full range, zero is redefined as */
/* 2 * gapOpen. the lowest scaled score will an insert followed */
/* by a delete. */
vHInit = _mm_srli_si128 (vGapOpen, 15);
/* vNull = _mm_xor_si128 (vNull, vNull); */
vNull = _mm_setzero_si128(); /* initialize cf Apple Devel smith_waterman_sse2.c */
vScaleAmt = vNull;
/* Zero out the storage vector */
for (i = 0; i < iter; i++) {
_mm_store_si128 (pvH + i, vGapOpen);
_mm_store_si128 (pvE + i, vNull);
}
/* initialize F */
vF = vNull;
vFPrev = vNull;
/* load and scale H for the next round */
vH = _mm_load_si128 (pvH + iter - 1);
vH = _mm_slli_si128 (vH, 1);
vH = _mm_adds_epu8 (vH, vHInit);
vH = _mm_adds_epu8 (vH, vHInit);
for (i = 0; i < dbLength; ++i) {
/* fetch first data asap. */
pvScore = (__m128i *) profile + dbSeq[i] * iter;
vF = _mm_xor_si128 (vF, vF);
vH = _mm_max_epu8 (vH, vFPrev);
for (j = 0; j < iter; j++) {
/* correct H from the previous columns F */
vHNext = _mm_load_si128 (pvH + j);
vHNext = _mm_max_epu8 (vHNext, vFPrev);
/* load and correct E value */
vE = _mm_load_si128 (pvE + j);
vTemp = _mm_subs_epu8 (vHNext, vGapOpen);
vE = _mm_max_epu8 (vE, vTemp);
_mm_store_si128 (pvE + j, vE);
/* add score to vH */
vH = _mm_adds_epu8 (vH, *pvScore++);
vH = _mm_subs_epu8 (vH, vBias);
/* get max from vH, vE and vF */
vH = _mm_max_epu8 (vH, vE);
vH = _mm_max_epu8 (vH, vF);
_mm_store_si128 (pvH + j, vH);
/* update vF value */
vH = _mm_subs_epu8 (vH, vGapOpen);
vF = _mm_max_epu8 (vF, vH);
/* load the next h values */
vH = vHNext;
}
/* check if we need to scale before the next round */
vTemp = _mm_subs_epu8 (vCeiling, vF);
vTemp = _mm_cmpeq_epi8 (vTemp, vNull);
cmp = _mm_movemask_epi8 (vTemp);
/* broadcast F values */
vTemp = _mm_slli_si128 (vF, 1);
vTemp = _mm_subs_epu8 (vTemp, vScaleAmt);
vF = _mm_max_epu8 (vF, vTemp);
vScaleTmp = _mm_slli_si128 (vScaleAmt, 1);
vScaleTmp = _mm_adds_epu8 (vScaleTmp, vScaleAmt);
vTemp = _mm_slli_si128 (vF, 2);
vTemp = _mm_subs_epu8 (vTemp, vScaleTmp);
vF = _mm_max_epu8 (vF, vTemp);
vTemp = _mm_slli_si128 (vScaleTmp, 2);
vScaleTmp = _mm_adds_epu8 (vScaleTmp, vTemp);
vTemp = _mm_slli_si128 (vF, 4);
vTemp = _mm_subs_epu8 (vTemp, vScaleTmp);
vF = _mm_max_epu8 (vF, vTemp);
vTemp = _mm_slli_si128 (vScaleTmp, 4);
vScaleTmp = _mm_adds_epu8 (vScaleTmp, vTemp);
vTemp = _mm_slli_si128 (vF, 8);
vTemp = _mm_subs_epu8 (vTemp, vScaleTmp);
vF = _mm_max_epu8 (vF, vTemp);
/* scale if necessary */
if (cmp != 0x0000) {
vScale = _mm_slli_si128 (vF, 1);
vScale = _mm_subs_epu8 (vScale, vGapOpen);
vScale = _mm_subs_epu8 (vScale, vScaleAmt);
vTemp = _mm_slli_si128 (vScale, 1);
vTemp = _mm_subs_epu8 (vScale, vTemp);
vScaleAmt = _mm_adds_epu8 (vScaleAmt, vTemp);
vTemp = _mm_slli_si128 (vScale, 1);
vTemp = _mm_subs_epu8 (vTemp, vScale);
vScaleAmt = _mm_subs_epu8 (vScaleAmt, vTemp);
/* rescale the previous F */
vF = _mm_subs_epu8 (vF, vScale);
/* check if we can continue in 8-bits */
vTemp = _mm_subs_epu8 (vCeiling, vF);
vTemp = _mm_cmpeq_epi8 (vTemp, vNull);
cmp = _mm_movemask_epi8 (vTemp);
if (cmp != 0x0000) {
return OVERFLOW_SCORE;
}
/* scale all the vectors */
for (j = 0; j < iter; j++) {
/* load H and E */
vH = _mm_load_si128 (pvH + j);
vE = _mm_load_si128 (pvE + j);
/* get max from vH, vE and vF */
vH = _mm_subs_epu8 (vH, vScale);
vE = _mm_subs_epu8 (vE, vScale);
/* save the H and E */
_mm_store_si128 (pvH + j, vH);
_mm_store_si128 (pvE + j, vE);
}
/* calculate the final scaling amount */
vScale = vScaleAmt;
for (j = 0; j < position; ++j) {
vScale = _mm_slli_si128 (vScale, 1);
}
vTemp = _mm_unpacklo_epi8 (vScale, vNull);
vScale = _mm_unpackhi_epi8 (vScale, vNull);
vScale = _mm_adds_epi16 (vScale, vTemp);
vTemp = _mm_srli_si128 (vScale, 8);
vScale = _mm_adds_epi16 (vScale, vTemp);
vTemp = _mm_srli_si128 (vScale, 4);
vScale = _mm_adds_epi16 (vScale, vTemp);
vTemp = _mm_srli_si128 (vScale, 2);
vScale = _mm_adds_epi16 (vScale, vTemp);
scale = (int) _mm_extract_epi16 (vScale, 0);
}
/* scale the F value for the next round */
vFPrev = _mm_slli_si128 (vF, 1);
vFPrev = _mm_subs_epu8 (vFPrev, vScaleAmt);
/* load and scale H for the next round */
vH = _mm_load_si128 (pvH + iter - 1);
vH = _mm_slli_si128 (vH, 1);
vH = _mm_subs_epu8 (vH, vScaleAmt);
vH = _mm_or_si128 (vH, vHInit);
}
/* calculate the max global score */
vH = _mm_load_si128 (pvH + offset);
vH = _mm_max_epu8 (vH, vF);
for (j = 0; j < position; ++j) {
vH = _mm_slli_si128 (vH, 1);
}
score = (int) (unsigned short) _mm_extract_epi16 (vH, 7);
score >>= 8;
/* return largest score */
distance = (queryLength + dbLength) * gapExtend;
score = score - (gapOpen * 2) - distance + scale;
return score;
}
void FAST_t(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression)
{
Mat img = _img.getMat();
const int K = patternSize/2, N = patternSize + K + 1;
#if CV_SSE2
const int quarterPatternSize = patternSize/4;
(void)quarterPatternSize;
#endif
int i, j, k, pixel[25];
makeOffsets(pixel, (int)img.step, patternSize);
keypoints.clear();
threshold = std::min(std::max(threshold, 0), 255);
#if CV_SSE2
__m128i delta = _mm_set1_epi8(-128), t = _mm_set1_epi8((char)threshold), K16 = _mm_set1_epi8((char)K);
(void)K16;
(void)delta;
(void)t;
#endif
uchar threshold_tab[512];
for( i = -255; i <= 255; i++ )
threshold_tab[i+255] = (uchar)(i < -threshold ? 1 : i > threshold ? 2 : 0);
AutoBuffer<uchar> _buf((img.cols+16)*3*(sizeof(int) + sizeof(uchar)) + 128);
uchar* buf[3];
buf[0] = _buf; buf[1] = buf[0] + img.cols; buf[2] = buf[1] + img.cols;
int* cpbuf[3];
cpbuf[0] = (int*)alignPtr(buf[2] + img.cols, sizeof(int)) + 1;
cpbuf[1] = cpbuf[0] + img.cols + 1;
cpbuf[2] = cpbuf[1] + img.cols + 1;
memset(buf[0], 0, img.cols*3);
for(i = 3; i < img.rows-2; i++)
{
const uchar* ptr = img.ptr<uchar>(i) + 3;
uchar* curr = buf[(i - 3)%3];
int* cornerpos = cpbuf[(i - 3)%3];
memset(curr, 0, img.cols);
int ncorners = 0;
if( i < img.rows - 3 )
{
j = 3;
#if CV_SSE2
if( patternSize == 16 )
{
for(; j < img.cols - 16 - 3; j += 16, ptr += 16)
{
__m128i m0, m1;
__m128i v0 = _mm_loadu_si128((const __m128i*)ptr);
__m128i v1 = _mm_xor_si128(_mm_subs_epu8(v0, t), delta);
v0 = _mm_xor_si128(_mm_adds_epu8(v0, t), delta);
__m128i x0 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[0])), delta);
__m128i x1 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[quarterPatternSize])), delta);
__m128i x2 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[2*quarterPatternSize])), delta);
__m128i x3 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[3*quarterPatternSize])), delta);
m0 = _mm_and_si128(_mm_cmpgt_epi8(x0, v0), _mm_cmpgt_epi8(x1, v0));
m1 = _mm_and_si128(_mm_cmpgt_epi8(v1, x0), _mm_cmpgt_epi8(v1, x1));
m0 = _mm_or_si128(m0, _mm_and_si128(_mm_cmpgt_epi8(x1, v0), _mm_cmpgt_epi8(x2, v0)));
m1 = _mm_or_si128(m1, _mm_and_si128(_mm_cmpgt_epi8(v1, x1), _mm_cmpgt_epi8(v1, x2)));
m0 = _mm_or_si128(m0, _mm_and_si128(_mm_cmpgt_epi8(x2, v0), _mm_cmpgt_epi8(x3, v0)));
m1 = _mm_or_si128(m1, _mm_and_si128(_mm_cmpgt_epi8(v1, x2), _mm_cmpgt_epi8(v1, x3)));
m0 = _mm_or_si128(m0, _mm_and_si128(_mm_cmpgt_epi8(x3, v0), _mm_cmpgt_epi8(x0, v0)));
m1 = _mm_or_si128(m1, _mm_and_si128(_mm_cmpgt_epi8(v1, x3), _mm_cmpgt_epi8(v1, x0)));
m0 = _mm_or_si128(m0, m1);
int mask = _mm_movemask_epi8(m0);
if( mask == 0 )
continue;
if( (mask & 255) == 0 )
{
j -= 8;
ptr -= 8;
continue;
}
__m128i c0 = _mm_setzero_si128(), c1 = c0, max0 = c0, max1 = c0;
for( k = 0; k < N; k++ )
{
__m128i x = _mm_xor_si128(_mm_loadu_si128((const __m128i*)(ptr + pixel[k])), delta);
m0 = _mm_cmpgt_epi8(x, v0);
m1 = _mm_cmpgt_epi8(v1, x);
c0 = _mm_and_si128(_mm_sub_epi8(c0, m0), m0);
c1 = _mm_and_si128(_mm_sub_epi8(c1, m1), m1);
max0 = _mm_max_epu8(max0, c0);
max1 = _mm_max_epu8(max1, c1);
}
max0 = _mm_max_epu8(max0, max1);
int m = _mm_movemask_epi8(_mm_cmpgt_epi8(max0, K16));
for( k = 0; m > 0 && k < 16; k++, m >>= 1 )
if(m & 1)
{
cornerpos[ncorners++] = j+k;
if(nonmax_suppression)
curr[j+k] = (uchar)cornerScore<patternSize>(ptr+k, pixel, threshold);
}
}
}
#endif
for( ; j < img.cols - 3; j++, ptr++ )
{
int v = ptr[0];
const uchar* tab = &threshold_tab[0] - v + 255;
int d = tab[ptr[pixel[0]]] | tab[ptr[pixel[8]]];
if( d == 0 )
continue;
d &= tab[ptr[pixel[2]]] | tab[ptr[pixel[10]]];
d &= tab[ptr[pixel[4]]] | tab[ptr[pixel[12]]];
d &= tab[ptr[pixel[6]]] | tab[ptr[pixel[14]]];
if( d == 0 )
continue;
d &= tab[ptr[pixel[1]]] | tab[ptr[pixel[9]]];
d &= tab[ptr[pixel[3]]] | tab[ptr[pixel[11]]];
d &= tab[ptr[pixel[5]]] | tab[ptr[pixel[13]]];
d &= tab[ptr[pixel[7]]] | tab[ptr[pixel[15]]];
if( d & 1 )
{
int vt = v - threshold, count = 0;
for( k = 0; k < N; k++ )
{
int x = ptr[pixel[k]];
if(x < vt)
{
if( ++count > K )
{
cornerpos[ncorners++] = j;
if(nonmax_suppression)
curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
break;
}
}
else
count = 0;
}
}
if( d & 2 )
{
int vt = v + threshold, count = 0;
for( k = 0; k < N; k++ )
{
int x = ptr[pixel[k]];
if(x > vt)
{
if( ++count > K )
{
cornerpos[ncorners++] = j;
if(nonmax_suppression)
curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
break;
}
}
else
count = 0;
}
}
}
}
cornerpos[-1] = ncorners;
if( i == 3 )
continue;
const uchar* prev = buf[(i - 4 + 3)%3];
const uchar* pprev = buf[(i - 5 + 3)%3];
cornerpos = cpbuf[(i - 4 + 3)%3];
ncorners = cornerpos[-1];
for( k = 0; k < ncorners; k++ )
{
j = cornerpos[k];
int score = prev[j];
if( !nonmax_suppression ||
(score > prev[j+1] && score > prev[j-1] &&
score > pprev[j-1] && score > pprev[j] && score > pprev[j+1] &&
score > curr[j-1] && score > curr[j] && score > curr[j+1]) )
{
keypoints.push_back(KeyPoint((float)j, (float)(i-1), 7.f, -1, (float)score));
}
}
}
template <bool align> SIMD_INLINE void EdgeBackgroundGrowRangeFast(const uint8_t * value, uint8_t * background)
{
const __m128i _value = Load<align>((__m128i*)value);
const __m128i _background = Load<align>((__m128i*)background);
Store<align>((__m128i*)background, _mm_max_epu8(_background, _value));
}
SIMD_INLINE __m128i FeatureDifference(__m128i value, __m128i lo, __m128i hi)
{
return _mm_max_epu8(_mm_subs_epu8(value, hi), _mm_subs_epu8(lo, value));
}
EXPORT double swps3_alignmentByteSSE( ProfileByte * query, const char * db, int dbLen, Options * options )
{
/**********************************************************************
* This version of the code implements the idea presented in
*
***********************************************************************
* Striped Smith-Waterman speeds database searches six times over other
* SIMD implementations
*
* Michael Farrar, Bioinformatics, 23(2), pp. 156-161, 2007
**********************************************************************/
int i, j;
unsigned char MaxScore = 0;
int segLength = (query->len+15)/16; /* the segment length */
__m128i * loadOpt = query->loadOpt;
__m128i * storeOpt = query->storeOpt;
__m128i * rD = query->rD;
__m128i * current_profile;
__m128i * swap;
__m128i vMinimums = _mm_set1_epi32(0);
__m128i vDelIncr = _mm_set1_epi8(-options->gapExt);
__m128i vDelFixed = _mm_set1_epi8(-options->gapOpen);
__m128i vBias = _mm_set1_epi8(query->bias);
__m128i vMaxScore = vMinimums; /* vMaxScore = [0,0] */
__m128i vStoreOpt; /* the new optimal score */
__m128i vRD; /* the new row deletion score */
__m128i vCD = vMinimums; /* the column deletion score */
__m128i zero = vMinimums; /* the column deletion score */
__m128i vTmp;
#ifdef DEBUG
int ii,jj;
#endif
/* initialize the other arrays used for the dynProg code */
/*********************************************************/
for(i=0; LIKELY(i<segLength); i++){
_mm_store_si128(loadOpt+i,zero);
_mm_store_si128(storeOpt+i,zero);
_mm_store_si128(rD+i,zero);
}
/* looping through all the columns */
/***********************************/
for(j=0; LIKELY(j<dbLen); j++){
/* compute the opt and cd score depending on the previous column
*******************************************************************
* set the column deletion score to zero, has to be fixed later on */
vCD = zero;
/* set the opt score to the elements computed in the previous column*/
/* set the low of storeOpt to MaxS[j] */
vStoreOpt = _mm_load_si128(storeOpt+segLength-1);
vStoreOpt = _mm_slli_si128(vStoreOpt, 1);
/* compute the current profile, depending on the character in s2 */
/*****************************************************************/
current_profile = query->profile + db[j]*segLength;
/* swap the old optimal score with the new one */
/***********************************************/
swap = storeOpt;
storeOpt = loadOpt;
loadOpt = swap;
/* main loop computing the max, precomputing etc. */
/**************************************************/
for(i=0; LIKELY(i<segLength); i++){
vRD = _mm_load_si128(rD+i);
vRD = _mm_subs_epu8(vRD, vDelIncr);
vTmp = _mm_load_si128(loadOpt+i);
vTmp = _mm_subs_epu8(vTmp,vDelFixed);
vRD = _mm_max_epu8(vRD,vTmp);
_mm_store_si128(rD+i, vRD);
/* add the profile the prev. opt */
vStoreOpt = _mm_adds_epu8(vStoreOpt, *(current_profile+i));
vStoreOpt = _mm_subs_epu8(vStoreOpt, vBias);
/* update the maxscore found so far */
vMaxScore = _mm_max_epu8(vMaxScore, vStoreOpt);
/* compute the correct opt score of the cell */
vStoreOpt = _mm_max_epu8(vStoreOpt, vRD);
vStoreOpt = _mm_max_epu8(vStoreOpt, vCD);
/* store the opt score of the cell */
_mm_store_si128(storeOpt+i, vStoreOpt);
/* precompute cd for next iteration */
vStoreOpt = _mm_subs_epu8(vStoreOpt, vDelFixed);
vCD = _mm_subs_epu8(vCD, vDelIncr);
vCD = _mm_max_epu8(vCD, vStoreOpt);
/* load precomputed opt for next iteration */
vStoreOpt = _mm_load_si128(loadOpt+i);
}
for(i=0;LIKELY(i<16);++i){
int k;
/* compute the gap extend penalty for the current cell */
vCD = _mm_slli_si128(vCD,1);
for(k=0;LIKELY(k<segLength);++k) {
/* compute the current optimal value of the cell */
vStoreOpt = _mm_load_si128(storeOpt+k);
vStoreOpt = _mm_max_epu8(vStoreOpt,vCD);
_mm_store_si128(storeOpt+k,vStoreOpt);
/* precompute the scores for the next cell */
vStoreOpt = _mm_subs_epu8(vStoreOpt,vDelFixed);
vCD = _mm_subs_epu8(vCD, vDelIncr);
if(UNLIKELY(_mm_movemask_epi8(_mm_cmpeq_epi8(_mm_subs_epu8(vCD,vStoreOpt),zero)) == 0xFFFF)) goto shortcut;
}
}
shortcut:
#ifdef DEBUG
debug("%c\t",db[j]);
for(ii=0; ii<16;++ii) {
for(jj=0; jj<segLength;++jj) {
if(ii*segLength+jj < query->len)
debug("%d\t",(int)((unsigned char*)storeOpt)[ii+jj*16]);
}
}
debug("\n");
#endif
/* store the new MaxScore for the next line block */
/**************************************************/
/* store the element of storeOpt in MaxS */
vStoreOpt = _mm_load_si128(storeOpt+segLength-1);
}
vMaxScore = _mm_max_epu8(vMaxScore, _mm_srli_si128(vMaxScore, 8));
vMaxScore = _mm_max_epu8(vMaxScore, _mm_srli_si128(vMaxScore, 4));
vMaxScore = _mm_max_epu8(vMaxScore, _mm_srli_si128(vMaxScore, 2));
vMaxScore = _mm_max_epu8(vMaxScore, _mm_srli_si128(vMaxScore, 1));
MaxScore = (unsigned char)_mm_extract_epi16(vMaxScore,0);
if ((int)MaxScore + (int)query->bias >=255)
return DBL_MAX;
return((double)MaxScore);
}
void FileIconDrawGlass::Text(HDC hdc, PCTCHAR pcszText, const RECT &rc, eTextColor eColor, UINT uFlags)
{
if (!pcszText || !*pcszText) return;
// Find out actual size of text
int nChars = _tcslen(pcszText);
uFlags |= DT_NOCLIP;
int iX = rc.left;
int iY = rc.top;
int iXW = (rc.right - iX);
int iYH = (rc.bottom - iY);
RECT rcMin = rc;
if (DrawText(hdcTextDIB, pcszText, nChars, &rcMin, uFlags | DT_CALCRECT)) {
int iMinXW = rcMin.right - rcMin.left;
int iMinYH = rcMin.bottom - rcMin.top;
if (iMinXW < iXW) {
if (uFlags & DT_CENTER) {
iX += (iXW - iMinXW)/2;
uFlags &= ~DT_CENTER;
} else if (uFlags & DT_RIGHT) {
iX += (iXW - iMinXW);
uFlags &= ~DT_RIGHT;
}
iXW = iMinXW;
}
if (iMinYH < iYH) {
if (uFlags & DT_SINGLELINE) {
if (uFlags & DT_VCENTER) {
iY += (iYH - iMinYH)/2;
uFlags &= ~DT_VCENTER;
} else if (uFlags & DT_BOTTOM) {
iY += (iYH - iMinYH);
uFlags &= ~DT_BOTTOM;
}
}
iYH = iMinYH;
}
}
iXW += 2; // NB: +2 'cause we want an extra pixel at the border so that the font smoothing will look bette!
iYH += 2;
// Ensure we have a big enough DIB to draw the text to
if ((iXW > iTextDIBXW) || (iYH > iTextDIBYH)) CreateTextDIB(iXW, iYH);
if (!hbmpTextDIB) return;
// Select color
ieBGRA clr;
switch (eColor) {
case eFileName: clr = clrFileName; break;
case eComment: clr = clrComment; break;
case eFileInfo: clr = clrFileInfo; break;
default: clr = ieBGRA(0,0,0); break;
}
clr.A = 0xFF - clrBkg.A;
// Draw the text to in-memory DIB
RECT rcTextDIB = { 0, 0, iXW, iYH };
FillRect(hdcTextDIB, &rcTextDIB, hbrBkg);
rcTextDIB.left++;
rcTextDIB.top++;
DrawText(hdcTextDIB, pcszText, nChars, &rcTextDIB, uFlags);
// Modify DIB:
#ifndef __X64__
if (g_bSSE2)
#endif
{
__m128i r0, r1, r2, r3, r4, r5, r6, r7;
r7 = _mm_setzero_si128(); // 0
r6 = _mm_set1_epi32(clr.dw); // CA CR CG CB CA CR CG CB CA CR CG CB CA CR CG CB
r6 = _mm_unpacklo_epi8(r7, r6); // CA<<8 CR<<8 CG<<8 CB<<8 CA<<8 CR<<8 CG<<8 CB<<8
r5 = _mm_set1_epi16(1); // 1 1 1 1 1 1 1 1
r4 = _mm_set1_epi32(0xFF); // FF FF FF FF
r3 = _mm_set1_epi32(clrBkg.dw); // DA 0 0 0 DA 0 0 0 DA 0 0 0 DA 0 0 0
ieBGRA *py = pTextDIB;
for (int y = iYH; y--; py += iTextDIBXW) {
ieBGRA *px = py;
for (int x_4 = (iXW+3)>>2; x_4--; px += 4) {
r0 = _mm_load_si128((__m128i *)px);
r1 = r0;
r2 = r0; // X3 R3 G3 B3 X2 R2 G2 B2 X1 R1 G1 B1 X0 R0 G0 B0
r0 = _mm_srli_epi32(r0, 16); // 0 0 X3 R3 0 0 X2 R2 0 0 X1 R1 0 0 X0 R0
r1 = _mm_srli_epi32(r1, 8); // 0 X3 R3 G3 0 X2 R2 G2 0 X1 R1 G1 0 X0 R0 G0
r0 = _mm_max_epu8(r0, r2);
r0 = _mm_max_epu8(r0, r1); // x x x A3 x x x A2 x x x A1 x x x A0
r0 = _mm_and_si128(r0, r4); // 0 A3 0 A2 0 A1 0 A0
r0 = _mm_shufflelo_epi16(r0, _MM_SHUFFLE(2,2,0,0));
r0 = _mm_shufflehi_epi16(r0, _MM_SHUFFLE(2,2,0,0)); // A3 A3 A2 A2 A1 A1 A0 A0
r1 = r0;
r0 = _mm_unpacklo_epi32(r0, r0); // A1 A1 A1 A1 A0 A0 A0 A0
r1 = _mm_unpackhi_epi32(r1, r1); // A3 A3 A3 A3 A2 A2 A2 A2
r0 = _mm_add_epi16(r0, r5); // A1' A1' A1' A1' A0' A0' A0' A0'
r1 = _mm_add_epi16(r1, r5); // A3' A3' A3' A3' A2' A2' A2' A2'
r0 = _mm_mulhi_epu16(r0, r6); // xA1" xR1 xG1 xB1 xA0" xR0 xG0 xB0
r1 = _mm_mulhi_epu16(r1, r6); // xA3" xR3 xG3 xB3 xA2" xR2 xG2 xB2
r0 = _mm_packus_epi16(r0, r1); // xA3"xR3 xG3 xB3 xA2"xR2 xG2 xB2 xA1"xR1 xG1 xB1 xA0"xR0 xG0 xB0
r0 = _mm_adds_epu8(r0, r3); // xA3 xR3 xG3 xB3 xA2 xR2 xG2 xB2 xA1 xR1 xG1 xB1 xA0 xR0 xG0 xB0
_mm_store_si128((__m128i *)px, r0);
}
}
}
#ifndef __X64__
else {
/* Function: p7_SSVFilter_longtarget()
* Synopsis: Finds windows with SSV scores above some threshold (vewy vewy fast, in limited precision)
*
* Purpose: Calculates an approximation of the SSV (single ungapped diagonal)
* score for regions of sequence <dsq> of length <L> residues, using
* optimized profile <om>, and a preallocated one-row DP matrix <ox>,
* and captures the positions at which such regions exceed the score
* required to be significant in the eyes of the calling function,
* which depends on the <bg> and <p> (usually p=0.02 for nhmmer).
* Note that this variant performs only SSV computations, never
* passing through the J state - the score required to pass SSV at
* the default threshold (or less restrictive) is sufficient to
* pass MSV in essentially all DNA models we've tested.
*
* Above-threshold diagonals are captured into a preallocated list
* <windowlist>. Rather than simply capturing positions at which a
* score threshold is reached, this function establishes windows
* around those high-scoring positions, using scores in <msvdata>.
* These windows can be merged by the calling function.
*
*
* Args: dsq - digital target sequence, 1..L
* L - length of dsq in residues
* om - optimized profile
* ox - DP matrix
* msvdata - compact representation of substitution scores, for backtracking diagonals
* bg - the background model, required for translating a P-value threshold into a score threshold
* P - p-value below which a region is captured as being above threshold
* windowlist - preallocated container for all hits (resized if necessary)
*
*
* Note: We misuse the matrix <ox> here, using only a third of the
* first dp row, accessing it as <dp[0..Q-1]> rather than
* in triplets via <{MDI}MX(q)> macros, since we only need
* to store M state values. We know that if <ox> was big
* enough for normal DP calculations, it must be big enough
* to hold the MSVFilter calculation.
*
* Returns: <eslOK> on success.
*
* Throws: <eslEINVAL> if <ox> allocation is too small.
*/
int
p7_SSVFilter_longtarget(const ESL_DSQ *dsq, int L, P7_OPROFILE *om, P7_OMX *ox, const P7_SCOREDATA *msvdata,
P7_BG *bg, double P, P7_HMM_WINDOWLIST *windowlist)
{
register __m128i mpv; /* previous row values */
register __m128i xEv; /* E state: keeps max for Mk->E for a single iteration */
register __m128i xBv; /* B state: splatted vector of B[i-1] for B->Mk calculations */
register __m128i sv; /* temp storage of 1 curr row value in progress */
register __m128i biasv; /* emission bias in a vector */
uint8_t xJ; /* special states' scores */
int i; /* counter over sequence positions 1..L */
int q; /* counter over vectors 0..nq-1 */
int Q = p7O_NQB(om->M); /* segment length: # of vectors */
__m128i *dp = ox->dpb[0]; /* we're going to use dp[0][0..q..Q-1], not {MDI}MX(q) macros*/
__m128i *rsc; /* will point at om->rbv[x] for residue x[i] */
__m128i tecv; /* vector for E->C cost */
__m128i tjbmv; /* vector for J->B move cost + B->M move costs */
__m128i basev; /* offset for scores */
__m128i ceilingv; /* saturated simd value used to test for overflow */
__m128i tempv; /* work vector */
int cmp;
int k;
int n;
int end;
int rem_sc;
int start;
int target_end;
int target_start;
int max_end;
int max_sc;
int sc;
int pos_since_max;
float ret_sc;
union { __m128i v; uint8_t b[16]; } u;
/*
* Computing the score required to let P meet the F1 prob threshold
* In original code, converting from a scaled int MSV
* score S (the score getting to state E) to a probability goes like this:
* usc = S - om->tec_b - om->tjb_b - om->base_b;
* usc /= om->scale_b;
* usc -= 3.0;
* P = f ( (usc - nullsc) / eslCONST_LOG2 , mu, lambda)
* and we're computing the threshold usc, so reverse it:
* (usc - nullsc) / eslCONST_LOG2 = inv_f( P, mu, lambda)
* usc = nullsc + eslCONST_LOG2 * inv_f( P, mu, lambda)
* usc += 3
* usc *= om->scale_b
* S = usc + om->tec_b + om->tjb_b + om->base_b
*
* Here, I compute threshold with length model based on max_length. Doesn't
* matter much - in any case, both the bg and om models will change with roughly
* 1 bit for each doubling of the length model, so they offset.
*/
float nullsc;
__m128i sc_threshv;
uint8_t sc_thresh;
float invP = esl_gumbel_invsurv(P, om->evparam[p7_MMU], om->evparam[p7_MLAMBDA]);
/* Check that the DP matrix is ok for us. */
if (Q > ox->allocQ16) ESL_EXCEPTION(eslEINVAL, "DP matrix allocated too small");
ox->M = om->M;
p7_bg_SetLength(bg, om->max_length);
p7_oprofile_ReconfigMSVLength(om, om->max_length);
p7_bg_NullOne (bg, dsq, om->max_length, &nullsc);
sc_thresh = (int) ceil( ( ( nullsc + (invP * eslCONST_LOG2) + 3.0 ) * om->scale_b ) + om->base_b + om->tec_b + om->tjb_b );
sc_threshv = _mm_set1_epi8((int8_t) 255 - sc_thresh);
/* Initialization. In offset unsigned arithmetic, -infinity is 0, and 0 is om->base.
*/
biasv = _mm_set1_epi8((int8_t) om->bias_b); /* yes, you can set1() an unsigned char vector this way */
ceilingv = _mm_cmpeq_epi8(biasv, biasv);
for (q = 0; q < Q; q++) dp[q] = _mm_setzero_si128();
xJ = 0;
basev = _mm_set1_epi8((int8_t) om->base_b);
tecv = _mm_set1_epi8((int8_t) om->tec_b);
tjbmv = _mm_set1_epi8((int8_t) om->tjb_b + (int8_t) om->tbm_b);
xBv = _mm_subs_epu8(basev, tjbmv);
for (i = 1; i <= L; i++) {
rsc = om->rbv[dsq[i]];
xEv = _mm_setzero_si128();
/* Right shifts by 1 byte. 4,8,12,x becomes x,4,8,12.
* Because ia32 is littlendian, this means a left bit shift.
* Zeros shift on automatically, which is our -infinity.
*/
mpv = _mm_slli_si128(dp[Q-1], 1);
for (q = 0; q < Q; q++) {
/* Calculate new MMXo(i,q); don't store it yet, hold it in sv. */
sv = _mm_max_epu8(mpv, xBv);
sv = _mm_adds_epu8(sv, biasv);
sv = _mm_subs_epu8(sv, *rsc); rsc++;
xEv = _mm_max_epu8(xEv, sv);
mpv = dp[q]; /* Load {MDI}(i-1,q) into mpv */
dp[q] = sv; /* Do delayed store of M(i,q) now that memory is usable */
}
/* test if the pthresh significance threshold has been reached;
* note: don't use _mm_cmpgt_epi8, because it's a signed comparison, which won't work on uint8s */
tempv = _mm_adds_epu8(xEv, sc_threshv);
tempv = _mm_cmpeq_epi8(tempv, ceilingv);
cmp = _mm_movemask_epi8(tempv);
if (cmp != 0) { //hit pthresh, so add position to list and reset values
//figure out which model state hit threshold
end = -1;
rem_sc = -1;
for (q = 0; q < Q; q++) { /// Unpack and unstripe, so we can find the state that exceeded pthresh
u.v = dp[q];
for (k = 0; k < 16; k++) { // unstripe
//(q+Q*k+1) is the model position k at which the xE score is found
if (u.b[k] >= sc_thresh && u.b[k] > rem_sc && (q+Q*k+1) <= om->M) {
end = (q+Q*k+1);
rem_sc = u.b[k];
}
}
dp[q] = _mm_set1_epi8(0); // while we're here ... this will cause values to get reset to xB in next dp iteration
}
//recover the diagonal that hit threshold
start = end;
target_end = target_start = i;
sc = rem_sc;
while (rem_sc > om->base_b - om->tjb_b - om->tbm_b) {
rem_sc -= om->bias_b - msvdata->msv_scores[start*om->abc->Kp + dsq[target_start]];
--start;
--target_start;
}
start++;
target_start++;
//extend diagonal further with single diagonal extension
k = end+1;
n = target_end+1;
max_end = target_end;
max_sc = sc;
pos_since_max = 0;
while (k<om->M && n<=L) {
sc += om->bias_b - msvdata->msv_scores[k*om->abc->Kp + dsq[n]];
if (sc >= max_sc) {
max_sc = sc;
max_end = n;
pos_since_max=0;
} else {
pos_since_max++;
if (pos_since_max == 5)
break;
}
k++;
n++;
}
end += (max_end - target_end);
k += (max_end - target_end);
target_end = max_end;
ret_sc = ((float) (max_sc - om->tjb_b) - (float) om->base_b);
ret_sc /= om->scale_b;
ret_sc -= 3.0; // that's ~ L \log \frac{L}{L+3}, for our NN,CC,JJ
p7_hmmwindow_new(windowlist, 0, target_start, k, end, end-start+1 , ret_sc, p7_NOCOMPLEMENT );
i = target_end; // skip forward
}
} /* end loop over sequence residues 1..L */
return eslOK;
}
template <> SIMD_INLINE __m128i OperationBinary8u<SimdOperationBinary8uMaximum>(const __m128i & a, const __m128i & b)
{
return _mm_max_epu8(a, b);
}
/* Function: p7_MSVFilter()
* Synopsis: Calculates MSV score, vewy vewy fast, in limited precision.
* Incept: SRE, Wed Dec 26 15:12:25 2007 [Janelia]
*
* Purpose: Calculates an approximation of the MSV score for sequence
* <dsq> of length <L> residues, using optimized profile <om>,
* and a preallocated one-row DP matrix <ox>. Return the
* estimated MSV score (in nats) in <ret_sc>.
*
* Score may overflow (and will, on high-scoring
* sequences), but will not underflow.
*
* The model may be in any mode, because only its match
* emission scores will be used. The MSV filter inherently
* assumes a multihit local mode, and uses its own special
* state transition scores, not the scores in the profile.
*
* Args: dsq - digital target sequence, 1..L
* L - length of dsq in residues
* om - optimized profile
* ox - DP matrix
* ret_sc - RETURN: MSV score (in nats)
*
* Note: We misuse the matrix <ox> here, using only a third of the
* first dp row, accessing it as <dp[0..Q-1]> rather than
* in triplets via <{MDI}MX(q)> macros, since we only need
* to store M state values. We know that if <ox> was big
* enough for normal DP calculations, it must be big enough
* to hold the MSVFilter calculation.
*
* Returns: <eslOK> on success.
* <eslERANGE> if the score overflows the limited range; in
* this case, this is a high-scoring hit.
*
* Throws: <eslEINVAL> if <ox> allocation is too small.
*/
int
p7_MSVFilter(const ESL_DSQ *dsq, int L, const P7_OPROFILE *om, P7_OMX *ox, float *ret_sc)
{
register __m128i mpv; /* previous row values */
register __m128i xEv; /* E state: keeps max for Mk->E as we go */
register __m128i xBv; /* B state: splatted vector of B[i-1] for B->Mk calculations */
register __m128i sv; /* temp storage of 1 curr row value in progress */
register __m128i biasv; /* emission bias in a vector */
uint8_t xJ; /* special states' scores */
int i; /* counter over sequence positions 1..L */
int q; /* counter over vectors 0..nq-1 */
int Q = p7O_NQB(om->M); /* segment length: # of vectors */
__m128i *dp = ox->dpb[0]; /* we're going to use dp[0][0..q..Q-1], not {MDI}MX(q) macros*/
__m128i *rsc; /* will point at om->rbv[x] for residue x[i] */
__m128i xJv; /* vector for states score */
__m128i tjbmv; /* vector for cost of moving from either J or N through B to an M state */
__m128i tecv; /* vector for E->C cost */
__m128i basev; /* offset for scores */
__m128i ceilingv; /* saturateed simd value used to test for overflow */
__m128i tempv; /* work vector */
int cmp;
int status = eslOK;
/* Check that the DP matrix is ok for us. */
if (Q > ox->allocQ16) ESL_EXCEPTION(eslEINVAL, "DP matrix allocated too small");
ox->M = om->M;
/* Try highly optimized ssv filter first */
status = p7_SSVFilter(dsq, L, om, ret_sc);
if (status != eslENORESULT) return status;
/* Initialization. In offset unsigned arithmetic, -infinity is 0, and 0 is om->base.
*/
biasv = _mm_set1_epi8((int8_t) om->bias_b); /* yes, you can set1() an unsigned char vector this way */
for (q = 0; q < Q; q++) dp[q] = _mm_setzero_si128();
xJ = 0;
/* saturate simd register for overflow test */
ceilingv = _mm_cmpeq_epi8(biasv, biasv);
basev = _mm_set1_epi8((int8_t) om->base_b);
tjbmv = _mm_set1_epi8((int8_t) om->tjb_b + (int8_t) om->tbm_b);
tecv = _mm_set1_epi8((int8_t) om->tec_b);
xJv = _mm_subs_epu8(biasv, biasv);
xBv = _mm_subs_epu8(basev, tjbmv);
#if p7_DEBUGGING
if (ox->debugging)
{
uint8_t xB;
xB = _mm_extract_epi16(xBv, 0);
xJ = _mm_extract_epi16(xJv, 0);
p7_omx_DumpMFRow(ox, 0, 0, 0, xJ, xB, xJ);
}
#endif
for (i = 1; i <= L; i++)
{
rsc = om->rbv[dsq[i]];
xEv = _mm_setzero_si128();
/* Right shifts by 1 byte. 4,8,12,x becomes x,4,8,12.
* Because ia32 is littlendian, this means a left bit shift.
* Zeros shift on automatically, which is our -infinity.
*/
mpv = _mm_slli_si128(dp[Q-1], 1);
for (q = 0; q < Q; q++)
{
/* Calculate new MMXo(i,q); don't store it yet, hold it in sv. */
sv = _mm_max_epu8(mpv, xBv);
sv = _mm_adds_epu8(sv, biasv);
sv = _mm_subs_epu8(sv, *rsc); rsc++;
xEv = _mm_max_epu8(xEv, sv);
mpv = dp[q]; /* Load {MDI}(i-1,q) into mpv */
dp[q] = sv; /* Do delayed store of M(i,q) now that memory is usable */
}
/* test for the overflow condition */
tempv = _mm_adds_epu8(xEv, biasv);
tempv = _mm_cmpeq_epi8(tempv, ceilingv);
cmp = _mm_movemask_epi8(tempv);
/* Now the "special" states, which start from Mk->E (->C, ->J->B)
* Use shuffles instead of shifts so when the last max has completed,
* the last four elements of the simd register will contain the
* max value. Then the last shuffle will broadcast the max value
* to all simd elements.
*/
tempv = _mm_shuffle_epi32(xEv, _MM_SHUFFLE(2, 3, 0, 1));
xEv = _mm_max_epu8(xEv, tempv);
tempv = _mm_shuffle_epi32(xEv, _MM_SHUFFLE(0, 1, 2, 3));
xEv = _mm_max_epu8(xEv, tempv);
tempv = _mm_shufflelo_epi16(xEv, _MM_SHUFFLE(2, 3, 0, 1));
xEv = _mm_max_epu8(xEv, tempv);
tempv = _mm_srli_si128(xEv, 1);
xEv = _mm_max_epu8(xEv, tempv);
xEv = _mm_shuffle_epi32(xEv, _MM_SHUFFLE(0, 0, 0, 0));
/* immediately detect overflow */
if (cmp != 0x0000)
{
*ret_sc = eslINFINITY;
return eslERANGE;
}
xEv = _mm_subs_epu8(xEv, tecv);
xJv = _mm_max_epu8(xJv,xEv);
xBv = _mm_max_epu8(basev, xJv);
xBv = _mm_subs_epu8(xBv, tjbmv);
#if p7_DEBUGGING
if (ox->debugging)
{
uint8_t xB, xE;
xB = _mm_extract_epi16(xBv, 0);
xE = _mm_extract_epi16(xEv, 0);
xJ = _mm_extract_epi16(xJv, 0);
p7_omx_DumpMFRow(ox, i, xE, 0, xJ, xB, xJ);
}
#endif
} /* end loop over sequence residues 1..L */
xJ = (uint8_t) _mm_extract_epi16(xJv, 0);
/* finally C->T, and add our missing precision on the NN,CC,JJ back */
*ret_sc = ((float) (xJ - om->tjb_b) - (float) om->base_b);
*ret_sc /= om->scale_b;
*ret_sc -= 3.0; /* that's ~ L \log \frac{L}{L+3}, for our NN,CC,JJ */
return eslOK;
}
