#include <config.h>
#include "asm.h"

/*\
|*| MMX assembly blending routines for Imlib2
|*| Written by Willem Monsuwe <willem@stack.nl>
|*|
|*| Special (hairy) constructs are only commented on first use.
\*/

/*\ All functions have the same calling convention:
|*|  __imlib_mmx_<op>_rgba_to_rgb[A](void *src, int sw, void *dst, int dw,
|*|				     int w, int h, ImlibColorModifier *cm)
\*/

#define src	8(%ebp)
#define sw	12(%ebp)
#define dst	16(%ebp)
#define dw	20(%ebp)
#define w	24(%ebp)
#define h	28(%ebp)
#define cm	32(%ebp)

.text
	.align 8
FN_(imlib_mmx_blend_rgba_to_rgb)
FN_(imlib_mmx_blend_rgba_to_rgba)
FN_(imlib_mmx_copy_rgba_to_rgb)
FN_(imlib_mmx_copy_rgba_to_rgba)
FN_(imlib_mmx_copy_rgb_to_rgba)

FN_(imlib_mmx_add_blend_rgba_to_rgb)
FN_(imlib_mmx_add_blend_rgba_to_rgba)
FN_(imlib_mmx_add_copy_rgba_to_rgb)
FN_(imlib_mmx_add_copy_rgba_to_rgba)
FN_(imlib_mmx_add_copy_rgb_to_rgba)

FN_(imlib_mmx_subtract_blend_rgba_to_rgb)
FN_(imlib_mmx_subtract_blend_rgba_to_rgba)
FN_(imlib_mmx_subtract_copy_rgba_to_rgb)
FN_(imlib_mmx_subtract_copy_rgba_to_rgba)
FN_(imlib_mmx_subtract_copy_rgb_to_rgba)

FN_(imlib_mmx_reshade_blend_rgba_to_rgb)
FN_(imlib_mmx_reshade_blend_rgba_to_rgba)
FN_(imlib_mmx_reshade_copy_rgba_to_rgb)
FN_(imlib_mmx_reshade_copy_rgba_to_rgba)
FN_(imlib_mmx_reshade_copy_rgb_to_rgba)

#include "asm_loadimmq.S"


/*\ MMX register use:
|*| %mm1 = Source value
|*| %mm2 = Destination value
|*| %mm3 = Alpha value
|*| %mm4 = 0
|*| %mm5-%mm6 = masks
\*/

/*\ Common code \*/
/*\ Set MMX mode, save registers, load common parameters \*/
#define ENTER				\
	ENDBR_				;\
	pushl %ebp			;\
	movl  %esp, %ebp		;\
	pushl %ebx			;\
	pushl %ecx			;\
	pushl %edx			;\
	pushl %edi			;\
	pushl %esi			;\
	movl  h,    %edx		;\
	movl  w,    %ebx		;\
	movl  src,  %esi		;\
	movl  dst,  %edi		;\
	leal (%esi, %ebx, 4), %esi	;\
	leal (%edi, %ebx, 4), %edi	;\
	negl %ebx			;\
	jz 9f				;\
	incl  %edx			;\
	decl  %edx			;\
	jz 9f				;\
	decl  %edx			;\

#define LOOP_START		\
8:				;\
	movl %ebx, %ecx

#define LOOP_END			\
	movl sw, %ecx			;\
	leal (%esi, %ecx, 4), %esi	;\
	movl dw, %ecx			;\
	leal (%edi, %ecx, 4), %edi	;\
	decl %edx			;\
	jns 8b

/*\ Unset MMX mode, reset registers, return \*/
#define LEAVE			\
9:				;\
	emms			;\
	popl %esi		;\
	popl %edi		;\
	popl %edx		;\
	popl %ecx		;\
	popl %ebx		;\
	movl %ebp, %esp		;\
	popl %ebp		;\
	ret


PR_(imlib_mmx_blend_rgba_to_rgb):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(c1, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and unpack/copy to eight bytes
	|*|  which are treated as four words.
	|*| Result ranges from [0, 0x7fff), and is mapped to
	|*|  point value in [0.0, 1.0) by using the high word
	|*|  of the 16->32 multiplications.
	|*| (Because we want the unsigned value we shift one bit,
	|*|  and also shift the other factor to compensate.)
	|*| Magic to get the fourth byte: lhh
	\*/
	movq %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	/*\ Make the alpha value that gets multiplied to the
	|*|  alpha channels 0, so the resulting alpha value is
	|*|  the destination alpha value.
	\*/
	psrlq $16, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d + (a * ((s - d) + 0.5)) \*/
	psubw %mm2, %mm1
	psllw $1, %mm1
	paddw %mm5, %mm1	/*\ Roundoff \*/
	pmulhw %mm3, %mm1
	paddw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_blend_rgba_to_rgb)

