Subversion Repositories Games.Prince of Persia

// ****************************************************************************

// * This file is part of the HqMAME project. It is distributed under         *

// * GNU General Public License: https://www.gnu.org/licenses/gpl-3.0         *

// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved          *

// *                                                                          *

// * Additionally and as a special exception, the author gives permission     *

// * to link the code of this program with the MAME library (or with modified *

// * versions of MAME that use the same license as MAME), and distribute      *

// * linked combinations including the two. You must obey the GNU General     *

// * Public License in all respects for all of the code used other than MAME. *

// * If you modify this file, you may extend this exception to your version   *

// * of the file, but you are not obligated to do so. If you do not wish to   *

// * do so, delete this exception statement from your version.                *

// ****************************************************************************

#include <cstddef> //size_t

#include <cstdint> //uint32_t

#include <limits>

#include <cassert>

#include <algorithm>

#include <type_traits>

#include <vector>

#include <math.h>

#ifdef __cplusplus

#define EXTERN_C extern "C"

#else // !__cplusplus

#define EXTERN_C

#endif // __cplusplus

// scaler configuration

#define XBRZ_CFG_LUMINANCE_WEIGHT 1

#define XBRZ_CFG_EQUAL_COLOR_TOLERANCE 30

#define XBRZ_CFG_DOMINANT_DIRECTION_THRESHOLD 3.6

#define XBRZ_CFG_STEEP_DIRECTION_THRESHOLD 2.2

// slice types

#define XBRZ_SLICETYPE_SOURCE 1

#define XBRZ_SLICETYPE_TARGET 2

// handy macros

#define GET_BYTE(val,byteno) ((unsigned char) (((val) >> ((byteno) << 3)) & 0xff))

#define GET_BLUE(val)  GET_BYTE (val, 0)

#define GET_GREEN(val) GET_BYTE (val, 1)

#define GET_RED(val)   GET_BYTE (val, 2)

#define GET_ALPHA(val) GET_BYTE (val, 3)

//inline uint32_t rgb555to888(uint16_t pix) { return ((pix & 0x7C00) << 9) | ((pix & 0x03E0) << 6) | ((pix & 0x001F) << 3); }

//inline uint32_t rgb565to888(uint16_t pix) { return ((pix & 0xF800) << 8) | ((pix & 0x07E0) << 5) | ((pix & 0x001F) << 3); }

//inline uint16_t rgb888to555(uint32_t pix) { return static_cast<uint16_t>(((pix & 0xF80000) >> 9) | ((pix & 0x00F800) >> 6) | ((pix & 0x0000F8) >> 3)); }

//inline uint16_t rgb888to565(uint32_t pix) { return static_cast<uint16_t>(((pix & 0xF80000) >> 8) | ((pix & 0x00FC00) >> 5) | ((pix & 0x0000F8) >> 3)); }

namespace xbrz

{

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

        // | xBRZ: "Scale by rules" - high quality image upscaling filter by Zenju |

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

        // using a modified approach of xBR:

        // http://board.byuu.org/viewtopic.php?f=10&t=2248

        //  - new rule set preserving small image features

        //  - highly optimized for performance

        //  - support alpha channel

        //  - support multithreading

        //  - support 64-bit architectures

        //  - support processing image slices

        //  - support scaling up to 6xBRZ

        // -> map source (srcWidth * srcHeight) to target (scale * width x scale * height) image, optionally processing a half-open slice of rows [yFirst, yLast) only

        // -> support for source/target pitch in bytes!

        // -> if your emulator changes only a few image slices during each cycle (e.g. DOSBox) then there's no need to run xBRZ on the complete image:

        //    Just make sure you enlarge the source image slice by 2 rows on top and 2 on bottom (this is the additional range the xBRZ algorithm is using during analysis)

        //    CAVEAT: If there are multiple changed slices, make sure they do not overlap after adding these additional rows in order to avoid a memory race condition

        //    in the target image data if you are using multiple threads for processing each enlarged slice!

