path: root/bltsville/bltsville/include/bvblend.h

/*
 * bvblend.h
 *
 * Copyright (C) 2011 Texas Instruments, Inc.
 *
 * This file is part of BLTsville, an open application programming interface
 * (API) for accessing 2-D software or hardware implementations.
 *
 * This work is licensed under the Creative Commons Attribution-NoDerivs 3.0
 * Unported License. To view a copy of this license, visit
 * http://creativecommons.org/licenses/by-nd/3.0/ or send a letter to
 * Creative Commons, 444 Castro Street, Suite 900, Mountain View, California,
 * 94041, USA.
 */

/*
 * This file defines the types of shared blends available.
 *
 * To extend the list of blends, create a file containing additional
 * enumerations to be added to enum bvblend below.  Then #define
 * BVBLEND_EXTERNAL_INCLUDE as the name of that file before including
 * this file in your project.
 */

#ifndef BVBLEND_H
#define BVBLEND_H

/*
 * bvblend - specifies the type of blending operation to perform; only valid
 *	     when BVFLAG_BLEND is set in the bvbltparams.flags field.
 */

/*
 * The blendmode value is divided into two sections.
 *
 * [31:28] The most significant 4 bits indicate the blend format.
 *
 * [27:0] The remainder of the bits is defined by the format chosen.
 *
 *   3322222222221111111111
 *   10987654321098765432109876543210
 *   [  ][                          ]
 *    |               |
 *  format    defined by format
 */

#define BVBLENDDEF_FORMAT_SHIFT 28
#define BVBLENDDEF_FORMAT_MASK (0xF << BVBLENDDEF_FORMAT_SHIFT)

#define BVBLENDDEF_FORMAT_CLASSIC	(0x0 << BVBLENDDEF_FORMAT_SHIFT)
#define BVBLENDDEF_FORMAT_ESSENTIAL	(0x1 << BVBLENDDEF_FORMAT_SHIFT)

/*
 * The BVBLENDDEF_FORMAT_CLASSIC is meant to handle the classic Porter-Duff
 * equations.  It can also handle the DirectFB blending.
 * BVBLENDDEF_FORMAT_CLASSIC is based on the following equations:
 *
 *   Cd = K1 x C1 + K2 x C2
 *   Ad = K3 x A1 + K4 x A2
 *
 * where:
 *   Cd: destination color
 *   C1: source 1 color
 *   C2: source 2 color
 *   Ad: destination alpha
 *   A1: source 1 alpha
 *   A2: source 2 alpha
 *   K#: one of the constants defined using the bitfields below.
 */

