haiku.git

/*
 * Copyright 2009, Christian Packmann.
 * Copyright 2008, Andrej Spielmann <andrej.spielmann@seh.ox.ac.uk>.
 * Copyright 2005-2014, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2015, Julian Harnath <julian.harnath@rwth-aachen.de>
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#ifndef DRAW_BITMAP_BILINEAR_H
#define DRAW_BITMAP_BILINEAR_H

#include "Painter.h"

#include <typeinfo>


// Prototypes for assembler routines
extern "C" {
	void bilinear_scale_xloop_mmxsse(const uint8* src, void* dst,
		void* xWeights, uint32 xmin, uint32 xmax, uint32 wTop, uint32 srcBPR);
}


extern uint32 gSIMDFlags;


namespace BitmapPainterPrivate {


struct FilterInfo {
	uint16 index;	// index into source bitmap row/column
	uint16 weight;	// weight of the pixel at index [0..255]
};


struct FilterData {
	FilterInfo* fWeightsX;
	FilterInfo* fWeightsY;
	uint32 fIndexOffsetX;
	uint32 fIndexOffsetY;
};


template<class OptimizedVersion>
struct DrawBitmapBilinearOptimized {
	void Draw(PainterAggInterface& aggInterface, const BRect& destinationRect,
		agg::rendering_buffer* bitmap, const FilterData& filterData)
	{
		fSource = bitmap;
		fSourceBytesPerRow = bitmap->stride();
		fDestination = NULL;
		fDestinationBytesPerRow = aggInterface.fBuffer.stride();
		fWeightsX = filterData.fWeightsX;
		fWeightsY = filterData.fWeightsY;

		const int32 left = (int32)destinationRect.left;
		const int32 top = (int32)destinationRect.top;
		const int32 right = (int32)destinationRect.right;
		const int32 bottom = (int32)destinationRect.bottom;

		renderer_base& baseRenderer = aggInterface.fBaseRenderer;

		// iterate over clipping boxes
		baseRenderer.first_clip_box();
		do {
			const int32 x1 = max_c(baseRenderer.xmin(), left);
			const int32 x2 = min_c(baseRenderer.xmax(), right);
			if (x1 > x2)
				continue;

			int32 y1 = max_c(baseRenderer.ymin(), top);
			int32 y2 = min_c(baseRenderer.ymax(), bottom);
			if (y1 > y2)
				continue;

			// buffer offset into destination
			fDestination = aggInterface.fBuffer.row_ptr(y1) + x1 * 4;

			// x and y are needed as indices into the weight arrays, so the
			// offset into the target buffer needs to be compensated
			const int32 xIndexL = x1 - left - filterData.fIndexOffsetX;
			const int32 xIndexR = x2 - left - filterData.fIndexOffsetX;
			y1 -= top + filterData.fIndexOffsetY;
			y2 -= top + filterData.fIndexOffsetY;

			//printf("x: %ld - %ld\n", xIndexL, xIndexR);
			//printf("y: %ld - %ld\n", y1, y2);

			static_cast<OptimizedVersion*>(this)->DrawToClipRect(
				xIndexL, xIndexR, y1, y2);

		} while (baseRenderer.next_clip_box());
	}

protected:
	agg::rendering_buffer*	fSource;
	uint32					fSourceBytesPerRow;
	uint8*					fDestination;
	uint32					fDestinationBytesPerRow;
	FilterInfo*				fWeightsX;
	FilterInfo*				fWeightsY;
};


struct ColorTypeRgb {
	static void
	Interpolate(uint32* t, const uint8* s, uint32 sourceBytesPerRow,
		uint16 wLeft, uint16 wTop, uint16 wRight, uint16 wBottom)
	{
		// left and right of top row
		t[0] = (s[0] * wLeft + s[4] * wRight) * wTop;
		t[1] = (s[1] * wLeft + s[5] * wRight) * wTop;
		t[2] = (s[2] * wLeft + s[6] * wRight) * wTop;

		// left and right of bottom row
		s += sourceBytesPerRow;
		t[0] += (s[0] * wLeft + s[4] * wRight) * wBottom;
		t[1] += (s[1] * wLeft + s[5] * wRight) * wBottom;
		t[2] += (s[2] * wLeft + s[6] * wRight) * wBottom;

		t[0] >>= 16;
		t[1] >>= 16;
		t[2] >>= 16;
	}

	static void
	InterpolateLastColumn(uint32* t, const uint8* s, const uint8* sBottom,
		uint16 wTop, uint16 wBottom)
	{
		t[0] = (s[0] * wTop + sBottom[0] * wBottom) >> 8;
		t[1] = (s[1] * wTop + sBottom[1] * wBottom) >> 8;
		t[2] = (s[2] * wTop + sBottom[2] * wBottom) >> 8;
	}

	static void
	InterpolateLastRow(uint32* t, const uint8* s, uint16 wLeft,
		uint16 wRight)
	{
		t[0] = (s[0] * wLeft + s[4] * wRight) >> 8;
		t[1] = (s[1] * wLeft + s[5] * wRight) >> 8;
		t[2] = (s[2] * wLeft + s[6] * wRight) >> 8;
	}
};


struct ColorTypeRgba {
	static void
	Interpolate(uint32* t, const uint8* s, uint32 sourceBytesPerRow,
		uint16 wLeft, uint16 wTop, uint16 wRight, uint16 wBottom)
	{
		// left and right of top row
		t[0] = (s[0] * wLeft + s[4] * wRight) * wTop;
		t[1] = (s[1] * wLeft + s[5] * wRight) * wTop;
		t[2] = (s[2] * wLeft + s[6] * wRight) * wTop;
		t[3] = (s[3] * wLeft + s[7] * wRight) * wTop;

		// left and right of bottom row
		s += sourceBytesPerRow;

		t[0] += (s[0] * wLeft + s[4] * wRight) * wBottom;
		t[1] += (s[1] * wLeft + s[5] * wRight) * wBottom;
		t[2] += (s[2] * wLeft + s[6] * wRight) * wBottom;
		t[3] += (s[3] * wLeft + s[7] * wRight) * wBottom;

		t[0] >>= 16;
		t[1] >>= 16;
		t[2] >>= 16;
		t[3] >>= 16;
	}

	static void
	InterpolateLastColumn(uint32* t, const uint8* s, const uint8* sBottom,
		uint16 wTop, uint16 wBottom)
	{
		t[0] = (s[0] * wTop + sBottom[0] * wBottom) >> 8;
		t[1] = (s[1] * wTop + sBottom[1] * wBottom) >> 8;
		t[2] = (s[2] * wTop + sBottom[2] * wBottom) >> 8;
		t[3] = (s[3] * wTop + sBottom[3] * wBottom) >> 8;
	}

	static void
	InterpolateLastRow(uint32* t, const uint8* s, uint16 wLeft,
		uint16 wRight)
	{
		t[0] = (s[0] * wLeft + s[4] * wRight) >> 8;
		t[1] = (s[1] * wLeft + s[5] * wRight) >> 8;
		t[2] = (s[2] * wLeft + s[6] * wRight) >> 8;
		t[3] = (s[3] * wLeft + s[7] * wRight) >> 8;
	}
};


struct DrawModeCopy {
	static void
	Blend(uint8*& d, uint32* t)
	{
		d[0] = t[0];
		d[1] = t[1];
		d[2] = t[2];
		d += 4;
	}
};


struct DrawModeAlphaOverlay {
	static void
	Blend(uint8*& d, uint32* t)
	{
		uint8 t0 = t[0];
		uint8 t1 = t[1];
		uint8 t2 = t[2];
		uint8 t3 = t[3];

		if (t3 == 255) {
			d[0] = t0;
			d[1] = t1;
			d[2] = t2;
		} else {
			d[0] = ((t0 - d[0]) * t3 + (d[0] << 8)) >> 8;
			d[1] = ((t1 - d[1]) * t3 + (d[1] << 8)) >> 8;
			d[2] = ((t2 - d[2]) * t3 + (d[2] << 8)) >> 8;
		}

		d += 4;
	}
};


template<class ColorType, class DrawMode>
struct BilinearDefault :
	DrawBitmapBilinearOptimized<BilinearDefault<ColorType, DrawMode> > {

	void DrawToClipRect(int32 xIndexL, int32 xIndexR, int32 y1, int32 y2)
	{
		// In this mode we anticipate many pixels wich need filtering,
		// there are no special cases for direct hit pixels except for
		// the last column/row and the right/bottom corner pixel.

		// The last column/row handling does not need to be performed
		// for all clipping rects!
		int32 yMax = y2;
		if (this->fWeightsY[yMax].weight == 255)
			yMax--;
		int32 xIndexMax = xIndexR;
		if (this->fWeightsX[xIndexMax].weight == 255)
			xIndexMax--;

		for (; y1 <= yMax; y1++) {
			// cache the weight of the top and bottom row
			const uint16 wTop = this->fWeightsY[y1].weight;
			const uint16 wBottom = 255 - this->fWeightsY[y1].weight;

			// buffer offset into source (top row)
			const uint8* src = this->fSource->row_ptr(
				this->fWeightsY[y1].index);

			// buffer handle for destination to be incremented per
			// pixel
			uint8* d = this->fDestination;

			for (int32 x = xIndexL; x <= xIndexMax; x++) {
				const uint8* s = src + this->fWeightsX[x].index;

				// calculate the weighted sum of all four
				// interpolated pixels
				const uint16 wLeft = this->fWeightsX[x].weight;
				const uint16 wRight = 255 - wLeft;

				uint32 t[4];

				if (this->fSource->height() > 1) {
					ColorType::Interpolate(&t[0], s, this->fSourceBytesPerRow,
						wLeft, wTop, wRight, wBottom);
				} else {
					ColorType::InterpolateLastRow(&t[0], s,  wLeft, wRight);
				}
				DrawMode::Blend(d, &t[0]);
			}
			// last column of pixels if necessary
			if (xIndexMax < xIndexR && this->fSource->height() > 1) {
				const uint8* s = src + this->fWeightsX[xIndexR].index;
				const uint8* sBottom = s + this->fSourceBytesPerRow;

				uint32 t[4];
				ColorType::InterpolateLastColumn(&t[0], s, sBottom, wTop,
					wBottom);
				DrawMode::Blend(d, &t[0]);
			}

			this->fDestination += this->fDestinationBytesPerRow;
		}

		// last row of pixels if necessary
		// buffer offset into source (bottom row)
		const uint8* src
			= this->fSource->row_ptr(this->fWeightsY[y2].index);
		// buffer handle for destination to be incremented per pixel
		uint8* d = this->fDestination;

		if (yMax < y2) {
			for (int32 x = xIndexL; x <= xIndexMax; x++) {
				const uint8* s = src + this->fWeightsX[x].index;
				const uint16 wLeft = this->fWeightsX[x].weight;
				const uint16 wRight = 255 - wLeft;
				uint32 t[4];
				ColorType::InterpolateLastRow(&t[0], s, wLeft, wRight);
				DrawMode::Blend(d, &t[0]);
			}
		}

		// pixel in bottom right corner if necessary
		if (yMax < y2 && xIndexMax < xIndexR) {
			const uint8* s = src + this->fWeightsX[xIndexR].index;
			*(uint32*)d = *(uint32*)s;
		}
	}
};


struct BilinearLowFilterRatio :
	DrawBitmapBilinearOptimized<BilinearLowFilterRatio> {
	void DrawToClipRect(int32 xIndexL, int32 xIndexR, int32 y1, int32 y2)
	{
		// In this mode, we anticipate to hit many destination pixels
		// that map directly to a source pixel, we have more branches
		// in the inner loop but save time because of the special
		// cases. If there are too few direct hit pixels, the branches
		// only waste time.

		for (; y1 <= y2; y1++) {
			// cache the weight of the top and bottom row
			const uint16 wTop = fWeightsY[y1].weight;
			const uint16 wBottom = 255 - fWeightsY[y1].weight;

			// buffer offset into source (top row)
			const uint8* src = fSource->row_ptr(fWeightsY[y1].index);
			// buffer handle for destination to be incremented per
			// pixel
			uint8* d = fDestination;

			if (wTop == 255) {
				for (int32 x = xIndexL; x <= xIndexR; x++) {
					const uint8* s = src + fWeightsX[x].index;
					// This case is important to prevent out
					// of bounds access at bottom edge of the source
					// bitmap. If the scale is low and integer, it will
					// also help the speed.
					if (fWeightsX[x].weight == 255) {
						// As above, but to prevent out of bounds
						// on the right edge.
						*(uint32*)d = *(uint32*)s;
					} else {
						// Only the left and right pixels are
						// interpolated, since the top row has 100%
						// weight.
						const uint16 wLeft = fWeightsX[x].weight;
						const uint16 wRight = 255 - wLeft;
						d[0] = (s[0] * wLeft + s[4] * wRight) >> 8;
						d[1] = (s[1] * wLeft + s[5] * wRight) >> 8;
						d[2] = (s[2] * wLeft + s[6] * wRight) >> 8;
					}
					d += 4;
				}
			} else {
				for (int32 x = xIndexL; x <= xIndexR; x++) {
					const uint8* s = src + fWeightsX[x].index;
					if (fWeightsX[x].weight == 255) {
						// Prevent out of bounds access on the right
						// edge or simply speed up.
						const uint8* sBottom = s + fSourceBytesPerRow;
						d[0] = (s[0] * wTop + sBottom[0] * wBottom)
							>> 8;
						d[1] = (s[1] * wTop + sBottom[1] * wBottom)
							>> 8;
						d[2] = (s[2] * wTop + sBottom[2] * wBottom)
							>> 8;
					} else {
						// calculate the weighted sum of all four
						// interpolated pixels
						const uint16 wLeft = fWeightsX[x].weight;
						const uint16 wRight = 255 - wLeft;
						// left and right of top row
						uint32 t0 = (s[0] * wLeft + s[4] * wRight)
							* wTop;
						uint32 t1 = (s[1] * wLeft + s[5] * wRight)
							* wTop;
						uint32 t2 = (s[2] * wLeft + s[6] * wRight)
							* wTop;

						// left and right of bottom row
						s += fSourceBytesPerRow;
						t0 += (s[0] * wLeft + s[4] * wRight) * wBottom;
						t1 += (s[1] * wLeft + s[5] * wRight) * wBottom;
						t2 += (s[2] * wLeft + s[6] * wRight) * wBottom;

						d[0] = t0 >> 16;
						d[1] = t1 >> 16;
						d[2] = t2 >> 16;
					}
					d += 4;
				}
			}
			fDestination += fDestinationBytesPerRow;
		}
	}
};


#ifdef __i386__

struct BilinearSimd : DrawBitmapBilinearOptimized<BilinearSimd> {
	void DrawToClipRect(int32 xIndexL, int32 xIndexR, int32 y1, int32 y2)
	{
		// Basically the same as the "standard" mode, but we use SIMD
		// routines for the processing of the single display lines.

		// The last column/row handling does not need to be performed
		// for all clipping rects!
		int32 yMax = y2;
		if (fWeightsY[yMax].weight == 255)
			yMax--;
		int32 xIndexMax = xIndexR;
		if (fWeightsX[xIndexMax].weight == 255)
			xIndexMax--;

		for (; y1 <= yMax; y1++) {
			// cache the weight of the top and bottom row
			const uint16 wTop = fWeightsY[y1].weight;
			const uint16 wBottom = 255 - fWeightsY[y1].weight;

			// buffer offset into source (top row)
			const uint8* src = fSource->row_ptr(fWeightsY[y1].index);
			// buffer handle for destination to be incremented per
			// pixel
			uint8* d = fDestination;
			bilinear_scale_xloop_mmxsse(src, fDestination, fWeightsX, xIndexL,
				xIndexMax, wTop, fSourceBytesPerRow);
			// increase pointer by processed pixels
			d += (xIndexMax - xIndexL + 1) * 4;

			// last column of pixels if necessary
			if (xIndexMax < xIndexR) {
				const uint8* s = src + fWeightsX[xIndexR].index;
				const uint8* sBottom = s + fSourceBytesPerRow;
				d[0] = (s[0] * wTop + sBottom[0] * wBottom) >> 8;
				d[1] = (s[1] * wTop + sBottom[1] * wBottom) >> 8;
				d[2] = (s[2] * wTop + sBottom[2] * wBottom) >> 8;
			}

			fDestination += fDestinationBytesPerRow;
		}

		// last row of pixels if necessary
		// buffer offset into source (bottom row)
		const uint8* src = fSource->row_ptr(fWeightsY[y2].index);
		// buffer handle for destination to be incremented per pixel
		uint8* d = fDestination;

		if (yMax < y2) {
			for (int32 x = xIndexL; x <= xIndexMax; x++) {
				const uint8* s = src + fWeightsX[x].index;
				const uint16 wLeft = fWeightsX[x].weight;
				const uint16 wRight = 255 - wLeft;
				d[0] = (s[0] * wLeft + s[4] * wRight) >> 8;
				d[1] = (s[1] * wLeft + s[5] * wRight) >> 8;
				d[2] = (s[2] * wLeft + s[6] * wRight) >> 8;
				d += 4;
			}
		}

		// pixel in bottom right corner if necessary
		if (yMax < y2 && xIndexMax < xIndexR) {
			const uint8* s = src + fWeightsX[xIndexR].index;
			*(uint32*)d = *(uint32*)s;
		}
	}
};

#endif	// __i386__


template<class ColorType, class DrawMode>
struct DrawBitmapBilinear {
	void
	Draw(const Painter* painter, PainterAggInterface& aggInterface,
		agg::rendering_buffer& bitmap, BPoint offset,
		double scaleX, double scaleY, BRect destinationRect)
	{
		//bigtime_t now = system_time();
		uint32 dstWidth = destinationRect.IntegerWidth() + 1;
		uint32 dstHeight = destinationRect.IntegerHeight() + 1;
		uint32 srcWidth = bitmap.width();
		uint32 srcHeight = bitmap.height();

		// Do not calculate more filter weights than necessary and also
		// keep the stack based allocations reasonably sized
		const BRegion& clippingRegion = *painter->ClippingRegion();
		if (clippingRegion.Frame().IntegerWidth() + 1 < (int32)dstWidth)
			dstWidth = clippingRegion.Frame().IntegerWidth() + 1;
		if (clippingRegion.Frame().IntegerHeight() + 1 < (int32)dstHeight)
			dstHeight = clippingRegion.Frame().IntegerHeight() + 1;

		// When calculating less filter weights than specified by
		// destinationRect, we need to compensate the offset.
		FilterData filterData;
		filterData.fIndexOffsetX = 0;
		filterData.fIndexOffsetY = 0;
		if (clippingRegion.Frame().left > destinationRect.left) {
			filterData.fIndexOffsetX = (int32)(clippingRegion.Frame().left
				- destinationRect.left);
		}
		if (clippingRegion.Frame().top > destinationRect.top) {
			filterData.fIndexOffsetY = (int32)(clippingRegion.Frame().top
				- destinationRect.top);
		}

//#define FILTER_INFOS_ON_HEAP
#ifdef FILTER_INFOS_ON_HEAP
		filterData.fWeightsX = new (nothrow) FilterInfo[dstWidth];
		filterData.fWeightsY = new (nothrow) FilterInfo[dstHeight];
		if (filterData.fWeightsX == NULL || filterData.fWeightsY == NULL) {
			delete[] filterData.fWeightsX;
			delete[] filterData.fWeightsY;
			return;
		}
#else
		// stack based saves about 200µs on 1.85 GHz Core 2 Duo
		// should not pose a problem with stack overflows
		// (needs around 12Kb for 1920x1200)
		FilterInfo xWeights[dstWidth];
		FilterInfo yWeights[dstHeight];
		filterData.fWeightsX = &xWeights[0];
		filterData.fWeightsY = &yWeights[0];
#endif

		// Extract the cropping information for the source bitmap,
		// If only a part of the source bitmap is to be drawn with scale,
		// the offset will be different from the destinationRect left top
		// corner.
		const int32 xBitmapShift = (int32)(destinationRect.left - offset.x);
		const int32 yBitmapShift = (int32)(destinationRect.top - offset.y);

		for (uint32 i = 0; i < dstWidth; i++) {
			// fractional index into source
			// NOTE: It is very important to calculate the fractional index
			// into the source pixel grid like this to prevent out of bounds
			// access! It will result in the rightmost pixel of the destination
			// to access the rightmost pixel of the source with a weighting
			// of 255. This in turn will trigger an optimization in the loop
			// that also prevents out of bounds access.
			float index = (i + filterData.fIndexOffsetX) * (srcWidth - 1)
				/ (srcWidth * scaleX - 1);
			// round down to get the left pixel
			filterData.fWeightsX[i].index = (uint16)index;
			filterData.fWeightsX[i].weight =
				255 - (uint16)((index - filterData.fWeightsX[i].index) * 255);
			// handle cropped source bitmap
			filterData.fWeightsX[i].index += xBitmapShift;
			// precompute index for 32 bit pixels
			filterData.fWeightsX[i].index *= 4;
		}

		for (uint32 i = 0; i < dstHeight; i++) {
			// fractional index into source
			// NOTE: It is very important to calculate the fractional index
			// into the source pixel grid like this to prevent out of bounds
			// access! It will result in the bottommost pixel of the
			// destination to access the bottommost pixel of the source with a
			// weighting of 255. This in turn will trigger an optimization in
			// the loop that also prevents out of bounds access.
			float index = (i + filterData.fIndexOffsetY) * (srcHeight - 1)
				/ (srcHeight * scaleY - 1);
			// round down to get the top pixel
			filterData.fWeightsY[i].index = (uint16)index;
			filterData.fWeightsY[i].weight =
				255 - (uint16)((index - filterData.fWeightsY[i].index) * 255);
			// handle cropped source bitmap
			filterData.fWeightsY[i].index += yBitmapShift;
		}
		//printf("X: %d/%d ... %d/%d, %d/%d (%ld)\n",
		//	xWeights[0].index, xWeights[0].weight,
		//	xWeights[dstWidth - 2].index, xWeights[dstWidth - 2].weight,
		//	xWeights[dstWidth - 1].index, xWeights[dstWidth - 1].weight,
		//	dstWidth);
		//printf("Y: %d/%d ... %d/%d, %d/%d (%ld)\n",
		//	yWeights[0].index, yWeights[0].weight,
		//	yWeights[dstHeight - 2].index, yWeights[dstHeight - 2].weight,
		//	yWeights[dstHeight - 1].index, yWeights[dstHeight - 1].weight,
		//	dstHeight);

		// Figure out which version of the code we want to use...
		enum {
			kOptimizeForLowFilterRatio = 0,
			kUseDefaultVersion,
			kUseSIMDVersion
		};

		int codeSelect = kUseDefaultVersion;

		if (typeid(ColorType) == typeid(ColorTypeRgb)
			&& typeid(DrawMode) == typeid(DrawModeCopy)) {
			uint32 neededSIMDFlags = APPSERVER_SIMD_MMX | APPSERVER_SIMD_SSE;
			if ((gSIMDFlags & neededSIMDFlags) == neededSIMDFlags)
				codeSelect = kUseSIMDVersion;
			else {
				if (scaleX == scaleY && (scaleX == 1.5 || scaleX == 2.0
					|| scaleX == 2.5 || scaleX == 3.0)) {
					codeSelect = kOptimizeForLowFilterRatio;
				}
			}
		}

		switch (codeSelect) {
			case kUseDefaultVersion:
			{
				BilinearDefault<ColorType, DrawMode> bilinearPainter;
				bilinearPainter.Draw(aggInterface, destinationRect, &bitmap,
					filterData);
				break;
			}

			case kOptimizeForLowFilterRatio:
			{
				BilinearLowFilterRatio bilinearPainter;
				bilinearPainter.Draw(aggInterface, destinationRect,
					&bitmap, filterData);
				break;
			}

#ifdef __i386__
			case kUseSIMDVersion:
			{
				BilinearSimd bilinearPainter;
				bilinearPainter.Draw(aggInterface, destinationRect, &bitmap,
					filterData);
				break;
			}
#endif	// __i386__
		}

#ifdef FILTER_INFOS_ON_HEAP
		delete[] filterData.fWeightsX;
		delete[] filterData.fWeightsY;
#endif
		//printf("draw bitmap %.5fx%.5f: %lld\n", scaleX, scaleY,
		//	system_time() - now);
	}
};


} // namespace BitmapPainterPrivate


#endif // DRAW_BITMAP_BILINEAR_H