static inline void mmx_end(uint8_t *src3, uint8_t *src5,
uint8_t *dst, int X)
{
punpcklbw_m2r (mm_cpool[0], mm4);
punpckhbw_m2r (mm_cpool[0], mm5);
psubusw_r2r (mm2, mm0);
psubusw_r2r (mm3, mm1);
movq_m2r (src5[X], mm2);
movq_m2r (src5[X], mm3);
punpcklbw_m2r (mm_cpool[0], mm2);
punpckhbw_m2r (mm_cpool[0], mm3);
psubusw_r2r (mm2, mm0);
psubusw_r2r (mm3, mm1);
psrlw_i2r (3, mm0);
psrlw_i2r (3, mm1);
psubw_r2r (mm6, mm4);
psubw_r2r (mm7, mm5);
packuswb_r2r (mm1,mm0);
movq_r2r (mm4, mm6);
movq_r2r (mm5, mm7);
pcmpgtw_m2r (mm_lthr, mm4);
pcmpgtw_m2r (mm_lthr, mm5);
pcmpgtw_m2r (mm_hthr, mm6);
pcmpgtw_m2r (mm_hthr, mm7);
packsswb_r2r (mm5, mm4);
packsswb_r2r (mm7, mm6);
pxor_r2r (mm6, mm4);
movq_r2r (mm4, mm5);
pandn_r2r (mm0, mm4);
pand_m2r (src3[X], mm5);
por_r2r (mm4, mm5);
movq_r2m (mm5, dst[X]);
}
void deinterlace_bob_yuv_mmx(uint8_t *pdst, uint8_t *psrc,
int width, int height )
{
int Line;
long long* YVal1;
long long* YVal2;
long long* YVal3;
long long* Dest;
uint8_t* pEvenLines = psrc;
uint8_t* pOddLines = psrc+width;
int LineLength = width;
int Pitch = width * 2;
int IsOdd = 1;
long EdgeDetect = 625;
long JaggieThreshold = 73;
int n;
unsigned long long qwEdgeDetect;
unsigned long long qwThreshold;
const unsigned long long Mask = 0xfefefefefefefefeULL;
const unsigned long long YMask = 0x00ff00ff00ff00ffULL;
qwEdgeDetect = EdgeDetect;
qwEdgeDetect += (qwEdgeDetect << 48) + (qwEdgeDetect << 32) + (qwEdgeDetect << 16);
qwThreshold = JaggieThreshold;
qwThreshold += (qwThreshold << 48) + (qwThreshold << 32) + (qwThreshold << 16);
// copy first even line no matter what, and the first odd line if we're
// processing an odd field.
ac_memcpy(pdst, pEvenLines, LineLength);
if (IsOdd)
ac_memcpy(pdst + LineLength, pOddLines, LineLength);
height = height / 2;
for (Line = 0; Line < height - 1; ++Line)
{
if (IsOdd)
{
YVal1 = (long long *)(pOddLines + Line * Pitch);
YVal2 = (long long *)(pEvenLines + (Line + 1) * Pitch);
YVal3 = (long long *)(pOddLines + (Line + 1) * Pitch);
Dest = (long long *)(pdst + (Line * 2 + 2) * LineLength);
}
else
{
YVal1 = (long long *)(pEvenLines + Line * Pitch);
YVal2 = (long long *)(pOddLines + Line * Pitch);
YVal3 = (long long *)(pEvenLines + (Line + 1) * Pitch);
Dest = (long long *)(pdst + (Line * 2 + 1) * LineLength);
}
// For ease of reading, the comments below assume that we're operating on an odd
// field (i.e., that bIsOdd is true). The exact same processing is done when we
// operate on an even field, but the roles of the odd and even fields are reversed.
// It's just too cumbersome to explain the algorithm in terms of "the next odd
// line if we're doing an odd field, or the next even line if we're doing an
// even field" etc. So wherever you see "odd" or "even" below, keep in mind that
// half the time this function is called, those words' meanings will invert.
// Copy the odd line to the overlay verbatim.
ac_memcpy((char *)Dest + LineLength, YVal3, LineLength);
n = LineLength >> 3;
while( n-- )
{
movq_m2r (*YVal1++, mm0);
movq_m2r (*YVal2++, mm1);
movq_m2r (*YVal3++, mm2);
// get intensities in mm3 - 4
movq_r2r ( mm0, mm3 );
movq_r2r ( mm1, mm4 );
movq_r2r ( mm2, mm5 );
pand_m2r ( *&YMask, mm3 );
pand_m2r ( *&YMask, mm4 );
pand_m2r ( *&YMask, mm5 );
// get average in mm0
pand_m2r ( *&Mask, mm0 );
pand_m2r ( *&Mask, mm2 );
psrlw_i2r ( 01, mm0 );
psrlw_i2r ( 01, mm2 );
paddw_r2r ( mm2, mm0 );
// work out (O1 - E) * (O2 - E) / 2 - EdgeDetect * (O1 - O2) ^ 2 >> 12
// result will be in mm6
psrlw_i2r ( 01, mm3 );
psrlw_i2r ( 01, mm4 );
psrlw_i2r ( 01, mm5 );
movq_r2r ( mm3, mm6 );
psubw_r2r ( mm4, mm6 ); //mm6 = O1 - E
movq_r2r ( mm5, mm7 );
psubw_r2r ( mm4, mm7 ); //mm7 = O2 - E
pmullw_r2r ( mm7, mm6 ); // mm6 = (O1 - E) * (O2 - E)
movq_r2r ( mm3, mm7 );
psubw_r2r ( mm5, mm7 ); // mm7 = (O1 - O2)
pmullw_r2r ( mm7, mm7 ); // mm7 = (O1 - O2) ^ 2
psrlw_i2r ( 12, mm7 ); // mm7 = (O1 - O2) ^ 2 >> 12
pmullw_m2r ( *&qwEdgeDetect, mm7 );// mm7 = EdgeDetect * (O1 - O2) ^ 2 >> 12
psubw_r2r ( mm7, mm6 ); // mm6 is what we want
pcmpgtw_m2r ( *&qwThreshold, mm6 );
movq_r2r ( mm6, mm7 );
pand_r2r ( mm6, mm0 );
pandn_r2r ( mm1, mm7 );
por_r2r ( mm0, mm7 );
movq_r2m ( mm7, *Dest++ );
}
}
// Copy last odd line if we're processing an even field.
if (! IsOdd)
{
ac_memcpy(pdst + (height * 2 - 1) * LineLength,
pOddLines + (height - 1) * Pitch,
LineLength);
}
// clear out the MMX registers ready for doing floating point
// again
emms();
}