1509 lines
31 KiB
C++
1509 lines
31 KiB
C++
// VirtualDub - Video processing and capture application
|
|
// Copyright (C) 1998-2001 Avery Lee
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//
|
|
// Notes:
|
|
// - BitBltFromI420ToRGB is from VirtualDub
|
|
// - The core assembly function of CCpuID is from DVD2AVI
|
|
// - sse2 yv12 to yuy2 conversion by Haali
|
|
// (- vd.cpp/h should be renamed to something more sensible already :)
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "vd.h"
|
|
|
|
#pragma warning(disable : 4799) // no emms... blahblahblah
|
|
|
|
CCpuID::CCpuID()
|
|
{
|
|
DWORD flags = 0;
|
|
|
|
__asm
|
|
{
|
|
mov eax, 1
|
|
cpuid
|
|
test edx, 0x00800000 // STD MMX
|
|
jz TEST_SSE
|
|
or [flags], 1
|
|
TEST_SSE:
|
|
test edx, 0x02000000 // STD SSE
|
|
jz TEST_SSE2
|
|
or [flags], 2
|
|
or [flags], 4
|
|
TEST_SSE2:
|
|
test edx, 0x04000000 // SSE2
|
|
jz TEST_3DNOW
|
|
or [flags], 8
|
|
TEST_3DNOW:
|
|
mov eax, 0x80000001
|
|
cpuid
|
|
test edx, 0x80000000 // 3D NOW
|
|
jz TEST_SSEMMX
|
|
or [flags], 16
|
|
TEST_SSEMMX:
|
|
test edx, 0x00400000 // SSE MMX
|
|
jz TEST_END
|
|
or [flags], 2
|
|
TEST_END:
|
|
}
|
|
|
|
m_flags = (flag_t)flags;
|
|
}
|
|
|
|
CCpuID g_cpuid;
|
|
|
|
void memcpy_accel(void* dst, const void* src, size_t len)
|
|
{
|
|
if((g_cpuid.m_flags & CCpuID::flag_t::ssefpu) && len >= 128
|
|
&& !((DWORD)src&15) && !((DWORD)dst&15))
|
|
{
|
|
__asm
|
|
{
|
|
mov esi, dword ptr [src]
|
|
mov edi, dword ptr [dst]
|
|
mov ecx, len
|
|
shr ecx, 7
|
|
memcpy_accel_sse_loop:
|
|
prefetchnta [esi+16*8]
|
|
movaps xmm0, [esi]
|
|
movaps xmm1, [esi+16*1]
|
|
movaps xmm2, [esi+16*2]
|
|
movaps xmm3, [esi+16*3]
|
|
movaps xmm4, [esi+16*4]
|
|
movaps xmm5, [esi+16*5]
|
|
movaps xmm6, [esi+16*6]
|
|
movaps xmm7, [esi+16*7]
|
|
movntps [edi], xmm0
|
|
movntps [edi+16*1], xmm1
|
|
movntps [edi+16*2], xmm2
|
|
movntps [edi+16*3], xmm3
|
|
movntps [edi+16*4], xmm4
|
|
movntps [edi+16*5], xmm5
|
|
movntps [edi+16*6], xmm6
|
|
movntps [edi+16*7], xmm7
|
|
add esi, 128
|
|
add edi, 128
|
|
dec ecx
|
|
jne memcpy_accel_sse_loop
|
|
mov ecx, len
|
|
and ecx, 127
|
|
cmp ecx, 0
|
|
je memcpy_accel_sse_end
|
|
memcpy_accel_sse_loop2:
|
|
mov dl, byte ptr[esi]
|
|
mov byte ptr[edi], dl
|
|
inc esi
|
|
inc edi
|
|
dec ecx
|
|
jne memcpy_accel_sse_loop2
|
|
memcpy_accel_sse_end:
|
|
emms
|
|
sfence
|
|
}
|
|
}
|
|
else if((g_cpuid.m_flags & CCpuID::flag_t::mmx) && len >= 64
|
|
&& !((DWORD)src&7) && !((DWORD)dst&7))
|
|
{
|
|
__asm
|
|
{
|
|
mov esi, dword ptr [src]
|
|
mov edi, dword ptr [dst]
|
|
mov ecx, len
|
|
shr ecx, 6
|
|
memcpy_accel_mmx_loop:
|
|
movq mm0, qword ptr [esi]
|
|
movq mm1, qword ptr [esi+8*1]
|
|
movq mm2, qword ptr [esi+8*2]
|
|
movq mm3, qword ptr [esi+8*3]
|
|
movq mm4, qword ptr [esi+8*4]
|
|
movq mm5, qword ptr [esi+8*5]
|
|
movq mm6, qword ptr [esi+8*6]
|
|
movq mm7, qword ptr [esi+8*7]
|
|
movq qword ptr [edi], mm0
|
|
movq qword ptr [edi+8*1], mm1
|
|
movq qword ptr [edi+8*2], mm2
|
|
movq qword ptr [edi+8*3], mm3
|
|
movq qword ptr [edi+8*4], mm4
|
|
movq qword ptr [edi+8*5], mm5
|
|
movq qword ptr [edi+8*6], mm6
|
|
movq qword ptr [edi+8*7], mm7
|
|
add esi, 64
|
|
add edi, 64
|
|
loop memcpy_accel_mmx_loop
|
|
mov ecx, len
|
|
and ecx, 63
|
|
cmp ecx, 0
|
|
je memcpy_accel_mmx_end
|
|
memcpy_accel_mmx_loop2:
|
|
mov dl, byte ptr [esi]
|
|
mov byte ptr [edi], dl
|
|
inc esi
|
|
inc edi
|
|
dec ecx
|
|
jne memcpy_accel_mmx_loop2
|
|
memcpy_accel_mmx_end:
|
|
emms
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy(dst, src, len);
|
|
}
|
|
}
|
|
|
|
bool BitBltFromI420ToI420(int w, int h, BYTE* dsty, BYTE* dstu, BYTE* dstv, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)
|
|
{
|
|
if((w&1)) return(false);
|
|
|
|
if(w > 0 && w == srcpitch && w == dstpitch)
|
|
{
|
|
memcpy_accel(dsty, srcy, h*srcpitch);
|
|
memcpy_accel(dstu, srcu, h/2*srcpitch/2);
|
|
memcpy_accel(dstv, srcv, h/2*srcpitch/2);
|
|
}
|
|
else
|
|
{
|
|
int pitch = min(abs(srcpitch), abs(dstpitch));
|
|
|
|
for(int y = 0; y < h; y++, srcy += srcpitch, dsty += dstpitch)
|
|
memcpy_accel(dsty, srcy, pitch);
|
|
|
|
srcpitch >>= 1;
|
|
dstpitch >>= 1;
|
|
|
|
pitch = min(abs(srcpitch), abs(dstpitch));
|
|
|
|
for(int y = 0; y < h; y+=2, srcu += srcpitch, dstu += dstpitch)
|
|
memcpy_accel(dstu, srcu, pitch);
|
|
|
|
for(int y = 0; y < h; y+=2, srcv += srcpitch, dstv += dstpitch)
|
|
memcpy_accel(dstv, srcv, pitch);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BitBltFromYUY2ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* src, int srcpitch)
|
|
{
|
|
if(w > 0 && w == srcpitch && w == dstpitch)
|
|
{
|
|
memcpy_accel(dst, src, h*srcpitch);
|
|
}
|
|
else
|
|
{
|
|
int pitch = min(abs(srcpitch), abs(dstpitch));
|
|
|
|
for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
|
|
memcpy_accel(dst, src, pitch);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
extern "C" void asm_YUVtoRGB32_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB24_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB16_row(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB32_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB24_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB16_row_MMX(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB32_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB24_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
extern "C" void asm_YUVtoRGB16_row_ISSE(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width);
|
|
|
|
bool BitBltFromI420ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch)
|
|
{
|
|
if(w<=0 || h<=0 || (w&1) || (h&1))
|
|
return(false);
|
|
|
|
void (*asm_YUVtoRGB_row)(void* ARGB1, void* ARGB2, BYTE* Y1, BYTE* Y2, BYTE* U, BYTE* V, long width) = NULL;;
|
|
|
|
if((g_cpuid.m_flags & CCpuID::ssefpu) && !(w&7))
|
|
{
|
|
switch(dbpp)
|
|
{
|
|
case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row/*_ISSE*/; break; // TODO: fix _ISSE (555->565)
|
|
case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row_ISSE; break;
|
|
case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row_ISSE; break;
|
|
}
|
|
}
|
|
else if((g_cpuid.m_flags & CCpuID::mmx) && !(w&7))
|
|
{
|
|
switch(dbpp)
|
|
{
|
|
case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row/*_MMX*/; break; // TODO: fix _MMX (555->565)
|
|
case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row_MMX; break;
|
|
case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row_MMX; break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(dbpp)
|
|
{
|
|
case 16: asm_YUVtoRGB_row = asm_YUVtoRGB16_row; break;
|
|
case 24: asm_YUVtoRGB_row = asm_YUVtoRGB24_row; break;
|
|
case 32: asm_YUVtoRGB_row = asm_YUVtoRGB32_row; break;
|
|
}
|
|
}
|
|
|
|
if(!asm_YUVtoRGB_row)
|
|
return(false);
|
|
|
|
do
|
|
{
|
|
asm_YUVtoRGB_row(dst + dstpitch, dst, srcy + srcpitch, srcy, srcu, srcv, w/2);
|
|
|
|
dst += 2*dstpitch;
|
|
srcy += srcpitch*2;
|
|
srcu += srcpitch/2;
|
|
srcv += srcpitch/2;
|
|
}
|
|
while(h -= 2);
|
|
|
|
if(g_cpuid.m_flags & CCpuID::mmx)
|
|
__asm emms
|
|
|
|
if(g_cpuid.m_flags & CCpuID::ssefpu)
|
|
__asm sfence
|
|
|
|
return true;
|
|
}
|
|
|
|
static void yuvtoyuy2row_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)
|
|
{
|
|
WORD* dstw = (WORD*)dst;
|
|
for(; width > 1; width -= 2)
|
|
{
|
|
*dstw++ = (*srcu++<<8)|*srcy++;
|
|
*dstw++ = (*srcv++<<8)|*srcy++;
|
|
}
|
|
}
|
|
|
|
static void __declspec(naked) yuvtoyuy2row_MMX(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width)
|
|
{
|
|
__asm {
|
|
push ebp
|
|
push edi
|
|
push esi
|
|
push ebx
|
|
|
|
mov edi, [esp+20] // dst
|
|
mov ebp, [esp+24] // srcy
|
|
mov ebx, [esp+28] // srcu
|
|
mov esi, [esp+32] // srcv
|
|
mov ecx, [esp+36] // width
|
|
|
|
shr ecx, 3
|
|
|
|
yuvtoyuy2row_loop:
|
|
|
|
movd mm0, [ebx]
|
|
punpcklbw mm0, [esi]
|
|
|
|
movq mm1, [ebp]
|
|
movq mm2, mm1
|
|
punpcklbw mm1, mm0
|
|
punpckhbw mm2, mm0
|
|
|
|
movq [edi], mm1
|
|
movq [edi+8], mm2
|
|
|
|
add ebp, 8
|
|
add ebx, 4
|
|
add esi, 4
|
|
add edi, 16
|
|
|
|
dec ecx
|
|
jnz yuvtoyuy2row_loop
|
|
|
|
pop ebx
|
|
pop esi
|
|
pop edi
|
|
pop ebp
|
|
ret
|
|
};
|
|
}
|
|
|
|
static void yuvtoyuy2row_avg_c(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)
|
|
{
|
|
WORD* dstw = (WORD*)dst;
|
|
for(; width > 1; width -= 2, srcu++, srcv++)
|
|
{
|
|
*dstw++ = (((srcu[0]+srcu[pitchuv])>>1)<<8)|*srcy++;
|
|
*dstw++ = (((srcv[0]+srcv[pitchuv])>>1)<<8)|*srcy++;
|
|
}
|
|
}
|
|
|
|
static void __declspec(naked) yuvtoyuy2row_avg_MMX(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv)
|
|
{
|
|
static const __int64 mask = 0x7f7f7f7f7f7f7f7fi64;
|
|
|
|
__asm {
|
|
push ebp
|
|
push edi
|
|
push esi
|
|
push ebx
|
|
|
|
movq mm7, mask
|
|
|
|
mov edi, [esp+20] // dst
|
|
mov ebp, [esp+24] // srcy
|
|
mov ebx, [esp+28] // srcu
|
|
mov esi, [esp+32] // srcv
|
|
mov ecx, [esp+36] // width
|
|
mov eax, [esp+40] // pitchuv
|
|
|
|
shr ecx, 3
|
|
|
|
yuvtoyuy2row_avg_loop:
|
|
|
|
movd mm0, [ebx]
|
|
punpcklbw mm0, [esi]
|
|
movq mm1, mm0
|
|
|
|
movd mm2, [ebx + eax]
|
|
punpcklbw mm2, [esi + eax]
|
|
movq mm3, mm2
|
|
|
|
// (x+y)>>1 == (x&y)+((x^y)>>1)
|
|
|
|
pand mm0, mm2
|
|
pxor mm1, mm3
|
|
psrlq mm1, 1
|
|
pand mm1, mm7
|
|
paddb mm0, mm1
|
|
|
|
movq mm1, [ebp]
|
|
movq mm2, mm1
|
|
punpcklbw mm1, mm0
|
|
punpckhbw mm2, mm0
|
|
|
|
movq [edi], mm1
|
|
movq [edi+8], mm2
|
|
|
|
add ebp, 8
|
|
add ebx, 4
|
|
add esi, 4
|
|
add edi, 16
|
|
|
|
dec ecx
|
|
jnz yuvtoyuy2row_avg_loop
|
|
|
|
pop ebx
|
|
pop esi
|
|
pop edi
|
|
pop ebp
|
|
ret
|
|
};
|
|
}
|
|
|
|
static void __declspec(naked) yv12_yuy2_row_sse2() {
|
|
__asm {
|
|
// ebx - Y
|
|
// edx - U
|
|
// esi - V
|
|
// edi - dest
|
|
// ecx - halfwidth
|
|
xor eax, eax
|
|
|
|
one:
|
|
movdqa xmm0, [ebx + eax*2] // YYYYYYYY
|
|
movdqa xmm1, [ebx + eax*2 + 16] // YYYYYYYY
|
|
|
|
movdqa xmm2, [edx + eax] // UUUUUUUU
|
|
movdqa xmm3, [esi + eax] // VVVVVVVV
|
|
|
|
movdqa xmm4, xmm2
|
|
movdqa xmm5, xmm0
|
|
movdqa xmm6, xmm1
|
|
punpcklbw xmm2, xmm3 // VUVUVUVU
|
|
punpckhbw xmm4, xmm3 // VUVUVUVU
|
|
|
|
punpcklbw xmm0, xmm2 // VYUYVYUY
|
|
punpcklbw xmm1, xmm4
|
|
punpckhbw xmm5, xmm2
|
|
punpckhbw xmm6, xmm4
|
|
|
|
movntdq [edi + eax*4], xmm0
|
|
movntdq [edi + eax*4 + 16], xmm5
|
|
movntdq [edi + eax*4 + 32], xmm1
|
|
movntdq [edi + eax*4 + 48], xmm6
|
|
|
|
add eax, 16
|
|
cmp eax, ecx
|
|
|
|
jb one
|
|
|
|
ret
|
|
};
|
|
}
|
|
|
|
static void __declspec(naked) yv12_yuy2_row_sse2_linear() {
|
|
__asm {
|
|
// ebx - Y
|
|
// edx - U
|
|
// esi - V
|
|
// edi - dest
|
|
// ecx - width
|
|
// ebp - uv_stride
|
|
xor eax, eax
|
|
|
|
one:
|
|
movdqa xmm0, [ebx + eax*2] // YYYYYYYY
|
|
movdqa xmm1, [ebx + eax*2 + 16] // YYYYYYYY
|
|
|
|
movdqa xmm2, [edx]
|
|
movdqa xmm3, [esi]
|
|
pavgb xmm2, [edx + ebp] // UUUUUUUU
|
|
pavgb xmm3, [esi + ebp] // VVVVVVVV
|
|
|
|
movdqa xmm4, xmm2
|
|
movdqa xmm5, xmm0
|
|
movdqa xmm6, xmm1
|
|
punpcklbw xmm2, xmm3 // VUVUVUVU
|
|
punpckhbw xmm4, xmm3 // VUVUVUVU
|
|
|
|
punpcklbw xmm0, xmm2 // VYUYVYUY
|
|
punpcklbw xmm1, xmm4
|
|
punpckhbw xmm5, xmm2
|
|
punpckhbw xmm6, xmm4
|
|
|
|
movntdq [edi + eax*4], xmm0
|
|
movntdq [edi + eax*4 + 16], xmm5
|
|
movntdq [edi + eax*4 + 32], xmm1
|
|
movntdq [edi + eax*4 + 48], xmm6
|
|
|
|
add eax, 16
|
|
add edx, 16
|
|
add esi, 16
|
|
cmp eax, ecx
|
|
|
|
jb one
|
|
|
|
ret
|
|
};
|
|
}
|
|
|
|
static void __declspec(naked) yv12_yuy2_row_sse2_linear_interlaced() {
|
|
__asm {
|
|
// ebx - Y
|
|
// edx - U
|
|
// esi - V
|
|
// edi - dest
|
|
// ecx - width
|
|
// ebp - uv_stride
|
|
xor eax, eax
|
|
|
|
one:
|
|
movdqa xmm0, [ebx + eax*2] // YYYYYYYY
|
|
movdqa xmm1, [ebx + eax*2 + 16] // YYYYYYYY
|
|
|
|
movdqa xmm2, [edx]
|
|
movdqa xmm3, [esi]
|
|
pavgb xmm2, [edx + ebp*2] // UUUUUUUU
|
|
pavgb xmm3, [esi + ebp*2] // VVVVVVVV
|
|
|
|
movdqa xmm4, xmm2
|
|
movdqa xmm5, xmm0
|
|
movdqa xmm6, xmm1
|
|
punpcklbw xmm2, xmm3 // VUVUVUVU
|
|
punpckhbw xmm4, xmm3 // VUVUVUVU
|
|
|
|
punpcklbw xmm0, xmm2 // VYUYVYUY
|
|
punpcklbw xmm1, xmm4
|
|
punpckhbw xmm5, xmm2
|
|
punpckhbw xmm6, xmm4
|
|
|
|
movntdq [edi + eax*4], xmm0
|
|
movntdq [edi + eax*4 + 16], xmm5
|
|
movntdq [edi + eax*4 + 32], xmm1
|
|
movntdq [edi + eax*4 + 48], xmm6
|
|
|
|
add eax, 16
|
|
add edx, 16
|
|
add esi, 16
|
|
cmp eax, ecx
|
|
|
|
jb one
|
|
|
|
ret
|
|
};
|
|
}
|
|
|
|
void __declspec(naked) yv12_yuy2_sse2(const BYTE *Y, const BYTE *U, const BYTE *V,
|
|
int halfstride, unsigned halfwidth, unsigned height,
|
|
BYTE *YUY2, int d_stride)
|
|
{
|
|
__asm {
|
|
push ebx
|
|
push esi
|
|
push edi
|
|
push ebp
|
|
|
|
mov ebx, [esp + 20] // Y
|
|
mov edx, [esp + 24] // U
|
|
mov esi, [esp + 28] // V
|
|
mov edi, [esp + 44] // D
|
|
mov ebp, [esp + 32] // uv_stride
|
|
mov ecx, [esp + 36] // uv_width
|
|
|
|
mov eax, ecx
|
|
add eax, 15
|
|
and eax, 0xfffffff0
|
|
sub [esp + 32], eax
|
|
|
|
cmp dword ptr [esp + 40], 2
|
|
jbe last2
|
|
|
|
row:
|
|
sub dword ptr [esp + 40], 2
|
|
call yv12_yuy2_row_sse2
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
call yv12_yuy2_row_sse2_linear
|
|
|
|
add edx, [esp + 32]
|
|
add esi, [esp + 32]
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
cmp dword ptr [esp + 40], 2
|
|
ja row
|
|
|
|
last2:
|
|
call yv12_yuy2_row_sse2
|
|
|
|
dec dword ptr [esp + 40]
|
|
jz done
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
call yv12_yuy2_row_sse2
|
|
done:
|
|
|
|
pop ebp
|
|
pop edi
|
|
pop esi
|
|
pop ebx
|
|
|
|
ret
|
|
};
|
|
}
|
|
|
|
void __declspec(naked) yv12_yuy2_sse2_interlaced(const BYTE *Y, const BYTE *U, const BYTE *V,
|
|
int halfstride, unsigned halfwidth, unsigned height,
|
|
BYTE *YUY2, int d_stride)
|
|
{
|
|
__asm {
|
|
push ebx
|
|
push esi
|
|
push edi
|
|
push ebp
|
|
|
|
mov ebx, [esp + 20] // Y
|
|
mov edx, [esp + 24] // U
|
|
mov esi, [esp + 28] // V
|
|
mov edi, [esp + 44] // D
|
|
mov ebp, [esp + 32] // uv_stride
|
|
mov ecx, [esp + 36] // uv_width
|
|
|
|
mov eax, ecx
|
|
add eax, 15
|
|
and eax, 0xfffffff0
|
|
sub [esp + 32], eax
|
|
|
|
cmp dword ptr [esp + 40], 4
|
|
jbe last4
|
|
|
|
row:
|
|
sub dword ptr [esp + 40], 4
|
|
call yv12_yuy2_row_sse2 // first row, first field
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
add edx, ebp
|
|
add esi, ebp
|
|
|
|
call yv12_yuy2_row_sse2 // first row, second field
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
sub edx, ebp
|
|
sub esi, ebp
|
|
|
|
call yv12_yuy2_row_sse2_linear_interlaced // second row, first field
|
|
|
|
add edx, [esp + 32]
|
|
add esi, [esp + 32]
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
call yv12_yuy2_row_sse2_linear_interlaced // second row, second field
|
|
|
|
add edx, [esp + 32]
|
|
add esi, [esp + 32]
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
cmp dword ptr [esp + 40], 4
|
|
ja row
|
|
|
|
last4:
|
|
call yv12_yuy2_row_sse2
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
add edx, ebp
|
|
add esi, ebp
|
|
|
|
call yv12_yuy2_row_sse2
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
sub edx, ebp
|
|
sub esi, ebp
|
|
|
|
call yv12_yuy2_row_sse2
|
|
|
|
lea ebx, [ebx + ebp*2]
|
|
add edi, [esp + 48]
|
|
|
|
add edx, ebp
|
|
add esi, ebp
|
|
|
|
call yv12_yuy2_row_sse2
|
|
|
|
pop ebp
|
|
pop edi
|
|
pop esi
|
|
pop ebx
|
|
|
|
ret
|
|
};
|
|
}
|
|
|
|
bool BitBltFromI420ToYUY2(int w, int h, BYTE* dst, int dstpitch, BYTE* srcy, BYTE* srcu, BYTE* srcv, int srcpitch, bool fInterlaced)
|
|
{
|
|
if(w<=0 || h<=0 || (w&1) || (h&1))
|
|
return(false);
|
|
|
|
if(srcpitch == 0) srcpitch = w;
|
|
|
|
if((g_cpuid.m_flags & CCpuID::sse2)
|
|
&& ((DWORD_PTR)srcy&15) && ((DWORD_PTR)srcu&15) && ((DWORD_PTR)srcv&15) && !(srcpitch&15)
|
|
&& ((DWORD_PTR)dst&15) && !(dstpitch&15))
|
|
{
|
|
if(!fInterlaced) yv12_yuy2_sse2(srcy, srcu, srcv, srcpitch/2, w/2, h, dst, dstpitch);
|
|
else yv12_yuy2_sse2_interlaced(srcy, srcu, srcv, srcpitch/2, w/2, h, dst, dstpitch);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(!fInterlaced);
|
|
}
|
|
|
|
void (*yuvtoyuy2row)(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width) = NULL;
|
|
void (*yuvtoyuy2row_avg)(BYTE* dst, BYTE* srcy, BYTE* srcu, BYTE* srcv, DWORD width, DWORD pitchuv) = NULL;
|
|
|
|
if((g_cpuid.m_flags & CCpuID::mmx) && !(w&7))
|
|
{
|
|
yuvtoyuy2row = yuvtoyuy2row_MMX;
|
|
yuvtoyuy2row_avg = yuvtoyuy2row_avg_MMX;
|
|
}
|
|
else
|
|
{
|
|
yuvtoyuy2row = yuvtoyuy2row_c;
|
|
yuvtoyuy2row_avg = yuvtoyuy2row_avg_c;
|
|
}
|
|
|
|
if(!yuvtoyuy2row)
|
|
return(false);
|
|
|
|
do
|
|
{
|
|
yuvtoyuy2row(dst, srcy, srcu, srcv, w);
|
|
yuvtoyuy2row_avg(dst + dstpitch, srcy + srcpitch, srcu, srcv, w, srcpitch/2);
|
|
|
|
dst += 2*dstpitch;
|
|
srcy += srcpitch*2;
|
|
srcu += srcpitch/2;
|
|
srcv += srcpitch/2;
|
|
}
|
|
while((h -= 2) > 2);
|
|
|
|
yuvtoyuy2row(dst, srcy, srcu, srcv, w);
|
|
yuvtoyuy2row(dst + dstpitch, srcy + srcpitch, srcu, srcv, w);
|
|
|
|
if(g_cpuid.m_flags & CCpuID::mmx)
|
|
__asm emms
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool BitBltFromRGBToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch, int sbpp)
|
|
{
|
|
if(dbpp == sbpp)
|
|
{
|
|
int rowbytes = w*dbpp>>3;
|
|
|
|
if(rowbytes > 0 && rowbytes == srcpitch && rowbytes == dstpitch)
|
|
{
|
|
memcpy_accel(dst, src, h*rowbytes);
|
|
}
|
|
else
|
|
{
|
|
for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
|
|
memcpy_accel(dst, src, rowbytes);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
if(sbpp != 16 && sbpp != 24 && sbpp != 32
|
|
|| dbpp != 16 && dbpp != 24 && dbpp != 32)
|
|
return(false);
|
|
|
|
if(dbpp == 16)
|
|
{
|
|
for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
|
|
{
|
|
if(sbpp == 24)
|
|
{
|
|
BYTE* s = (BYTE*)src;
|
|
WORD* d = (WORD*)dst;
|
|
for(int x = 0; x < w; x++, s+=3, d++)
|
|
*d = (WORD)(((*((DWORD*)s)>>8)&0xf800)|((*((DWORD*)s)>>5)&0x07e0)|((*((DWORD*)s)>>3)&0x1f));
|
|
}
|
|
else if(sbpp == 32)
|
|
{
|
|
DWORD* s = (DWORD*)src;
|
|
WORD* d = (WORD*)dst;
|
|
for(int x = 0; x < w; x++, s++, d++)
|
|
*d = (WORD)(((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x1f));
|
|
}
|
|
}
|
|
}
|
|
else if(dbpp == 24)
|
|
{
|
|
for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
|
|
{
|
|
if(sbpp == 16)
|
|
{
|
|
WORD* s = (WORD*)src;
|
|
BYTE* d = (BYTE*)dst;
|
|
for(int x = 0; x < w; x++, s++, d+=3)
|
|
{ // not tested, r-g-b might be in reverse
|
|
d[0] = (*s&0x001f)<<3;
|
|
d[1] = (*s&0x07e0)<<5;
|
|
d[2] = (*s&0xf800)<<8;
|
|
}
|
|
}
|
|
else if(sbpp == 32)
|
|
{
|
|
BYTE* s = (BYTE*)src;
|
|
BYTE* d = (BYTE*)dst;
|
|
for(int x = 0; x < w; x++, s+=4, d+=3)
|
|
{d[0] = s[0]; d[1] = s[1]; d[2] = s[2];}
|
|
}
|
|
}
|
|
}
|
|
else if(dbpp == 32)
|
|
{
|
|
for(int y = 0; y < h; y++, src += srcpitch, dst += dstpitch)
|
|
{
|
|
if(sbpp == 16)
|
|
{
|
|
WORD* s = (WORD*)src;
|
|
DWORD* d = (DWORD*)dst;
|
|
for(int x = 0; x < w; x++, s++, d++)
|
|
*d = ((*s&0xf800)<<8)|((*s&0x07e0)<<5)|((*s&0x001f)<<3);
|
|
}
|
|
else if(sbpp == 24)
|
|
{
|
|
BYTE* s = (BYTE*)src;
|
|
DWORD* d = (DWORD*)dst;
|
|
for(int x = 0; x < w; x++, s+=3, d++)
|
|
*d = *((DWORD*)s)&0xffffff;
|
|
}
|
|
}
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
static void asm_blend_row_clipped_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
|
|
{
|
|
BYTE* src2 = src + srcpitch;
|
|
do {*dst++ = (*src++ + *src2++ + 1) >> 1;}
|
|
while(w--);
|
|
}
|
|
|
|
static void asm_blend_row_c(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
|
|
{
|
|
BYTE* src2 = src + srcpitch;
|
|
BYTE* src3 = src2 + srcpitch;
|
|
do {*dst++ = (*src++ + (*src2++ << 1) + *src3++ + 2) >> 2;}
|
|
while(w--);
|
|
}
|
|
|
|
static void __declspec(naked) asm_blend_row_clipped_MMX(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
|
|
{
|
|
static const __int64 _x0001000100010001 = 0x0001000100010001;
|
|
|
|
__asm {
|
|
push ebp
|
|
push edi
|
|
push esi
|
|
push ebx
|
|
|
|
mov edi,[esp+20]
|
|
mov esi,[esp+24]
|
|
sub edi,esi
|
|
mov ebp,[esp+28]
|
|
mov edx,[esp+32]
|
|
|
|
shr ebp, 3
|
|
|
|
movq mm6, _x0001000100010001
|
|
pxor mm7, mm7
|
|
|
|
xloop:
|
|
movq mm0, [esi]
|
|
movq mm3, mm0
|
|
punpcklbw mm0, mm7
|
|
punpckhbw mm3, mm7
|
|
|
|
movq mm1, [esi+edx]
|
|
movq mm4, mm1
|
|
punpcklbw mm1, mm7
|
|
punpckhbw mm4, mm7
|
|
|
|
paddw mm1, mm0
|
|
paddw mm1, mm6
|
|
psrlw mm1, 1
|
|
|
|
paddw mm4, mm3
|
|
paddw mm4, mm6
|
|
psrlw mm4, 1
|
|
|
|
add esi, 8
|
|
packuswb mm1, mm4
|
|
movq [edi+esi-8], mm1
|
|
|
|
dec ebp
|
|
jne xloop
|
|
|
|
pop ebx
|
|
pop esi
|
|
pop edi
|
|
pop ebp
|
|
ret
|
|
};
|
|
}
|
|
|
|
static void __declspec(naked) asm_blend_row_MMX(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
|
|
{
|
|
static const __int64 mask0 = 0xfcfcfcfcfcfcfcfci64;
|
|
static const __int64 mask1 = 0x7f7f7f7f7f7f7f7fi64;
|
|
static const __int64 mask2 = 0x3f3f3f3f3f3f3f3fi64;
|
|
static const __int64 _x0002000200020002 = 0x0002000200020002;
|
|
|
|
__asm {
|
|
push ebp
|
|
push edi
|
|
push esi
|
|
push ebx
|
|
|
|
mov edi, [esp+20]
|
|
mov esi, [esp+24]
|
|
sub edi, esi
|
|
mov ebp, [esp+28]
|
|
mov edx, [esp+32]
|
|
|
|
shr ebp, 3
|
|
|
|
movq mm6, _x0002000200020002
|
|
pxor mm7, mm7
|
|
|
|
xloop:
|
|
movq mm0, [esi]
|
|
movq mm3, mm0
|
|
punpcklbw mm0, mm7
|
|
punpckhbw mm3, mm7
|
|
|
|
movq mm1, [esi+edx]
|
|
movq mm4, mm1
|
|
punpcklbw mm1, mm7
|
|
punpckhbw mm4, mm7
|
|
|
|
movq mm2, [esi+edx*2]
|
|
movq mm5, mm2
|
|
punpcklbw mm2, mm7
|
|
punpckhbw mm5, mm7
|
|
|
|
psllw mm1, 1
|
|
paddw mm1, mm0
|
|
paddw mm1, mm2
|
|
paddw mm1, mm6
|
|
psrlw mm1, 2
|
|
|
|
psllw mm4, 1
|
|
paddw mm4, mm3
|
|
paddw mm4, mm5
|
|
paddw mm4, mm6
|
|
psrlw mm4, 2
|
|
|
|
add esi, 8
|
|
packuswb mm1, mm4
|
|
movq [edi+esi-8], mm1
|
|
|
|
dec ebp
|
|
jne xloop
|
|
|
|
// sadly the original code makes a lot of visible banding artifacts on yuv
|
|
// (it seems those shiftings without rounding introduce too much error)
|
|
/*
|
|
mov edi,[esp+20]
|
|
mov esi,[esp+24]
|
|
sub edi,esi
|
|
mov ebp,[esp+28]
|
|
mov edx,[esp+32]
|
|
|
|
movq mm5,mask0
|
|
movq mm6,mask1
|
|
movq mm7,mask2
|
|
shr ebp,1
|
|
jz oddpart
|
|
|
|
xloop:
|
|
movq mm2,[esi]
|
|
movq mm0,mm5
|
|
|
|
movq mm1,[esi+edx]
|
|
pand mm0,mm2
|
|
|
|
psrlq mm1,1
|
|
movq mm2,[esi+edx*2]
|
|
|
|
psrlq mm2,2
|
|
pand mm1,mm6
|
|
|
|
psrlq mm0,2
|
|
pand mm2,mm7
|
|
|
|
paddb mm0,mm1
|
|
add esi,8
|
|
|
|
paddb mm0,mm2
|
|
dec ebp
|
|
|
|
movq [edi+esi-8],mm0
|
|
jne xloop
|
|
|
|
oddpart:
|
|
test byte ptr [esp+28],1
|
|
jz nooddpart
|
|
|
|
mov ecx,[esi]
|
|
mov eax,0fcfcfcfch
|
|
mov ebx,[esi+edx]
|
|
and eax,ecx
|
|
shr ebx,1
|
|
mov ecx,[esi+edx*2]
|
|
shr ecx,2
|
|
and ebx,07f7f7f7fh
|
|
shr eax,2
|
|
and ecx,03f3f3f3fh
|
|
add eax,ebx
|
|
add eax,ecx
|
|
mov [edi+esi],eax
|
|
|
|
nooddpart:
|
|
*/
|
|
pop ebx
|
|
pop esi
|
|
pop edi
|
|
pop ebp
|
|
ret
|
|
};
|
|
}
|
|
|
|
__declspec(align(16)) static BYTE const_1_16_bytes[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
|
|
|
|
static void asm_blend_row_SSE2(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
|
|
{
|
|
__asm
|
|
{
|
|
mov edx, srcpitch
|
|
mov esi, src
|
|
mov edi, dst
|
|
sub edi, esi
|
|
mov ecx, w
|
|
mov ebx, ecx
|
|
shr ecx, 4
|
|
and ebx, 15
|
|
|
|
movdqa xmm7, [const_1_16_bytes]
|
|
|
|
asm_blend_row_SSE2_loop:
|
|
movdqa xmm0, [esi]
|
|
movdqa xmm1, [esi+edx]
|
|
movdqa xmm2, [esi+edx*2]
|
|
pavgb xmm0, xmm1
|
|
pavgb xmm2, xmm1
|
|
psubusb xmm0, xmm7
|
|
pavgb xmm0, xmm2
|
|
movdqa [esi+edi], xmm0
|
|
add esi, 16
|
|
dec ecx
|
|
jnz asm_blend_row_SSE2_loop
|
|
|
|
test ebx,15
|
|
jz asm_blend_row_SSE2_end
|
|
|
|
mov ecx, ebx
|
|
xor ax, ax
|
|
xor bx, bx
|
|
xor dx, dx
|
|
asm_blend_row_SSE2_loop2:
|
|
mov al, [esi]
|
|
mov bl, [esi+edx]
|
|
mov dl, [esi+edx*2]
|
|
add ax, bx
|
|
inc ax
|
|
shr ax, 1
|
|
add dx, bx
|
|
inc dx
|
|
shr dx, 1
|
|
add ax, dx
|
|
shr ax, 1
|
|
mov [esi+edi], al
|
|
inc esi
|
|
dec ecx
|
|
jnz asm_blend_row_SSE2_loop2
|
|
|
|
asm_blend_row_SSE2_end:
|
|
}
|
|
}
|
|
|
|
static void asm_blend_row_clipped_SSE2(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch)
|
|
{
|
|
__asm
|
|
{
|
|
mov edx, srcpitch
|
|
mov esi, src
|
|
mov edi, dst
|
|
sub edi, esi
|
|
mov ecx, w
|
|
mov ebx, ecx
|
|
shr ecx, 4
|
|
and ebx, 15
|
|
|
|
movdqa xmm7, [const_1_16_bytes]
|
|
|
|
asm_blend_row_clipped_SSE2_loop:
|
|
movdqa xmm0, [esi]
|
|
movdqa xmm1, [esi+edx]
|
|
pavgb xmm0, xmm1
|
|
movdqa [esi+edi], xmm0
|
|
add esi, 16
|
|
dec ecx
|
|
jnz asm_blend_row_clipped_SSE2_loop
|
|
|
|
test ebx,15
|
|
jz asm_blend_row_clipped_SSE2_end
|
|
|
|
mov ecx, ebx
|
|
xor ax, ax
|
|
xor bx, bx
|
|
asm_blend_row_clipped_SSE2_loop2:
|
|
mov al, [esi]
|
|
mov bl, [esi+edx]
|
|
add ax, bx
|
|
inc ax
|
|
shr ax, 1
|
|
mov [esi+edi], al
|
|
inc esi
|
|
dec ecx
|
|
jnz asm_blend_row_clipped_SSE2_loop2
|
|
|
|
asm_blend_row_clipped_SSE2_end:
|
|
}
|
|
}
|
|
|
|
void DeinterlaceBlend(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch)
|
|
{
|
|
void (*asm_blend_row_clipped)(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch) = NULL;
|
|
void (*asm_blend_row)(BYTE* dst, BYTE* src, DWORD w, DWORD srcpitch) = NULL;
|
|
|
|
if((g_cpuid.m_flags & CCpuID::sse2) && !((DWORD)src&0xf) && !((DWORD)dst&0xf) && !(srcpitch&0xf))
|
|
{
|
|
asm_blend_row_clipped = asm_blend_row_clipped_SSE2;
|
|
asm_blend_row = asm_blend_row_SSE2;
|
|
}
|
|
else if(g_cpuid.m_flags & CCpuID::mmx)
|
|
{
|
|
asm_blend_row_clipped = asm_blend_row_clipped_MMX;
|
|
asm_blend_row = asm_blend_row_MMX;
|
|
}
|
|
else
|
|
{
|
|
asm_blend_row_clipped = asm_blend_row_clipped_c;
|
|
asm_blend_row = asm_blend_row_c;
|
|
}
|
|
|
|
if(!asm_blend_row_clipped)
|
|
return;
|
|
|
|
asm_blend_row_clipped(dst, src, rowbytes, srcpitch);
|
|
|
|
if((h -= 2) > 0) do
|
|
{
|
|
dst += dstpitch;
|
|
asm_blend_row(dst, src, rowbytes, srcpitch);
|
|
src += srcpitch;
|
|
}
|
|
while(--h);
|
|
|
|
asm_blend_row_clipped(dst + dstpitch, src, rowbytes, srcpitch);
|
|
|
|
if(g_cpuid.m_flags & CCpuID::mmx)
|
|
__asm emms
|
|
}
|
|
|
|
void DeinterlaceBob(BYTE* dst, BYTE* src, DWORD rowbytes, DWORD h, DWORD dstpitch, DWORD srcpitch, bool topfield)
|
|
{
|
|
if(topfield)
|
|
{
|
|
BitBltFromRGBToRGB(rowbytes, h/2, dst, dstpitch*2, 8, src, srcpitch*2, 8);
|
|
AvgLines8(dst, h, dstpitch);
|
|
}
|
|
else
|
|
{
|
|
BitBltFromRGBToRGB(rowbytes, h/2, dst + dstpitch, dstpitch*2, 8, src + srcpitch, srcpitch*2, 8);
|
|
AvgLines8(dst + dstpitch, h-1, dstpitch);
|
|
}
|
|
}
|
|
|
|
void AvgLines8(BYTE* dst, DWORD h, DWORD pitch)
|
|
{
|
|
if(h <= 1) return;
|
|
|
|
BYTE* s = dst;
|
|
BYTE* d = dst + (h-2)*pitch;
|
|
|
|
for(; s < d; s += pitch*2)
|
|
{
|
|
BYTE* tmp = s;
|
|
|
|
if((g_cpuid.m_flags & CCpuID::sse2) && !((DWORD)tmp&0xf) && !((DWORD)pitch&0xf))
|
|
{
|
|
__asm
|
|
{
|
|
mov esi, tmp
|
|
mov ebx, pitch
|
|
|
|
mov ecx, ebx
|
|
shr ecx, 4
|
|
|
|
AvgLines8_sse2_loop:
|
|
movdqa xmm0, [esi]
|
|
pavgb xmm0, [esi+ebx*2]
|
|
movdqa [esi+ebx], xmm0
|
|
add esi, 16
|
|
|
|
dec ecx
|
|
jnz AvgLines8_sse2_loop
|
|
|
|
mov tmp, esi
|
|
}
|
|
|
|
for(int i = pitch&7; i--; tmp++)
|
|
{
|
|
tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;
|
|
}
|
|
}
|
|
else if(g_cpuid.m_flags & CCpuID::mmx)
|
|
{
|
|
__asm
|
|
{
|
|
mov esi, tmp
|
|
mov ebx, pitch
|
|
|
|
mov ecx, ebx
|
|
shr ecx, 3
|
|
|
|
pxor mm7, mm7
|
|
AvgLines8_mmx_loop:
|
|
movq mm0, [esi]
|
|
movq mm1, mm0
|
|
|
|
punpcklbw mm0, mm7
|
|
punpckhbw mm1, mm7
|
|
|
|
movq mm2, [esi+ebx*2]
|
|
movq mm3, mm2
|
|
|
|
punpcklbw mm2, mm7
|
|
punpckhbw mm3, mm7
|
|
|
|
paddw mm0, mm2
|
|
psrlw mm0, 1
|
|
|
|
paddw mm1, mm3
|
|
psrlw mm1, 1
|
|
|
|
packuswb mm0, mm1
|
|
|
|
movq [esi+ebx], mm0
|
|
|
|
lea esi, [esi+8]
|
|
|
|
dec ecx
|
|
jnz AvgLines8_mmx_loop
|
|
|
|
mov tmp, esi
|
|
}
|
|
|
|
for(int i = pitch&7; i--; tmp++)
|
|
{
|
|
tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i = pitch; i--; tmp++)
|
|
{
|
|
tmp[pitch] = (tmp[0] + tmp[pitch<<1] + 1) >> 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!(h&1) && h >= 2)
|
|
{
|
|
dst += (h-2)*pitch;
|
|
memcpy_accel(dst + pitch, dst, pitch);
|
|
}
|
|
|
|
__asm emms;
|
|
}
|
|
|
|
void AvgLines555(BYTE* dst, DWORD h, DWORD pitch)
|
|
{
|
|
if(h <= 1) return;
|
|
|
|
unsigned __int64 __0x7c007c007c007c00 = 0x7c007c007c007c00;
|
|
unsigned __int64 __0x03e003e003e003e0 = 0x03e003e003e003e0;
|
|
unsigned __int64 __0x001f001f001f001f = 0x001f001f001f001f;
|
|
|
|
BYTE* s = dst;
|
|
BYTE* d = dst + (h-2)*pitch;
|
|
|
|
for(; s < d; s += pitch*2)
|
|
{
|
|
BYTE* tmp = s;
|
|
|
|
__asm
|
|
{
|
|
mov esi, tmp
|
|
mov ebx, pitch
|
|
|
|
mov ecx, ebx
|
|
shr ecx, 3
|
|
|
|
movq mm6, __0x03e003e003e003e0
|
|
movq mm7, __0x001f001f001f001f
|
|
|
|
AvgLines555_loop:
|
|
movq mm0, [esi]
|
|
movq mm1, mm0
|
|
movq mm2, mm0
|
|
|
|
psrlw mm0, 10 // red1 bits: mm0 = 001f001f001f001f
|
|
pand mm1, mm6 // green1 bits: mm1 = 03e003e003e003e0
|
|
pand mm2, mm7 // blue1 bits: mm2 = 001f001f001f001f
|
|
|
|
movq mm3, [esi+ebx*2]
|
|
movq mm4, mm3
|
|
movq mm5, mm3
|
|
|
|
psrlw mm3, 10 // red2 bits: mm3 = 001f001f001f001f
|
|
pand mm4, mm6 // green2 bits: mm4 = 03e003e003e003e0
|
|
pand mm5, mm7 // blue2 bits: mm5 = 001f001f001f001f
|
|
|
|
paddw mm0, mm3
|
|
psrlw mm0, 1 // (red1+red2)/2
|
|
psllw mm0, 10 // red bits at 7c007c007c007c00
|
|
|
|
paddw mm1, mm4
|
|
psrlw mm1, 1 // (green1+green2)/2
|
|
pand mm1, mm6 // green bits at 03e003e003e003e0
|
|
|
|
paddw mm2, mm5
|
|
psrlw mm2, 1 // (blue1+blue2)/2
|
|
// blue bits at 001f001f001f001f (no need to pand, lower bits were discareded)
|
|
|
|
por mm0, mm1
|
|
por mm0, mm2
|
|
|
|
movq [esi+ebx], mm0
|
|
|
|
lea esi, [esi+8]
|
|
|
|
dec ecx
|
|
jnz AvgLines555_loop
|
|
|
|
mov tmp, esi
|
|
}
|
|
|
|
for(int i = (pitch&7)>>1; i--; tmp++)
|
|
{
|
|
tmp[pitch] =
|
|
((((*tmp&0x7c00) + (tmp[pitch<<1]&0x7c00)) >> 1)&0x7c00)|
|
|
((((*tmp&0x03e0) + (tmp[pitch<<1]&0x03e0)) >> 1)&0x03e0)|
|
|
((((*tmp&0x001f) + (tmp[pitch<<1]&0x001f)) >> 1)&0x001f);
|
|
}
|
|
}
|
|
|
|
if(!(h&1) && h >= 2)
|
|
{
|
|
dst += (h-2)*pitch;
|
|
memcpy_accel(dst + pitch, dst, pitch);
|
|
}
|
|
|
|
__asm emms;
|
|
}
|
|
|
|
void AvgLines565(BYTE* dst, DWORD h, DWORD pitch)
|
|
{
|
|
if(h <= 1) return;
|
|
|
|
unsigned __int64 __0xf800f800f800f800 = 0xf800f800f800f800;
|
|
unsigned __int64 __0x07e007e007e007e0 = 0x07e007e007e007e0;
|
|
unsigned __int64 __0x001f001f001f001f = 0x001f001f001f001f;
|
|
|
|
BYTE* s = dst;
|
|
BYTE* d = dst + (h-2)*pitch;
|
|
|
|
for(; s < d; s += pitch*2)
|
|
{
|
|
WORD* tmp = (WORD*)s;
|
|
|
|
__asm
|
|
{
|
|
mov esi, tmp
|
|
mov ebx, pitch
|
|
|
|
mov ecx, ebx
|
|
shr ecx, 3
|
|
|
|
movq mm6, __0x07e007e007e007e0
|
|
movq mm7, __0x001f001f001f001f
|
|
|
|
AvgLines565_loop:
|
|
movq mm0, [esi]
|
|
movq mm1, mm0
|
|
movq mm2, mm0
|
|
|
|
psrlw mm0, 11 // red1 bits: mm0 = 001f001f001f001f
|
|
pand mm1, mm6 // green1 bits: mm1 = 07e007e007e007e0
|
|
pand mm2, mm7 // blue1 bits: mm2 = 001f001f001f001f
|
|
|
|
movq mm3, [esi+ebx*2]
|
|
movq mm4, mm3
|
|
movq mm5, mm3
|
|
|
|
psrlw mm3, 11 // red2 bits: mm3 = 001f001f001f001f
|
|
pand mm4, mm6 // green2 bits: mm4 = 07e007e007e007e0
|
|
pand mm5, mm7 // blue2 bits: mm5 = 001f001f001f001f
|
|
|
|
paddw mm0, mm3
|
|
psrlw mm0, 1 // (red1+red2)/2
|
|
psllw mm0, 11 // red bits at f800f800f800f800
|
|
|
|
paddw mm1, mm4
|
|
psrlw mm1, 1 // (green1+green2)/2
|
|
pand mm1, mm6 // green bits at 03e003e003e003e0
|
|
|
|
paddw mm2, mm5
|
|
psrlw mm2, 1 // (blue1+blue2)/2
|
|
// blue bits at 001f001f001f001f (no need to pand, lower bits were discareded)
|
|
|
|
por mm0, mm1
|
|
por mm0, mm2
|
|
|
|
movq [esi+ebx], mm0
|
|
|
|
lea esi, [esi+8]
|
|
|
|
dec ecx
|
|
jnz AvgLines565_loop
|
|
|
|
mov tmp, esi
|
|
}
|
|
|
|
for(int i = (pitch&7)>>1; i--; tmp++)
|
|
{
|
|
tmp[pitch] =
|
|
((((*tmp&0xf800) + (tmp[pitch<<1]&0xf800)) >> 1)&0xf800)|
|
|
((((*tmp&0x07e0) + (tmp[pitch<<1]&0x07e0)) >> 1)&0x07e0)|
|
|
((((*tmp&0x001f) + (tmp[pitch<<1]&0x001f)) >> 1)&0x001f);
|
|
}
|
|
}
|
|
|
|
if(!(h&1) && h >= 2)
|
|
{
|
|
dst += (h-2)*pitch;
|
|
memcpy_accel(dst + pitch, dst, pitch);
|
|
}
|
|
|
|
__asm emms;
|
|
}
|
|
|
|
extern "C" void mmx_YUY2toRGB24(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709);
|
|
extern "C" void mmx_YUY2toRGB32(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709);
|
|
|
|
bool BitBltFromYUY2ToRGB(int w, int h, BYTE* dst, int dstpitch, int dbpp, BYTE* src, int srcpitch)
|
|
{
|
|
void (* YUY2toRGB)(const BYTE* src, BYTE* dst, const BYTE* src_end, int src_pitch, int row_size, bool rec709) = NULL;
|
|
|
|
if(g_cpuid.m_flags & CCpuID::mmx)
|
|
{
|
|
YUY2toRGB =
|
|
dbpp == 32 ? mmx_YUY2toRGB32 :
|
|
dbpp == 24 ? mmx_YUY2toRGB24 :
|
|
// dbpp == 16 ? mmx_YUY2toRGB16 : // TODO
|
|
NULL;
|
|
}
|
|
else
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
if(!YUY2toRGB) return(false);
|
|
|
|
YUY2toRGB(src, dst, src + h*srcpitch, srcpitch, w, false);
|
|
|
|
return(true);
|
|
}
|