/*
 *  The 28 bits for BVBLENDDEF_FORMAT_CLASSIC are divided into 5 sections.
 *
 *  The most significant 4 bits are modifiers, used to include additional
 *  alpha values from global or remote sources.
 *
 *  [27] The most significant bit indicates that a remote alpha is to be
 *  included in the blend.  The format of this is defined by
 *  bvbltparams.maskgeom.format.
 *
 *  [26] The next bit is reserved.
 *
 *  [25:24] The next 2 bits are used to indicate that a global alpha is to be
 *  included, and what its format is:
 *    00: no global included
 *    01: global included; bvbltparams.globalalpha.size8 is used (0 -> 255)
 *    10: this value is reserved
 *    11: global included; bvbltparams.flogalalpha.fp is used (0.0 -> 1.0)
 *
 *  The remaining bits are divided into 4 sections, one to define each of the
 *  constants:
 *
 *  [23:18] - K1
 *  [17:12] - K2
 *  [11:6]  - K3
 *  [5:0]   - K4
 *
 *  The format is the same for all 4 constant fields:
 *
 *  [5:4] The first 2 bits of each field indicates the way in which the other
 *  2 fields are interpreted:
 *    00: only As: the other two fields contain only As; there should be only
 *                 one valid A value between the two fields
 *    01: minimum: the value of the constant is the minimum of the two fields
 *    10: maximum: the value of the constant is the maximum of the two fields
 *    11: only Cs: the other two fields contain only Cs; there should be only
 *                 one valid C value between the two fields
 *
 *  [3:2] The middle 2 bits of each field contain the inverse field:
 *    00: 1-C1 ("don't care" for "only As")
 *    01: 1-A1 ("don't care" for "only Cs")
 *    10: 1-C2 ("don't care" for "only As")
 *    11: 1-A2 ("don't care" for "only Cs")
 *
 *  [1:0] The last 2 bits if each field contain the normal field:
 *    00: C1 ("don't care" for "only As")
 *    01: A1 ("don't care" for "only Cs")
 *    10: C2 ("don't care" for "only As")
 *    11: A2 ("don't care" for "only Cs")
 *
 *  EXCEPTIONS:
 *
 *  00 00 00 - The value 00 00 00, which normally would indicate "only As"
 *             with two "don't care" fields, is interpreted as a 0.
 *
 *  11 11 11 - The value 11 11 11, which normally would indicate "only Cs"
 *             with two "don't care" fields, is interpreted as a 1.
 *
 * --------------------------------------------------------------------------
 *
 * Put together, these can define portions of the blend equations that can be
 * put together in a variety of ways:
 *
 *   00 00 00: undefined -> zero
 *   00 00 01: A1 (preferred)
 *   00 00 10: undefined
 *   00 00 11: A2 (preferred)
 *   00 01 00: 1-A1 (preferred)
 *   00 01 01: undefined
 *   00 01 10: 1-A1 (use 00 01 00)
 *   00 01 11: undefined
 *   00 10 00: undefined
 *   00 10 01: A1 (use 00 00 01)
 *   00 10 10: undefined
 *   00 10 11: A2 (use 00 00 11)
 *   00 11 00: 1-A2 (preferred)
 *   00 11 01: undefined
 *   00 11 10: 1-A2 (use 00 11 00)
 *   00 11 11: undefined
 *
 *   01 00 00: min(C1,1-C1)
 *   01 00 01: min(A1,1-C1)
 *   01 00 10: min(C2,1-C1)
 *   01 00 11: min(A2,1-C1)
 *   01 01 00: min(C1,1-A1)
 *   01 01 01: min(A1,1-A1)
 *   01 01 10: min(C2,1-A1)
 *   01 01 11: min(A2,1-A1)
 *   01 10 00: min(C1,1-C2)
 *   01 10 01: min(A1,1-C2)
 *   01 10 10: min(C2,1-C2)
 *   01 10 11: min(A2,1-C2)
 *   01 11 00: min(C1,1-A2)
 *   01 11 01: min(A1,1-A2)
 *   01 11 10: min(C2,1-A2)
 *   01 11 11: min(A2,1-A2)
 *
 *   10 00 00: max(C1,1-C1)
 *   10 00 01: max(A1,1-C1)
 *   10 00 10: max(C2,1-C1)
 *   10 00 11: max(A2,1-C1)
 *   10 01 00: max(C1,1-A1)
 *   10 01 01: max(A1,1-A1)
 *   10 01 10: max(C2,1-A1)
 *   10 01 11: max(A2,1-A1)
 *   10 10 00: max(C1,1-C2)
 *   10 10 01: max(A1,1-C2)
 *   10 10 10: max(C2,1-C2)
 *   10 10 11: max(A2,1-C2)
 *   10 11 00: max(C1,1-A2)
 *   10 11 01: max(A1,1-A2)
 *   10 11 10: max(C2,1-A2)
 *   10 11 11: max(A2,1-A2)
 *
 *   11 00 00: undefined
 *   11 00 01: 1-C1 (use 11 00 11)
 *   11 00 10: undefined
 *   11 00 11: 1-C1 (preferred)
 *   11 01 00: C1 (use 11 11 00)
 *   11 01 01: undefined
 *   11 01 10: C2 (use 11 11 10)
 *   11 01 11: undefined
 *   11 10 00: undefined
 *   11 10 01: 1-C2 (use 11 10 11)
 *   11 10 10: undefined
 *   11 10 11: 1-C2 (preferred)
 *   11 11 00: C1 (preferred)
 *   11 11 01: undefined
 *   11 11 10: C2 (preferred)
 *   11 11 11: undefined -> one
 *
 * ==========================================================================
 * DirectFB
 * ==========================================================================
 *
 * Putting these together into the proper constants, the blending equations
 * can be built for DirectFB as well:
 *
 * For DirectFB, the SetSrcBlendFunction() and SetDstBlendFunction() can
 * specify 121 combinations of blends (11 x 11). It's impractical to
 * specify these combinations individually. Instead, the settings indicated
 * by each call should be bitwise OR'd to make the proper single value used in
 * BLTsville.
 *
 * binary value <- SetSrcBlendFunction()
 *           [--K1--] [--K2--] [--K3--] [--K4--]
 * 0000 0000 00 00 00 xx xx xx 00 00 00 xx xx xx <- DSBF_ZERO
 * 0000 0000 11 11 11 xx xx xx 11 11 11 xx xx xx <- DSBF_ONE
 * 0000 0000 11 11 00 xx xx xx 00 00 01 xx xx xx <- DSBF_SRCCOLOR
 * 0000 0000 11 00 11 xx xx xx 00 01 00 xx xx xx <- DSBF_INVSRCCOLOR
 * 0000 0000 00 00 01 xx xx xx 00 00 01 xx xx xx <- DSBF_SRCALPHA
 * 0000 0000 00 01 00 xx xx xx 00 01 00 xx xx xx <- DSBF_INVSRCALPHA
 * 0000 0000 11 11 10 xx xx xx 00 00 11 xx xx xx <- DSBF_DESTCOLOR
 * 0000 0000 11 10 11 xx xx xx 00 11 00 xx xx xx <- DSBF_INVDESTCOLOR
 * 0000 0000 00 00 11 xx xx xx 00 00 11 xx xx xx <- DSBF_DESTALPHA
 * 0000 0000 00 11 00 xx xx xx 00 11 00 xx xx xx <- DSBF_INVDESTALPHA
 * 0000 0000 01 11 01 xx xx xx 11 11 11 xx xx xx <- DSBF_SRCALPHASAT
 *
 * binary value <- SetDstBlendFunction()
 *           [--K1--] [--K2--] [--K3--] [--K4--]
 * 0000 0000 xx xx xx 00 00 00 xx xx xx 00 00 00 <- DSBF_ZERO
 * 0000 0000 xx xx xx 11 11 11 xx xx xx 11 11 11 <- DSBF_ONE
 * 0000 0000 xx xx xx 11 11 00 xx xx xx 00 00 01 <- DSBF_SRCCOLOR
 * etc.
 *
 * ==========================================================================
 * Porter-Duff
 * ==========================================================================
 *
 * For Porter-Duff, the equations can be more specifically defined. For
 * convenience, these are enumerated below. These utilize the local alpha as
 * indicated. To use global or remote alpha, these enumerations need to be
 * modified. For example, to include the global alpha in the Porter-Duff
 * SRC1OVER blend, the blend could be defined like this:
 *   params.op.blend = BVBLEND_SRC1OVER +
 *                     BVBLENDDEF_GLOBAL_UCHAR;
 *
 * To include the remote alpha, the blend could be defined like this:
 *   params.op.blend = BVBLEND_SRC1OVER +
 *                     BVBLENDDEF_REMOTE;
 *
 * And to include both:
 *   params.op.blend = BVBLEND_SRC1OVER +
 *                     BVBLENDDEF_GLOBAL_UCHAR +
 *                     BVBLENDDEF_REMOTE;
 *
 * Note that if the source color formats include local alphas, the local
 * alphas, global alpha, and remote alpha will be used together.
 *
 * Note also that the equations assume the surfaces are premultiplied. So
 * if the surface formats indicate that they are not premultiplied, the
 * alpha multiplication of each color is done prior to using the surface
 * values in the equations.
 *
 * For example, BVBLEND_SRC1OVER specifies the equations:
 *   Cd = 1 x C1 + (1 - A1) x C2
 *   Ad = 1 x A1 + (1 - A1) x A2
 *
 * If the format of surface 1 is non-premultiplied, the equations
 * are modified to include the multiplication explicitly:
 *   Cd = 1 x A1 x C1 + (1 - A1) x C2
 *   Ad = 1 x A1      + (1 - A1) x A2
 *
 * Likewise, if the format of surface 2 is non-premultiplied, the
 * equations are modified for this:
 *   Cd = 1 x C1 + (1 - A1) x A2 x C2
 *   Ad = 1 x A1 + (1 - A1) x A2
 *
 * When including global or remote alphas, these values are used to modify
 * the source 1 value values before being used in the blend equation:
 *   C1 = Ag x C1
 *   A1 = Ag x A1
 *       -or-
 *   C1 = Ar x C1
 *   A1 = Ar x A1
 *       -or-
 *   C1 = Ag x Ar x C1
 *   A1 = Ag x Ar x A1
 *
 */