PR_(imlib_mmx_blend_rgba_to_rgba):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(m0X000000, %mm5)
	LOAD_IMMQ(m00XXXXXX, %mm6)
	LOAD_IMMQ(c1, %mm7)
	CLEANUP_IMMQ_LOADS(3)

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and target, a = src + (255 - dest) \*/
	movq %mm2, %mm3
	pxor %mm6, %mm3
	paddusb %mm1, %mm3
	/*\ Unpack/copy to eight bytes \*/
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ Separate alpha channel \*/
	movq %mm1, %mm0
	pand %mm5, %mm0

	/*\ d = d + (a * ((s - d) + 0.5)) \*/
	psubw %mm2, %mm1
	psllw $1, %mm1
	paddw %mm7, %mm1	/*\ Roundoff \*/
	pmulhw %mm3, %mm1

	/*\ Replace alpha channel with separated out version in mm0 and add \*/
	pand %mm6, %mm1
	por %mm0, %mm1
	paddw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_blend_rgba_to_rgba)

PR_(imlib_mmx_copy_rgba_to_rgb):
	ENTER

	LOAD_IMMQ(m0XXX0XXX, %mm5)
	LOAD_IMMQ(mX000X000, %mm6)
	CLEANUP_IMMQ_LOADS(2)

	/*\ Two at a time: last item is at %ecx = 0 \*/
	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ Clear alpha channel of source, get alpha of destination \*/
	pand %mm5, %mm1
	pand %mm6, %mm2

	/*\ d = d | s, and save \*/
	por %mm1, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2

	pand %mm5, %mm1
	pand %mm6, %mm2

	por %mm1, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_copy_rgba_to_rgb)

PR_(imlib_mmx_copy_rgba_to_rgba):
	ENTER

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source, save destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq %mm1, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd %mm1, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_copy_rgba_to_rgba)

PR_(imlib_mmx_copy_rgb_to_rgba):
	ENTER

	LOAD_IMMQ(mX000X000, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source, save destination \*/
	movq (%esi, %ecx, 4), %mm1
	por %mm5, %mm1
	movq %mm1, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	por %mm5, %mm1
	movd %mm1, (%edi)
3:

	LOOP_END
	LEAVE

SIZE(imlib_mmx_copy_rgb_to_rgba)

PR_(imlib_mmx_add_blend_rgba_to_rgb):
	ENTER

	pxor %mm4, %mm4

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and unpack/copy to eight bytes \*/
	movq %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	psrlq $16, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d + (a * s) \*/
	psllw $1, %mm1
	pmulhw %mm3, %mm1
	paddw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_add_blend_rgba_to_rgb)

PR_(imlib_mmx_add_blend_rgba_to_rgba):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(mVX000000, %mm5)
	LOAD_IMMQ(m00XXXXXX, %mm6)
	CLEANUP_IMMQ_LOADS(2)

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and target and unpack/copy to eight bytes \*/
	movq %mm2, %mm3
	pxor %mm6, %mm3
	paddusb %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	/*\ Make the alpha value that gets multiplied to the
	|*|  alpha channels 0x7fff, so the resulting alpha value is
	|*|  the sum of the source and destination alpha values.
	\*/
	por %mm5, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d + (a * s) \*/
	psllw $1, %mm1
	pmulhw %mm3, %mm1
	paddw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_add_blend_rgba_to_rgba)

PR_(imlib_mmx_add_copy_rgba_to_rgb):
	ENTER

	LOAD_IMMQ(m0XXX0XXX, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ Clear alpha channel of source \*/
	pand %mm5, %mm1

	/*\ d = d + s, unsigned saturation, and save \*/
	paddusb %mm1, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	pand %mm5, %mm1
	paddusb %mm1, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_add_copy_rgba_to_rgb)

PR_(imlib_mmx_add_copy_rgba_to_rgba):
	ENTER

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ d = d + s, unsigned saturation, and save \*/
	paddusb %mm1, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	paddusb %mm1, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_add_copy_rgba_to_rgba)

PR_(imlib_mmx_add_copy_rgb_to_rgba):
	ENTER

	LOAD_IMMQ(mX000X000, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ d = d + s, unsigned saturation, and save \*/
	paddusb %mm1, %mm2

	/*\ Make result alpha 0xff \*/
	por %mm5, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	paddusb %mm1, %mm2
	por %mm5, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_add_copy_rgb_to_rgba)

PR_(imlib_mmx_subtract_blend_rgba_to_rgb):
	ENTER

	pxor %mm4, %mm4

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and unpack/copy to eight bytes \*/
	movq %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	psrlq $16, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d - (a * s) \*/
	psllw $1, %mm1
	pmulhw %mm3, %mm1
	psubw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_subtract_blend_rgba_to_rgb)

