/*
 * Copyright 2006, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 */

#ifndef BLENDING_H
#define BLENDING_H

#include <SupportDefs.h>

// faster bit error version:
//#define INT_MULT(a, b, t)			((t) = (a) * (b), ((((t) >> 8) + (t)) >> 8))
// correct version
#define INT_MULT(a, b, t)			((t) = (a) * (b) + 0x80, ((((t) >> 8) + (t)) >> 8))

#define INT_LERP(p, q, a, t)		((p) + INT_MULT(a, ((q) - (p)), t))

#define INT_PRELERP(p, q, a, t)		((p) + (q) - INT_MULT(a, p, t))



#define GAMMA_BLEND 1

#if GAMMA_BLEND

extern uint16* kGammaTable;
extern uint8* kInverseGammaTable;

void init_gamma_blending();
void uninit_gamma_blending();

// blend
inline void
blend_gamma(uint16 b1, uint16 b2, uint16 b3, uint8 ba,	// bottom components
			uint16 t1, uint16 t2, uint16 t3, uint8 ta,	// top components
			uint8* d1, uint8* d2, uint8* d3, uint8* da)	// dest components
{
	if (ba == 255) {
		uint32 destAlpha = 255 - ta;
		*d1 = kInverseGammaTable[(b1 * destAlpha + t1 * ta) / 255];
		*d2 = kInverseGammaTable[(b2 * destAlpha + t2 * ta) / 255];
		*d3 = kInverseGammaTable[(b3 * destAlpha + t3 * ta) / 255];
		*da = 255;
	} else {
		uint8 alphaRest = 255 - ta;
		uint32 alphaTemp = (65025 - alphaRest * (255 - ba));
		uint32 alphaDest = ba * alphaRest;
		uint32 alphaSrc = 255 * ta;
		*d1 = kInverseGammaTable[(b1 * alphaDest + t1 * alphaSrc) / alphaTemp];
		*d2 = kInverseGammaTable[(b2 * alphaDest + t2 * alphaSrc) / alphaTemp];
		*d3 = kInverseGammaTable[(b3 * alphaDest + t3 * alphaSrc) / alphaTemp];
		*da = alphaTemp / 255;
	}
}

// blend
inline void
blend(uint8 b1, uint8 b2, uint8 b3, uint8 ba,		// bottom components
	  uint8 t1, uint8 t2, uint8 t3, uint8 ta,		// top components
	  uint8* d1, uint8* d2, uint8* d3, uint8* da)	// dest components
{
	// convert to linear rgb
	uint16 gt1 = kGammaTable[t1];
	uint16 gt2 = kGammaTable[t2];
	uint16 gt3 = kGammaTable[t3];

	uint16 gb1 = kGammaTable[b1];
	uint16 gb2 = kGammaTable[b2];
	uint16 gb3 = kGammaTable[b3];

	blend_gamma(gb1, gb2, gb3, ba,
				gt1, gt2, gt3, ta,
				d1, d2, d3, da);
}

// convert_to_gamma
//
// converted value will be gamma corrected in the range [0...2550]
// and can be passed on to the other functions that take uint16 components
uint16
convert_to_gamma(uint8 value);

// blend_colors_copy
inline void
blend_colors_copy(uint8* bottom, uint8 alpha, uint8* dest,
				  uint8 c1, uint8 c2, uint8 c3,
				  uint16 gc1, uint16 gc2, uint16 gc3)
{
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			dest[0] = c1;
			dest[1] = c2;
			dest[2] = c3;
			dest[3] = alpha;
		} else {
			// only bottom components need to be gamma corrected
			uint16 gb1 = kGammaTable[bottom[0]];
			uint16 gb2 = kGammaTable[bottom[1]];
			uint16 gb3 = kGammaTable[bottom[2]];

			blend_gamma(gb1, gb2, gb3, bottom[3],
						gc1, gc2, gc3, alpha,
						&dest[0], &dest[1], &dest[2], &dest[3]);
		}
	} else {
		*((uint32*)dest) = *((uint32*)bottom);
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8 alpha,
			 uint8 c1, uint8 c2, uint8 c3,
			 uint16 gc1, uint16 gc2, uint16 gc3)
{
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			bottom[0] = c1;
			bottom[1] = c2;
			bottom[2] = c3;
			bottom[3] = alpha;
		} else {
			// only bottom components need to be gamma corrected
			uint16 gb1 = kGammaTable[bottom[0]];
			uint16 gb2 = kGammaTable[bottom[1]];
			uint16 gb3 = kGammaTable[bottom[2]];

			blend_gamma(gb1, gb2, gb3, bottom[3],
						gc1, gc2, gc3, alpha,
						&bottom[0], &bottom[1], &bottom[2], &bottom[3]);
		}
	}
}