#define BVBLENDDEF_MODE_SHIFT	4
#define BVBLENDDEF_INV_SHIFT	2
#define BVBLENDDEF_NORM_SHIFT	0

#define BVBLENDDEF_ONLY_A	(0 << BVBLENDDEF_MODE_SHIFT)
#define BVBLENDDEF_MIN		(1 << BVBLENDDEF_MODE_SHIFT)
#define BVBLENDDEF_MAX		(2 << BVBLENDDEF_MODE_SHIFT)
#define BVBLENDDEF_ONLY_C	(3 << BVBLENDDEF_MODE_SHIFT)
#define BVBLENDDEF_MODE_MASK	(3 << BVBLENDDEF_MODE_SHIFT)

#define BVBLENDDEF_NORM_C1	(0 << BVBLENDDEF_NORM_SHIFT)
#define BVBLENDDEF_NORM_A1	(1 << BVBLENDDEF_NORM_SHIFT)
#define BVBLENDDEF_NORM_C2	(2 << BVBLENDDEF_NORM_SHIFT)
#define BVBLENDDEF_NORM_A2	(3 << BVBLENDDEF_NORM_SHIFT)
#define BVBLENDDEF_NORM_MASK	(3 << BVBLENDDEF_NORM_SHIFT)

#define BVBLENDDEF_INV_C1	(0 << BVBLENDDEF_INV_SHIFT)
#define BVBLENDDEF_INV_A1	(1 << BVBLENDDEF_INV_SHIFT)
#define BVBLENDDEF_INV_C2	(2 << BVBLENDDEF_INV_SHIFT)
#define BVBLENDDEF_INV_A2	(3 << BVBLENDDEF_INV_SHIFT)
#define BVBLENDDEF_INV_MASK	(3 << BVBLENDDEF_INV_SHIFT)

