{

// Bitwise

OPERATION_CLEAR,

OPERATION_AND,

OPERATION_AND_REVERSE,

OPERATION_COPY,

OPERATION_AND_INVERTED,

OPERATION_NOOP,

OPERATION_XOR,

OPERATION_OR,

OPERATION_NOR,

OPERATION_EQUIV,

OPERATION_INVERT,

OPERATION_OR_REVERSE,

OPERATION_COPY_INVERTED,

OPERATION_OR_INVERTED,

OPERATION_NAND,

OPERATION_SET,

LAST_BITWISE_OPERATION = OPERATION_SET,

{

// Arithmetic

OPERATION_BLEND = LAST_BITWISE_OPERATION + 1,

OPERATION_ADD_PIN,

OPERATION_ADD_OVER,

OPERATION_SUB_PIN,

OPERATION_TRANSPARENT,

OPERATION_AD_MAX,

OPERATION_SUB_OVER,

OPERATION_AD_MIN,

LAST_ARITHMETIC_OPERATION = OPERATION_AD_MIN,

{

// Basic Imaging Blends

OPERATION_BLEND_CLEAR = LAST_ARITHMETIC_OPERATION + 1,

OPERATION_BLEND_SRC,

OPERATION_BLEND_DST,

OPERATION_BLEND_SRC_OVER,

OPERATION_BLEND_DST_OVER,

OPERATION_BLEND_SRC_IN,

OPERATION_BLEND_DST_IN,

OPERATION_BLEND_SRC_OUT,

OPERATION_BLEND_DST_OUT,

OPERATION_BLEND_SRC_ATOP,

OPERATION_BLEND_DST_ATOP,

OPERATION_BLEND_XOR,

OPERATION_BLEND_PLUS,

OPERATION_BLEND_MULTIPLY,

OPERATION_BLEND_SCREEN,

LAST_BASIC_IMAGING_OPERATION = OPERATION_BLEND_SCREEN,

{

// Advanced Imaging Blends

OPERATION_BLEND_OVERLAY = LAST_BASIC_IMAGING_OPERATION + 1,

OPERATION_BLEND_DARKEN,

OPERATION_BLEND_LIGHTEN,

OPERATION_BLEND_DODGE,

OPERATION_BLEND_BURN,

OPERATION_BLEND_HARD_LIGHT,

OPERATION_BLEND_SOFT_LIGHT,

OPERATION_BLEND_DIFFERENCE,

OPERATION_BLEND_EXCLUSION,

LAST_ADVANCED_IMAGING_OPERATION = OPERATION_BLEND_EXCLUSION,

{

u += 0x800080;

v += 0x800080;

return (((u + ((u >> 8) & 0xff00ff)) >> 8) & 0xff00ff) + (((v + ((v >> 8) & 0xff00ff))) & 0xff00ff00);

{

x = x >> 8;

return ((x & 0xff) * ((y >> 8) & 0xff)) | ((x & 0xff0000) * (y >> 24));

{

uint32_t u, v;

u = ((x & 0xff00ff) * a) + 0x800080;

u = ((u + ((u >> 8) & 0xff00ff)) >> 8) & 0xff00ff;

v = (((x >> 8) & 0xff00ff) * a) + 0x800080;

v = (v + ((v >> 8) & 0xff00ff)) & 0xff00ff00;

return u + v;

{

uint32_t y;

y = a | a << 8;

y |= y << 16;

return x + y;

{

uint32_t u, v;

u = (x & 0xff00ff) * a + (y & 0xff00ff) * b + 0x800080;

u = ((u + ((u >> 8) & 0xff00ff)) >> 8) & 0xff00ff;

v = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b + 0x800080;

v = (v + ((v >> 8) & 0xff00ff)) & 0xff00ff00;

return u | v;

{

uint32_t u, v;

u = _low(x) + _low(y);

u = (u | (0x10000100 - ((u >> 8) & 0xff00ff))) & 0xff00ff;

v = _high(x) + _high(y);

v = (v | (0x10000100 - ((v >> 8) & 0xff00ff))) & 0xff00ff;

return u | (v << 8);

{

uint32_t u, v;

u = _low(x) - _low(y);

u = (u & ~((u >> 8) & 0xff00ff)) & 0xff00ff;

v = _high(x) - _high(y);

v = (v & ~((v >> 8) & 0xff00ff)) & 0xff00ff;

return u | (v << 8);

{

uint32_t u, v, w;

u = ((((x & 0xff0000) << 8) - (x & 0xff0000)) / a) & 0xff0000;

v = ((((x & 0x00ff00) << 8) - (x & 0x00ff00)) / a) & 0x00ff00;

w = ((((x & 0x0000ff) << 8) - (x & 0x0000ff)) / a) & 0x0000ff;

return u | v | w;

{

if (a + b > 255)

return 255;

return a + b;

{

uint32_t r = ((a + 0x80) + ((a + 0x80) >> 8)) >> 8;

return uint8_t(r);

{

uint8_t sa, da;

uint32_t r, s, d;

if (x_dst_alpha)

da = packed_alpha(dst);

else

da = 255;

if (x_src_alpha)

sa = packed_alpha(src);

else

sa = 255;

if (sa == 0)

return dst;

if (da == 0)

return src;

if (sa != 255)

s = packed_divide_bounded(src, sa);

else

s = src;

if (da != 255)

d = packed_divide_bounded(dst, da);

else

d = dst;

switch(x_combiner)

{

case OPERATION_CLEAR:

r = 0x00000000;

break;

case OPERATION_AND:

r = s & d;

break;

case OPERATION_AND_REVERSE:

r = (s & ~d) & 0xffffff;

break;

case OPERATION_COPY:

r = s;

break;

case OPERATION_AND_INVERTED:

r = (~s & d) & 0xffffff;

break;

case OPERATION_NOOP:

r = d;

break;

case OPERATION_XOR:

r = s ^ d;

break;

case OPERATION_OR:

r = s | d;

break;

case OPERATION_NOR:

r = (~(s | d)) & 0xffffff;

break;

case OPERATION_EQUIV:

r = (~s ^ d) & 0xffffff;

break;

case OPERATION_INVERT:

r = ~d & 0xffffff;

break;

case OPERATION_OR_REVERSE:

r = (s | ~d) & 0xffffff;

break;

case OPERATION_COPY_INVERTED:

r = (~s) & 0xffffff;

break;

case OPERATION_OR_INVERTED:

r = (~s | d) & 0xffffff;

break;

case OPERATION_NAND:

r = (~(s & d)) & 0xffffff;

break;

case OPERATION_SET:

r = 0x00ffffff;

break;

default:

MCUnreachableReturn(0);

}

if (x_src_alpha && x_dst_alpha)

{

uint8_t ra;

ra = downscale(sa * da);

r = packed_bilinear_bounded(src, 255 - da, dst, 255 - sa) + packed_scale_bounded(r | 0xff000000, ra);

}

else if (!x_src_alpha && x_dst_alpha)

r = packed_bilinear_bounded(src, 255 - da, r | 0xff000000, da);

else if (!x_dst_alpha && x_src_alpha)

r = packed_bilinear_bounded(dst, 255 - sa, r | 0xff000000, sa);

return r;

{

uint8_t sa, da;

uint32_t s, d;

if (x_dst_alpha)

da = packed_alpha(dst);

else

da = 255;

if (x_src_alpha)

sa = packed_alpha(src);

else

sa = 255;

if (sa == 0)

return dst;

if (da == 0)

return src;

if (sa != 255)

s = packed_divide_bounded(src, sa);

else

s = src;

if (da != 255)

d = packed_divide_bounded(dst, da);

else

d = dst;

uint32_t r;

switch(x_combiner)

{

case OPERATION_BLEND:

{

uint32_t u, v;

u = (((d & 0xff00ff) + (s & 0xff00ff)) >> 1) & 0xff00ff;

v = (((d & 0x00ff00) + (s & 0x00ff00)) >> 1) & 0x00ff00;

r = u | v;

}

break;

case OPERATION_ADD_PIN:

{

uint32_t u, v;

u = (d & 0xff00ff) + (s & 0xff00ff);

u = (u | (0x1000100 - ((u >> 8) & 0xff00ff))) & 0xff00ff;

v = (d & 0x00ff00) + (s & 0x00ff00);

v = (v | (0x0010000 - ((v >> 8) & 0x00ff00))) & 0x00ff00;

r = u | v;

}

break;

case OPERATION_ADD_OVER:

{

uint32_t u, v;

u = ((d & 0xff00ff) + (s & 0xff00ff)) & 0xff00ff;

v = ((d & 0x00ff00) + (s & 0x00ff00)) & 0x00ff00;

r = u | v;

}

break;

case OPERATION_SUB_PIN:

{

uint32_t u, v;

u = (s & 0xff00ff) - (d & 0xff00ff);

u = (u & (((u >> 8) & 0xff00ff) - 0x100101)) & 0xff00ff;

v = (s & 0x00ff00) - (d & 0x00ff00);

v = (v & (((v >> 8) & 0x00ff00) - 0x0010100)) & 0x00ff00;

r = u | v;

}

break;

case OPERATION_TRANSPARENT:

r = (s == g_current_background_colour) ? d : s;

break;

case OPERATION_AD_MAX:

{

uint32_t sr, sg, sb;

sr = s & 0x0000ff; sg = s & 0x00ff00; sb = s & 0xff0000;

uint32_t dr, dg, db;

dr = d & 0x0000ff; dg = d & 0x00ff00; db = d & 0xff0000;

uint32_t rr, rg, rb;

rr = sr > dr ? sr : dr;

rg = sg > dg ? sg : dg;

rb = sb > db ? sb : db;

r = rr | rg | rb;

}

break;

case OPERATION_SUB_OVER:

{

uint32_t u, v;

u = ((s & 0xff00ff) - (d & 0xff00ff)) & 0xff00ff;

v = ((s & 0x00ff00) - (d & 0x00ff00)) & 0x00ff00;

r = u | v;

}

break;

case OPERATION_AD_MIN:

{

uint32_t sr, sg, sb;

sr = s & 0x0000ff; sg = s & 0x00ff00; sb = s & 0xff0000;

uint32_t dr, dg, db;

dr = d & 0x0000ff; dg = d & 0x00ff00; db = d & 0xff0000;

uint32_t rr, rg, rb;

rr = sr < dr ? sr : dr;

rg = sg < dg ? sg : dg;

rb = sb < db ? sb : db;

r = rr | rg | rb;

}

break;

default:

MCUnreachableReturn(0);

}

if (x_src_alpha && x_dst_alpha)

{

uint8_t ra;

ra = downscale(sa * da);

r = packed_bilinear_bounded(src, 255 - da, dst, 255 - sa) + packed_scale_bounded(r | 0xff000000, ra);

}

else if (!x_src_alpha && x_dst_alpha)

r = packed_bilinear_bounded(src, 255 - da, r | 0xff000000, da);

else if (!x_dst_alpha && x_src_alpha)

r = packed_bilinear_bounded(dst, 255 - sa, r | 0xff000000, sa);

return r;

{

uint32_t r;

switch(x_combiner)

{

case OPERATION_BLEND_CLEAR:

r = 0;

break;

case OPERATION_BLEND_SRC:

r = src;

break;

case OPERATION_BLEND_DST:

r = dst;

break;

case OPERATION_BLEND_SRC_OVER:

if (x_src_alpha)

r = packed_scale_add_bounded(dst, packed_inverse_alpha(src), src);

else

r = src;

break;

case OPERATION_BLEND_DST_OVER:

if (x_dst_alpha)

r = packed_scale_add_bounded(src, packed_inverse_alpha(dst), dst);

else

r = dst;

break;

case OPERATION_BLEND_SRC_IN:

if (x_dst_alpha)

r = packed_scale_bounded(src, packed_alpha(dst));

else

r = src;

break;

case OPERATION_BLEND_DST_IN:

if (x_src_alpha)

r = packed_scale_bounded(dst, packed_alpha(src));

else

r = dst;

break;

case OPERATION_BLEND_SRC_OUT:

if (x_dst_alpha)

r = packed_scale_bounded(src, packed_inverse_alpha(dst));

else

r = 0;

break;

case OPERATION_BLEND_DST_OUT:

if (x_src_alpha)

r = packed_scale_bounded(dst, packed_inverse_alpha(src));

else

r = 0;

break;

case OPERATION_BLEND_SRC_ATOP:

if (x_dst_alpha && x_src_alpha)

r = packed_bilinear_bounded(src, packed_alpha(dst), dst, packed_inverse_alpha(src));

else if (!x_dst_alpha && x_src_alpha)

r = packed_scale_add_bounded(dst, packed_inverse_alpha(src), src);

else if (!x_src_alpha && x_dst_alpha)

r = packed_scale_bounded(src, packed_alpha(dst));

else

r = src;

break;

case OPERATION_BLEND_DST_ATOP:

if (x_dst_alpha && x_src_alpha)

r = packed_bilinear_bounded(dst, packed_alpha(src), src, packed_inverse_alpha(dst));

else if (!x_src_alpha && x_dst_alpha)

r = packed_scale_add_bounded(src, packed_inverse_alpha(dst), dst);

else if (!x_dst_alpha && x_src_alpha)

r = packed_scale_bounded(dst, packed_alpha(src));

else

r = dst;

break;

case OPERATION_BLEND_XOR:

if (x_dst_alpha && x_src_alpha)

r = packed_bilinear_bounded(src, packed_inverse_alpha(dst), dst, packed_inverse_alpha(src));

else if (!x_dst_alpha && x_src_alpha)

r = packed_scale_bounded(dst, packed_inverse_alpha(src));

else if (!x_src_alpha && x_dst_alpha)

r = packed_scale_bounded(src, packed_inverse_alpha(dst));

else

r = 0;

break;

case OPERATION_BLEND_PLUS:

r = packed_add_saturated(src, dst);

break;

case OPERATION_BLEND_MULTIPLY:

if (x_dst_alpha && x_src_alpha)

r = packed_multiply_bounded(src, dst) + packed_bilinear_bounded(src, packed_inverse_alpha(dst), dst, packed_inverse_alpha(src));

else if (!x_dst_alpha && x_src_alpha)

r = packed_multiply_bounded(src, dst) + packed_scale_bounded(dst, packed_inverse_alpha(src));

else if (!x_src_alpha && x_dst_alpha)

r = packed_multiply_bounded(src, dst) + packed_scale_bounded(src, packed_inverse_alpha(dst));

else

r = packed_multiply_bounded(src, dst);

break;

case OPERATION_BLEND_SCREEN:

r = packed_multiply_bounded(src, packed_inverse(dst)) + dst;

break;

default:

MCUnreachableReturn(0);

}

return r;

{

uint8_t t_src_red, t_src_green, t_src_blue, t_src_alpha;

uint8_t t_dst_red, t_dst_green, t_dst_blue, t_dst_alpha;

uint16_t t_dst_alpha_src_red, t_dst_alpha_src_green, t_dst_alpha_src_blue, t_dst_alpha_src_alpha, t_dst_alpha_dst_alpha;

uint16_t t_dst_alpha_dst_red, t_dst_alpha_dst_green, t_dst_alpha_dst_blue;

uint16_t t_src_alpha_dst_red, t_src_alpha_dst_green, t_src_alpha_dst_blue, t_src_alpha_dst_alpha;

uint16_t t_inv_dst_alpha_src_red, t_inv_dst_alpha_src_green, t_inv_dst_alpha_src_blue, t_inv_dst_alpha_src_alpha ATTRIBUTE_UNUSED;

uint16_t t_inv_src_alpha_dst_red, t_inv_src_alpha_dst_green, t_inv_src_alpha_dst_blue, t_inv_src_alpha_dst_alpha ATTRIBUTE_UNUSED;

uint32_t t_dst_alpha_dst_alpha_src_alpha;

uint8_t t_red, t_green, t_blue, t_alpha;

t_src_red = src & 0xff;

t_src_green = (src >> 8) & 0xff;

t_src_blue = (src >> 16) & 0xff;

if (x_src_alpha)

t_src_alpha = src >> 24;

else

t_src_alpha = 255;

t_dst_red = dst & 0xff;

t_dst_green = (dst >> 8) & 0xff;

t_dst_blue = (dst >>16) & 0xff;

if (x_dst_alpha)

t_dst_alpha = dst >> 24;

else

t_dst_alpha = 255;

if (t_src_alpha == 0)

{

t_src_alpha_dst_red = 0;

t_src_alpha_dst_green = 0;

t_src_alpha_dst_blue = 0;

t_src_alpha_dst_alpha = 0;

t_inv_src_alpha_dst_red = upscale(t_dst_red);

t_inv_src_alpha_dst_green = upscale(t_dst_green);

t_inv_src_alpha_dst_blue = upscale(t_dst_blue);

t_inv_src_alpha_dst_alpha = upscale(t_dst_alpha);

}

else if (t_src_alpha == 255)

{

t_src_alpha_dst_red = upscale(t_dst_red);

t_src_alpha_dst_green = upscale(t_dst_green);

t_src_alpha_dst_blue = upscale(t_dst_blue);

t_src_alpha_dst_alpha = upscale(t_dst_alpha);

t_inv_src_alpha_dst_red = 0;

t_inv_src_alpha_dst_green = 0;

t_inv_src_alpha_dst_blue = 0;

t_inv_src_alpha_dst_alpha = 0;

}

else

{

t_src_alpha_dst_red = t_src_alpha * t_dst_red;

t_src_alpha_dst_green = t_src_alpha * t_dst_green;

t_src_alpha_dst_blue = t_src_alpha * t_dst_blue;

t_src_alpha_dst_alpha = t_src_alpha * t_dst_alpha;

t_inv_src_alpha_dst_red = (255 - t_src_alpha) * t_dst_red;

t_inv_src_alpha_dst_green = (255 - t_src_alpha) * t_dst_green;

t_inv_src_alpha_dst_blue = (255 - t_src_alpha) * t_dst_blue;

t_inv_src_alpha_dst_alpha = (255 - t_src_alpha) * t_dst_alpha;

}

if (t_dst_alpha == 0)

{

t_dst_alpha_src_red = 0;

t_dst_alpha_src_green = 0;

t_dst_alpha_src_blue = 0;

t_dst_alpha_src_alpha = 0;

t_dst_alpha_dst_red = 0;

t_dst_alpha_dst_blue = 0;

t_dst_alpha_dst_green = 0;

t_dst_alpha_dst_alpha = 0;

t_dst_alpha_dst_alpha_src_alpha = 0;

t_inv_dst_alpha_src_red = upscale(t_src_red);

t_inv_dst_alpha_src_green = upscale(t_src_green);

t_inv_dst_alpha_src_blue = upscale(t_src_blue);

t_inv_dst_alpha_src_alpha = upscale(t_src_alpha);

}

else if (t_dst_alpha == 255)

{

t_dst_alpha_src_red = upscale(t_src_red);

t_dst_alpha_src_green = upscale(t_src_green);

t_dst_alpha_src_blue = upscale(t_src_blue);

t_dst_alpha_src_alpha = upscale(t_src_alpha);

t_dst_alpha_dst_red = upscale(t_dst_red);

t_dst_alpha_dst_green = upscale(t_dst_green);

t_dst_alpha_dst_blue = upscale(t_dst_blue);

t_dst_alpha_dst_alpha = upscale((uint8_t)255);

t_dst_alpha_dst_alpha_src_alpha = t_src_alpha == 255 ? upscale(upscale(uint8_t(255))) : upscale(uint16_t(255 * t_src_alpha));

t_inv_dst_alpha_src_red = 0;

t_inv_dst_alpha_src_green = 0;

t_inv_dst_alpha_src_blue = 0;

t_inv_dst_alpha_src_alpha = 0;

}

else

{

t_dst_alpha_src_red = t_dst_alpha * t_src_red;

t_dst_alpha_src_green = t_dst_alpha * t_src_green;

t_dst_alpha_src_blue = t_dst_alpha * t_src_blue;

t_dst_alpha_src_alpha = t_dst_alpha * t_src_alpha;

t_dst_alpha_dst_red = t_dst_alpha * t_dst_red;

t_dst_alpha_dst_green = t_dst_alpha * t_dst_green;

t_dst_alpha_dst_blue = t_dst_alpha * t_dst_blue;

t_dst_alpha_dst_alpha = t_dst_alpha * t_dst_alpha;

t_dst_alpha_dst_alpha_src_alpha = t_dst_alpha_dst_alpha * t_src_alpha;

t_inv_dst_alpha_src_red = (255 - t_dst_alpha) * t_src_red;

t_inv_dst_alpha_src_green = (255 - t_dst_alpha) * t_src_green;

t_inv_dst_alpha_src_blue = (255 - t_dst_alpha) * t_src_blue;

t_inv_dst_alpha_src_alpha = (255 - t_dst_alpha) * t_src_alpha;

}

switch(x_combiner)

{

case OPERATION_BLEND_OVERLAY:

t_red = 2 * t_dst_red < t_dst_alpha ?

downscale(2 * t_src_red * t_dst_red + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red) :

downscale(t_src_alpha_dst_alpha - 2 * (t_dst_alpha - t_dst_red) * (t_src_alpha - t_src_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = 2 * t_dst_green < t_dst_alpha ?

downscale(2 * t_src_green * t_dst_green + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green) :

downscale(t_src_alpha_dst_alpha - 2 * (t_dst_alpha - t_dst_green) * (t_src_alpha - t_src_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = 2 * t_dst_blue < t_dst_alpha ?

downscale(2 * t_src_blue * t_dst_blue + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue) :

downscale(t_src_alpha_dst_alpha - 2 * (t_dst_alpha - t_dst_blue) * (t_src_alpha - t_src_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_DARKEN:

t_red = downscale(fastmin(t_dst_alpha_src_red, t_src_alpha_dst_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = downscale(fastmin(t_dst_alpha_src_green, t_src_alpha_dst_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = downscale(fastmin(t_dst_alpha_src_blue, t_src_alpha_dst_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_LIGHTEN:

t_red = downscale(fastmax(t_dst_alpha_src_red, t_src_alpha_dst_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = downscale(fastmax(t_dst_alpha_src_green, t_src_alpha_dst_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = downscale(fastmax(t_dst_alpha_src_blue, t_src_alpha_dst_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_DODGE:

t_red = t_dst_alpha_src_red + t_src_alpha_dst_red >= t_src_alpha_dst_alpha ?

downscale(t_dst_alpha_src_alpha + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red) :

downscale(scaled_divide(t_src_alpha_dst_red, t_src_alpha, t_src_alpha - t_src_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = t_dst_alpha_src_green + t_src_alpha_dst_green >= t_src_alpha_dst_alpha ?

downscale(t_dst_alpha_src_alpha + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green) :

downscale(scaled_divide(t_src_alpha_dst_green, t_src_alpha, t_src_alpha - t_src_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = t_dst_alpha_src_blue + t_src_alpha_dst_blue >= t_src_alpha_dst_alpha ?

downscale(t_dst_alpha_src_alpha + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue) :

downscale(scaled_divide(t_src_alpha_dst_blue, t_src_alpha, t_src_alpha - t_src_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_BURN:

t_red = t_dst_alpha_src_red + t_src_alpha_dst_red <= t_src_alpha_dst_alpha ?

downscale(t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red) :

downscale(scaled_divide(t_dst_alpha_src_red + t_src_alpha_dst_red - t_src_alpha_dst_alpha, t_src_alpha, t_src_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = t_dst_alpha_src_green + t_src_alpha_dst_green <= t_src_alpha_dst_alpha ?

downscale(t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green) :

downscale(scaled_divide(t_dst_alpha_src_green + t_src_alpha_dst_green - t_src_alpha_dst_alpha, t_src_alpha, t_src_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = t_dst_alpha_src_blue + t_src_alpha_dst_blue <= t_src_alpha_dst_alpha ?

downscale(t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue) :

downscale(scaled_divide(t_dst_alpha_src_blue + t_src_alpha_dst_blue - t_src_alpha_dst_alpha, t_src_alpha, t_src_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_HARD_LIGHT:

t_red = 2 * t_src_red < t_src_alpha ?

downscale(2 * t_src_red * t_dst_red + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red) :

downscale(t_src_alpha_dst_alpha - 2 * (t_dst_alpha - t_dst_red) * (t_src_alpha - t_src_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = 2 * t_src_green < t_src_alpha ?

downscale(2 * t_src_green * t_dst_green + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green) :

downscale(t_src_alpha_dst_alpha - 2 * (t_dst_alpha - t_dst_green) * (t_src_alpha - t_src_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = 2 * t_src_blue < t_src_alpha ?

downscale(2 * t_src_blue * t_dst_blue + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue) :

downscale(t_src_alpha_dst_alpha - 2 * (t_dst_alpha - t_dst_blue) * (t_src_alpha - t_src_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_SOFT_LIGHT:

if (2 * t_src_red < t_src_alpha)

t_red = downscale(scaled_divide(t_src_alpha_dst_alpha + (t_dst_alpha - t_dst_red) * (t_src_alpha - 2 * t_src_red), t_dst_red, t_dst_alpha) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

else if (8 * t_dst_red < t_dst_alpha)

t_red = downscale(long_scaled_divide(t_dst_alpha_dst_alpha_src_alpha - (t_dst_alpha - t_dst_red) * (2 * t_src_red - t_src_alpha) * (3 * t_dst_alpha - 8 * t_dst_red), t_dst_red, t_dst_alpha_dst_alpha) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

else

t_red = downscale(t_src_alpha_dst_red + (sqrt(t_dst_alpha_dst_red) - t_dst_red) * (2 * t_src_red - t_src_alpha) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

if (2 * t_src_green < t_src_alpha)

t_green = downscale(scaled_divide(t_src_alpha_dst_alpha + (t_dst_alpha - t_dst_green) * (t_src_alpha - 2 * t_src_green), t_dst_green, t_dst_alpha) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

else if (8 * t_dst_green < t_dst_alpha)

t_green = downscale(long_scaled_divide(t_dst_alpha_dst_alpha_src_alpha - (t_dst_alpha - t_dst_green) * (2 * t_src_green - t_src_alpha) * (3 * t_dst_alpha - 8 * t_dst_green), t_dst_green, t_dst_alpha_dst_alpha) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

else

t_green = downscale(t_src_alpha_dst_green + (sqrt(t_dst_alpha_dst_green) - t_dst_green) * (2 * t_src_green - t_src_alpha) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

if (2 * t_src_blue < t_src_alpha)

t_blue = downscale(scaled_divide(t_src_alpha_dst_alpha + (t_dst_alpha - t_dst_blue) * (t_src_alpha - 2 * t_src_blue), t_dst_blue, t_dst_alpha) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

else if (8 * t_dst_blue < t_dst_alpha)

t_blue = downscale(long_scaled_divide(t_dst_alpha_dst_alpha_src_alpha - (t_dst_alpha - t_dst_blue) * (2 * t_src_blue - t_src_alpha) * (3 * t_dst_alpha - 8 * t_dst_blue), t_dst_blue, t_dst_alpha_dst_alpha) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

else

t_blue = downscale(t_src_alpha_dst_blue + (sqrt(t_dst_alpha_dst_blue) - t_dst_blue) * (2 * t_src_blue - t_src_alpha) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_DIFFERENCE:

t_red = t_src_red + t_dst_red - 2 * downscale(fastmin(t_dst_alpha_src_red, t_src_alpha_dst_red));

t_green = t_src_green + t_dst_green - 2 * downscale(fastmin(t_dst_alpha_src_green, t_src_alpha_dst_green));

t_blue = t_src_blue + t_dst_blue - 2 * downscale(fastmin(t_dst_alpha_src_blue, t_src_alpha_dst_blue));

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

case OPERATION_BLEND_EXCLUSION:

t_red = downscale(t_src_red * (t_dst_alpha - t_dst_red) + t_dst_red * (t_src_alpha - t_src_red) + t_inv_dst_alpha_src_red + t_inv_src_alpha_dst_red);

t_green = downscale(t_src_green * (t_dst_alpha - t_dst_green) + t_dst_green * (t_src_alpha - t_src_green) + t_inv_dst_alpha_src_green + t_inv_src_alpha_dst_green);

t_blue = downscale(t_src_blue * (t_dst_alpha - t_dst_blue) + t_dst_blue * (t_src_alpha - t_src_blue) + t_inv_dst_alpha_src_blue + t_inv_src_alpha_dst_blue);

t_alpha = t_src_alpha + t_dst_alpha - downscale(t_src_alpha_dst_alpha);

break;

default:

MCUnreachableReturn(0);

}

if (x_dst_alpha)

return t_red | (t_green << 8) | (t_blue << 16) | (t_alpha << 24);

return t_red | (t_green << 8) | (t_blue << 16);

{

// These should get collapsed at compile-time so no need to worry about a

// performance hit (assuming the compiler is half-way sensible...)

if (x_combiner <= LAST_BITWISE_OPERATION)

return bitwise_combiner<BitwiseOperation(x_combiner), x_dst_alpha, x_src_alpha>(dst, src);

else if (x_combiner <= LAST_ARITHMETIC_OPERATION)

return arithmetic_combiner<ArithmeticOperation(x_combiner), x_dst_alpha, x_src_alpha>(dst, src);

else if (x_combiner <= LAST_BASIC_IMAGING_OPERATION)

return basic_imaging_combiner<BasicImagingOperation(x_combiner), x_dst_alpha, x_src_alpha>(dst, src);

else if (x_combiner <= LAST_ADVANCED_IMAGING_OPERATION)

return advanced_imaging_combiner<AdvancedImagingOperation(x_combiner), x_dst_alpha, x_src_alpha>(dst, src);

else

MCUnreachable();

{

if (p_opacity == 0)

return;

uint32_t *t_dst_ptr;

uint32_t t_dst_stride;

t_dst_ptr = (uint32_t *)p_dst;

t_dst_stride = (p_dst_stride >> 2) - p_width;

uint32_t *t_src_ptr;

uint32_t t_src_stride;

t_src_ptr = (uint32_t *)p_src;

t_src_stride = (p_src_stride >> 2) - p_width;

for(; p_height > 0; --p_height, t_dst_ptr += t_dst_stride, t_src_ptr += t_src_stride)

{

for(uint32_t t_width = p_width; t_width > 0; --t_width)

{

uint32_t t_src, t_dst;

uint32_t t_pixel;

t_src = *t_src_ptr++;

t_dst = *t_dst_ptr;

t_pixel = pixel_combine<x_combiner, x_dst_alpha, x_src_alpha>(t_dst, t_src);

if (p_opacity != 255)

t_pixel = packed_bilinear_bounded(t_pixel, p_opacity, t_dst, 255 - p_opacity);

*t_dst_ptr++ = t_pixel;

}

}

{

// These should get collapsed at compile-time so no need to worry about a

// performance hit (assuming the compiler is half-way sensible...)

if (x_combiner <= LAST_BITWISE_OPERATION)

return surface_combine<BitwiseOperation, BitwiseOperation(x_combiner), x_dst_alpha, x_src_alpha>(p_dst, p_dst_stride, p_src, p_src_stride, p_width, p_height, p_opacity);

else if (x_combiner <= LAST_ARITHMETIC_OPERATION)

return surface_combine<ArithmeticOperation, ArithmeticOperation(x_combiner), x_dst_alpha, x_src_alpha>(p_dst, p_dst_stride, p_src, p_src_stride, p_width, p_height, p_opacity);

else if (x_combiner <= LAST_BASIC_IMAGING_OPERATION)