WebSVN – Kolibri OS – Blame – /programs/develop/libraries/pixman/pixman-combine32.c

Rev	Author	Line No.	Line
3931	Serge	1	/*
		2	* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
		3	* 2005 Lars Knoll & Zack Rusin, Trolltech
		4	*
		5	* Permission to use, copy, modify, distribute, and sell this software and its
		6	* documentation for any purpose is hereby granted without fee, provided that
		7	* the above copyright notice appear in all copies and that both that
		8	* copyright notice and this permission notice appear in supporting
		9	* documentation, and that the name of Keith Packard not be used in
		10	* advertising or publicity pertaining to distribution of the software without
		11	* specific, written prior permission. Keith Packard makes no
		12	* representations about the suitability of this software for any purpose. It
		13	* is provided "as is" without express or implied warranty.
		14	*
		15	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
		16	* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
		17	* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
		18	* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
		19	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
		20	* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
		21	* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
		22	* SOFTWARE.
		23	*/
1891	serge	24	#ifdef HAVE_CONFIG_H
		25	#include
		26	#endif
		27
		28	#include
		29	#include
		30
		31	#include "pixman-private.h"
		32	#include "pixman-combine32.h"
		33
3931	Serge	34	/* component alpha helper functions */
1891	serge	35
		36	static void
		37	combine_mask_ca (uint32_t src, uint32_t mask)
		38	{
		39	uint32_t a = *mask;
		40
		41	uint32_t x;
		42	uint16_t xa;
		43
		44	if (!a)
		45	{
		46	*(src) = 0;
		47	return;
		48	}
		49
		50	x = *(src);
		51	if (a == ~0)
		52	{
		53	x = x >> A_SHIFT;
		54	x \|= x << G_SHIFT;
		55	x \|= x << R_SHIFT;
		56	*(mask) = x;
		57	return;
		58	}
		59
		60	xa = x >> A_SHIFT;
		61	UN8x4_MUL_UN8x4 (x, a);
		62	*(src) = x;
		63
		64	UN8x4_MUL_UN8 (a, xa);
		65	*(mask) = a;
		66	}
		67
		68	static void
		69	combine_mask_value_ca (uint32_t src, const uint32_t mask)
		70	{
		71	uint32_t a = *mask;
		72	uint32_t x;
		73
		74	if (!a)
		75	{
		76	*(src) = 0;
		77	return;
		78	}
		79
		80	if (a == ~0)
		81	return;
		82
		83	x = *(src);
		84	UN8x4_MUL_UN8x4 (x, a);
		85	*(src) = x;
		86	}
		87
		88	static void
		89	combine_mask_alpha_ca (const uint32_t src, uint32_t mask)
		90	{
		91	uint32_t a = *(mask);
		92	uint32_t x;
		93
		94	if (!a)
		95	return;
		96
		97	x = *(src) >> A_SHIFT;
		98	if (x == MASK)
		99	return;
		100
		101	if (a == ~0)
		102	{
		103	x \|= x << G_SHIFT;
		104	x \|= x << R_SHIFT;
		105	*(mask) = x;
		106	return;
		107	}
		108
		109	UN8x4_MUL_UN8 (a, x);
		110	*(mask) = a;
		111	}
		112
		113	/*
		114	* There are two ways of handling alpha -- either as a single unified value or
		115	* a separate value for each component, hence each macro must have two
3931	Serge	116	* versions. The unified alpha version has a 'u' at the end of the name,
		117	* the component version has a 'ca'. Similarly, functions which deal with
1891	serge	118	* this difference will have two versions using the same convention.
		119	*/
		120
		121	static force_inline uint32_t
		122	combine_mask (const uint32_t src, const uint32_t mask, int i)
		123	{
		124	uint32_t s, m;
		125
		126	if (mask)
		127	{
		128	m = *(mask + i) >> A_SHIFT;
		129
		130	if (!m)
		131	return 0;
		132	}
		133
		134	s = *(src + i);
		135
		136	if (mask)
		137	UN8x4_MUL_UN8 (s, m);
		138
		139	return s;
		140	}
		141
		142	static void
		143	combine_clear (pixman_implementation_t *imp,
		144	pixman_op_t op,
		145	uint32_t * dest,
		146	const uint32_t * src,
		147	const uint32_t * mask,
		148	int width)
		149	{
		150	memset (dest, 0, width * sizeof(uint32_t));
		151	}
		152
		153	static void
		154	combine_dst (pixman_implementation_t *imp,
		155	pixman_op_t op,
		156	uint32_t * dest,
		157	const uint32_t * src,
		158	const uint32_t * mask,
		159	int width)
		160	{
		161	return;
		162	}
		163
		164	static void
		165	combine_src_u (pixman_implementation_t *imp,
		166	pixman_op_t op,
		167	uint32_t * dest,
		168	const uint32_t * src,
		169	const uint32_t * mask,
		170	int width)
		171	{
		172	int i;
		173
		174	if (!mask)
3931	Serge	175	{
1891	serge	176	memcpy (dest, src, width * sizeof (uint32_t));
3931	Serge	177	}
1891	serge	178	else
		179	{
		180	for (i = 0; i < width; ++i)
		181	{
		182	uint32_t s = combine_mask (src, mask, i);
		183
		184	*(dest + i) = s;
		185	}
		186	}
		187	}
		188
		189	static void
		190	combine_over_u (pixman_implementation_t *imp,
		191	pixman_op_t op,
		192	uint32_t * dest,
		193	const uint32_t * src,
		194	const uint32_t * mask,
		195	int width)
		196	{
		197	int i;
		198
3931	Serge	199	if (!mask)
1891	serge	200	{
3931	Serge	201	for (i = 0; i < width; ++i)
		202	{
		203	uint32_t s = *(src + i);
		204	uint32_t a = ALPHA_8 (s);
		205	if (a == 0xFF)
		206	{
		207	*(dest + i) = s;
		208	}
		209	else if (s)
		210	{
		211	uint32_t d = *(dest + i);
		212	uint32_t ia = a ^ 0xFF;
		213	UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);
		214	*(dest + i) = d;
		215	}
		216	}
1891	serge	217	}
3931	Serge	218	else
		219	{
		220	for (i = 0; i < width; ++i)
		221	{
		222	uint32_t m = ALPHA_8 (*(mask + i));
		223	if (m == 0xFF)
		224	{
		225	uint32_t s = *(src + i);
		226	uint32_t a = ALPHA_8 (s);
		227	if (a == 0xFF)
		228	{
		229	*(dest + i) = s;
		230	}
		231	else if (s)
		232	{
		233	uint32_t d = *(dest + i);
		234	uint32_t ia = a ^ 0xFF;
		235	UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);
		236	*(dest + i) = d;
		237	}
		238	}
		239	else if (m)
		240	{
		241	uint32_t s = *(src + i);
		242	if (s)
		243	{
		244	uint32_t d = *(dest + i);
		245	UN8x4_MUL_UN8 (s, m);
		246	UN8x4_MUL_UN8_ADD_UN8x4 (d, ALPHA_8 (~s), s);
		247	*(dest + i) = d;
		248	}
		249	}
		250	}
		251	}