#define BVBLENDDEF_ONLY_A_NORM_xx	BVBLENDDEF_NORM_C1
#define BVBLENDDEF_ONLY_A_INV_xx	BVBLENDDEF_INV_C1
#define BVBLENDDEF_ONLY_C_NORM_xx	BVBLENDDEF_NORM_A2
#define BVBLENDDEF_ONLY_C_INV_xx	BVBLENDDEF_INV_A2

#define BVBLENDDEF_ZERO \
	(BVBLENDDEF_ONLY_A | \
	 BVBLENDDEF_ONLY_A_NORM_xx | \
	 BVBLENDDEF_ONLY_A_INV_xx)
#define BVBLENDDEF_C1 \
	(BVBLENDDEF_ONLY_C | \
	 BVBLENDDEF_NORM_C1 | \
	 BVBLENDDEF_ONLY_C_INV_xx)
#define BVBLENDDEF_A1 \
	(BVBLENDDEF_ONLY_A | \
	 BVBLENDDEF_NORM_A1 | \
	 BVBLENDDEF_ONLY_A_INV_xx)
#define BVBLENDDEF_C2 \
	(BVBLENDDEF_ONLY_C | \
	 BVBLENDDEF_NORM_C2 | \
	 BVBLENDDEF_ONLY_C_INV_xx)