// blend_colors_copy
inline void
blend_colors_copy(uint8* bottom, uint8 alpha, uint8* dest,
				  uint8 c1, uint8 c2, uint8 c3)
{
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			dest[0] = c1;
			dest[1] = c2;
			dest[2] = c3;
			dest[3] = alpha;
		} else {
			blend(bottom[0], bottom[1], bottom[2], bottom[3],
				  c1, c2, c3, alpha,
				  &dest[0], &dest[1], &dest[2], &dest[3]);
		}
	} else {
		*((uint32*)dest) = *((uint32*)bottom);
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8 alpha, uint8 c1, uint8 c2, uint8 c3)
{
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			bottom[0] = c1;
			bottom[1] = c2;
			bottom[2] = c3;
			bottom[3] = alpha;
		} else {
			blend(bottom[0], bottom[1], bottom[2], bottom[3],
				  c1, c2, c3, alpha,
				  &bottom[0], &bottom[1], &bottom[2], &bottom[3]);
		}
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8* source, uint8 alphaOverride)
{
	uint8 alpha = (source[3] * alphaOverride) / 255;
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			bottom[0] = source[0];
			bottom[1] = source[1];
			bottom[2] = source[2];
			bottom[3] = alpha;
		} else {
			blend(bottom[0], bottom[1], bottom[2], bottom[3],
				  source[0], source[1], source[2], alpha,
				  &bottom[0], &bottom[1], &bottom[2], &bottom[3]);
		}
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8* source)
{
	if (source[3] > 0) {
		if (bottom[3] == 0 || source[3] == 255) {
			bottom[0] = source[0];
			bottom[1] = source[1];
			bottom[2] = source[2];
			bottom[3] = source[3];
		} else {
			blend(bottom[0], bottom[1], bottom[2], bottom[3],
				  source[0], source[1], source[2], source[3],
				  &bottom[0], &bottom[1], &bottom[2], &bottom[3]);
		}
	}
}

// blend_colors_copy
inline void
blend_colors_copy(uint8* dest, uint8* bottom, uint8* top)
{
	if (bottom[3] == 0 || top[3] == 255) {
		dest[0] = top[0];
		dest[1] = top[1];
		dest[2] = top[2];
		dest[3] = top[3];
	} else {
			blend(bottom[0], bottom[1], bottom[2], bottom[3],
				  top[0], top[1], top[2], top[3],
				  &dest[0], &dest[1], &dest[2], &dest[3]);
	}
}