        // 

        // THREAD-SAFETY: - parts of the same image may be scaled by multiple threads as long as the [yFirst, yLast) ranges do not overlap!

        //                - there is a minor inefficiency for the first row of a slice, so avoid processing single rows only; suggestion: process at least 8-16 rows

        void nearestNeighborScale(const uint32_t* src, int srcWidth, int srcHeight, uint32_t* trg, int trgWidth, int trgHeight);

        template <class Pix> inline Pix* byteAdvance(Pix* ptr, int bytes)

        {

            using PixNonConst = typename std::remove_cv<Pix>::type;

            using PixByte     = typename std::conditional<std::is_same<Pix, PixNonConst>::value, char, const char>::type;

            static_assert(std::is_integral<PixNonConst>::value, "Pix* is expected to be cast-able to char*");

            return reinterpret_cast<Pix*>(reinterpret_cast<PixByte*>(ptr) + bytes);

        }

//fill block  with the given color

template <class Pix> inline void fillBlock(Pix* trg, int pitch, Pix col, int blockWidth, int blockHeight)

{

    //for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch))

    //    std::fill(trg, trg + blockWidth, col);

    for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch))

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

            trg[x] = col;

}

template <class PixSrc, class PixTrg, class PixConverter>

void nearestNeighborScale(const PixSrc* src, int srcWidth, int srcHeight, int srcPitch,

                          /**/  PixTrg* trg, int trgWidth, int trgHeight, int trgPitch,

                          int slice_type, int yFirst, int yLast, PixConverter pixCvrt /*convert PixSrc to PixTrg*/)

{

    static_assert(std::is_integral<PixSrc>::value, "PixSrc* is expected to be cast-able to char*");

    static_assert(std::is_integral<PixTrg>::value, "PixTrg* is expected to be cast-able to char*");

    static_assert(std::is_same<decltype(pixCvrt(PixSrc())), PixTrg>::value, "PixConverter returning wrong pixel format");

    if (srcPitch < srcWidth * static_cast<int>(sizeof(PixSrc))  ||

        trgPitch < trgWidth * static_cast<int>(sizeof(PixTrg)))

    {

        assert(false);

        return;

    }

    if (slice_type == XBRZ_SLICETYPE_SOURCE)

    {

            //nearest-neighbor (going over source image - fast for upscaling, since source is read only once

            yFirst = std::max(yFirst, 0);

            yLast  = std::min(yLast, srcHeight);

            if (yFirst >= yLast || trgWidth <= 0 || trgHeight <= 0) return;

            for (int y = yFirst; y < yLast; ++y)

            {

                //mathematically: ySrc = floor(srcHeight * yTrg / trgHeight)

                // => search for integers in: [ySrc, ySrc + 1) * trgHeight / srcHeight

                //keep within for loop to support MT input slices!

                const int yTrg_first = ( y      * trgHeight + srcHeight - 1) / srcHeight; //=ceil(y * trgHeight / srcHeight)

                const int yTrg_last  = ((y + 1) * trgHeight + srcHeight - 1) / srcHeight; //=ceil(((y + 1) * trgHeight) / srcHeight)

                const int blockHeight = yTrg_last - yTrg_first;

                if (blockHeight > 0)

                {

                    const PixSrc* srcLine = byteAdvance(src, y * srcPitch);

                    /**/  PixTrg* trgLine = byteAdvance(trg, yTrg_first * trgPitch);

                    int xTrg_first = 0;

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

                    {

                        const int xTrg_last = ((x + 1) * trgWidth + srcWidth - 1) / srcWidth;

                        const int blockWidth = xTrg_last - xTrg_first;

                        if (blockWidth > 0)

                        {

                            xTrg_first = xTrg_last;

                            const auto trgPix = pixCvrt(srcLine[x]);

                            fillBlock(trgLine, trgPitch, trgPix, blockWidth, blockHeight);

                            trgLine += blockWidth;

                        }

                    }

                }

            }

    }

    else if (slice_type == XBRZ_SLICETYPE_TARGET)

    {

            //nearest-neighbor (going over target image - slow for upscaling, since source is read multiple times missing out on cache! Fast for similar image sizes!)

            yFirst = std::max(yFirst, 0);

            yLast  = std::min(yLast, trgHeight);

            if (yFirst >= yLast || srcHeight <= 0 || srcWidth <= 0) return;

            for (int y = yFirst; y < yLast; ++y)

            {

                PixTrg* trgLine = byteAdvance(trg, y * trgPitch);

                const int ySrc = srcHeight * y / trgHeight;

                const PixSrc* srcLine = byteAdvance(src, ySrc * srcPitch);

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

                {

                    const int xSrc = srcWidth * x / trgWidth;

                    trgLine[x] = pixCvrt(srcLine[xSrc]);

                }

            }

    }

}

}

