#pragma once

#ifndef LOOP_MACROS_INCLUDED

#define LOOP_MACROS_INCLUDED

/*

	  assert ((0 <= xI) && (xI <= up->getLx() - 1) && \

		  (0 <= yI) && (yI <= up->getLy() - 1)    ); \

*/

#define INTERNAL_LOOP_THE_FIRST                                                   \

	xL += deltaXL;                                                                \

	yL += deltaYL;                                                                \

	xI = xL >> PADN;                                                              \

	yI = yL >> PADN;                                                              \

	upPix00 = upBasePix + (yI * upWrap + xI);                                     \

	upPix10 = upPix00 + 1;                                                        \

	upPix01 = upPix00 + upWrap;                                                   \

	upPix11 = upPix00 + upWrap + 1;                                               \

	xWeight1 = (xL & MASKN);                                                      \

	xWeight0 = (1 << PADN) - xWeight1;                                            \

	yWeight1 = (yL & MASKN);                                                      \

	yWeight0 = (1 << PADN) - yWeight1;                                            \

	c1 = MULT_2_X_16BIT(upPix00->r, upPix00->g, xWeight0);                        \

	c3 = MULT_2_X_16BIT(upPix00->b, upPix01->r, xWeight0);                        \

	c5 = MULT_2_X_16BIT(upPix01->g, upPix01->b, xWeight0);                        \

	c2 = MULT_2_X_16BIT(upPix10->r, upPix10->g, xWeight1);                        \

	c4 = MULT_2_X_16BIT(upPix10->b, upPix11->r, xWeight1);                        \

	c6 = MULT_2_X_16BIT(upPix11->g, upPix11->b, xWeight1);                        \

	s_gb = (c5 + c6) >> 16;                                                       \

	gColUpTmp = s_gb >> 32;                                                       \

	bColUpTmp = s_gb & 0x1FF;                                                     \

	s_br = (c3 + c4) >> 16;                                                       \

	bColDownTmp = s_br >> 32;                                                     \

	rColUpTmp = s_br & 0x1FF;                                                     \

	s_rg = (c1 + c2) >> 16;                                                       \

	rColDownTmp = s_rg >> 32;                                                     \

	gColDownTmp = s_rg & 0x1FF;                                                   \

	rCol =                                                                        \

		(unsigned char)((yWeight0 * rColDownTmp + yWeight1 * rColUpTmp) >> PADN); \

	gCol =                                                                        \

		(unsigned char)((yWeight0 * gColDownTmp + yWeight1 * gColUpTmp) >> PADN); \

	bCol =                                                                        \

		(unsigned char)((yWeight0 * bColDownTmp + yWeight1 * bColUpTmp) >> PADN); \

	*dnPix = TPixel32(rCol, gCol, bCol, upPix00->m);

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_FIRST_X_2 \

	INTERNAL_LOOP_THE_FIRST         \

	++dnPix;                        \

	INTERNAL_LOOP_THE_FIRST

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_FIRST_X_4 \

	INTERNAL_LOOP_THE_FIRST_X_2     \

	++dnPix;                        \

	INTERNAL_LOOP_THE_FIRST_X_2

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_FIRST_X_8 \

	INTERNAL_LOOP_THE_FIRST_X_4     \

	++dnPix;                        \

	INTERNAL_LOOP_THE_FIRST_X_4

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_FIRST_X_16 \

	INTERNAL_LOOP_THE_FIRST_X_8      \

	++dnPix;                         \

	INTERNAL_LOOP_THE_FIRST_X_8

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_FIRST_X_32 \

	INTERNAL_LOOP_THE_FIRST_X_16     \

	++dnPix;                         \

	INTERNAL_LOOP_THE_FIRST_X_16

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_FIRST                                \

	a = invAff * TPointD(xMin, y);                             \

	xL0 = tround(a.x * (1 << PADN));                           \

	yL0 = tround(a.y * (1 << PADN));                           \

	kMinX = 0;                                                 \

	kMaxX = xMax - xMin;                                       \

	kMinY = 0;                                                 \

	kMaxY = xMax - xMin;                                       \

	if (deltaXL == 0) {                                        \

		if ((xL0 < 0) || (lxPred < xL0))                       \

			continue;                                          \

	} else if (deltaXL > 0) {                                  \

		if (lxPred < xL0)                                      \

			continue;                                          \

		kMaxX = (lxPred - xL0) / deltaXL;                      \

		if (xL0 < 0) {                                         \

			kMinX = ((-xL0) + deltaXL - 1) / deltaXL;          \

		}                                                      \

	} else {                                                   \

		if (xL0 < 0)                                           \

			continue;                                          \

		kMaxX = xL0 / (-deltaXL);                              \

		if (lxPred < xL0) {                                    \

			kMinX = (xL0 - lxPred - deltaXL - 1) / (-deltaXL); \

		}                                                      \

	}                                                          \

	if (deltaYL == 0) {                                        \

		if ((yL0 < 0) || (lyPred < yL0))                       \

			continue;                                          \

	} else if (deltaYL > 0) {                                  \

		if (lyPred < yL0)                                      \

			continue;                                          \

		kMaxY = (lyPred - yL0) / deltaYL;                      \

		if (yL0 < 0) {                                         \

			kMinY = ((-yL0) + deltaYL - 1) / deltaYL;          \

		}                                                      \

	} else {                                                   \

		if (yL0 < 0)                                           \

			continue;                                          \

		kMaxY = yL0 / (-deltaYL);                              \

		if (lyPred < yL0) {                                    \

			kMinY = (yL0 - lyPred - deltaYL - 1) / (-deltaYL); \

		}                                                      \

	}                                                          \

	kMin = std::max({kMinX, kMinY, (int)0});                         \

	kMax = std::min(kMaxX, kMaxY, xMax - xMin);                    \

	dnPix = dnRow + xMin + kMin;                               \

	dnEndPix = dnRow + xMin + kMax + 1;                        \

	xL = xL0 + (kMin - 1) * deltaXL;                           \

	yL = yL0 + (kMin - 1) * deltaYL;                           \

	for (; dnPix < dnEndPix - 32; ++dnPix) {                   \

		INTERNAL_LOOP_THE_FIRST_X_32;                          \

	}                                                          \

	for (; dnPix < dnEndPix - 16; ++dnPix) {                   \

		INTERNAL_LOOP_THE_FIRST_X_16;                          \

	}                                                          \

	for (; dnPix < dnEndPix - 8; ++dnPix) {                    \

		INTERNAL_LOOP_THE_FIRST_X_8;                           \

	}                                                          \

	for (; dnPix < dnEndPix - 4; ++dnPix) {                    \

		INTERNAL_LOOP_THE_FIRST_X_4;                           \

	}                                                          \

	for (; dnPix < dnEndPix - 2; ++dnPix) {                    \

		INTERNAL_LOOP_THE_FIRST_X_2;                           \

	}                                                          \

	for (; dnPix < dnEndPix; ++dnPix) {                        \

		INTERNAL_LOOP_THE_FIRST                                \

	}

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_FIRST_X_2 \

	EXTERNAL_LOOP_THE_FIRST         \

	++y;                            \

	dnRow += dnWrap;                \

	EXTERNAL_LOOP_THE_FIRST

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_FIRST_X_4 \

	EXTERNAL_LOOP_THE_FIRST_X_2     \

	++y;                            \

	dnRow += dnWrap;                \

	EXTERNAL_LOOP_THE_FIRST_X_2

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_FIRST_X_8 \

	EXTERNAL_LOOP_THE_FIRST_X_4     \

	++y;                            \

	dnRow += dnWrap;                \

	EXTERNAL_LOOP_THE_FIRST_X_4

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_FIRST_X_16 \

	EXTERNAL_LOOP_THE_FIRST_X_8      \

	++y;                             \

	dnRow += dnWrap;                 \

	EXTERNAL_LOOP_THE_FIRST_X_8

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_FIRST_X_32 \

	EXTERNAL_LOOP_THE_FIRST_X_16     \

	++y;                             \

	dnRow += dnWrap;                 \

	EXTERNAL_LOOP_THE_FIRST_X_16