#define BVBLENDDEF_A2 \
	(BVBLENDDEF_ONLY_A | \
	 BVBLENDDEF_NORM_A2 | \
	 BVBLENDDEF_ONLY_A_INV_xx)
#define BVBLENDDEF_ONE_MINUS_C1 \
	(BVBLENDDEF_ONLY_C | \
	 BVBLENDDEF_ONLY_C_NORM_xx | \
	 BVBLENDDEF_INV_C1)
#define BVBLENDDEF_ONE_MINUS_A1 \
	(BVBLENDDEF_ONLY_A | \
	 BVBLENDDEF_ONLY_A_NORM_xx | \
	 BVBLENDDEF_INV_A1)
#define BVBLENDDEF_ONE_MINUS_C2 \
	(BVBLENDDEF_ONLY_C | \
	 BVBLENDDEF_ONLY_C_NORM_xx | \
	 BVBLENDDEF_INV_C2)
#define BVBLENDDEF_ONE_MINUS_A2 \
	(BVBLENDDEF_ONLY_A | \
	 BVBLENDDEF_ONLY_A_NORM_xx | \
	 BVBLENDDEF_INV_A2)
#define BVBLENDDEF_ONE \
	(BVBLENDDEF_ONLY_C | \
	 BVBLENDDEF_ONLY_C_NORM_xx | \
	 BVBLENDDEF_ONLY_C_INV_xx)

#define BVBLENDDEF_K_MASK \
	(BVBLENDDEF_MODE_MASK | \
	 BVBLENDDEF_INV_MASK  | \
	 BVBLENDDEF_NORM_MASK)

#define BVBLENDDEF_K1_SHIFT 18
#define BVBLENDDEF_K2_SHIFT 12
#define BVBLENDDEF_K3_SHIFT 6
#define BVBLENDDEF_K4_SHIFT 0

#define BVBLENDDEF_K1_MASK \
	(BVBLENDDEF_K_MASK << BVBLENDDEF_K1_SHIFT)
#define BVBLENDDEF_K2_MASK \
	(BVBLENDDEF_K_MASK << BVBLENDDEF_K2_SHIFT)
#define BVBLENDDEF_K3_MASK \
	(BVBLENDDEF_K_MASK << BVBLENDDEF_K3_SHIFT)
#define BVBLENDDEF_K4_MASK \
	(BVBLENDDEF_K_MASK << BVBLENDDEF_K4_SHIFT)

#define BVBLENDDEF_CLASSIC_EQUATION_MASK 0x00FFFFFF

/*
 * The following definitions are be used to modify the enumerations.
 */
#define BVBLENDDEF_REMOTE	0x08000000	/* mask surface provides alpha
						   for source 1 */

/* Bit 26 reserved */

/* These enable global alpha and define the type of globalalpha */
#define BVBLENDDEF_GLOBAL_SHIFT 24
#define BVBLENDDEF_GLOBAL_MASK	(3 << BVBLENDDEF_GLOBAL_SHIFT)

#define BVBLENDDEF_GLOBAL_NONE	(0 << BVBLENDDEF_GLOBAL_SHIFT)
#define BVBLENDDEF_GLOBAL_UCHAR	(1 << BVBLENDDEF_GLOBAL_SHIFT)
/* 2 reserved */
#define BVBLENDDEF_GLOBAL_FLOAT	(3 << BVBLENDDEF_GLOBAL_SHIFT)

union bvalpha {
	unsigned char size8;	/* btwn 0 (0.0) and 255 (1.0) */
	float fp;		/* btwn 0.0 and 1.0 */
};