namespace

{

template <unsigned int M, unsigned int N> inline

uint32_t gradientRGB(uint32_t pixFront, uint32_t pixBack) //blend front color with opacity M / N over opaque background: http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending

{

    static_assert(0 < M && M < N && N <= 1000, "");

    auto calcColor = [](unsigned char colFront, unsigned char colBack) -> unsigned char { return (colFront * M + colBack * (N - M)) / N; };

        return ((calcColor (GET_RED   (pixFront), GET_RED   (pixBack)) << 16)

              | (calcColor (GET_GREEN (pixFront), GET_GREEN (pixBack)) <<  8)

              | (calcColor (GET_BLUE  (pixFront), GET_BLUE  (pixBack)) <<  0));

}

template <unsigned int M, unsigned int N> inline

uint32_t gradientARGB(uint32_t pixFront, uint32_t pixBack) //find intermediate color between two colors with alpha channels (=> NO alpha blending!!!)

{

    static_assert(0 < M && M < N && N <= 1000, "");

    const unsigned int weightFront = GET_ALPHA (pixFront) * M;

    const unsigned int weightBack  = GET_ALPHA (pixBack) * (N - M);

    const unsigned int weightSum   = weightFront + weightBack;

    if (weightSum == 0)

        return 0;

    auto calcColor = [=](unsigned char colFront, unsigned char colBack)

    {

        return static_cast<unsigned char>((colFront * weightFront + colBack * weightBack) / weightSum);

    };

        return (((unsigned char) (weightSum / N))                      << 24)

              | (calcColor (GET_RED   (pixFront), GET_RED   (pixBack)) << 16)

              | (calcColor (GET_GREEN (pixFront), GET_GREEN (pixBack)) <<  8)

              | (calcColor (GET_BLUE  (pixFront), GET_BLUE  (pixBack)) <<  0);

}

//inline

//double fastSqrt(double n)

//{

//    __asm //speeds up xBRZ by about 9% compared to /*std::*/sqrt which internally uses the same assembler instructions but adds some "fluff"

//    {

//        fld n

//        fsqrt

//    }

//}

//

#ifdef _MSC_VER

    #define FORCE_INLINE __forceinline

#elif defined __GNUC__

    #define FORCE_INLINE __attribute__((always_inline)) inline

#else

    #define FORCE_INLINE inline

#endif

enum RotationDegree //clock-wise

{

    ROT_0,

    ROT_90,

    ROT_180,

    ROT_270

};

//calculate input matrix coordinates after rotation at compile time

template <RotationDegree rotDeg, size_t I, size_t J, size_t N>

struct MatrixRotation;

template <size_t I, size_t J, size_t N>

struct MatrixRotation<ROT_0, I, J, N>

{

    static const size_t I_old = I;

    static const size_t J_old = J;

};

template <RotationDegree rotDeg, size_t I, size_t J, size_t N> //(i, j) = (row, col) indices, N = size of (square) matrix

struct MatrixRotation

{

    static const size_t I_old = N - 1 - MatrixRotation<static_cast<RotationDegree>(rotDeg - 1), I, J, N>::J_old; //old coordinates before rotation!