PR_(imlib_mmx_subtract_blend_rgba_to_rgba):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(mV0000000, %mm5)
	LOAD_IMMQ(m00XXXXXX, %mm6)
	CLEANUP_IMMQ_LOADS(2)

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and target and unpack/copy to eight bytes \*/
	movq %mm2, %mm3
	pxor %mm6, %mm3
	paddusb %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	/*\ Make alpha value that gets multiplied with alpha channel
	|*| 0x8000, (-1.0), so that the alpha result is s + d
	\*/
	psrlq $16, %mm3
	por %mm5, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d - (a * s) \*/
	psllw $1, %mm1
	pmulhw %mm3, %mm1
	psubw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_subtract_blend_rgba_to_rgba)

PR_(imlib_mmx_subtract_copy_rgba_to_rgb):
	ENTER

	LOAD_IMMQ(m0XXX0XXX, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ Clear alpha channel of source \*/
	pand %mm5, %mm1

	/*\ d = d - s, unsigned saturation, and save \*/
	psubusb %mm1, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	pand %mm5, %mm1
	psubusb %mm1, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_subtract_copy_rgba_to_rgb)

PR_(imlib_mmx_subtract_copy_rgba_to_rgba):
	ENTER

	LOAD_IMMQ(mX000X000, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ Negate destination alphas \*/
	pxor %mm5, %mm2

	/*\ d = d - s, unsigned saturation, and save \*/
	psubusb %mm1, %mm2

	/*\ Negate result alphas \*/
	pxor %mm5, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	pxor %mm5, %mm2
	psubusb %mm1, %mm2
	pxor %mm5, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_subtract_copy_rgba_to_rgba)

PR_(imlib_mmx_subtract_copy_rgb_to_rgba):
	ENTER

	LOAD_IMMQ(mX000X000, %mm5)
	CLEANUP_IMMQ_LOADS(1)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ d = d - s, unsigned saturation, and save \*/
	psubusb %mm1, %mm2

	/*\ Make result alpha 0xff \*/
	por %mm5, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	psubusb %mm1, %mm2
	por %mm5, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_subtract_copy_rgb_to_rgba)

PR_(imlib_mmx_reshade_blend_rgba_to_rgb):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(m000V0V0V, %mm6)
	CLEANUP_IMMQ_LOADS(1)

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and unpack/copy to eight bytes \*/
	movq %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	psrlq $16, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d + (2 * a * (s - 127)) \*/
	psubw %mm6, %mm1
	psllw $2, %mm1
	pmulhw %mm3, %mm1
	paddw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_reshade_blend_rgba_to_rgb)

PR_(imlib_mmx_reshade_blend_rgba_to_rgba):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(mI0000000, %mm5)
	LOAD_IMMQ(m000V0V0V, %mm6)
	LOAD_IMMQ(m00XXXXXX, %mm7)
	CLEANUP_IMMQ_LOADS(3)

	LOOP_START
1:
	/*\ Load source and destination \*/
	movd (%esi, %ecx, 4), %mm1
	movd (%edi, %ecx, 4), %mm2

	/*\ Get alpha from source and target and unpack/copy to eight bytes \*/
	movq %mm2, %mm3
	pxor %mm7, %mm3
	paddusb %mm1, %mm3
	punpcklbw %mm3, %mm3
	punpckhwd %mm3, %mm3
	punpckhdq %mm3, %mm3
	psrlw $1, %mm3

	/*\ Make the alpha value that gets multiplied to the
	|*|  alpha channels 0x4000 (0.5), so the resulting alpha value is
	|*|  the sum of the source and destination alpha values.
	\*/
	psrlq $16, %mm3
	por %mm5, %mm3

	/*\ Unpack source and destination, bytes to words \*/
	punpcklbw %mm4, %mm1
	punpcklbw %mm4, %mm2

	/*\ d = d + (2 * a * (s - 127)), (alpha channel: d = d + (2 * 0.5 * (s - 0)) ) \*/
	psubw %mm6, %mm1
	psllw $2, %mm1
	pmulhw %mm3, %mm1
	paddw %mm1, %mm2

	/*\ Pack into lower 4 bytes and save \*/
	packuswb %mm4, %mm2
	movd %mm2, (%edi, %ecx, 4)

	incl %ecx
	js 1b

	LOOP_END
	LEAVE

SIZE(imlib_mmx_reshade_blend_rgba_to_rgba)