1891	serge	252	}
		253
		254	static void
		255	combine_over_reverse_u (pixman_implementation_t *imp,
		256	pixman_op_t op,
		257	uint32_t * dest,
		258	const uint32_t * src,
		259	const uint32_t * mask,
		260	int width)
		261	{
		262	int i;
		263
		264	for (i = 0; i < width; ++i)
		265	{
		266	uint32_t s = combine_mask (src, mask, i);
		267	uint32_t d = *(dest + i);
		268	uint32_t ia = ALPHA_8 (~*(dest + i));
		269	UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);
		270	*(dest + i) = s;
		271	}
		272	}
		273
		274	static void
		275	combine_in_u (pixman_implementation_t *imp,
		276	pixman_op_t op,
		277	uint32_t * dest,
		278	const uint32_t * src,
		279	const uint32_t * mask,
		280	int width)
		281	{
		282	int i;
		283
		284	for (i = 0; i < width; ++i)
		285	{
		286	uint32_t s = combine_mask (src, mask, i);
		287	uint32_t a = ALPHA_8 (*(dest + i));
		288	UN8x4_MUL_UN8 (s, a);
		289	*(dest + i) = s;
		290	}
		291	}
		292
		293	static void
		294	combine_in_reverse_u (pixman_implementation_t *imp,
		295	pixman_op_t op,
		296	uint32_t * dest,
		297	const uint32_t * src,
		298	const uint32_t * mask,
		299	int width)
		300	{
		301	int i;
		302
		303	for (i = 0; i < width; ++i)
		304	{
		305	uint32_t s = combine_mask (src, mask, i);
		306	uint32_t d = *(dest + i);
		307	uint32_t a = ALPHA_8 (s);
		308	UN8x4_MUL_UN8 (d, a);
		309	*(dest + i) = d;
		310	}
		311	}
		312
		313	static void
		314	combine_out_u (pixman_implementation_t *imp,
		315	pixman_op_t op,
		316	uint32_t * dest,
		317	const uint32_t * src,
		318	const uint32_t * mask,
		319	int width)
		320	{
		321	int i;
		322
		323	for (i = 0; i < width; ++i)
		324	{
		325	uint32_t s = combine_mask (src, mask, i);
		326	uint32_t a = ALPHA_8 (~*(dest + i));
		327	UN8x4_MUL_UN8 (s, a);
		328	*(dest + i) = s;
		329	}
		330	}
		331
		332	static void
		333	combine_out_reverse_u (pixman_implementation_t *imp,
		334	pixman_op_t op,
		335	uint32_t * dest,
		336	const uint32_t * src,
		337	const uint32_t * mask,
		338	int width)
		339	{
		340	int i;
		341
		342	for (i = 0; i < width; ++i)
		343	{
		344	uint32_t s = combine_mask (src, mask, i);
		345	uint32_t d = *(dest + i);
		346	uint32_t a = ALPHA_8 (~s);
		347	UN8x4_MUL_UN8 (d, a);
		348	*(dest + i) = d;
		349	}
		350	}
		351
		352	static void
		353	combine_atop_u (pixman_implementation_t *imp,
		354	pixman_op_t op,
		355	uint32_t * dest,
		356	const uint32_t * src,
		357	const uint32_t * mask,
		358	int width)
		359	{
		360	int i;
		361
		362	for (i = 0; i < width; ++i)
		363	{
		364	uint32_t s = combine_mask (src, mask, i);
		365	uint32_t d = *(dest + i);
		366	uint32_t dest_a = ALPHA_8 (d);
		367	uint32_t src_ia = ALPHA_8 (~s);
		368
		369	UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_a, d, src_ia);
		370	*(dest + i) = s;
		371	}
		372	}
		373
		374	static void
		375	combine_atop_reverse_u (pixman_implementation_t *imp,
		376	pixman_op_t op,
		377	uint32_t * dest,
		378	const uint32_t * src,
		379	const uint32_t * mask,
		380	int width)
		381	{
		382	int i;
		383
		384	for (i = 0; i < width; ++i)
		385	{
		386	uint32_t s = combine_mask (src, mask, i);
		387	uint32_t d = *(dest + i);
		388	uint32_t src_a = ALPHA_8 (s);
		389	uint32_t dest_ia = ALPHA_8 (~d);
		390
		391	UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_ia, d, src_a);
		392	*(dest + i) = s;
		393	}
		394	}
		395
		396	static void
		397	combine_xor_u (pixman_implementation_t *imp,
		398	pixman_op_t op,
		399	uint32_t * dest,
		400	const uint32_t * src,
		401	const uint32_t * mask,
		402	int width)
		403	{
		404	int i;
		405
		406	for (i = 0; i < width; ++i)
		407	{
		408	uint32_t s = combine_mask (src, mask, i);
		409	uint32_t d = *(dest + i);
		410	uint32_t src_ia = ALPHA_8 (~s);
		411	uint32_t dest_ia = ALPHA_8 (~d);
		412
		413	UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_ia, d, src_ia);
		414	*(dest + i) = s;
		415	}
		416	}
		417
		418	static void
		419	combine_add_u (pixman_implementation_t *imp,
		420	pixman_op_t op,
		421	uint32_t * dest,
		422	const uint32_t * src,
		423	const uint32_t * mask,
		424	int width)
		425	{
		426	int i;
		427
		428	for (i = 0; i < width; ++i)
		429	{
		430	uint32_t s = combine_mask (src, mask, i);
		431	uint32_t d = *(dest + i);
		432	UN8x4_ADD_UN8x4 (d, s);
		433	*(dest + i) = d;
		434	}
		435	}
		436
		437	static void
		438	combine_saturate_u (pixman_implementation_t *imp,
		439	pixman_op_t op,
		440	uint32_t * dest,
		441	const uint32_t * src,
		442	const uint32_t * mask,
		443	int width)
		444	{
		445	int i;
		446
		447	for (i = 0; i < width; ++i)
		448	{
		449	uint32_t s = combine_mask (src, mask, i);
		450	uint32_t d = *(dest + i);
		451	uint16_t sa, da;
		452
		453	sa = s >> A_SHIFT;
		454	da = ~d >> A_SHIFT;
		455	if (sa > da)
		456	{
		457	sa = DIV_UN8 (da, sa);
		458	UN8x4_MUL_UN8 (s, sa);
		459	}
		460	;
		461	UN8x4_ADD_UN8x4 (d, s);
		462	*(dest + i) = d;
		463	}
		464	}
		465
		466	/*
		467	* PDF blend modes:
		468	* The following blend modes have been taken from the PDF ISO 32000
		469	* specification, which at this point in time is available from
		470	* http://www.adobe.com/devnet/acrobat/pdfs/PDF32000_2008.pdf
		471	* The relevant chapters are 11.3.5 and 11.3.6.
		472	* The formula for computing the final pixel color given in 11.3.6 is:
		473	* αr × Cr = (1 – αs) × αb × Cb + (1 – αb) × αs × Cs + αb × αs × B(Cb, Cs)
		474	* with B() being the blend function.
		475	* Note that OVER is a special case of this operation, using B(Cb, Cs) = Cs
		476	*
		477	* These blend modes should match the SVG filter draft specification, as
		478	* it has been designed to mirror ISO 32000. Note that at the current point
		479	* no released draft exists that shows this, as the formulas have not been
		480	* updated yet after the release of ISO 32000.
		481	*
		482	* The default implementation here uses the PDF_SEPARABLE_BLEND_MODE and
		483	* PDF_NON_SEPARABLE_BLEND_MODE macros, which take the blend function as an
		484	* argument. Note that this implementation operates on premultiplied colors,
		485	* while the PDF specification does not. Therefore the code uses the formula
3931	Serge	486	* Cra = (1 – as) . Dca + (1 – ad) . Sca + B(Dca, ad, Sca, as)
1891	serge	487	*/
		488
		489	/*
		490	* Multiply
		491	* B(Dca, ad, Sca, as) = Dca.Sca
		492	*/
		493	static void
		494	combine_multiply_u (pixman_implementation_t *imp,
		495	pixman_op_t op,
		496	uint32_t * dest,
		497	const uint32_t * src,
		498	const uint32_t * mask,
		499	int width)
		500	{
		501	int i;
		502
		503	for (i = 0; i < width; ++i)
		504	{
		505	uint32_t s = combine_mask (src, mask, i);
		506	uint32_t d = *(dest + i);
		507	uint32_t ss = s;
		508	uint32_t src_ia = ALPHA_8 (~s);
		509	uint32_t dest_ia = ALPHA_8 (~d);
		510
		511	UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (ss, dest_ia, d, src_ia);
		512	UN8x4_MUL_UN8x4 (d, s);
		513	UN8x4_ADD_UN8x4 (d, ss);
		514
		515	*(dest + i) = d;
		516	}
		517	}
		518
		519	static void
		520	combine_multiply_ca (pixman_implementation_t *imp,
		521	pixman_op_t op,
		522	uint32_t * dest,
		523	const uint32_t * src,
		524	const uint32_t * mask,
		525	int width)
		526	{
		527	int i;
		528
		529	for (i = 0; i < width; ++i)
		530	{
		531	uint32_t m = *(mask + i);
		532	uint32_t s = *(src + i);
		533	uint32_t d = *(dest + i);
		534	uint32_t r = d;
		535	uint32_t dest_ia = ALPHA_8 (~d);
		536
3931	Serge	537	combine_mask_ca (&s, &m);
1891	serge	538
		539	UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (r, ~m, s, dest_ia);
		540	UN8x4_MUL_UN8x4 (d, s);
		541	UN8x4_ADD_UN8x4 (r, d);
		542
		543	*(dest + i) = r;
		544	}
		545	}
		546
		547	#define PDF_SEPARABLE_BLEND_MODE(name) \
		548	static void \
		549	combine_ ## name ## _u (pixman_implementation_t *imp, \
		550	pixman_op_t op, \
		551	uint32_t * dest, \
		552	const uint32_t * src, \
		553	const uint32_t * mask, \
		554	int width) \
		555	{ \
		556	int i; \
		557	for (i = 0; i < width; ++i) { \
		558	uint32_t s = combine_mask (src, mask, i); \
		559	uint32_t d = *(dest + i); \
		560	uint8_t sa = ALPHA_8 (s); \
		561	uint8_t isa = ~sa; \
		562	uint8_t da = ALPHA_8 (d); \
		563	uint8_t ida = ~da; \
		564	uint32_t result; \
		565	\
		566	result = d; \
		567	UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (result, isa, s, ida); \
		568	\
		569	*(dest + i) = result + \
3931	Serge	570	(DIV_ONE_UN8 (sa * (uint32_t)da) << A_SHIFT) + \
1891	serge	571	(blend_ ## name (RED_8 (d), da, RED_8 (s), sa) << R_SHIFT) + \
		572	(blend_ ## name (GREEN_8 (d), da, GREEN_8 (s), sa) << G_SHIFT) + \
		573	(blend_ ## name (BLUE_8 (d), da, BLUE_8 (s), sa)); \
		574	} \
		575	} \
		576	\
		577	static void \
		578	combine_ ## name ## _ca (pixman_implementation_t *imp, \
		579	pixman_op_t op, \
		580	uint32_t * dest, \
		581	const uint32_t * src, \
		582	const uint32_t * mask, \
		583	int width) \
		584	{ \
		585	int i; \
		586	for (i = 0; i < width; ++i) { \
		587	uint32_t m = *(mask + i); \
		588	uint32_t s = *(src + i); \
		589	uint32_t d = *(dest + i); \
		590	uint8_t da = ALPHA_8 (d); \
		591	uint8_t ida = ~da; \
		592	uint32_t result; \
		593	\
3931	Serge	594	combine_mask_ca (&s, &m); \
1891	serge	595	\
		596	result = d; \
		597	UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (result, ~m, s, ida); \
		598	\
		599	result += \
3931	Serge	600	(DIV_ONE_UN8 (ALPHA_8 (m) * (uint32_t)da) << A_SHIFT) + \
1891	serge	601	(blend_ ## name (RED_8 (d), da, RED_8 (s), RED_8 (m)) << R_SHIFT) + \
		602	(blend_ ## name (GREEN_8 (d), da, GREEN_8 (s), GREEN_8 (m)) << G_SHIFT) + \
		603	(blend_ ## name (BLUE_8 (d), da, BLUE_8 (s), BLUE_8 (m))); \
		604	\
		605	*(dest + i) = result; \
		606	} \
		607	}
		608
		609	/*
		610	* Screen
		611	* B(Dca, ad, Sca, as) = Dca.sa + Sca.da - Dca.Sca
		612	*/
		613	static inline uint32_t
		614	blend_screen (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		615	{
		616	return DIV_ONE_UN8 (sca * da + dca * sa - sca * dca);
		617	}
		618
		619	PDF_SEPARABLE_BLEND_MODE (screen)
		620
		621	/*
		622	* Overlay
		623	* B(Dca, Da, Sca, Sa) =
		624	* if 2.Dca < Da
		625	* 2.Sca.Dca
		626	* otherwise
		627	* Sa.Da - 2.(Da - Dca).(Sa - Sca)
		628	*/
		629	static inline uint32_t
		630	blend_overlay (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		631	{
		632	uint32_t rca;
		633
		634	if (2 * dca < da)
		635	rca = 2 * sca * dca;
		636	else
		637	rca = sa * da - 2 * (da - dca) * (sa - sca);
		638	return DIV_ONE_UN8 (rca);
		639	}
		640
		641	PDF_SEPARABLE_BLEND_MODE (overlay)
		642
		643	/*
		644	* Darken
		645	* B(Dca, Da, Sca, Sa) = min (Sca.Da, Dca.Sa)
		646	*/
		647	static inline uint32_t
		648	blend_darken (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		649	{
		650	uint32_t s, d;
		651
		652	s = sca * da;
		653	d = dca * sa;
		654	return DIV_ONE_UN8 (s > d ? d : s);
		655	}
		656
		657	PDF_SEPARABLE_BLEND_MODE (darken)
		658
		659	/*
		660	* Lighten
		661	* B(Dca, Da, Sca, Sa) = max (Sca.Da, Dca.Sa)
		662	*/
		663	static inline uint32_t
		664	blend_lighten (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		665	{
		666	uint32_t s, d;
		667
		668	s = sca * da;
		669	d = dca * sa;
		670	return DIV_ONE_UN8 (s > d ? s : d);
		671	}
		672
		673	PDF_SEPARABLE_BLEND_MODE (lighten)
		674
		675	/*
		676	* Color dodge
		677	* B(Dca, Da, Sca, Sa) =
		678	* if Dca == 0
		679	* 0
		680	* if Sca == Sa
		681	* Sa.Da
		682	* otherwise
		683	* Sa.Da. min (1, Dca / Da / (1 - Sca/Sa))
		684	*/
		685	static inline uint32_t
		686	blend_color_dodge (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		687	{
		688	if (sca >= sa)
		689	{
		690	return dca == 0 ? 0 : DIV_ONE_UN8 (sa * da);
		691	}
		692	else
		693	{
		694	uint32_t rca = dca * sa / (sa - sca);
		695	return DIV_ONE_UN8 (sa * MIN (rca, da));
		696	}
		697	}
		698
		699	PDF_SEPARABLE_BLEND_MODE (color_dodge)
		700
		701	/*
		702	* Color burn
		703	* B(Dca, Da, Sca, Sa) =
		704	* if Dca == Da
		705	* Sa.Da
		706	* if Sca == 0
		707	* 0
		708	* otherwise
		709	* Sa.Da.(1 - min (1, (1 - Dca/Da).Sa / Sca))
		710	*/
		711	static inline uint32_t
		712	blend_color_burn (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		713	{
		714	if (sca == 0)
		715	{
		716	return dca < da ? 0 : DIV_ONE_UN8 (sa * da);
		717	}
		718	else
		719	{
		720	uint32_t rca = (da - dca) * sa / sca;
		721	return DIV_ONE_UN8 (sa * (MAX (rca, da) - rca));
		722	}
		723	}
		724
		725	PDF_SEPARABLE_BLEND_MODE (color_burn)
		726
		727	/*
		728	* Hard light
		729	* B(Dca, Da, Sca, Sa) =
		730	* if 2.Sca < Sa
		731	* 2.Sca.Dca
		732	* otherwise
		733	* Sa.Da - 2.(Da - Dca).(Sa - Sca)
		734	*/
		735	static inline uint32_t
		736	blend_hard_light (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		737	{
		738	if (2 * sca < sa)
		739	return DIV_ONE_UN8 (2 * sca * dca);
		740	else
		741	return DIV_ONE_UN8 (sa * da - 2 * (da - dca) * (sa - sca));
		742	}
		743
		744	PDF_SEPARABLE_BLEND_MODE (hard_light)
		745
		746	/*
		747	* Soft light
		748	* B(Dca, Da, Sca, Sa) =
		749	* if (2.Sca <= Sa)
		750	* Dca.(Sa - (1 - Dca/Da).(2.Sca - Sa))
		751	* otherwise if Dca.4 <= Da
		752	* Dca.(Sa + (2.Sca - Sa).((16.Dca/Da - 12).Dca/Da + 3)
		753	* otherwise
		754	* (Dca.Sa + (SQRT (Dca/Da).Da - Dca).(2.Sca - Sa))
		755	*/
		756	static inline uint32_t
		757	blend_soft_light (uint32_t dca_org,
		758	uint32_t da_org,
		759	uint32_t sca_org,
		760	uint32_t sa_org)
		761	{
		762	double dca = dca_org * (1.0 / MASK);
		763	double da = da_org * (1.0 / MASK);
		764	double sca = sca_org * (1.0 / MASK);
		765	double sa = sa_org * (1.0 / MASK);
		766	double rca;
		767
		768	if (2 * sca < sa)
		769	{
		770	if (da == 0)
		771	rca = dca * sa;
		772	else
		773	rca = dca * sa - dca * (da - dca) * (sa - 2 * sca) / da;
		774	}
		775	else if (da == 0)
		776	{
		777	rca = 0;
		778	}
		779	else if (4 * dca <= da)
		780	{
		781	rca = dca * sa +
		782	(2 * sca - sa) * dca * ((16 * dca / da - 12) * dca / da + 3);
		783	}
		784	else
		785	{
		786	rca = dca * sa + (sqrt (dca * da) - dca) * (2 * sca - sa);
		787	}
		788	return rca * MASK + 0.5;
		789	}
		790
		791	PDF_SEPARABLE_BLEND_MODE (soft_light)
		792
		793	/*
		794	* Difference
		795	* B(Dca, Da, Sca, Sa) = abs (Dca.Sa - Sca.Da)
		796	*/
		797	static inline uint32_t
		798	blend_difference (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		799	{
		800	uint32_t dcasa = dca * sa;
		801	uint32_t scada = sca * da;
		802
		803	if (scada < dcasa)
		804	return DIV_ONE_UN8 (dcasa - scada);
		805	else
		806	return DIV_ONE_UN8 (scada - dcasa);
		807	}
		808
		809	PDF_SEPARABLE_BLEND_MODE (difference)
		810
		811	/*
		812	* Exclusion
		813	* B(Dca, Da, Sca, Sa) = (Sca.Da + Dca.Sa - 2.Sca.Dca)
		814	*/
		815
		816	/* This can be made faster by writing it directly and not using
		817	* PDF_SEPARABLE_BLEND_MODE, but that's a performance optimization */
		818
		819	static inline uint32_t
		820	blend_exclusion (uint32_t dca, uint32_t da, uint32_t sca, uint32_t sa)
		821	{
		822	return DIV_ONE_UN8 (sca * da + dca * sa - 2 * dca * sca);
		823	}
		824
		825	PDF_SEPARABLE_BLEND_MODE (exclusion)
		826
		827	#undef PDF_SEPARABLE_BLEND_MODE
		828
		829	/*
		830	* PDF nonseperable blend modes are implemented using the following functions
		831	* to operate in Hsl space, with Cmax, Cmid, Cmin referring to the max, mid
		832	* and min value of the red, green and blue components.
		833	*
		834	* LUM (C) = 0.3 × Cred + 0.59 × Cgreen + 0.11 × Cblue
		835	*
		836	* clip_color (C):
		837	* l = LUM (C)
		838	* min = Cmin
		839	* max = Cmax
		840	* if n < 0.0
		841	* C = l + ( ( ( C – l ) × l ) ⁄ ( l – min ) )
		842	* if x > 1.0
		843	* C = l + ( ( ( C – l ) × ( 1 – l ) ) ⁄ ( max – l ) )
		844	* return C
		845	*
		846	* set_lum (C, l):
		847	* d = l – LUM (C)
		848	* C += d
		849	* return clip_color (C)
		850	*
		851	* SAT (C) = CH_MAX (C) - CH_MIN (C)
		852	*
		853	* set_sat (C, s):
		854	* if Cmax > Cmin
		855	* Cmid = ( ( ( Cmid – Cmin ) × s ) ⁄ ( Cmax – Cmin ) )
		856	* Cmax = s
		857	* else
		858	* Cmid = Cmax = 0.0
		859	* Cmin = 0.0
		860	* return C
		861	*/
		862
		863	/* For premultiplied colors, we need to know what happens when C is
		864	* multiplied by a real number. LUM and SAT are linear:
		865	*
		866	* LUM (r × C) = r × LUM (C) SAT (r * C) = r * SAT (C)
		867	*
		868	* If we extend clip_color with an extra argument a and change
		869	*
		870	* if x >= 1.0
		871	*
		872	* into
		873	*
		874	* if x >= a
		875	*
		876	* then clip_color is also linear:
		877	*
		878	* r * clip_color (C, a) = clip_color (r_c, ra);
		879	*
		880	* for positive r.
		881	*
		882	* Similarly, we can extend set_lum with an extra argument that is just passed
		883	* on to clip_color:
		884	*
		885	* r * set_lum ( C, l, a)
		886	*
		887	* = r × clip_color ( C + l - LUM (C), a)
		888	*
		889	* = clip_color ( r * C + r × l - r * LUM (C), r * a)
		890	*
		891	* = set_lum ( r * C, r * l, r * a)
		892	*
		893	* Finally, set_sat:
		894	*
		895	* r * set_sat (C, s) = set_sat (x * C, r * s)
		896	*
3931	Serge	897	* The above holds for all non-zero x, because the x'es in the fraction for
1891	serge	898	* C_mid cancel out. Specifically, it holds for x = r:
		899	*
		900	* r * set_sat (C, s) = set_sat (r_c, rs)
		901	*
		902	*/
		903
		904	/* So, for the non-separable PDF blend modes, we have (using s, d for
		905	* non-premultiplied colors, and S, D for premultiplied:
		906	*
		907	* Color:
		908	*
		909	* a_s * a_d * B(s, d)
		910	* = a_s * a_d * set_lum (S/a_s, LUM (D/a_d), 1)
		911	* = set_lum (S * a_d, a_s * LUM (D), a_s * a_d)
		912	*
		913	*
		914	* Luminosity:
		915	*
		916	* a_s * a_d * B(s, d)
		917	* = a_s * a_d * set_lum (D/a_d, LUM(S/a_s), 1)
		918	* = set_lum (a_s * D, a_d * LUM(S), a_s * a_d)
		919	*
		920	*
		921	* Saturation:
		922	*
		923	* a_s * a_d * B(s, d)
		924	* = a_s * a_d * set_lum (set_sat (D/a_d, SAT (S/a_s)), LUM (D/a_d), 1)
		925	* = set_lum (a_s * a_d * set_sat (D/a_d, SAT (S/a_s)),
		926	* a_s * LUM (D), a_s * a_d)
		927	* = set_lum (set_sat (a_s * D, a_d * SAT (S), a_s * LUM (D), a_s * a_d))
		928	*
		929	* Hue:
		930	*
		931	* a_s * a_d * B(s, d)
		932	* = a_s * a_d * set_lum (set_sat (S/a_s, SAT (D/a_d)), LUM (D/a_d), 1)
3931	Serge	933	* = set_lum (set_sat (a_d * S, a_s * SAT (D)), a_s * LUM (D), a_s * a_d)
1891	serge	934	*
		935	*/
		936
		937	#define CH_MIN(c) (c[0] < c[1] ? (c[0] < c[2] ? c[0] : c[2]) : (c[1] < c[2] ? c[1] : c[2]))
		938	#define CH_MAX(c) (c[0] > c[1] ? (c[0] > c[2] ? c[0] : c[2]) : (c[1] > c[2] ? c[1] : c[2]))
		939	#define LUM(c) ((c[0] * 30 + c[1] * 59 + c[2] * 11) / 100)
		940	#define SAT(c) (CH_MAX (c) - CH_MIN (c))
		941
		942	#define PDF_NON_SEPARABLE_BLEND_MODE(name) \
		943	static void \
		944	combine_ ## name ## _u (pixman_implementation_t *imp, \
		945	pixman_op_t op, \
		946	uint32_t *dest, \
		947	const uint32_t *src, \
		948	const uint32_t *mask, \
		949	int width) \
		950	{ \
		951	int i; \
		952	for (i = 0; i < width; ++i) \
		953	{ \
		954	uint32_t s = combine_mask (src, mask, i); \
		955	uint32_t d = *(dest + i); \
		956	uint8_t sa = ALPHA_8 (s); \
		957	uint8_t isa = ~sa; \
		958	uint8_t da = ALPHA_8 (d); \
		959	uint8_t ida = ~da; \
		960	uint32_t result; \
		961	uint32_t sc[3], dc[3], c[3]; \
		962	\
		963	result = d; \
		964	UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (result, isa, s, ida); \
		965	dc[0] = RED_8 (d); \
		966	sc[0] = RED_8 (s); \
		967	dc[1] = GREEN_8 (d); \
		968	sc[1] = GREEN_8 (s); \
		969	dc[2] = BLUE_8 (d); \
		970	sc[2] = BLUE_8 (s); \
		971	blend_ ## name (c, dc, da, sc, sa); \
		972	\
		973	*(dest + i) = result + \
3931	Serge	974	(DIV_ONE_UN8 (sa * (uint32_t)da) << A_SHIFT) + \
1891	serge	975	(DIV_ONE_UN8 (c[0]) << R_SHIFT) + \
		976	(DIV_ONE_UN8 (c[1]) << G_SHIFT) + \
		977	(DIV_ONE_UN8 (c[2])); \
		978	} \
		979	}
		980
		981	static void
		982	set_lum (uint32_t dest[3], uint32_t src[3], uint32_t sa, uint32_t lum)
		983	{
		984	double a, l, min, max;
		985	double tmp[3];
		986
		987	a = sa * (1.0 / MASK);
		988
		989	l = lum * (1.0 / MASK);
		990	tmp[0] = src[0] * (1.0 / MASK);
		991	tmp[1] = src[1] * (1.0 / MASK);
		992	tmp[2] = src[2] * (1.0 / MASK);
		993
		994	l = l - LUM (tmp);
		995	tmp[0] += l;
		996	tmp[1] += l;
		997	tmp[2] += l;
		998
		999	/* clip_color */
		1000	l = LUM (tmp);
		1001	min = CH_MIN (tmp);
		1002	max = CH_MAX (tmp);
		1003
		1004	if (min < 0)
		1005	{
		1006	if (l - min == 0.0)
		1007	{
		1008	tmp[0] = 0;
		1009	tmp[1] = 0;
		1010	tmp[2] = 0;
		1011	}
		1012	else
		1013	{
		1014	tmp[0] = l + (tmp[0] - l) * l / (l - min);
		1015	tmp[1] = l + (tmp[1] - l) * l / (l - min);
		1016	tmp[2] = l + (tmp[2] - l) * l / (l - min);
		1017	}
		1018	}
		1019	if (max > a)
		1020	{
		1021	if (max - l == 0.0)
		1022	{
		1023	tmp[0] = a;
		1024	tmp[1] = a;
		1025	tmp[2] = a;
		1026	}
		1027	else
		1028	{
		1029	tmp[0] = l + (tmp[0] - l) * (a - l) / (max - l);
		1030	tmp[1] = l + (tmp[1] - l) * (a - l) / (max - l);
		1031	tmp[2] = l + (tmp[2] - l) * (a - l) / (max - l);
		1032	}
		1033	}
		1034
		1035	dest[0] = tmp[0] * MASK + 0.5;
		1036	dest[1] = tmp[1] * MASK + 0.5;
		1037	dest[2] = tmp[2] * MASK + 0.5;
		1038	}
		1039
		1040	static void
		1041	set_sat (uint32_t dest[3], uint32_t src[3], uint32_t sat)
		1042	{
		1043	int id[3];
		1044	uint32_t min, max;
		1045
		1046	if (src[0] > src[1])
		1047	{
		1048	if (src[0] > src[2])
		1049	{
		1050	id[0] = 0;
		1051	if (src[1] > src[2])
		1052	{
		1053	id[1] = 1;
		1054	id[2] = 2;
		1055	}
		1056	else
		1057	{
		1058	id[1] = 2;
		1059	id[2] = 1;
		1060	}
		1061	}
		1062	else
		1063	{
		1064	id[0] = 2;
		1065	id[1] = 0;
		1066	id[2] = 1;
		1067	}
		1068	}
		1069	else
		1070	{
		1071	if (src[0] > src[2])
		1072	{
		1073	id[0] = 1;
		1074	id[1] = 0;
		1075	id[2] = 2;
		1076	}
		1077	else
		1078	{
		1079	id[2] = 0;
		1080	if (src[1] > src[2])
		1081	{
		1082	id[0] = 1;
		1083	id[1] = 2;
		1084	}
		1085	else
		1086	{
		1087	id[0] = 2;
		1088	id[1] = 1;
		1089	}
		1090	}
		1091	}
		1092
		1093	max = dest[id[0]];
		1094	min = dest[id[2]];
		1095	if (max > min)
		1096	{
		1097	dest[id[1]] = (dest[id[1]] - min) * sat / (max - min);
		1098	dest[id[0]] = sat;
		1099	dest[id[2]] = 0;
		1100	}
		1101	else
		1102	{
		1103	dest[0] = dest[1] = dest[2] = 0;
		1104	}
		1105	}
		1106
		1107	/*
		1108	* Hue:
		1109	* B(Cb, Cs) = set_lum (set_sat (Cs, SAT (Cb)), LUM (Cb))
		1110	*/
		1111	static inline void
		1112	blend_hsl_hue (uint32_t c[3],
		1113	uint32_t dc[3],
		1114	uint32_t da,
		1115	uint32_t sc[3],
		1116	uint32_t sa)
		1117	{
		1118	c[0] = sc[0] * da;
		1119	c[1] = sc[1] * da;
		1120	c[2] = sc[2] * da;
		1121	set_sat (c, c, SAT (dc) * sa);
		1122	set_lum (c, c, sa * da, LUM (dc) * sa);
		1123	}
		1124
		1125	PDF_NON_SEPARABLE_BLEND_MODE (hsl_hue)
		1126
		1127	/*
		1128	* Saturation:
		1129	* B(Cb, Cs) = set_lum (set_sat (Cb, SAT (Cs)), LUM (Cb))
		1130	*/
		1131	static inline void
		1132	blend_hsl_saturation (uint32_t c[3],
		1133	uint32_t dc[3],
		1134	uint32_t da,
		1135	uint32_t sc[3],
		1136	uint32_t sa)
		1137	{
		1138	c[0] = dc[0] * sa;
		1139	c[1] = dc[1] * sa;
		1140	c[2] = dc[2] * sa;
		1141	set_sat (c, c, SAT (sc) * da);
		1142	set_lum (c, c, sa * da, LUM (dc) * sa);
		1143	}
		1144
		1145	PDF_NON_SEPARABLE_BLEND_MODE (hsl_saturation)
		1146
		1147	/*
		1148	* Color:
		1149	* B(Cb, Cs) = set_lum (Cs, LUM (Cb))
		1150	*/
		1151	static inline void
		1152	blend_hsl_color (uint32_t c[3],
		1153	uint32_t dc[3],
		1154	uint32_t da,
		1155	uint32_t sc[3],
		1156	uint32_t sa)
		1157	{
		1158	c[0] = sc[0] * da;
		1159	c[1] = sc[1] * da;
		1160	c[2] = sc[2] * da;
		1161	set_lum (c, c, sa * da, LUM (dc) * sa);
		1162	}
		1163
		1164	PDF_NON_SEPARABLE_BLEND_MODE (hsl_color)
		1165
		1166	/*
		1167	* Luminosity:
		1168	* B(Cb, Cs) = set_lum (Cb, LUM (Cs))
		1169	*/
		1170	static inline void
		1171	blend_hsl_luminosity (uint32_t c[3],
		1172	uint32_t dc[3],
		1173	uint32_t da,
		1174	uint32_t sc[3],
		1175	uint32_t sa)
		1176	{
		1177	c[0] = dc[0] * sa;
		1178	c[1] = dc[1] * sa;
		1179	c[2] = dc[2] * sa;
		1180	set_lum (c, c, sa * da, LUM (sc) * da);
		1181	}
		1182
		1183	PDF_NON_SEPARABLE_BLEND_MODE (hsl_luminosity)
		1184
		1185	#undef SAT
		1186	#undef LUM
		1187	#undef CH_MAX
		1188	#undef CH_MIN
		1189	#undef PDF_NON_SEPARABLE_BLEND_MODE
		1190
3931	Serge	1191	/* All of the disjoint/conjoint composing functions
1891	serge	1192	*
		1193	* The four entries in the first column indicate what source contributions
		1194	* come from each of the four areas of the picture -- areas covered by neither
		1195	* A nor B, areas covered only by A, areas covered only by B and finally
		1196	* areas covered by both A and B.
		1197	*
		1198	* Disjoint Conjoint
		1199	* Fa Fb Fa Fb
		1200	* (0,0,0,0) 0 0 0 0
		1201	* (0,A,0,A) 1 0 1 0
		1202	* (0,0,B,B) 0 1 0 1
		1203	* (0,A,B,A) 1 min((1-a)/b,1) 1 max(1-a/b,0)
		1204	* (0,A,B,B) min((1-b)/a,1) 1 max(1-b/a,0) 1
		1205	* (0,0,0,A) max(1-(1-b)/a,0) 0 min(1,b/a) 0
		1206	* (0,0,0,B) 0 max(1-(1-a)/b,0) 0 min(a/b,1)
		1207	* (0,A,0,0) min(1,(1-b)/a) 0 max(1-b/a,0) 0
		1208	* (0,0,B,0) 0 min(1,(1-a)/b) 0 max(1-a/b,0)
		1209	* (0,0,B,A) max(1-(1-b)/a,0) min(1,(1-a)/b) min(1,b/a) max(1-a/b,0)
		1210	* (0,A,0,B) min(1,(1-b)/a) max(1-(1-a)/b,0) max(1-b/a,0) min(1,a/b)
		1211	* (0,A,B,0) min(1,(1-b)/a) min(1,(1-a)/b) max(1-b/a,0) max(1-a/b,0)
3931	Serge	1212	*
		1213	* See http://marc.info/?l=xfree-render&m=99792000027857&w=2 for more
		1214	* information about these operators.
1891	serge	1215	*/
		1216
		1217	#define COMBINE_A_OUT 1
		1218	#define COMBINE_A_IN 2
		1219	#define COMBINE_B_OUT 4
		1220	#define COMBINE_B_IN 8
		1221
		1222	#define COMBINE_CLEAR 0
		1223	#define COMBINE_A (COMBINE_A_OUT \| COMBINE_A_IN)
		1224	#define COMBINE_B (COMBINE_B_OUT \| COMBINE_B_IN)
		1225	#define COMBINE_A_OVER (COMBINE_A_OUT \| COMBINE_B_OUT \| COMBINE_A_IN)
		1226	#define COMBINE_B_OVER (COMBINE_A_OUT \| COMBINE_B_OUT \| COMBINE_B_IN)
		1227	#define COMBINE_A_ATOP (COMBINE_B_OUT \| COMBINE_A_IN)
		1228	#define COMBINE_B_ATOP (COMBINE_A_OUT \| COMBINE_B_IN)
		1229	#define COMBINE_XOR (COMBINE_A_OUT \| COMBINE_B_OUT)
		1230
		1231	/* portion covered by a but not b */
		1232	static uint8_t
		1233	combine_disjoint_out_part (uint8_t a, uint8_t b)
		1234	{
		1235	/* min (1, (1-b) / a) */
		1236
		1237	b = ~b; /* 1 - b */
		1238	if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
		1239	return MASK; /* 1 */
		1240	return DIV_UN8 (b, a); /* (1-b) / a */
		1241	}
		1242
		1243	/* portion covered by both a and b */
		1244	static uint8_t
		1245	combine_disjoint_in_part (uint8_t a, uint8_t b)
		1246	{
		1247	/* max (1-(1-b)/a,0) */
		1248	/* = - min ((1-b)/a - 1, 0) */
		1249	/* = 1 - min (1, (1-b)/a) */
		1250
		1251	b = ~b; /* 1 - b */
		1252	if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
		1253	return 0; /* 1 - 1 */
		1254	return ~DIV_UN8(b, a); /* 1 - (1-b) / a */
		1255	}
		1256
		1257	/* portion covered by a but not b */
		1258	static uint8_t
		1259	combine_conjoint_out_part (uint8_t a, uint8_t b)
		1260	{
		1261	/* max (1-b/a,0) */
		1262	/* = 1-min(b/a,1) */
		1263
		1264	/* min (1, (1-b) / a) */
		1265
		1266	if (b >= a) /* b >= a -> b/a >= 1 */
		1267	return 0x00; /* 0 */
		1268	return ~DIV_UN8(b, a); /* 1 - b/a */
		1269	}
		1270
		1271	/* portion covered by both a and b */
		1272	static uint8_t
		1273	combine_conjoint_in_part (uint8_t a, uint8_t b)
		1274	{
		1275	/* min (1,b/a) */
		1276
		1277	if (b >= a) /* b >= a -> b/a >= 1 */
		1278	return MASK; /* 1 */
		1279	return DIV_UN8 (b, a); /* b/a */
		1280	}
		1281
		1282	#define GET_COMP(v, i) ((uint16_t) (uint8_t) ((v) >> i))
		1283
		1284	#define ADD(x, y, i, t) \
		1285	((t) = GET_COMP (x, i) + GET_COMP (y, i), \
		1286	(uint32_t) ((uint8_t) ((t) \| (0 - ((t) >> G_SHIFT)))) << (i))
		1287
		1288	#define GENERIC(x, y, i, ax, ay, t, u, v) \
		1289	((t) = (MUL_UN8 (GET_COMP (y, i), ay, (u)) + \
		1290	MUL_UN8 (GET_COMP (x, i), ax, (v))), \
		1291	(uint32_t) ((uint8_t) ((t) \| \
		1292	(0 - ((t) >> G_SHIFT)))) << (i))
		1293
		1294	static void
		1295	combine_disjoint_general_u (uint32_t * dest,
		1296	const uint32_t *src,
		1297	const uint32_t *mask,
		1298	int width,
		1299	uint8_t combine)
		1300	{
		1301	int i;
		1302
		1303	for (i = 0; i < width; ++i)
		1304	{
		1305	uint32_t s = combine_mask (src, mask, i);
		1306	uint32_t d = *(dest + i);
		1307	uint32_t m, n, o, p;
		1308	uint16_t Fa, Fb, t, u, v;
		1309	uint8_t sa = s >> A_SHIFT;
		1310	uint8_t da = d >> A_SHIFT;
		1311
		1312	switch (combine & COMBINE_A)
		1313	{
		1314	default:
		1315	Fa = 0;
		1316	break;
		1317
		1318	case COMBINE_A_OUT:
		1319	Fa = combine_disjoint_out_part (sa, da);
		1320	break;
		1321
		1322	case COMBINE_A_IN:
		1323	Fa = combine_disjoint_in_part (sa, da);
		1324	break;
		1325
		1326	case COMBINE_A:
		1327	Fa = MASK;
		1328	break;
		1329	}
		1330
		1331	switch (combine & COMBINE_B)
		1332	{
		1333	default:
		1334	Fb = 0;
		1335	break;
		1336
		1337	case COMBINE_B_OUT:
		1338	Fb = combine_disjoint_out_part (da, sa);
		1339	break;
		1340
		1341	case COMBINE_B_IN:
		1342	Fb = combine_disjoint_in_part (da, sa);
		1343	break;
		1344
		1345	case COMBINE_B:
		1346	Fb = MASK;
		1347	break;
		1348	}
		1349	m = GENERIC (s, d, 0, Fa, Fb, t, u, v);
		1350	n = GENERIC (s, d, G_SHIFT, Fa, Fb, t, u, v);
		1351	o = GENERIC (s, d, R_SHIFT, Fa, Fb, t, u, v);
		1352	p = GENERIC (s, d, A_SHIFT, Fa, Fb, t, u, v);
		1353	s = m \| n \| o \| p;
		1354	*(dest + i) = s;
		1355	}
		1356	}
		1357
		1358	static void
		1359	combine_disjoint_over_u (pixman_implementation_t *imp,
		1360	pixman_op_t op,
		1361	uint32_t * dest,
		1362	const uint32_t * src,
		1363	const uint32_t * mask,
		1364	int width)
		1365	{
		1366	int i;
		1367
		1368	for (i = 0; i < width; ++i)
		1369	{
		1370	uint32_t s = combine_mask (src, mask, i);
		1371	uint16_t a = s >> A_SHIFT;
		1372
		1373	if (s != 0x00)
		1374	{
		1375	uint32_t d = *(dest + i);
		1376	a = combine_disjoint_out_part (d >> A_SHIFT, a);
		1377	UN8x4_MUL_UN8_ADD_UN8x4 (d, a, s);
		1378
		1379	*(dest + i) = d;
		1380	}
		1381	}
		1382	}
		1383
		1384	static void
		1385	combine_disjoint_in_u (pixman_implementation_t *imp,
		1386	pixman_op_t op,
		1387	uint32_t * dest,
		1388	const uint32_t * src,
		1389	const uint32_t * mask,
		1390	int width)
		1391	{
		1392	combine_disjoint_general_u (dest, src, mask, width, COMBINE_A_IN);
		1393	}
		1394
		1395	static void
		1396	combine_disjoint_in_reverse_u (pixman_implementation_t *imp,
		1397	pixman_op_t op,
		1398	uint32_t * dest,
		1399	const uint32_t * src,
		1400	const uint32_t * mask,
		1401	int width)
		1402	{
		1403	combine_disjoint_general_u (dest, src, mask, width, COMBINE_B_IN);
		1404	}
		1405
		1406	static void
		1407	combine_disjoint_out_u (pixman_implementation_t *imp,
		1408	pixman_op_t op,
		1409	uint32_t * dest,
		1410	const uint32_t * src,
		1411	const uint32_t * mask,
		1412	int width)
		1413	{
		1414	combine_disjoint_general_u (dest, src, mask, width, COMBINE_A_OUT);
		1415	}
		1416
		1417	static void
		1418	combine_disjoint_out_reverse_u (pixman_implementation_t *imp,
		1419	pixman_op_t op,
		1420	uint32_t * dest,
		1421	const uint32_t * src,
		1422	const uint32_t * mask,
		1423	int width)
		1424	{
		1425	combine_disjoint_general_u (dest, src, mask, width, COMBINE_B_OUT);
		1426	}
		1427
		1428	static void
		1429	combine_disjoint_atop_u (pixman_implementation_t *imp,
		1430	pixman_op_t op,
		1431	uint32_t * dest,
		1432	const uint32_t * src,
		1433	const uint32_t * mask,
		1434	int width)
		1435	{
		1436	combine_disjoint_general_u (dest, src, mask, width, COMBINE_A_ATOP);
		1437	}
		1438
		1439	static void
		1440	combine_disjoint_atop_reverse_u (pixman_implementation_t *imp,
		1441	pixman_op_t op,
		1442	uint32_t * dest,
		1443	const uint32_t * src,
		1444	const uint32_t * mask,
		1445	int width)
		1446	{
		1447	combine_disjoint_general_u (dest, src, mask, width, COMBINE_B_ATOP);
		1448	}
		1449
		1450	static void
		1451	combine_disjoint_xor_u (pixman_implementation_t *imp,
		1452	pixman_op_t op,
		1453	uint32_t * dest,
		1454	const uint32_t * src,
		1455	const uint32_t * mask,
		1456	int width)
		1457	{
		1458	combine_disjoint_general_u (dest, src, mask, width, COMBINE_XOR);
		1459	}
		1460
		1461	static void
		1462	combine_conjoint_general_u (uint32_t * dest,
		1463	const uint32_t *src,
		1464	const uint32_t *mask,
		1465	int width,
		1466	uint8_t combine)
		1467	{
		1468	int i;
		1469
		1470	for (i = 0; i < width; ++i)
		1471	{
		1472	uint32_t s = combine_mask (src, mask, i);
		1473	uint32_t d = *(dest + i);
		1474	uint32_t m, n, o, p;
		1475	uint16_t Fa, Fb, t, u, v;
		1476	uint8_t sa = s >> A_SHIFT;
		1477	uint8_t da = d >> A_SHIFT;
		1478
		1479	switch (combine & COMBINE_A)
		1480	{
		1481	default:
		1482	Fa = 0;
		1483	break;
		1484
		1485	case COMBINE_A_OUT:
		1486	Fa = combine_conjoint_out_part (sa, da);
		1487	break;
		1488
		1489	case COMBINE_A_IN:
		1490	Fa = combine_conjoint_in_part (sa, da);
		1491	break;
		1492
		1493	case COMBINE_A:
		1494	Fa = MASK;
		1495	break;
		1496	}
		1497
		1498	switch (combine & COMBINE_B)
		1499	{
		1500	default:
		1501	Fb = 0;
		1502	break;
		1503
		1504	case COMBINE_B_OUT:
		1505	Fb = combine_conjoint_out_part (da, sa);
		1506	break;
		1507
		1508	case COMBINE_B_IN:
		1509	Fb = combine_conjoint_in_part (da, sa);
		1510	break;
		1511
		1512	case COMBINE_B:
		1513	Fb = MASK;
		1514	break;
		1515	}
		1516
		1517	m = GENERIC (s, d, 0, Fa, Fb, t, u, v);
		1518	n = GENERIC (s, d, G_SHIFT, Fa, Fb, t, u, v);
		1519	o = GENERIC (s, d, R_SHIFT, Fa, Fb, t, u, v);
		1520	p = GENERIC (s, d, A_SHIFT, Fa, Fb, t, u, v);
		1521
		1522	s = m \| n \| o \| p;
		1523
		1524	*(dest + i) = s;
		1525	}
		1526	}
		1527
		1528	static void
		1529	combine_conjoint_over_u (pixman_implementation_t *imp,
		1530	pixman_op_t op,
		1531	uint32_t * dest,
		1532	const uint32_t * src,
		1533	const uint32_t * mask,
		1534	int width)
		1535	{
		1536	combine_conjoint_general_u (dest, src, mask, width, COMBINE_A_OVER);
		1537	}
		1538
		1539	static void
		1540	combine_conjoint_over_reverse_u (pixman_implementation_t *imp,
		1541	pixman_op_t op,
		1542	uint32_t * dest,
		1543	const uint32_t * src,
		1544	const uint32_t * mask,
		1545	int width)
		1546	{
		1547	combine_conjoint_general_u (dest, src, mask, width, COMBINE_B_OVER);
		1548	}
		1549
		1550	static void
		1551	combine_conjoint_in_u (pixman_implementation_t *imp,
		1552	pixman_op_t op,
		1553	uint32_t * dest,
		1554	const uint32_t * src,
		1555	const uint32_t * mask,
		1556	int width)
		1557	{
		1558	combine_conjoint_general_u (dest, src, mask, width, COMBINE_A_IN);
		1559	}
		1560
		1561	static void
		1562	combine_conjoint_in_reverse_u (pixman_implementation_t *imp,
		1563	pixman_op_t op,
		1564	uint32_t * dest,
		1565	const uint32_t * src,
		1566	const uint32_t * mask,
		1567	int width)
		1568	{
		1569	combine_conjoint_general_u (dest, src, mask, width, COMBINE_B_IN);
		1570	}
		1571
		1572	static void
		1573	combine_conjoint_out_u (pixman_implementation_t *imp,
		1574	pixman_op_t op,
		1575	uint32_t * dest,
		1576	const uint32_t * src,
		1577	const uint32_t * mask,
		1578	int width)
		1579	{
		1580	combine_conjoint_general_u (dest, src, mask, width, COMBINE_A_OUT);
		1581	}
		1582
		1583	static void
		1584	combine_conjoint_out_reverse_u (pixman_implementation_t *imp,
		1585	pixman_op_t op,
		1586	uint32_t * dest,
		1587	const uint32_t * src,
		1588	const uint32_t * mask,
		1589	int width)
		1590	{
		1591	combine_conjoint_general_u (dest, src, mask, width, COMBINE_B_OUT);
		1592	}
		1593
		1594	static void
		1595	combine_conjoint_atop_u (pixman_implementation_t *imp,
		1596	pixman_op_t op,
		1597	uint32_t * dest,
		1598	const uint32_t * src,
		1599	const uint32_t * mask,
		1600	int width)
		1601	{
		1602	combine_conjoint_general_u (dest, src, mask, width, COMBINE_A_ATOP);
		1603	}
		1604
		1605	static void
		1606	combine_conjoint_atop_reverse_u (pixman_implementation_t *imp,
		1607	pixman_op_t op,
		1608	uint32_t * dest,
		1609	const uint32_t * src,
		1610	const uint32_t * mask,
		1611	int width)
		1612	{
		1613	combine_conjoint_general_u (dest, src, mask, width, COMBINE_B_ATOP);
		1614	}
		1615
		1616	static void
		1617	combine_conjoint_xor_u (pixman_implementation_t *imp,
		1618	pixman_op_t op,
		1619	uint32_t * dest,
		1620	const uint32_t * src,
		1621	const uint32_t * mask,
		1622	int width)
		1623	{
		1624	combine_conjoint_general_u (dest, src, mask, width, COMBINE_XOR);
		1625	}
		1626
		1627
3931	Serge	1628	/* Component alpha combiners */
		1629
1891	serge	1630	static void
		1631	combine_clear_ca (pixman_implementation_t *imp,
		1632	pixman_op_t op,
		1633	uint32_t * dest,
		1634	const uint32_t * src,
		1635	const uint32_t * mask,
		1636	int width)
		1637	{
		1638	memset (dest, 0, width * sizeof(uint32_t));
		1639	}
		1640
		1641	static void
		1642	combine_src_ca (pixman_implementation_t *imp,
		1643	pixman_op_t op,
		1644	uint32_t * dest,
		1645	const uint32_t * src,
		1646	const uint32_t * mask,
		1647	int width)
		1648	{
		1649	int i;
		1650
		1651	for (i = 0; i < width; ++i)
		1652	{
		1653	uint32_t s = *(src + i);
		1654	uint32_t m = *(mask + i);
		1655
		1656	combine_mask_value_ca (&s, &m);
		1657
		1658	*(dest + i) = s;
		1659	}
		1660	}
		1661
		1662	static void
		1663	combine_over_ca (pixman_implementation_t *imp,
		1664	pixman_op_t op,
		1665	uint32_t * dest,
		1666	const uint32_t * src,
		1667	const uint32_t * mask,
		1668	int width)
		1669	{
		1670	int i;
		1671
		1672	for (i = 0; i < width; ++i)
		1673	{
		1674	uint32_t s = *(src + i);
		1675	uint32_t m = *(mask + i);
		1676	uint32_t a;
		1677
		1678	combine_mask_ca (&s, &m);
		1679
		1680	a = ~m;
		1681	if (a)
		1682	{
		1683	uint32_t d = *(dest + i);
		1684	UN8x4_MUL_UN8x4_ADD_UN8x4 (d, a, s);
		1685	s = d;
		1686	}
		1687
		1688	*(dest + i) = s;
		1689	}
		1690	}
		1691
		1692	static void
		1693	combine_over_reverse_ca (pixman_implementation_t *imp,
		1694	pixman_op_t op,
		1695	uint32_t * dest,
		1696	const uint32_t * src,
		1697	const uint32_t * mask,
		1698	int width)
		1699	{
		1700	int i;
		1701
		1702	for (i = 0; i < width; ++i)
		1703	{
		1704	uint32_t d = *(dest + i);
		1705	uint32_t a = ~d >> A_SHIFT;
		1706
		1707	if (a)
		1708	{
		1709	uint32_t s = *(src + i);
		1710	uint32_t m = *(mask + i);
		1711
		1712	UN8x4_MUL_UN8x4 (s, m);
		1713	UN8x4_MUL_UN8_ADD_UN8x4 (s, a, d);
		1714
		1715	*(dest + i) = s;
		1716	}
		1717	}
		1718	}
		1719
		1720	static void
		1721	combine_in_ca (pixman_implementation_t *imp,
		1722	pixman_op_t op,
		1723	uint32_t * dest,
		1724	const uint32_t * src,
		1725	const uint32_t * mask,
		1726	int width)
		1727	{
		1728	int i;
		1729
		1730	for (i = 0; i < width; ++i)
		1731	{
		1732	uint32_t d = *(dest + i);
		1733	uint16_t a = d >> A_SHIFT;
		1734	uint32_t s = 0;
		1735
		1736	if (a)
		1737	{
		1738	uint32_t m = *(mask + i);
		1739
		1740	s = *(src + i);
		1741	combine_mask_value_ca (&s, &m);
		1742
		1743	if (a != MASK)
		1744	UN8x4_MUL_UN8 (s, a);
		1745	}
		1746
		1747	*(dest + i) = s;
		1748	}
		1749	}
		1750
		1751	static void
		1752	combine_in_reverse_ca (pixman_implementation_t *imp,
		1753	pixman_op_t op,
		1754	uint32_t * dest,
		1755	const uint32_t * src,
		1756	const uint32_t * mask,
		1757	int width)
		1758	{
		1759	int i;
		1760
		1761	for (i = 0; i < width; ++i)
		1762	{
		1763	uint32_t s = *(src + i);
		1764	uint32_t m = *(mask + i);
		1765	uint32_t a;
		1766
		1767	combine_mask_alpha_ca (&s, &m);
		1768
		1769	a = m;
		1770	if (a != ~0)
		1771	{
		1772	uint32_t d = 0;
		1773
		1774	if (a)
		1775	{
		1776	d = *(dest + i);
		1777	UN8x4_MUL_UN8x4 (d, a);
		1778	}
		1779
		1780	*(dest + i) = d;
		1781	}
		1782	}
		1783	}
		1784
		1785	static void
		1786	combine_out_ca (pixman_implementation_t *imp,
		1787	pixman_op_t op,
		1788	uint32_t * dest,
		1789	const uint32_t * src,
		1790	const uint32_t * mask,
		1791	int width)
		1792	{
		1793	int i;
		1794
		1795	for (i = 0; i < width; ++i)
		1796	{
		1797	uint32_t d = *(dest + i);
		1798	uint16_t a = ~d >> A_SHIFT;
		1799	uint32_t s = 0;
		1800
		1801	if (a)
		1802	{
		1803	uint32_t m = *(mask + i);
		1804
		1805	s = *(src + i);
		1806	combine_mask_value_ca (&s, &m);
		1807
		1808	if (a != MASK)
		1809	UN8x4_MUL_UN8 (s, a);
		1810	}
		1811
		1812	*(dest + i) = s;
		1813	}
		1814	}
		1815
		1816	static void
		1817	combine_out_reverse_ca (pixman_implementation_t *imp,
		1818	pixman_op_t op,
		1819	uint32_t * dest,
		1820	const uint32_t * src,
		1821	const uint32_t * mask,
		1822	int width)
		1823	{
		1824	int i;
		1825
		1826	for (i = 0; i < width; ++i)
		1827	{
		1828	uint32_t s = *(src + i);
		1829	uint32_t m = *(mask + i);
		1830	uint32_t a;
		1831
		1832	combine_mask_alpha_ca (&s, &m);
		1833
		1834	a = ~m;
		1835	if (a != ~0)
		1836	{
		1837	uint32_t d = 0;
		1838
		1839	if (a)
		1840	{
		1841	d = *(dest + i);
		1842	UN8x4_MUL_UN8x4 (d, a);
		1843	}
		1844
		1845	*(dest + i) = d;
		1846	}
		1847	}
		1848	}
		1849
		1850	static void
		1851	combine_atop_ca (pixman_implementation_t *imp,
		1852	pixman_op_t op,
		1853	uint32_t * dest,
		1854	const uint32_t * src,
		1855	const uint32_t * mask,
		1856	int width)
		1857	{
		1858	int i;
		1859
		1860	for (i = 0; i < width; ++i)
		1861	{
		1862	uint32_t d = *(dest + i);
		1863	uint32_t s = *(src + i);
		1864	uint32_t m = *(mask + i);
		1865	uint32_t ad;
		1866	uint16_t as = d >> A_SHIFT;
		1867
		1868	combine_mask_ca (&s, &m);
		1869
		1870	ad = ~m;
		1871
		1872	UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (d, ad, s, as);
		1873
		1874	*(dest + i) = d;
		1875	}
		1876	}
		1877
		1878	static void
		1879	combine_atop_reverse_ca (pixman_implementation_t *imp,
		1880	pixman_op_t op,
		1881	uint32_t * dest,
		1882	const uint32_t * src,
		1883	const uint32_t * mask,
		1884	int width)
		1885	{
		1886	int i;
		1887
		1888	for (i = 0; i < width; ++i)
		1889	{
		1890	uint32_t d = *(dest + i);
		1891	uint32_t s = *(src + i);
		1892	uint32_t m = *(mask + i);
		1893	uint32_t ad;
		1894	uint16_t as = ~d >> A_SHIFT;
		1895
		1896	combine_mask_ca (&s, &m);
		1897
		1898	ad = m;
		1899
		1900	UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (d, ad, s, as);
		1901
		1902	*(dest + i) = d;
		1903	}
		1904	}
		1905
		1906	static void
		1907	combine_xor_ca (pixman_implementation_t *imp,
		1908	pixman_op_t op,
		1909	uint32_t * dest,
		1910	const uint32_t * src,
		1911	const uint32_t * mask,
		1912	int width)
		1913	{
		1914	int i;
		1915
		1916	for (i = 0; i < width; ++i)
		1917	{
		1918	uint32_t d = *(dest + i);
		1919	uint32_t s = *(src + i);
		1920	uint32_t m = *(mask + i);
		1921	uint32_t ad;
		1922	uint16_t as = ~d >> A_SHIFT;
		1923
		1924	combine_mask_ca (&s, &m);
		1925
		1926	ad = ~m;
		1927
		1928	UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (d, ad, s, as);
		1929
		1930	*(dest + i) = d;
		1931	}
		1932	}
		1933
		1934	static void
		1935	combine_add_ca (pixman_implementation_t *imp,
		1936	pixman_op_t op,
		1937	uint32_t * dest,
		1938	const uint32_t * src,
		1939	const uint32_t * mask,
		1940	int width)
		1941	{
		1942	int i;
		1943
		1944	for (i = 0; i < width; ++i)
		1945	{
		1946	uint32_t s = *(src + i);
		1947	uint32_t m = *(mask + i);
		1948	uint32_t d = *(dest + i);
		1949
		1950	combine_mask_value_ca (&s, &m);
		1951
		1952	UN8x4_ADD_UN8x4 (d, s);
		1953
		1954	*(dest + i) = d;
		1955	}
		1956	}
		1957
		1958	static void
		1959	combine_saturate_ca (pixman_implementation_t *imp,
		1960	pixman_op_t op,
		1961	uint32_t * dest,
		1962	const uint32_t * src,
		1963	const uint32_t * mask,
		1964	int width)
		1965	{
		1966	int i;
		1967
		1968	for (i = 0; i < width; ++i)
		1969	{
		1970	uint32_t s, d;
		1971	uint16_t sa, sr, sg, sb, da;
		1972	uint16_t t, u, v;
		1973	uint32_t m, n, o, p;
		1974
		1975	d = *(dest + i);
		1976	s = *(src + i);
		1977	m = *(mask + i);
		1978
		1979	combine_mask_ca (&s, &m);
		1980
		1981	sa = (m >> A_SHIFT);
		1982	sr = (m >> R_SHIFT) & MASK;
		1983	sg = (m >> G_SHIFT) & MASK;
		1984	sb = m & MASK;
		1985	da = ~d >> A_SHIFT;
		1986
		1987	if (sb <= da)
		1988	m = ADD (s, d, 0, t);
		1989	else
		1990	m = GENERIC (s, d, 0, (da << G_SHIFT) / sb, MASK, t, u, v);
		1991
		1992	if (sg <= da)
		1993	n = ADD (s, d, G_SHIFT, t);
		1994	else
		1995	n = GENERIC (s, d, G_SHIFT, (da << G_SHIFT) / sg, MASK, t, u, v);
		1996
		1997	if (sr <= da)
		1998	o = ADD (s, d, R_SHIFT, t);
		1999	else
		2000	o = GENERIC (s, d, R_SHIFT, (da << G_SHIFT) / sr, MASK, t, u, v);
		2001
		2002	if (sa <= da)
		2003	p = ADD (s, d, A_SHIFT, t);
		2004	else
		2005	p = GENERIC (s, d, A_SHIFT, (da << G_SHIFT) / sa, MASK, t, u, v);
		2006
		2007	*(dest + i) = m \| n \| o \| p;
		2008	}
		2009	}
		2010
		2011	static void
		2012	combine_disjoint_general_ca (uint32_t * dest,
		2013	const uint32_t *src,
		2014	const uint32_t *mask,
		2015	int width,
		2016	uint8_t combine)
		2017	{
		2018	int i;
		2019
		2020	for (i = 0; i < width; ++i)
		2021	{
		2022	uint32_t s, d;
		2023	uint32_t m, n, o, p;
		2024	uint32_t Fa, Fb;
		2025	uint16_t t, u, v;
		2026	uint32_t sa;
		2027	uint8_t da;
		2028
		2029	s = *(src + i);
		2030	m = *(mask + i);
		2031	d = *(dest + i);
		2032	da = d >> A_SHIFT;
		2033
		2034	combine_mask_ca (&s, &m);
		2035
		2036	sa = m;
		2037
		2038	switch (combine & COMBINE_A)
		2039	{
		2040	default:
		2041	Fa = 0;
		2042	break;
		2043
		2044	case COMBINE_A_OUT:
		2045	m = (uint32_t)combine_disjoint_out_part ((uint8_t) (sa >> 0), da);
		2046	n = (uint32_t)combine_disjoint_out_part ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
		2047	o = (uint32_t)combine_disjoint_out_part ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
		2048	p = (uint32_t)combine_disjoint_out_part ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
		2049	Fa = m \| n \| o \| p;
		2050	break;
		2051
		2052	case COMBINE_A_IN:
		2053	m = (uint32_t)combine_disjoint_in_part ((uint8_t) (sa >> 0), da);
		2054	n = (uint32_t)combine_disjoint_in_part ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
		2055	o = (uint32_t)combine_disjoint_in_part ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
		2056	p = (uint32_t)combine_disjoint_in_part ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
		2057	Fa = m \| n \| o \| p;
		2058	break;
		2059
		2060	case COMBINE_A:
		2061	Fa = ~0;
		2062	break;
		2063	}
		2064
		2065	switch (combine & COMBINE_B)
		2066	{
		2067	default:
		2068	Fb = 0;
		2069	break;
		2070
		2071	case COMBINE_B_OUT:
		2072	m = (uint32_t)combine_disjoint_out_part (da, (uint8_t) (sa >> 0));
		2073	n = (uint32_t)combine_disjoint_out_part (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
		2074	o = (uint32_t)combine_disjoint_out_part (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
		2075	p = (uint32_t)combine_disjoint_out_part (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
		2076	Fb = m \| n \| o \| p;
		2077	break;
		2078
		2079	case COMBINE_B_IN:
		2080	m = (uint32_t)combine_disjoint_in_part (da, (uint8_t) (sa >> 0));
		2081	n = (uint32_t)combine_disjoint_in_part (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
		2082	o = (uint32_t)combine_disjoint_in_part (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
		2083	p = (uint32_t)combine_disjoint_in_part (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
		2084	Fb = m \| n \| o \| p;
		2085	break;
		2086
		2087	case COMBINE_B:
		2088	Fb = ~0;
		2089	break;
		2090	}
		2091	m = GENERIC (s, d, 0, GET_COMP (Fa, 0), GET_COMP (Fb, 0), t, u, v);
		2092	n = GENERIC (s, d, G_SHIFT, GET_COMP (Fa, G_SHIFT), GET_COMP (Fb, G_SHIFT), t, u, v);
		2093	o = GENERIC (s, d, R_SHIFT, GET_COMP (Fa, R_SHIFT), GET_COMP (Fb, R_SHIFT), t, u, v);
		2094	p = GENERIC (s, d, A_SHIFT, GET_COMP (Fa, A_SHIFT), GET_COMP (Fb, A_SHIFT), t, u, v);
		2095
		2096	s = m \| n \| o \| p;
		2097
		2098	*(dest + i) = s;
		2099	}
		2100	}
		2101
		2102	static void
		2103	combine_disjoint_over_ca (pixman_implementation_t *imp,
		2104	pixman_op_t op,
		2105	uint32_t * dest,
		2106	const uint32_t * src,
		2107	const uint32_t * mask,
		2108	int width)
		2109	{
		2110	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_A_OVER);
		2111	}
		2112
		2113	static void
		2114	combine_disjoint_in_ca (pixman_implementation_t *imp,
		2115	pixman_op_t op,
		2116	uint32_t * dest,
		2117	const uint32_t * src,
		2118	const uint32_t * mask,
		2119	int width)
		2120	{
		2121	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_A_IN);
		2122	}
		2123
		2124	static void
		2125	combine_disjoint_in_reverse_ca (pixman_implementation_t *imp,
		2126	pixman_op_t op,
		2127	uint32_t * dest,
		2128	const uint32_t * src,
		2129	const uint32_t * mask,
		2130	int width)
		2131	{
		2132	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_B_IN);
		2133	}
		2134
		2135	static void
		2136	combine_disjoint_out_ca (pixman_implementation_t *imp,
		2137	pixman_op_t op,
		2138	uint32_t * dest,
		2139	const uint32_t * src,
		2140	const uint32_t * mask,
		2141	int width)
		2142	{
		2143	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_A_OUT);
		2144	}
		2145
		2146	static void
		2147	combine_disjoint_out_reverse_ca (pixman_implementation_t *imp,
		2148	pixman_op_t op,
		2149	uint32_t * dest,
		2150	const uint32_t * src,
		2151	const uint32_t * mask,
		2152	int width)
		2153	{
		2154	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_B_OUT);
		2155	}
		2156
		2157	static void
		2158	combine_disjoint_atop_ca (pixman_implementation_t *imp,
		2159	pixman_op_t op,
		2160	uint32_t * dest,
		2161	const uint32_t * src,
		2162	const uint32_t * mask,
		2163	int width)
		2164	{
		2165	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_A_ATOP);
		2166	}
		2167
		2168	static void
		2169	combine_disjoint_atop_reverse_ca (pixman_implementation_t *imp,
		2170	pixman_op_t op,
		2171	uint32_t * dest,
		2172	const uint32_t * src,
		2173	const uint32_t * mask,
		2174	int width)
		2175	{
		2176	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_B_ATOP);
		2177	}
		2178
		2179	static void
		2180	combine_disjoint_xor_ca (pixman_implementation_t *imp,
		2181	pixman_op_t op,
		2182	uint32_t * dest,
		2183	const uint32_t * src,
		2184	const uint32_t * mask,
		2185	int width)
		2186	{
		2187	combine_disjoint_general_ca (dest, src, mask, width, COMBINE_XOR);
		2188	}
		2189
		2190	static void
		2191	combine_conjoint_general_ca (uint32_t * dest,
		2192	const uint32_t *src,
		2193	const uint32_t *mask,
		2194	int width,
		2195	uint8_t combine)
		2196	{
		2197	int i;
		2198
		2199	for (i = 0; i < width; ++i)
		2200	{
		2201	uint32_t s, d;
		2202	uint32_t m, n, o, p;
		2203	uint32_t Fa, Fb;
		2204	uint16_t t, u, v;
		2205	uint32_t sa;
		2206	uint8_t da;
		2207
		2208	s = *(src + i);
		2209	m = *(mask + i);
		2210	d = *(dest + i);
		2211	da = d >> A_SHIFT;
		2212
		2213	combine_mask_ca (&s, &m);
		2214
		2215	sa = m;
		2216
		2217	switch (combine & COMBINE_A)
		2218	{
		2219	default:
		2220	Fa = 0;
		2221	break;
		2222
		2223	case COMBINE_A_OUT:
		2224	m = (uint32_t)combine_conjoint_out_part ((uint8_t) (sa >> 0), da);
		2225	n = (uint32_t)combine_conjoint_out_part ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
		2226	o = (uint32_t)combine_conjoint_out_part ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
		2227	p = (uint32_t)combine_conjoint_out_part ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
		2228	Fa = m \| n \| o \| p;
		2229	break;
		2230
		2231	case COMBINE_A_IN:
		2232	m = (uint32_t)combine_conjoint_in_part ((uint8_t) (sa >> 0), da);
		2233	n = (uint32_t)combine_conjoint_in_part ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
		2234	o = (uint32_t)combine_conjoint_in_part ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
		2235	p = (uint32_t)combine_conjoint_in_part ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
		2236	Fa = m \| n \| o \| p;
		2237	break;
		2238
		2239	case COMBINE_A:
		2240	Fa = ~0;
		2241	break;
		2242	}
		2243
		2244	switch (combine & COMBINE_B)
		2245	{
		2246	default:
		2247	Fb = 0;
		2248	break;
		2249
		2250	case COMBINE_B_OUT:
		2251	m = (uint32_t)combine_conjoint_out_part (da, (uint8_t) (sa >> 0));
		2252	n = (uint32_t)combine_conjoint_out_part (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
		2253	o = (uint32_t)combine_conjoint_out_part (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
		2254	p = (uint32_t)combine_conjoint_out_part (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
		2255	Fb = m \| n \| o \| p;
		2256	break;
		2257
		2258	case COMBINE_B_IN:
		2259	m = (uint32_t)combine_conjoint_in_part (da, (uint8_t) (sa >> 0));
		2260	n = (uint32_t)combine_conjoint_in_part (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
		2261	o = (uint32_t)combine_conjoint_in_part (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
		2262	p = (uint32_t)combine_conjoint_in_part (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
		2263	Fb = m \| n \| o \| p;
		2264	break;
		2265
		2266	case COMBINE_B:
		2267	Fb = ~0;
		2268	break;
		2269	}
		2270	m = GENERIC (s, d, 0, GET_COMP (Fa, 0), GET_COMP (Fb, 0), t, u, v);
		2271	n = GENERIC (s, d, G_SHIFT, GET_COMP (Fa, G_SHIFT), GET_COMP (Fb, G_SHIFT), t, u, v);
		2272	o = GENERIC (s, d, R_SHIFT, GET_COMP (Fa, R_SHIFT), GET_COMP (Fb, R_SHIFT), t, u, v);
		2273	p = GENERIC (s, d, A_SHIFT, GET_COMP (Fa, A_SHIFT), GET_COMP (Fb, A_SHIFT), t, u, v);
		2274
		2275	s = m \| n \| o \| p;
		2276
		2277	*(dest + i) = s;
		2278	}
		2279	}
		2280
		2281	static void
		2282	combine_conjoint_over_ca (pixman_implementation_t *imp,
		2283	pixman_op_t op,
		2284	uint32_t * dest,
		2285	const uint32_t * src,
		2286	const uint32_t * mask,
		2287	int width)
		2288	{
		2289	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_A_OVER);
		2290	}
		2291
		2292	static void
		2293	combine_conjoint_over_reverse_ca (pixman_implementation_t *imp,
		2294	pixman_op_t op,
		2295	uint32_t * dest,
		2296	const uint32_t * src,
		2297	const uint32_t * mask,
		2298	int width)
		2299	{
		2300	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_B_OVER);
		2301	}
		2302
		2303	static void
		2304	combine_conjoint_in_ca (pixman_implementation_t *imp,
		2305	pixman_op_t op,
		2306	uint32_t * dest,
		2307	const uint32_t * src,
		2308	const uint32_t * mask,
		2309	int width)
		2310	{
		2311	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_A_IN);
		2312	}
		2313
		2314	static void
		2315	combine_conjoint_in_reverse_ca (pixman_implementation_t *imp,
		2316	pixman_op_t op,
		2317	uint32_t * dest,
		2318	const uint32_t * src,
		2319	const uint32_t * mask,
		2320	int width)
		2321	{
		2322	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_B_IN);
		2323	}
		2324
		2325	static void
		2326	combine_conjoint_out_ca (pixman_implementation_t *imp,
		2327	pixman_op_t op,
		2328	uint32_t * dest,
		2329	const uint32_t * src,
		2330	const uint32_t * mask,
		2331	int width)
		2332	{
		2333	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_A_OUT);
		2334	}
		2335
		2336	static void
		2337	combine_conjoint_out_reverse_ca (pixman_implementation_t *imp,
		2338	pixman_op_t op,
		2339	uint32_t * dest,
		2340	const uint32_t * src,
		2341	const uint32_t * mask,
		2342	int width)
		2343	{
		2344	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_B_OUT);
		2345	}
		2346
		2347	static void
		2348	combine_conjoint_atop_ca (pixman_implementation_t *imp,
		2349	pixman_op_t op,
		2350	uint32_t * dest,
		2351	const uint32_t * src,
		2352	const uint32_t * mask,
		2353	int width)
		2354	{
		2355	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_A_ATOP);
		2356	}
		2357
		2358	static void
		2359	combine_conjoint_atop_reverse_ca (pixman_implementation_t *imp,
		2360	pixman_op_t op,
		2361	uint32_t * dest,
		2362	const uint32_t * src,
		2363	const uint32_t * mask,
		2364	int width)
		2365	{
		2366	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_B_ATOP);
		2367	}
		2368
		2369	static void
		2370	combine_conjoint_xor_ca (pixman_implementation_t *imp,
		2371	pixman_op_t op,
		2372	uint32_t * dest,
		2373	const uint32_t * src,
		2374	const uint32_t * mask,
		2375	int width)
		2376	{
		2377	combine_conjoint_general_ca (dest, src, mask, width, COMBINE_XOR);
		2378	}
		2379
		2380	void
		2381	_pixman_setup_combiner_functions_32 (pixman_implementation_t *imp)
		2382	{
		2383	/* Unified alpha */
		2384	imp->combine_32[PIXMAN_OP_CLEAR] = combine_clear;
		2385	imp->combine_32[PIXMAN_OP_SRC] = combine_src_u;
		2386	imp->combine_32[PIXMAN_OP_DST] = combine_dst;
		2387	imp->combine_32[PIXMAN_OP_OVER] = combine_over_u;
		2388	imp->combine_32[PIXMAN_OP_OVER_REVERSE] = combine_over_reverse_u;
		2389	imp->combine_32[PIXMAN_OP_IN] = combine_in_u;
		2390	imp->combine_32[PIXMAN_OP_IN_REVERSE] = combine_in_reverse_u;
		2391	imp->combine_32[PIXMAN_OP_OUT] = combine_out_u;
		2392	imp->combine_32[PIXMAN_OP_OUT_REVERSE] = combine_out_reverse_u;
		2393	imp->combine_32[PIXMAN_OP_ATOP] = combine_atop_u;
		2394	imp->combine_32[PIXMAN_OP_ATOP_REVERSE] = combine_atop_reverse_u;
		2395	imp->combine_32[PIXMAN_OP_XOR] = combine_xor_u;
		2396	imp->combine_32[PIXMAN_OP_ADD] = combine_add_u;
		2397	imp->combine_32[PIXMAN_OP_SATURATE] = combine_saturate_u;
		2398
		2399	/* Disjoint, unified */
		2400	imp->combine_32[PIXMAN_OP_DISJOINT_CLEAR] = combine_clear;
		2401	imp->combine_32[PIXMAN_OP_DISJOINT_SRC] = combine_src_u;
		2402	imp->combine_32[PIXMAN_OP_DISJOINT_DST] = combine_dst;
		2403	imp->combine_32[PIXMAN_OP_DISJOINT_OVER] = combine_disjoint_over_u;
		2404	imp->combine_32[PIXMAN_OP_DISJOINT_OVER_REVERSE] = combine_saturate_u;
		2405	imp->combine_32[PIXMAN_OP_DISJOINT_IN] = combine_disjoint_in_u;
		2406	imp->combine_32[PIXMAN_OP_DISJOINT_IN_REVERSE] = combine_disjoint_in_reverse_u;
		2407	imp->combine_32[PIXMAN_OP_DISJOINT_OUT] = combine_disjoint_out_u;
		2408	imp->combine_32[PIXMAN_OP_DISJOINT_OUT_REVERSE] = combine_disjoint_out_reverse_u;
		2409	imp->combine_32[PIXMAN_OP_DISJOINT_ATOP] = combine_disjoint_atop_u;
		2410	imp->combine_32[PIXMAN_OP_DISJOINT_ATOP_REVERSE] = combine_disjoint_atop_reverse_u;
		2411	imp->combine_32[PIXMAN_OP_DISJOINT_XOR] = combine_disjoint_xor_u;
		2412
		2413	/* Conjoint, unified */
		2414	imp->combine_32[PIXMAN_OP_CONJOINT_CLEAR] = combine_clear;
		2415	imp->combine_32[PIXMAN_OP_CONJOINT_SRC] = combine_src_u;
		2416	imp->combine_32[PIXMAN_OP_CONJOINT_DST] = combine_dst;
		2417	imp->combine_32[PIXMAN_OP_CONJOINT_OVER] = combine_conjoint_over_u;
		2418	imp->combine_32[PIXMAN_OP_CONJOINT_OVER_REVERSE] = combine_conjoint_over_reverse_u;
		2419	imp->combine_32[PIXMAN_OP_CONJOINT_IN] = combine_conjoint_in_u;
		2420	imp->combine_32[PIXMAN_OP_CONJOINT_IN_REVERSE] = combine_conjoint_in_reverse_u;
		2421	imp->combine_32[PIXMAN_OP_CONJOINT_OUT] = combine_conjoint_out_u;
		2422	imp->combine_32[PIXMAN_OP_CONJOINT_OUT_REVERSE] = combine_conjoint_out_reverse_u;
		2423	imp->combine_32[PIXMAN_OP_CONJOINT_ATOP] = combine_conjoint_atop_u;
		2424	imp->combine_32[PIXMAN_OP_CONJOINT_ATOP_REVERSE] = combine_conjoint_atop_reverse_u;
		2425	imp->combine_32[PIXMAN_OP_CONJOINT_XOR] = combine_conjoint_xor_u;
		2426
		2427	imp->combine_32[PIXMAN_OP_MULTIPLY] = combine_multiply_u;
		2428	imp->combine_32[PIXMAN_OP_SCREEN] = combine_screen_u;
		2429	imp->combine_32[PIXMAN_OP_OVERLAY] = combine_overlay_u;
		2430	imp->combine_32[PIXMAN_OP_DARKEN] = combine_darken_u;
		2431	imp->combine_32[PIXMAN_OP_LIGHTEN] = combine_lighten_u;
		2432	imp->combine_32[PIXMAN_OP_COLOR_DODGE] = combine_color_dodge_u;
		2433	imp->combine_32[PIXMAN_OP_COLOR_BURN] = combine_color_burn_u;
		2434	imp->combine_32[PIXMAN_OP_HARD_LIGHT] = combine_hard_light_u;
		2435	imp->combine_32[PIXMAN_OP_SOFT_LIGHT] = combine_soft_light_u;
		2436	imp->combine_32[PIXMAN_OP_DIFFERENCE] = combine_difference_u;
		2437	imp->combine_32[PIXMAN_OP_EXCLUSION] = combine_exclusion_u;
		2438	imp->combine_32[PIXMAN_OP_HSL_HUE] = combine_hsl_hue_u;
		2439	imp->combine_32[PIXMAN_OP_HSL_SATURATION] = combine_hsl_saturation_u;
		2440	imp->combine_32[PIXMAN_OP_HSL_COLOR] = combine_hsl_color_u;
		2441	imp->combine_32[PIXMAN_OP_HSL_LUMINOSITY] = combine_hsl_luminosity_u;
		2442
		2443	/* Component alpha combiners */
		2444	imp->combine_32_ca[PIXMAN_OP_CLEAR] = combine_clear_ca;
		2445	imp->combine_32_ca[PIXMAN_OP_SRC] = combine_src_ca;
		2446	/* dest */
		2447	imp->combine_32_ca[PIXMAN_OP_OVER] = combine_over_ca;
		2448	imp->combine_32_ca[PIXMAN_OP_OVER_REVERSE] = combine_over_reverse_ca;
		2449	imp->combine_32_ca[PIXMAN_OP_IN] = combine_in_ca;
		2450	imp->combine_32_ca[PIXMAN_OP_IN_REVERSE] = combine_in_reverse_ca;
		2451	imp->combine_32_ca[PIXMAN_OP_OUT] = combine_out_ca;
		2452	imp->combine_32_ca[PIXMAN_OP_OUT_REVERSE] = combine_out_reverse_ca;
		2453	imp->combine_32_ca[PIXMAN_OP_ATOP] = combine_atop_ca;
		2454	imp->combine_32_ca[PIXMAN_OP_ATOP_REVERSE] = combine_atop_reverse_ca;
		2455	imp->combine_32_ca[PIXMAN_OP_XOR] = combine_xor_ca;
		2456	imp->combine_32_ca[PIXMAN_OP_ADD] = combine_add_ca;
		2457	imp->combine_32_ca[PIXMAN_OP_SATURATE] = combine_saturate_ca;
		2458
		2459	/* Disjoint CA */
		2460	imp->combine_32_ca[PIXMAN_OP_DISJOINT_CLEAR] = combine_clear_ca;
		2461	imp->combine_32_ca[PIXMAN_OP_DISJOINT_SRC] = combine_src_ca;
		2462	imp->combine_32_ca[PIXMAN_OP_DISJOINT_DST] = combine_dst;
		2463	imp->combine_32_ca[PIXMAN_OP_DISJOINT_OVER] = combine_disjoint_over_ca;
		2464	imp->combine_32_ca[PIXMAN_OP_DISJOINT_OVER_REVERSE] = combine_saturate_ca;
		2465	imp->combine_32_ca[PIXMAN_OP_DISJOINT_IN] = combine_disjoint_in_ca;
		2466	imp->combine_32_ca[PIXMAN_OP_DISJOINT_IN_REVERSE] = combine_disjoint_in_reverse_ca;
		2467	imp->combine_32_ca[PIXMAN_OP_DISJOINT_OUT] = combine_disjoint_out_ca;
		2468	imp->combine_32_ca[PIXMAN_OP_DISJOINT_OUT_REVERSE] = combine_disjoint_out_reverse_ca;
		2469	imp->combine_32_ca[PIXMAN_OP_DISJOINT_ATOP] = combine_disjoint_atop_ca;
		2470	imp->combine_32_ca[PIXMAN_OP_DISJOINT_ATOP_REVERSE] = combine_disjoint_atop_reverse_ca;
		2471	imp->combine_32_ca[PIXMAN_OP_DISJOINT_XOR] = combine_disjoint_xor_ca;
		2472
		2473	/* Conjoint CA */
		2474	imp->combine_32_ca[PIXMAN_OP_CONJOINT_CLEAR] = combine_clear_ca;
		2475	imp->combine_32_ca[PIXMAN_OP_CONJOINT_SRC] = combine_src_ca;
		2476	imp->combine_32_ca[PIXMAN_OP_CONJOINT_DST] = combine_dst;
		2477	imp->combine_32_ca[PIXMAN_OP_CONJOINT_OVER] = combine_conjoint_over_ca;
		2478	imp->combine_32_ca[PIXMAN_OP_CONJOINT_OVER_REVERSE] = combine_conjoint_over_reverse_ca;
		2479	imp->combine_32_ca[PIXMAN_OP_CONJOINT_IN] = combine_conjoint_in_ca;
		2480	imp->combine_32_ca[PIXMAN_OP_CONJOINT_IN_REVERSE] = combine_conjoint_in_reverse_ca;
		2481	imp->combine_32_ca[PIXMAN_OP_CONJOINT_OUT] = combine_conjoint_out_ca;
		2482	imp->combine_32_ca[PIXMAN_OP_CONJOINT_OUT_REVERSE] = combine_conjoint_out_reverse_ca;
		2483	imp->combine_32_ca[PIXMAN_OP_CONJOINT_ATOP] = combine_conjoint_atop_ca;
		2484	imp->combine_32_ca[PIXMAN_OP_CONJOINT_ATOP_REVERSE] = combine_conjoint_atop_reverse_ca;
		2485	imp->combine_32_ca[PIXMAN_OP_CONJOINT_XOR] = combine_conjoint_xor_ca;
		2486
		2487	imp->combine_32_ca[PIXMAN_OP_MULTIPLY] = combine_multiply_ca;
		2488	imp->combine_32_ca[PIXMAN_OP_SCREEN] = combine_screen_ca;
		2489	imp->combine_32_ca[PIXMAN_OP_OVERLAY] = combine_overlay_ca;
		2490	imp->combine_32_ca[PIXMAN_OP_DARKEN] = combine_darken_ca;
		2491	imp->combine_32_ca[PIXMAN_OP_LIGHTEN] = combine_lighten_ca;
		2492	imp->combine_32_ca[PIXMAN_OP_COLOR_DODGE] = combine_color_dodge_ca;
		2493	imp->combine_32_ca[PIXMAN_OP_COLOR_BURN] = combine_color_burn_ca;
		2494	imp->combine_32_ca[PIXMAN_OP_HARD_LIGHT] = combine_hard_light_ca;
		2495	imp->combine_32_ca[PIXMAN_OP_SOFT_LIGHT] = combine_soft_light_ca;
		2496	imp->combine_32_ca[PIXMAN_OP_DIFFERENCE] = combine_difference_ca;
		2497	imp->combine_32_ca[PIXMAN_OP_EXCLUSION] = combine_exclusion_ca;
		2498
		2499	/* It is not clear that these make sense, so make them noops for now */
		2500	imp->combine_32_ca[PIXMAN_OP_HSL_HUE] = combine_dst;
		2501	imp->combine_32_ca[PIXMAN_OP_HSL_SATURATION] = combine_dst;
		2502	imp->combine_32_ca[PIXMAN_OP_HSL_COLOR] = combine_dst;
		2503	imp->combine_32_ca[PIXMAN_OP_HSL_LUMINOSITY] = combine_dst;
		2504	}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixman/pixman-combine32.c – Rev 3931