    static const size_t J_old =         MatrixRotation<static_cast<RotationDegree>(rotDeg - 1), I, J, N>::I_old; //

};

template <size_t N, RotationDegree rotDeg>

class OutputMatrix

{

public:

    OutputMatrix(uint32_t* out, int outWidth) : //access matrix area, top-left at position "out" for image with given width

        out_(out),

        outWidth_(outWidth) {}

    template <size_t I, size_t J>

    uint32_t& ref() const

    {

        static const size_t I_old = MatrixRotation<rotDeg, I, J, N>::I_old;

        static const size_t J_old = MatrixRotation<rotDeg, I, J, N>::J_old;

        return *(out_ + J_old + I_old * outWidth_);

    }

private:

    uint32_t* out_;

    const int outWidth_;

};

template <class T> inline

T square(T value) { return value * value; }

inline

double distRGB(uint32_t pix1, uint32_t pix2)

{

    const double r_diff = static_cast<int>(GET_RED   (pix1)) - GET_RED   (pix2);

    const double g_diff = static_cast<int>(GET_GREEN (pix1)) - GET_GREEN (pix2);

    const double b_diff = static_cast<int>(GET_BLUE  (pix1)) - GET_BLUE  (pix2);

    //euklidean RGB distance

    return /*std::*/sqrt(square(r_diff) + square(g_diff) + square(b_diff));

}

inline

double distYCbCr(uint32_t pix1, uint32_t pix2, double lumaWeight)

{

    //http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion

    //YCbCr conversion is a matrix multiplication => take advantage of linearity by subtracting first!

    const int r_diff = static_cast<int>(GET_RED   (pix1)) - GET_RED   (pix2); //we may delay division by 255 to after matrix multiplication

    const int g_diff = static_cast<int>(GET_GREEN (pix1)) - GET_GREEN (pix2); //

    const int b_diff = static_cast<int>(GET_BLUE  (pix1)) - GET_BLUE  (pix2); //substraction for int is noticeable faster than for double!

    //const double k_b = 0.0722; //ITU-R BT.709 conversion

    //const double k_r = 0.2126; //

    const double k_b = 0.0593; //ITU-R BT.2020 conversion

    const double k_r = 0.2627; //

    const double k_g = 1 - k_b - k_r;

    const double scale_b = 0.5 / (1 - k_b);

    const double scale_r = 0.5 / (1 - k_r);

    const double y   = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr!

    const double c_b = scale_b * (b_diff - y);

    const double c_r = scale_r * (r_diff - y);

    //we skip division by 255 to have similar range like other distance functions

    return /*std::*/sqrt(square(lumaWeight * y) + square(c_b) + square(c_r));

}

inline double distYCbCrBuffered(uint32_t pix1, uint32_t pix2)

{

    //30% perf boost compared to plain distYCbCr()!

    //consumes 64 MB memory; using double is only 2% faster, but takes 128 MB

    static const std::vector<float> diffToDist = []

    {

        std::vector<float> tmp;

        for (uint32_t i = 0; i < 256 * 256 * 256; ++i) //startup time: 114 ms on Intel Core i5 (four cores)

        {

            const int r_diff = GET_RED (i) * 2 - 0xFF;

            const int g_diff = GET_GREEN (i) * 2 - 0xFF;

            const int b_diff = GET_BLUE (i) * 2 - 0xFF;

            const double k_b = 0.0593; //ITU-R BT.2020 conversion

            const double k_r = 0.2627; //

            const double k_g = 1 - k_b - k_r;

            const double scale_b = 0.5 / (1 - k_b);

            const double scale_r = 0.5 / (1 - k_r);

            const double y   = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr!

            const double c_b = scale_b * (b_diff - y);

            const double c_r = scale_r * (r_diff - y);

            tmp.push_back(static_cast<float>(/*std::*/sqrt(square(y) + square(c_b) + square(c_r))));

        }

        return tmp;

    }();

    //if (pix1 == pix2) -> 8% perf degradation!

    //    return 0;

    //if (pix1 < pix2)

    //    std::swap(pix1, pix2); -> 30% perf degradation!!!

#if 1

    const int r_diff = static_cast<int>(GET_RED   (pix1)) - GET_RED   (pix2);

    const int g_diff = static_cast<int>(GET_GREEN (pix1)) - GET_GREEN (pix2);

    const int b_diff = static_cast<int>(GET_BLUE  (pix1)) - GET_BLUE  (pix2);

    return diffToDist[(((r_diff + 0xFF) / 2) << 16) | //slightly reduce precision (division by 2) to squeeze value into single byte

                      (((g_diff + 0xFF) / 2) <<  8) |

                      (( b_diff + 0xFF) / 2)];

#else //not noticeably faster:

    const int r_diff_tmp = ((pix1 & 0xFF0000) + 0xFF0000 - (pix2 & 0xFF0000)) / 2;

    const int g_diff_tmp = ((pix1 & 0x00FF00) + 0x00FF00 - (pix2 & 0x00FF00)) / 2; //slightly reduce precision (division by 2) to squeeze value into single byte

    const int b_diff_tmp = ((pix1 & 0x0000FF) + 0x0000FF - (pix2 & 0x0000FF)) / 2;

    return diffToDist[(r_diff_tmp & 0xFF0000) | (g_diff_tmp & 0x00FF00) | (b_diff_tmp & 0x0000FF)];

#endif

}

enum BlendType

{

