1 files changed, 37 insertions, 27 deletions

diff --git a/source/LinearUpscale.h b/source/LinearUpscale.h
index 60aa005bd..9f40b5d81 100644
--- a/source/LinearUpscale.h
+++ b/source/LinearUpscale.h
@@ -88,49 +88,59 @@ template<typename TYPE> void LinearUpscale2DArray(
 	int a_UpscaleX, int a_UpscaleY   ///< Upscale factor for each direction

 )

 {

+	// For optimization reasons, we're storing the upscaling ratios in a fixed-size arrays of these sizes

+	// Feel free to enlarge them if needed, but keep in mind that they're on the stack

+	const int MAX_UPSCALE_X = 128;

+	const int MAX_UPSCALE_Y = 128;

+	

 	ASSERT(a_Src != NULL);

 	ASSERT(a_Dst != NULL);

 	ASSERT(a_SrcSizeX > 0);

 	ASSERT(a_SrcSizeY > 0);

 	ASSERT(a_UpscaleX > 0);

 	ASSERT(a_UpscaleY > 0);

+	ASSERT(a_UpscaleX <= MAX_UPSCALE_X);

+	ASSERT(a_UpscaleY <= MAX_UPSCALE_Y);

 	

-	// First interpolate columns (same-Y) where the anchor points are:

-	int idx = 0;

-	for (int y = 0; y < a_SrcSizeY; y++)

+	// Pre-calculate the upscaling ratios:

+	TYPE RatioX[MAX_UPSCALE_X];

+	TYPE RatioY[MAX_UPSCALE_Y];

+	for (int x = 0; x <= a_UpscaleX; x++)

+	{

+		RatioX[x] = (TYPE)x / a_UpscaleX;

+	}

+	for (int y = 0; y <= a_UpscaleY; y++)

+	{

+		RatioY[y] = (TYPE)y / a_UpscaleY;

+	}

+	

+	// Interpolate each XY cell:

+	int DstSizeX = (a_SrcSizeX - 1) * a_UpscaleX + 1;

+	int DstSizeY = (a_SrcSizeY - 1) * a_UpscaleY + 1;

+	for (int y = 0; y < (a_SrcSizeY - 1); y++)

 	{

 		int DstY = y * a_UpscaleY;

-		for (int x = 0; x < a_SrcSizeX; x++)

+		int idx = y * a_SrcSizeX;

+		for (int x = 0; x < (a_SrcSizeX - 1); x++, idx++)

 		{

 			int DstX = x * a_UpscaleX;

-			TYPE StartValue = a_Src[idx];               // [x, y]

-			TYPE EndValue   = a_Src[idx + a_SrcSizeX];  // [x, y + 1]

-			TYPE Diff = EndValue - StartValue;

+			TYPE LoXLoY = a_Src[idx];

+			TYPE LoXHiY = a_Src[idx + a_SrcSizeX];

+			TYPE HiXLoY = a_Src[idx + 1];

+			TYPE HiXHiY = a_Src[idx + 1 + a_SrcSizeX];

 			for (int CellY = 0; CellY <= a_UpscaleY; CellY++)

 			{

-				a_Dst[DstX + (DstY + CellY) * a_SizeY] = StartValue + Diff * CellY / a_AnchorStepY;

+				int DestIdx = (DstY + CellY) * DstSizeX + DstX;

+				ASSERT(DestIdx + a_UpscaleX < DstSizeX * DstSizeY);

+				TYPE LoXInY = LoXLoY + (LoXHiY - LoXLoY) * RatioY[CellY];

+				TYPE HiXInY = HiXLoY + (HiXHiY - HiXLoY) * RatioY[CellY];

+				for (int CellX = 0; CellX <= a_UpscaleX; CellX++, DestIdx++)

+				{

+					a_Dst[DestIdx] = LoXInY + (HiXInY - LoXInY) * RatioX[CellX];

+				}

 			}  // for CellY

 		}  // for x

 	}  // for y

-	

-	// Now interpolate in rows (same-X), each row already has valid values in the anchor columns

-	int DstSizeY = a_SizeY * a_UpscaleY;

-	int DstSizeX = a_SizeX * a_UpscaleX;

-	for (int y = 0; y < DstSizeY; y++)

-	{

-		int Idx = y * DstSizeX;

-		for (int x = 0; x < a_SizeX; x++)

-		{

-			TYPE StartValue = a_Dst[Idx];               // [x,     y] in the src coords

-			TYPE EndValue   = a_Dst[Idx + a_UpscaleX];  // [x + 1, y] in the src coords

-			TYPE Diff = EndValue - StartValue;

-			for (int CellX = 0; CellX <= a_UpscaleX; CellX++)

-			{

-				a_Dst[Idx + CellX] = StartValue + CellX * Diff / a_UpscaleX;

-			}  // for CellY

-			Idx += a_UpscaleX;

-		}

-	}

 }