/*

	  assert ((0 <= xI) && (xI <= up->getLx() - 1) &&  \

		  (0 <= yI) && (yI <= up->getLy() - 1)    ); \

*/

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_SECOND                                                  \

	xL += deltaXL;                                                                \

	xI = xL >> PADN;                                                              \

	upPix00 = upBasePix + (yI * upWrap + xI);                                     \

	upPix10 = upPix00 + 1;                                                        \

	upPix01 = upPix00 + upWrap;                                                   \

	upPix11 = upPix00 + upWrap + 1;                                               \

	xWeight1 = (xL & MASKN);                                                      \

	xWeight0 = (1 << PADN) - xWeight1;                                            \

	c1 = MULT_2_X_16BIT(upPix00->r, upPix00->g, xWeight0);                        \

	c3 = MULT_2_X_16BIT(upPix00->b, upPix01->r, xWeight0);                        \

	c5 = MULT_2_X_16BIT(upPix01->g, upPix01->b, xWeight0);                        \

	c2 = MULT_2_X_16BIT(upPix10->r, upPix10->g, xWeight1);                        \

	c4 = MULT_2_X_16BIT(upPix10->b, upPix11->r, xWeight1);                        \

	c6 = MULT_2_X_16BIT(upPix11->g, upPix11->b, xWeight1);                        \

	s_gb = (c5 + c6) >> 16;                                                       \

	gColUpTmp = s_gb >> 32;                                                       \

	bColUpTmp = s_gb & 0x1FF;                                                     \

	s_br = (c3 + c4) >> 16;                                                       \

	bColDownTmp = s_br >> 32;                                                     \

	rColUpTmp = s_br & 0x1FF;                                                     \

	s_rg = (c1 + c2) >> 16;                                                       \

	rColDownTmp = s_rg >> 32;                                                     \

	gColDownTmp = s_rg & 0x1FF;                                                   \

	rCol =                                                                        \

		(unsigned char)((yWeight0 * rColDownTmp + yWeight1 * rColUpTmp) >> PADN); \

	gCol =                                                                        \

		(unsigned char)((yWeight0 * gColDownTmp + yWeight1 * gColUpTmp) >> PADN); \

	bCol =                                                                        \

		(unsigned char)((yWeight0 * bColDownTmp + yWeight1 * bColUpTmp) >> PADN); \

	*dnPix = TPixel32(rCol, gCol, bCol, upPix00->m);

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_SECOND_X_2 \

	INTERNAL_LOOP_THE_SECOND         \

	++dnPix;                         \

	INTERNAL_LOOP_THE_SECOND

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_SECOND_X_4 \

	INTERNAL_LOOP_THE_SECOND_X_2     \

	++dnPix;                         \

	INTERNAL_LOOP_THE_SECOND_X_2

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_SECOND_X_8 \

	INTERNAL_LOOP_THE_SECOND_X_4     \

	++dnPix;                         \

	INTERNAL_LOOP_THE_SECOND_X_4

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_SECOND_X_16 \

	INTERNAL_LOOP_THE_SECOND_X_8      \

	++dnPix;                          \

	INTERNAL_LOOP_THE_SECOND_X_8