    BLEND_NONE = 0,

    BLEND_NORMAL,   //a normal indication to blend

    BLEND_DOMINANT, //a strong indication to blend

    //attention: BlendType must fit into the value range of 2 bit!!!

};

struct BlendResult

{

    BlendType

    /**/blend_f, blend_g,

    /**/blend_j, blend_k;

};

struct Kernel_4x4 //kernel for preprocessing step

{

    uint32_t

    /**/a, b, c, d,

    /**/e, f, g, h,

    /**/i, j, k, l,

    /**/m, n, o, p;

};

/*

input kernel area naming convention:

-----------------

| A | B | C | D |

----|---|---|---|

| E | F | G | H |   //evaluate the four corners between F, G, J, K

----|---|---|---|   //input pixel is at position F

| I | J | K | L |

----|---|---|---|

| M | N | O | P |

-----------------

*/

template <class ColorDistance>

FORCE_INLINE //detect blend direction

BlendResult preProcessCorners(const Kernel_4x4& ker) //result: F, G, J, K corners of "GradientType"

{

    BlendResult result = {};

    if ((ker.f == ker.g &&

         ker.j == ker.k) ||

        (ker.f == ker.j &&

         ker.g == ker.k))

        return result;

    auto dist = [&](uint32_t pix1, uint32_t pix2) { return ColorDistance::dist(pix1, pix2, XBRZ_CFG_LUMINANCE_WEIGHT); };

    const int weight = 4;

    double jg = dist(ker.i, ker.f) + dist(ker.f, ker.c) + dist(ker.n, ker.k) + dist(ker.k, ker.h) + weight * dist(ker.j, ker.g);

    double fk = dist(ker.e, ker.j) + dist(ker.j, ker.o) + dist(ker.b, ker.g) + dist(ker.g, ker.l) + weight * dist(ker.f, ker.k);

    if (jg < fk) //test sample: 70% of values max(jg, fk) / min(jg, fk) are between 1.1 and 3.7 with median being 1.8

    {

        const bool dominantGradient = XBRZ_CFG_DOMINANT_DIRECTION_THRESHOLD * jg < fk;

        if (ker.f != ker.g && ker.f != ker.j)

            result.blend_f = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL;

        if (ker.k != ker.j && ker.k != ker.g)

            result.blend_k = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL;

    }

    else if (fk < jg)

    {

        const bool dominantGradient = XBRZ_CFG_DOMINANT_DIRECTION_THRESHOLD * fk < jg;

        if (ker.j != ker.f && ker.j != ker.k)

            result.blend_j = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL;

        if (ker.g != ker.f && ker.g != ker.k)

            result.blend_g = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL;

    }

    return result;

}

struct Kernel_3x3

{