// blend_pixels
inline void
blend_pixels(uint8* bottom, uint8* top, uint8 alpha)
{
	if (alpha > 0) {
		if (alpha == 255) {
			bottom[0] = top[0];
			bottom[1] = top[1];
			bottom[2] = top[2];
			bottom[3] = top[3];
		} else {
			// convert to linear rgb
			uint16 t1 = kGammaTable[top[0]];
			uint16 t2 = kGammaTable[top[1]];
			uint16 t3 = kGammaTable[top[2]];
			uint16 b1 = kGammaTable[bottom[0]];
			uint16 b2 = kGammaTable[bottom[1]];
			uint16 b3 = kGammaTable[bottom[2]];

			uint8 mergeAlpha = bottom[3] ? (top[3] * alpha) / 255 : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			bottom[0] = kInverseGammaTable[(b1 * invAlpha + t1 * mergeAlpha) / 255];
			bottom[1] = kInverseGammaTable[(b2 * invAlpha + t2 * mergeAlpha) / 255];
			bottom[2] = kInverseGammaTable[(b3 * invAlpha + t3 * mergeAlpha) / 255];
			bottom[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	}
}

// blend_pixels_copy
inline void
blend_pixels_copy(uint8* bottom, uint8* top, uint8* dest, uint8 alpha)
{
	if (alpha > 0) {	
		if (alpha == 255) {
			dest[0] = top[0];
			dest[1] = top[1];
			dest[2] = top[2];
			dest[3] = top[3];
		} else {
			// convert to linear rgb
			uint16 t1 = kGammaTable[top[0]];
			uint16 t2 = kGammaTable[top[1]];
			uint16 t3 = kGammaTable[top[2]];
			uint16 b1 = kGammaTable[bottom[0]];
			uint16 b2 = kGammaTable[bottom[1]];
			uint16 b3 = kGammaTable[bottom[2]];

			uint8 mergeAlpha = bottom[3] ? (top[3] * alpha) / 255 : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			dest[0] = kInverseGammaTable[(b1 * invAlpha + t1 * mergeAlpha) / 255];
			dest[1] = kInverseGammaTable[(b2 * invAlpha + t2 * mergeAlpha) / 255];
			dest[2] = kInverseGammaTable[(b3 * invAlpha + t3 * mergeAlpha) / 255];
			dest[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	} else {
		dest[0] = bottom[0];
		dest[1] = bottom[1];
		dest[2] = bottom[2];
		dest[3] = bottom[3];
	}
}

// blend_pixels_overlay
inline void
blend_pixels_overlay(uint8* bottom, uint8* top, uint8 alphaOverride)
{
	uint8 alpha = (top[3] * alphaOverride) / 255;
	if (alpha > 0) {
		if (alpha == 255) {
			bottom[0] = top[0];
			bottom[1] = top[1];
			bottom[2] = top[2];
			bottom[3] = top[3];
		} else {
			// convert to linear rgb
			uint16 t1 = kGammaTable[top[0]];
			uint16 t2 = kGammaTable[top[1]];
			uint16 t3 = kGammaTable[top[2]];
			uint16 b1 = kGammaTable[bottom[0]];
			uint16 b2 = kGammaTable[bottom[1]];
			uint16 b3 = kGammaTable[bottom[2]];

			uint8 mergeAlpha = bottom[3] ? alpha : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			bottom[0] = kInverseGammaTable[(b1 * invAlpha + t1 * mergeAlpha) / 255];
			bottom[1] = kInverseGammaTable[(b2 * invAlpha + t2 * mergeAlpha) / 255];
			bottom[2] = kInverseGammaTable[(b3 * invAlpha + t3 * mergeAlpha) / 255];
			bottom[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	}
}

// blend_pixels_overlay_copy
inline void
blend_pixels_overlay_copy(uint8* bottom, uint8* top, uint8* dest, uint8 alphaOverride)
{
	uint8 alpha = (top[3] * alphaOverride) / 255;
	if (alpha > 0) {
		if (alpha == 255) {
			dest[0] = top[0];
			dest[1] = top[1];
			dest[2] = top[2];
			dest[3] = top[3];
		} else {
			// convert to linear rgb
			uint16 t1 = kGammaTable[top[0]];
			uint16 t2 = kGammaTable[top[1]];
			uint16 t3 = kGammaTable[top[2]];
			uint16 b1 = kGammaTable[bottom[0]];
			uint16 b2 = kGammaTable[bottom[1]];
			uint16 b3 = kGammaTable[bottom[2]];

			uint8 mergeAlpha = bottom[3] ? alpha : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			dest[0] = kInverseGammaTable[(b1 * invAlpha + t1 * mergeAlpha) / 255];
			dest[1] = kInverseGammaTable[(b2 * invAlpha + t2 * mergeAlpha) / 255];
			dest[2] = kInverseGammaTable[(b3 * invAlpha + t3 * mergeAlpha) / 255];
			dest[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	} else {
		dest[0] = bottom[0];
		dest[1] = bottom[1];
		dest[2] = bottom[2];
		dest[3] = bottom[3];
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////
#else // GAMMA_BLEND

// blend_colors_copy
inline void
blend_colors_copy(uint8* bottom, uint8 alpha, uint8* dest,
				  uint8 c1, uint8 c2, uint8 c3)
{
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			dest[0] = c1;
			dest[1] = c2;
			dest[2] = c3;
			dest[3] = alpha;
		} else {
			if (bottom[3] == 255) {
				uint32 destAlpha = 255 - alpha;
				dest[0] = (uint8)((bottom[0] * destAlpha + c1 * alpha) / 255);
				dest[1] = (uint8)((bottom[1] * destAlpha + c2 * alpha) / 255);
				dest[2] = (uint8)((bottom[2] * destAlpha + c3 * alpha) / 255);
				dest[3] = 255;
			} else {
				uint8 alphaRest = 255 - alpha;
				uint32 alphaTemp = (65025 - alphaRest * (255 - bottom[3]));
				uint32 alphaDest = bottom[3] * alphaRest;
				uint32 alphaSrc = 255 * alpha;
				dest[0] = (bottom[0] * alphaDest + c1 * alphaSrc) / alphaTemp;
				dest[1] = (bottom[1] * alphaDest + c2 * alphaSrc) / alphaTemp;
				dest[2] = (bottom[2] * alphaDest + c3 * alphaSrc) / alphaTemp;
				dest[3] = alphaTemp / 255;
			}
		}
	} else {
		*((uint32*)dest) = *((uint32*)bottom);
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8 alpha, uint8 c1, uint8 c2, uint8 c3)
{
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			bottom[0] = c1;
			bottom[1] = c2;
			bottom[2] = c3;
			bottom[3] = alpha;
		} else {
			if (bottom[3] == 255) {
				uint32 destAlpha = 255 - alpha;
				bottom[0] = (uint8)((bottom[0] * destAlpha + c1 * alpha) / 255);
				bottom[1] = (uint8)((bottom[1] * destAlpha + c2 * alpha) / 255);
				bottom[2] = (uint8)((bottom[2] * destAlpha + c3 * alpha) / 255);
			} else {
				uint8 alphaRest = 255 - alpha;
				uint32 alphaTemp = (65025 - alphaRest * (255 - bottom[3]));
				uint32 alphaDest = bottom[3] * alphaRest;
				uint32 alphaSrc = 255 * alpha;
				bottom[0] = (bottom[0] * alphaDest + c1 * alphaSrc) / alphaTemp;
				bottom[1] = (bottom[1] * alphaDest + c2 * alphaSrc) / alphaTemp;
				bottom[2] = (bottom[2] * alphaDest + c3 * alphaSrc) / alphaTemp;
				bottom[3] = alphaTemp / 255;
			}
		}
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8* source, uint8 alphaOverride)
{
	uint8 alpha = (source[3] * alphaOverride) / 255;
	if (alpha > 0) {
		if (bottom[3] == 0 || alpha == 255) {
			bottom[0] = source[0];
			bottom[1] = source[1];
			bottom[2] = source[2];
			bottom[3] = alpha;
		} else {
			if (bottom[3] == 255) {
				uint32 destAlpha = 255 - alpha;
				bottom[0] = (uint8)((bottom[0] * destAlpha + source[0] * alpha) / 255);
				bottom[1] = (uint8)((bottom[1] * destAlpha + source[1] * alpha) / 255);
				bottom[2] = (uint8)((bottom[2] * destAlpha + source[2] * alpha) / 255);
			} else {
				uint8 alphaRest = 255 - alpha;
				uint32 alphaTemp = (65025 - alphaRest * (255 - bottom[3]));
				uint32 alphaDest = bottom[3] * alphaRest;
				uint32 alphaSrc = 255 * alpha;
				bottom[0] = (bottom[0] * alphaDest + source[0] * alphaSrc) / alphaTemp;
				bottom[1] = (bottom[1] * alphaDest + source[1] * alphaSrc) / alphaTemp;
				bottom[2] = (bottom[2] * alphaDest + source[2] * alphaSrc) / alphaTemp;
				bottom[3] = alphaTemp / 255;
			}
		}
	}
}

// blend_colors
inline void
blend_colors(uint8* bottom, uint8* source)
{
	if (source[3] > 0) {
		if (bottom[3] == 0 || source[3] == 255) {
			bottom[0] = source[0];
			bottom[1] = source[1];
			bottom[2] = source[2];
			bottom[3] = source[3];
		} else {
			if (bottom[3] == 255) {
				uint32 destAlpha = 255 - source[3];
				bottom[0] = (uint8)((bottom[0] * destAlpha + source[0] * source[3]) / 255);
				bottom[1] = (uint8)((bottom[1] * destAlpha + source[1] * source[3]) / 255);
				bottom[2] = (uint8)((bottom[2] * destAlpha + source[2] * source[3]) / 255);
			} else {
				uint8 alphaRest = 255 - source[3];
				uint32 alphaTemp = (65025 - alphaRest * (255 - bottom[3]));
				uint32 alphaDest = bottom[3] * alphaRest;
				uint32 alphaSrc = 255 * source[3];
				bottom[0] = (bottom[0] * alphaDest + source[0] * alphaSrc) / alphaTemp;
				bottom[1] = (bottom[1] * alphaDest + source[1] * alphaSrc) / alphaTemp;
				bottom[2] = (bottom[2] * alphaDest + source[2] * alphaSrc) / alphaTemp;
				bottom[3] = alphaTemp / 255;
			}
		}
	}
}

// blend_colors_copy
inline void
blend_colors_copy(uint8* dest, uint8* bottom, uint8* top)
{
	if (bottom[3] == 0 || top[3] == 255) {
		dest[0] = top[0];
		dest[1] = top[1];
		dest[2] = top[2];
		dest[3] = top[3];
	} else {
		if (bottom[3] == 255) {
			uint32 destAlpha = 255 - top[3];
			dest[0] = (uint8)((bottom[0] * destAlpha + top[0] * top[3]) / 255);
			dest[1] = (uint8)((bottom[1] * destAlpha + top[1] * top[3]) / 255);
			dest[2] = (uint8)((bottom[2] * destAlpha + top[2] * top[3]) / 255);
			dest[3] = 255;
		} else {
			uint8 alphaRest = 255 - top[3];
			uint32 alphaTemp = (65025 - alphaRest * (255 - bottom[3]));
			uint32 alphaDest = bottom[3] * alphaRest;
			uint32 alphaSrc = 255 * top[3];
			dest[0] = (bottom[0] * alphaDest + top[0] * alphaSrc) / alphaTemp;
			dest[1] = (bottom[1] * alphaDest + top[1] * alphaSrc) / alphaTemp;
			dest[2] = (bottom[2] * alphaDest + top[2] * alphaSrc) / alphaTemp;
			dest[3] = alphaTemp / 255;
		}
	}
}

// blend_pixels
inline void
blend_pixels(uint8* bottom, uint8* top, uint8 alpha)
{
	if (alpha > 0) {
		if (alpha == 255) {
			bottom[0] = top[0];
			bottom[1] = top[1];
			bottom[2] = top[2];
			bottom[3] = top[3];
		} else {
			uint8 mergeAlpha = bottom[3] ? (top[3] * alpha) / 255 : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			bottom[0] = (bottom[0] * invAlpha + top[0] * mergeAlpha) / 255;
			bottom[1] = (bottom[1] * invAlpha + top[1] * mergeAlpha) / 255;
			bottom[2] = (bottom[2] * invAlpha + top[2] * mergeAlpha) / 255;
			bottom[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	}
}

// blend_pixels_copy
inline void
blend_pixels_copy(uint8* bottom, uint8* top, uint8* dest, uint8 alpha)
{
	if (alpha > 0) {
		if (alpha == 255) {
			dest[0] = top[0];
			dest[1] = top[1];
			dest[2] = top[2];
			dest[3] = top[3];
		} else {
			uint8 mergeAlpha = bottom[3] ? (top[3] * alpha) / 255 : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			dest[0] = (bottom[0] * invAlpha + top[0] * mergeAlpha) / 255;
			dest[1] = (bottom[1] * invAlpha + top[1] * mergeAlpha) / 255;
			dest[2] = (bottom[2] * invAlpha + top[2] * mergeAlpha) / 255;
			dest[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	} else {
		dest[0] = bottom[0];
		dest[1] = bottom[1];
		dest[2] = bottom[2];
		dest[3] = bottom[3];
	}
}

// blend_pixels_overlay
inline void
blend_pixels_overlay(uint8* bottom, uint8* top, uint8 alphaOverride)
{
	uint8 alpha = (top[3] * alphaOverride) / 255;
	if (alpha > 0) {
		if (alpha == 255) {
			bottom[0] = top[0];
			bottom[1] = top[1];
			bottom[2] = top[2];
			bottom[3] = top[3];
		} else {
			uint8 mergeAlpha = bottom[3] ? alpha : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			bottom[0] = (bottom[0] * invAlpha + top[0] * mergeAlpha) / 255;
			bottom[1] = (bottom[1] * invAlpha + top[1] * mergeAlpha) / 255;
			bottom[2] = (bottom[2] * invAlpha + top[2] * mergeAlpha) / 255;
			bottom[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	}
}

// blend_pixels_overlay_copy
inline void
blend_pixels_overlay_copy(uint8* bottom, uint8* top, uint8* dest, uint8 alphaOverride)
{
	uint8 alpha = (top[3] * alphaOverride) / 255;
	if (alpha > 0) {
		if (alpha == 255) {
			dest[0] = top[0];
			dest[1] = top[1];
			dest[2] = top[2];
			dest[3] = top[3];
		} else {
			uint8 mergeAlpha = bottom[3] ? alpha : 255;
			uint8 invAlpha = 255 - mergeAlpha;
			dest[0] = (bottom[0] * invAlpha + top[0] * mergeAlpha) / 255;
			dest[1] = (bottom[1] * invAlpha + top[1] * mergeAlpha) / 255;
			dest[2] = (bottom[2] * invAlpha + top[2] * mergeAlpha) / 255;
			dest[3] = (bottom[3] * (255 - alpha) + top[3] * alpha) / 255;
		}
	} else {
		dest[0] = bottom[0];
		dest[1] = bottom[1];
		dest[2] = bottom[2];
		dest[3] = bottom[3];
	}
}

#endif	// GAMMA_BLEND

#endif // BLENDING_H