enum bvblend {
  /* Porter-Duff blending equations */
	BVBLEND_CLEAR = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC1 =	BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC2 =	BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC1OVER = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC2OVER = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC1IN = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_A2 << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_A2 << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC2IN = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_A1 << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_A1 << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC1OUT = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC2OUT = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ZERO << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC1ATOP = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_A2 << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_A2 << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K4_SHIFT),
	BVBLEND_SRC2ATOP = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_A1 << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_A1 << BVBLENDDEF_K4_SHIFT),
	BVBLEND_XOR = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A2 << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE_MINUS_A1 << BVBLENDDEF_K4_SHIFT),
	BVBLEND_PLUS = BVBLENDDEF_FORMAT_CLASSIC |
			(BVBLENDDEF_ONE << BVBLENDDEF_K1_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K2_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K3_SHIFT) |
			(BVBLENDDEF_ONE << BVBLENDDEF_K4_SHIFT),

/*
 * For FORMAT_ESSENTIAL, the variety of well-known blending functions from
 * popular image manipulation programs are specified.
 */

	BVBLEND_NORMAL = BVBLENDDEF_FORMAT_ESSENTIAL + 0,
	BVBLEND_LIGHTEN = BVBLENDDEF_FORMAT_ESSENTIAL + 1,
	BVBLEND_DARKEN = BVBLENDDEF_FORMAT_ESSENTIAL + 2,
	BVBLEND_MULTIPLY = BVBLENDDEF_FORMAT_ESSENTIAL + 3,
	BVBLEND_AVERAGE = BVBLENDDEF_FORMAT_ESSENTIAL + 4,
	BVBLEND_ADD = BVBLENDDEF_FORMAT_ESSENTIAL + 5,
	BVBLEND_LINEAR_DODGE = BVBLEND_ADD,
	BVBLEND_SUBTRACT = BVBLENDDEF_FORMAT_ESSENTIAL + 6,
	BVBLEND_LINEAR_BURN = BVBLEND_SUBTRACT,
	BVBLEND_DIFFERENCE = BVBLENDDEF_FORMAT_ESSENTIAL + 7,
	BVBLEND_NEGATE = BVBLENDDEF_FORMAT_ESSENTIAL + 8,
	BVBLEND_SCREEN = BVBLENDDEF_FORMAT_ESSENTIAL + 9,
	BVBLEND_EXCLUSION = BVBLENDDEF_FORMAT_ESSENTIAL + 10,
	BVBLEND_OVERLAY = BVBLENDDEF_FORMAT_ESSENTIAL + 11,
	BVBLEND_SOFT_LIGHT = BVBLENDDEF_FORMAT_ESSENTIAL + 12,
	BVBLEND_HARD_LIGHT = BVBLENDDEF_FORMAT_ESSENTIAL + 13,
	BVBLEND_COLOR_DODGE = BVBLENDDEF_FORMAT_ESSENTIAL + 14,
	BVBLEND_COLOR_BURN = BVBLENDDEF_FORMAT_ESSENTIAL + 15,
	BVBLEND_LINEAR_LIGHT = BVBLENDDEF_FORMAT_ESSENTIAL + 16,
	BVBLEND_VIVID_LIGHT = BVBLENDDEF_FORMAT_ESSENTIAL + 17,
	BVBLEND_PIN_LIGHT = BVBLENDDEF_FORMAT_ESSENTIAL + 18,
	BVBLEND_HARD_MIX = BVBLENDDEF_FORMAT_ESSENTIAL + 19,
	BVBLEND_REFLECT = BVBLENDDEF_FORMAT_ESSENTIAL + 20,
	BVBLEND_GLOW = BVBLENDDEF_FORMAT_ESSENTIAL + 21,
	BVBLEND_PHOENIX = BVBLENDDEF_FORMAT_ESSENTIAL + 22,

#ifdef BVBLEND_EXTERNAL_INCLUDE
#define BVBLEND_EXTERNAL_INCLUDE
#endif
};

#endif /* BVBLEND_H */