    uint32_t

    /**/a,  b,  c,

    /**/d,  e,  f,

    /**/g,  h,  i;

};

#define DEF_GETTER(x) template <RotationDegree rotDeg> uint32_t inline get_##x(const Kernel_3x3& ker) { return ker.x; }

//we cannot and NEED NOT write "ker.##x" since ## concatenates preprocessor tokens but "." is not a token

DEF_GETTER(a) DEF_GETTER(b) DEF_GETTER(c)

DEF_GETTER(d) DEF_GETTER(e) DEF_GETTER(f)

DEF_GETTER(g) DEF_GETTER(h) DEF_GETTER(i)

#undef DEF_GETTER

#define DEF_GETTER(x, y) template <> inline uint32_t get_##x<ROT_90>(const Kernel_3x3& ker) { return ker.y; }

DEF_GETTER(a, g) DEF_GETTER(b, d) DEF_GETTER(c, a)

DEF_GETTER(d, h) DEF_GETTER(e, e) DEF_GETTER(f, b)

DEF_GETTER(g, i) DEF_GETTER(h, f) DEF_GETTER(i, c)

#undef DEF_GETTER

#define DEF_GETTER(x, y) template <> inline uint32_t get_##x<ROT_180>(const Kernel_3x3& ker) { return ker.y; }

DEF_GETTER(a, i) DEF_GETTER(b, h) DEF_GETTER(c, g)

DEF_GETTER(d, f) DEF_GETTER(e, e) DEF_GETTER(f, d)

DEF_GETTER(g, c) DEF_GETTER(h, b) DEF_GETTER(i, a)

#undef DEF_GETTER

#define DEF_GETTER(x, y) template <> inline uint32_t get_##x<ROT_270>(const Kernel_3x3& ker) { return ker.y; }

DEF_GETTER(a, c) DEF_GETTER(b, f) DEF_GETTER(c, i)

DEF_GETTER(d, b) DEF_GETTER(e, e) DEF_GETTER(f, h)

DEF_GETTER(g, a) DEF_GETTER(h, d) DEF_GETTER(i, g)

#undef DEF_GETTER

//compress four blend types into a single byte

inline BlendType getTopL   (unsigned char b) { return static_cast<BlendType>(0x3 & b); }

inline BlendType getTopR   (unsigned char b) { return static_cast<BlendType>(0x3 & (b >> 2)); }

inline BlendType getBottomR(unsigned char b) { return static_cast<BlendType>(0x3 & (b >> 4)); }

inline BlendType getBottomL(unsigned char b) { return static_cast<BlendType>(0x3 & (b >> 6)); }

inline void setTopL   (unsigned char& b, BlendType bt) { b |= bt; } //buffer is assumed to be initialized before preprocessing!

inline void setTopR   (unsigned char& b, BlendType bt) { b |= (bt << 2); }

inline void setBottomR(unsigned char& b, BlendType bt) { b |= (bt << 4); }

inline void setBottomL(unsigned char& b, BlendType bt) { b |= (bt << 6); }

inline bool blendingNeeded(unsigned char b) { return b != 0; }

template <RotationDegree rotDeg> inline

unsigned char rotateBlendInfo(unsigned char b) { return b; }

template <> inline unsigned char rotateBlendInfo<ROT_90 >(unsigned char b) { return ((b << 2) | (b >> 6)) & 0xff; }

template <> inline unsigned char rotateBlendInfo<ROT_180>(unsigned char b) { return ((b << 4) | (b >> 4)) & 0xff; }

template <> inline unsigned char rotateBlendInfo<ROT_270>(unsigned char b) { return ((b << 6) | (b >> 2)) & 0xff; }

/*

input kernel area naming convention:

-------------

| A | B | C |

----|---|---|

| D | E | F | //input pixel is at position E

----|---|---|

| G | H | I |

-------------

*/

template <class Scaler, class ColorDistance, RotationDegree rotDeg>

FORCE_INLINE //perf: quite worth it!

void blendPixel(const Kernel_3x3& ker,

                uint32_t* target, int trgWidth,

                unsigned char blendInfo) //result of preprocessing all four corners of pixel "e"

{

#define a get_a<rotDeg>(ker)

#define b get_b<rotDeg>(ker)

#define c get_c<rotDeg>(ker)

#define d get_d<rotDeg>(ker)

#define e get_e<rotDeg>(ker)

#define f get_f<rotDeg>(ker)

#define g get_g<rotDeg>(ker)

#define h get_h<rotDeg>(ker)

#define i get_i<rotDeg>(ker)

    const unsigned char blend = rotateBlendInfo<rotDeg>(blendInfo);

    if (getBottomR(blend) >= BLEND_NORMAL)

    {

        auto eq   = [&](uint32_t pix1, uint32_t pix2) { return ColorDistance::dist(pix1, pix2, XBRZ_CFG_LUMINANCE_WEIGHT) < XBRZ_CFG_EQUAL_COLOR_TOLERANCE; };

        auto dist = [&](uint32_t pix1, uint32_t pix2) { return ColorDistance::dist(pix1, pix2, XBRZ_CFG_LUMINANCE_WEIGHT); };

        const bool doLineBlend = [&]() -> bool

        {

            if (getBottomR(blend) >= BLEND_DOMINANT)

                return true;

            //make sure there is no second blending in an adjacent rotation for this pixel: handles insular pixels, mario eyes

            if (getTopR(blend) != BLEND_NONE && !eq(e, g)) //but support double-blending for 90° corners

                return false;

            if (getBottomL(blend) != BLEND_NONE && !eq(e, c))

                return false;

            //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes")

            if (!eq(e, i) && eq(g, h) && eq(h, i) && eq(i, f) && eq(f, c))

                return false;

            return true;

        }();

        const uint32_t px = dist(e, f) <= dist(e, h) ? f : h; //choose most similar color

        OutputMatrix<Scaler::scale, rotDeg> out(target, trgWidth);

        if (doLineBlend)

        {

            const double fg = dist(f, g); //test sample: 70% of values max(fg, hc) / min(fg, hc) are between 1.1 and 3.7 with median being 1.9

            const double hc = dist(h, c); //

            const bool haveShallowLine = XBRZ_CFG_STEEP_DIRECTION_THRESHOLD * fg <= hc && e != g && d != g;

            const bool haveSteepLine   = XBRZ_CFG_STEEP_DIRECTION_THRESHOLD * hc <= fg && e != c && b != c;

            if (haveShallowLine)

            {

                if (haveSteepLine)

                    Scaler::blendLineSteepAndShallow(px, out);

                else

                    Scaler::blendLineShallow(px, out);

            }

            else

            {

                if (haveSteepLine)

                    Scaler::blendLineSteep(px, out);

                else

                    Scaler::blendLineDiagonal(px, out);

            }

        }

        else

            Scaler::blendCorner(px, out);

    }

#undef a

#undef b

#undef c

#undef d

#undef e

#undef f

#undef g

#undef h

#undef i

}

template <class Scaler, class ColorDistance> //scaler policy: see "Scaler2x" reference implementation

void scaleImage(const uint32_t* src, uint32_t* trg, int srcWidth, int srcHeight, int yFirst, int yLast)

{

    yFirst = std::max(yFirst, 0);

    yLast  = std::min(yLast, srcHeight);

    if (yFirst >= yLast || srcWidth <= 0)

        return;

    const int trgWidth = srcWidth * Scaler::scale;

    //"use" space at the end of the image as temporary buffer for "on the fly preprocessing": we even could use larger area of

    //"sizeof(uint32_t) * srcWidth * (yLast - yFirst)" bytes without risk of accidental overwriting before accessing

    const int bufferSize = srcWidth;

    unsigned char* preProcBuffer = reinterpret_cast<unsigned char*>(trg + yLast * Scaler::scale * trgWidth) - bufferSize;

    std::fill(preProcBuffer, preProcBuffer + bufferSize, '\0');

    static_assert(BLEND_NONE == 0, "");

    //initialize preprocessing buffer for first row of current stripe: detect upper left and right corner blending

    //this cannot be optimized for adjacent processing stripes; we must not allow for a memory race condition!

    if (yFirst > 0)

    {

        const int y = yFirst - 1;

        const uint32_t* s_m1 = src + srcWidth * std::max(y - 1, 0);

        const uint32_t* s_0  = src + srcWidth * y; //center line

        const uint32_t* s_p1 = src + srcWidth * std::min(y + 1, srcHeight - 1);

        const uint32_t* s_p2 = src + srcWidth * std::min(y + 2, srcHeight - 1);

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

        {

            const int x_m1 = std::max(x - 1, 0);

            const int x_p1 = std::min(x + 1, srcWidth - 1);

            const int x_p2 = std::min(x + 2, srcWidth - 1);

            Kernel_4x4 ker = {}; //perf: initialization is negligible

            ker.a = s_m1[x_m1]; //read sequentially from memory as far as possible

            ker.b = s_m1[x];

            ker.c = s_m1[x_p1];

            ker.d = s_m1[x_p2];

            ker.e = s_0[x_m1];

            ker.f = s_0[x];

            ker.g = s_0[x_p1];

            ker.h = s_0[x_p2];

            ker.i = s_p1[x_m1];

            ker.j = s_p1[x];

            ker.k = s_p1[x_p1];

            ker.l = s_p1[x_p2];

            ker.m = s_p2[x_m1];

            ker.n = s_p2[x];

            ker.o = s_p2[x_p1];

            ker.p = s_p2[x_p2];

            const BlendResult res = preProcessCorners<ColorDistance>(ker);

            /*

            preprocessing blend result:

            ---------

            | F | G |   //evalute corner between F, G, J, K

            ----|---|   //input pixel is at position F

            | J | K |

            ---------

            */

            setTopR(preProcBuffer[x], res.blend_j);

            if (x + 1 < bufferSize)

                setTopL(preProcBuffer[x + 1], res.blend_k);

        }

    }

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

    for (int y = yFirst; y < yLast; ++y)

    {

        uint32_t* out = trg + Scaler::scale * y * trgWidth; //consider MT "striped" access

        const uint32_t* s_m1 = src + srcWidth * std::max(y - 1, 0);

        const uint32_t* s_0  = src + srcWidth * y; //center line

        const uint32_t* s_p1 = src + srcWidth * std::min(y + 1, srcHeight - 1);

        const uint32_t* s_p2 = src + srcWidth * std::min(y + 2, srcHeight - 1);

        unsigned char blend_xy1 = 0; //corner blending for current (x, y + 1) position

        for (int x = 0; x < srcWidth; ++x, out += Scaler::scale)

        {

            //all those bounds checks have only insignificant impact on performance!

            const int x_m1 = std::max(x - 1, 0); //perf: prefer array indexing to additional pointers!

            const int x_p1 = std::min(x + 1, srcWidth - 1);

            const int x_p2 = std::min(x + 2, srcWidth - 1);

            Kernel_4x4 ker4 = {}; //perf: initialization is negligible

            ker4.a = s_m1[x_m1]; //read sequentially from memory as far as possible

            ker4.b = s_m1[x];

            ker4.c = s_m1[x_p1];

            ker4.d = s_m1[x_p2];

            ker4.e = s_0[x_m1];

            ker4.f = s_0[x];

            ker4.g = s_0[x_p1];

            ker4.h = s_0[x_p2];

            ker4.i = s_p1[x_m1];

            ker4.j = s_p1[x];