// -------------------------------------------------------------------------------------------------

#define INTERNAL_LOOP_THE_SECOND_X_32 \

	INTERNAL_LOOP_THE_SECOND_X_16     \

	++dnPix;                          \

	INTERNAL_LOOP_THE_SECOND_X_16

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_SECOND             \

	xL = xL0 + (kMinX - 1) * deltaXL;        \

	yL += deltaYL;                           \

	yI = yL >> PADN;                         \

	yWeight1 = (yL & MASKN);                 \

	yWeight0 = (1 << PADN) - yWeight1;       \

	dnPix = dnRow + xMin + kMinX;            \

	dnEndPix = dnRow + xMin + kMaxX + 1;     \

	for (; dnPix < dnEndPix - 32; ++dnPix) { \

		INTERNAL_LOOP_THE_SECOND_X_32;       \

	}                                        \

	for (; dnPix < dnEndPix - 16; ++dnPix) { \

		INTERNAL_LOOP_THE_SECOND_X_16;       \

	}                                        \

	for (; dnPix < dnEndPix - 8; ++dnPix) {  \

		INTERNAL_LOOP_THE_SECOND_X_8;        \

	}                                        \

	for (; dnPix < dnEndPix - 4; ++dnPix) {  \

		INTERNAL_LOOP_THE_SECOND_X_4;        \

	}                                        \

	for (; dnPix < dnEndPix - 2; ++dnPix) {  \

		INTERNAL_LOOP_THE_SECOND_X_2;        \

	}                                        \

	for (; dnPix < dnEndPix; ++dnPix) {      \

		INTERNAL_LOOP_THE_SECOND             \

	}

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_SECOND_X_2 \

	EXTERNAL_LOOP_THE_SECOND         \

	++kY;                            \

	dnRow += dnWrap;                 \

	EXTERNAL_LOOP_THE_SECOND

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_SECOND_X_4 \

	EXTERNAL_LOOP_THE_SECOND_X_2     \

	++kY;                            \

	dnRow += dnWrap;                 \

	EXTERNAL_LOOP_THE_SECOND_X_2

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_SECOND_X_8 \

	EXTERNAL_LOOP_THE_SECOND_X_4     \

	++kY;                            \

	dnRow += dnWrap;                 \

	EXTERNAL_LOOP_THE_SECOND_X_4

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_SECOND_X_16 \

	EXTERNAL_LOOP_THE_SECOND_X_8      \

	++kY;                             \

	dnRow += dnWrap;                  \

	EXTERNAL_LOOP_THE_SECOND_X_8

// -------------------------------------------------------------------------------------------------

#define EXTERNAL_LOOP_THE_SECOND_X_32 \

	EXTERNAL_LOOP_THE_SECOND_X_16     \

	++kY;                             \

	dnRow += dnWrap;                  \

	EXTERNAL_LOOP_THE_SECOND_X_16

#endif