PR_(imlib_mmx_reshade_copy_rgba_to_rgb):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(m0XXX0XXX, %mm5)
	LOAD_IMMQ(m0VVV0VVV, %mm6)
	CLEANUP_IMMQ_LOADS(2)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ To take advantage of saturation and be able to do 8 bytes
	|*|  at a time, we divide reshading into two separate steps:
	|*|  adding values above 128, and subtracting values below 128
	|*| These values go into %mm1 and %mm3 respectively
	|*| - %mm1 becomes (2 * (s - 127))
	|*| - %mm3 becomes (2 * (255 - (127 + s))) = (2 * (128 - s))
	\*/
	movq %mm1, %mm3
	psubusb %mm6, %mm1
	paddusb %mm1, %mm1
	paddusb %mm6, %mm3
	pxor %mm5, %mm3
	paddusb %mm3, %mm3

	/*\ Clear alpha channel of s1 and s2 \*/
	pand %mm5, %mm1
	pand %mm5, %mm3

	/*\ d = d + s1 - s2, unsigned saturation, and save \*/
	paddusb %mm1, %mm2
	psubusb %mm3, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	movq %mm1, %mm3
	psubusb %mm6, %mm1
	paddusb %mm1, %mm1
	paddusb %mm6, %mm3
	pxor %mm5, %mm3
	paddusb %mm3, %mm3
	pand %mm5, %mm1
	pand %mm5, %mm3
	paddusb %mm1, %mm2
	psubusb %mm3, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_reshade_copy_rgba_to_rgb)

PR_(imlib_mmx_reshade_copy_rgba_to_rgba):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(m0XXX0XXX, %mm5)
	LOAD_IMMQ(m0VVV0VVV, %mm6)
	CLEANUP_IMMQ_LOADS(2)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	/*\ This time, the alpha channels have to be added.
	|*| For that, the alpha channel of %mm1 should remain
	|*|  the same.  This is done by subtracting 0 from the
	|*|  alpha channel, and then doing the *2 via a separate
	|*|  register, clearing its alpha channel first.
	\*/
	movq %mm1, %mm3
	psubusb %mm6, %mm1
	movq %mm1, %mm0
	pand %mm5, %mm0
	paddusb %mm0, %mm1
	paddusb %mm6, %mm3
	pxor %mm5, %mm3
	paddusb %mm3, %mm3

	/*\ Clear alpha channel of s2 \*/
	pand %mm5, %mm3

	/*\ d = d + s1 - s2, unsigned saturation, and save \*/
	paddusb %mm1, %mm2
	psubusb %mm3, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	movq %mm1, %mm3
	psubusb %mm6, %mm1
	movq %mm1, %mm0
	pand %mm5, %mm0
	paddusb %mm0, %mm1
	paddusb %mm6, %mm3
	pxor %mm5, %mm3
	paddusb %mm3, %mm3
	pand %mm5, %mm3
	paddusb %mm1, %mm2
	psubusb %mm3, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_reshade_copy_rgba_to_rgba)

PR_(imlib_mmx_reshade_copy_rgb_to_rgba):
	ENTER

	pxor %mm4, %mm4
	LOAD_IMMQ(m0XXX0XXX, %mm5)
	LOAD_IMMQ(m0VVV0VVV, %mm6)
	LOAD_IMMQ(mX000X000, %mm7)
	CLEANUP_IMMQ_LOADS(3)

	subl $4, %esi
	subl $4, %edi

	LOOP_START
	incl %ecx
	jz 2f
1:
	/*\ Load source and destination \*/
	movq (%esi, %ecx, 4), %mm1
	movq (%edi, %ecx, 4), %mm2

	movq %mm1, %mm3
	psubusb %mm6, %mm1
	paddusb %mm1, %mm1
	paddusb %mm6, %mm3
	pxor %mm5, %mm3
	paddusb %mm3, %mm3

	/*\ d = d + s1 - s2, unsigned saturation, and save \*/
	paddusb %mm1, %mm2
	psubusb %mm3, %mm2

	/*\ Make result alpha 0xff \*/
	por %mm7, %mm2
	movq %mm2, (%edi, %ecx, 4)

	addl $2, %ecx
	js 1b
	jnz 3f
2:
	movd (%esi), %mm1
	movd (%edi), %mm2
	movq %mm1, %mm3
	psubusb %mm6, %mm1
	paddusb %mm1, %mm1
	paddusb %mm6, %mm3
	pxor %mm5, %mm3
	paddusb %mm3, %mm3
	paddusb %mm1, %mm2
	psubusb %mm3, %mm2
	por %mm7, %mm2
	movd %mm2, (%edi)
3:
	LOOP_END
	LEAVE

SIZE(imlib_mmx_reshade_copy_rgb_to_rgba)

#ifdef __ELF__
.section .note.GNU-stack,"",@progbits
#endif
