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.                *

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

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

// | 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

#include <stddef.h> // for size_t

#include <stdint.h> // for uint32_t

#include <memory.h> // for memset()

#include <limits.h>

#include <math.h>

#ifdef __cplusplus

#define EXTERN_C extern "C"

#else // !__cplusplus

#define EXTERN_C

#endif // __cplusplus

#ifdef _MSC_VER

#define FORCE_INLINE __forceinline

#elif defined __GNUC__

#define FORCE_INLINE __attribute__((always_inline)) inline

#else

#define FORCE_INLINE inline

#endif

// 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)

#define CALC_COLOR24(colFront,colBack,M,N) (unsigned char) ((((unsigned char) (colFront)) * ((unsigned int) (M)) + ((unsigned char) (colBack)) * (((unsigned int) (N)) - ((unsigned int) (M)))) / ((unsigned int) (N)))

#define CALC_COLOR32(colFront,colBack,weightFront,weightBack,weightSum) ((unsigned char) ((((unsigned char) (colFront)) * ((unsigned int) (weightFront)) + ((unsigned char) (colBack)) * ((unsigned int) (weightBack))) / ((unsigned int) (weightSum))))

#define BYTE_ADVANCE(buffer,offset) (((char *) buffer) + (offset))

#ifndef MIN

#define MIN(a,b) ((a) < (b) ? (a) : (b))

#endif // MIN

#ifndef MAX

#define MAX(a,b) ((a) > (b) ? (a) : (b))

#endif // MAX

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!!!

};

typedef struct blendresult_s

{

   BlendType

      /**/blend_f, blend_g,

      /**/blend_j, blend_k;

} blendresult_t;

typedef struct kernel_3x3_s

{

   uint32_t

      /**/a, b, c,

      /**/d, e, f,

      /**/g, h, i;

} kernel_3x3_t;

typedef struct kernel_4x4_s //kernel for preprocessing step

{

   uint32_t

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

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

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

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

} kernel_4x4_t;

typedef struct outmatrix_s

{

   size_t size;

   uint32_t* ptr;

   int stride;

   int rotDeg; // either 0, 90, 180 or 270

} outmatrix_t;

static void outmatrix_create (outmatrix_t *mat, size_t size, uint32_t *ptr, int stride, int rotDeg) //access matrix area, top-left at position "out" for image with given width

{

   mat->size = size;

   mat->ptr = ptr;

   mat->stride = stride;

   mat->rotDeg = rotDeg;

}

static uint32_t *outmatrix_ref (outmatrix_t *mat, size_t I, size_t J)

{

   size_t I_old;

   size_t J_old;

   // calculate input matrix coordinates after rotation: (i, j) = (row, col) indices, N = size of (square) matrix

   if (mat->rotDeg == 270) { I_old = J;                 J_old = mat->size - 1 - I; }

   else if (mat->rotDeg == 180) { I_old = mat->size - 1 - I; J_old = mat->size - 1 - J; }

   else if (mat->rotDeg == 90) { I_old = mat->size - 1 - J; J_old = I; }

   else { I_old = I;                 J_old = J; }

   return (mat->ptr + I_old * mat->stride + J_old);

}

typedef void (alphagrad_func) (uint32_t *pixBack, uint32_t pixFront, unsigned int M, unsigned int N);

typedef double (dist_func) (uint32_t pix1, uint32_t pix2);

typedef struct scaler_s

{

   int factor;

   void (*blend_line_shallow) (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad);

   void (*blend_line_steep) (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad);

   void (*blend_line_steep_and_shallow) (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad);

   void (*blend_line_diagonal) (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad);

   void (*blend_corner) (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad);

} scaler_t;

/////////////////////////////////

// shallow line scaling functions

static void blend_line_shallow_2x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 2 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2 - 1, 1), col, 3, 4);

}

static void blend_line_shallow_3x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 3 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 3 - 2, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 3 - 1, 1), col, 3, 4);

   *outmatrix_ref (out, 3 - 1, 2) = col;

}

static void blend_line_shallow_4x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 4 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 4 - 2, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 4 - 1, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 4 - 2, 3), col, 3, 4);

   *outmatrix_ref (out, 4 - 1, 2) = col;

   *outmatrix_ref (out, 4 - 1, 3) = col;

}

static void blend_line_shallow_5x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 5 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 5 - 2, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 5 - 3, 4), col, 1, 4);

   alphagrad (outmatrix_ref (out, 5 - 1, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 5 - 2, 3), col, 3, 4);

   *outmatrix_ref (out, 5 - 1, 2) = col;

   *outmatrix_ref (out, 5 - 1, 3) = col;

   *outmatrix_ref (out, 5 - 1, 4) = col;

   *outmatrix_ref (out, 5 - 2, 4) = col;

}

static void blend_line_shallow_6x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 6 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 6 - 2, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 6 - 3, 4), col, 1, 4);

   alphagrad (outmatrix_ref (out, 6 - 1, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 6 - 2, 3), col, 3, 4);

   alphagrad (outmatrix_ref (out, 6 - 3, 5), col, 3, 4);

   *outmatrix_ref (out, 6 - 1, 2) = col;

   *outmatrix_ref (out, 6 - 1, 3) = col;

   *outmatrix_ref (out, 6 - 1, 4) = col;

   *outmatrix_ref (out, 6 - 1, 5) = col;

   *outmatrix_ref (out, 6 - 2, 4) = col;

   *outmatrix_ref (out, 6 - 2, 5) = col;

}

///////////////////////////////

// steep line scaling functions

static void blend_line_steep_2x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 2 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 2 - 1), col, 3, 4);

}

static void blend_line_steep_3x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 3 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 3 - 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 3 - 1), col, 3, 4);

   *outmatrix_ref (out, 2, 3 - 1) = col;

}

static void blend_line_steep_4x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 4 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 4 - 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 4 - 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 3, 4 - 2), col, 3, 4);

   *outmatrix_ref (out, 2, 4 - 1) = col;

   *outmatrix_ref (out, 3, 4 - 1) = col;

}

static void blend_line_steep_5x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 5 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 5 - 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 4, 5 - 3), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 5 - 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 3, 5 - 2), col, 3, 4);

   *outmatrix_ref (out, 2, 5 - 1) = col;

   *outmatrix_ref (out, 3, 5 - 1) = col;

   *outmatrix_ref (out, 4, 5 - 1) = col;

   *outmatrix_ref (out, 4, 5 - 2) = col;

}

static void blend_line_steep_6x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 6 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 6 - 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 4, 6 - 3), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 6 - 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 3, 6 - 2), col, 3, 4);

   alphagrad (outmatrix_ref (out, 5, 6 - 3), col, 3, 4);

   *outmatrix_ref (out, 2, 6 - 1) = col;

   *outmatrix_ref (out, 3, 6 - 1) = col;

   *outmatrix_ref (out, 4, 6 - 1) = col;

   *outmatrix_ref (out, 5, 6 - 1) = col;

   *outmatrix_ref (out, 4, 6 - 2) = col;

   *outmatrix_ref (out, 5, 6 - 2) = col;

}

///////////////////////////////////////////

// steep and shallow line scaling functions

static void blend_line_steep_and_shallow_2x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 0, 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 1), col, 5, 6); //[!] fixes 7/8 used in xBR

}

static void blend_line_steep_and_shallow_3x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 2, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 0, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 1, 2), col, 3, 4);

   *outmatrix_ref (out, 2, 2) = col;

}

static void blend_line_steep_and_shallow_4x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 3, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 1, 3), col, 3, 4);

   alphagrad (outmatrix_ref (out, 3, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 0, 3), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 2), col, 1, 3); //[!] fixes 1/4 used in xBR

   *outmatrix_ref (out, 3, 3) = col;

   *outmatrix_ref (out, 3, 2) = col;

   *outmatrix_ref (out, 2, 3) = col;

}

static void blend_line_steep_and_shallow_5x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 5 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 5 - 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 5 - 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 5 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 5 - 2, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 5 - 1, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 3, 3), col, 2, 3);

   *outmatrix_ref (out, 2, 5 - 1) = col;

   *outmatrix_ref (out, 3, 5 - 1) = col;

   *outmatrix_ref (out, 4, 5 - 1) = col;

   *outmatrix_ref (out, 5 - 1, 2) = col;

   *outmatrix_ref (out, 5 - 1, 3) = col;

}

static void blend_line_steep_and_shallow_6x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 0, 6 - 1), col, 1, 4);

   alphagrad (outmatrix_ref (out, 2, 6 - 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 1, 6 - 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 3, 6 - 2), col, 3, 4);

   alphagrad (outmatrix_ref (out, 6 - 1, 0), col, 1, 4);

   alphagrad (outmatrix_ref (out, 6 - 2, 2), col, 1, 4);

   alphagrad (outmatrix_ref (out, 6 - 1, 1), col, 3, 4);

   alphagrad (outmatrix_ref (out, 6 - 2, 3), col, 3, 4);

   *outmatrix_ref (out, 2, 6 - 1) = col;

   *outmatrix_ref (out, 3, 6 - 1) = col;

   *outmatrix_ref (out, 4, 6 - 1) = col;

   *outmatrix_ref (out, 5, 6 - 1) = col;

   *outmatrix_ref (out, 4, 6 - 2) = col;

   *outmatrix_ref (out, 5, 6 - 2) = col;

   *outmatrix_ref (out, 6 - 1, 2) = col;

   *outmatrix_ref (out, 6 - 1, 3) = col;

}

//////////////////////////////////

// diagonal line scaling functions

static void blend_line_diagonal_2x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 1, 1), col, 1, 2);

}

static void blend_line_diagonal_3x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 1, 2), col, 1, 8); //conflict with other rotations for this odd scale

   alphagrad (outmatrix_ref (out, 2, 1), col, 1, 8);

   alphagrad (outmatrix_ref (out, 2, 2), col, 7, 8); //

}

static void blend_line_diagonal_4x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 4 - 1, 4 / 2), col, 1, 2);

   alphagrad (outmatrix_ref (out, 4 - 2, 4 / 2 + 1), col, 1, 2);

   *outmatrix_ref (out, 4 - 1, 4 - 1) = col;

}

static void blend_line_diagonal_5x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 5 - 1, 5 / 2 + 0), col, 1, 8); //conflict with other rotations for this odd scale

   alphagrad (outmatrix_ref (out, 5 - 2, 5 / 2 + 1), col, 1, 8);

   alphagrad (outmatrix_ref (out, 5 - 3, 5 / 2 + 2), col, 1, 8); //

   alphagrad (outmatrix_ref (out, 4, 3), col, 7, 8);

   alphagrad (outmatrix_ref (out, 3, 4), col, 7, 8);

   *outmatrix_ref (out, 4, 4) = col;

}

static void blend_line_diagonal_6x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   alphagrad (outmatrix_ref (out, 6 - 1, 6 / 2 + 0), col, 1, 2);

   alphagrad (outmatrix_ref (out, 6 - 2, 6 / 2 + 1), col, 1, 2);

   alphagrad (outmatrix_ref (out, 6 - 3, 6 / 2 + 2), col, 1, 2);

   *outmatrix_ref (out, 6 - 2, 6 - 1) = col;

   *outmatrix_ref (out, 6 - 1, 6 - 1) = col;

   *outmatrix_ref (out, 6 - 1, 6 - 2) = col;

}

///////////////////////////

// corner scaling functions

static void blend_corner_2x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   //model a round corner

   alphagrad (outmatrix_ref (out, 1, 1), col, 21, 100); //exact: 1 - pi/4 = 0.2146018366

}

static void blend_corner_3x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   //model a round corner

   alphagrad (outmatrix_ref (out, 2, 2), col, 45, 100); //exact: 0.4545939598

   //alphagrad (outmatrix_ref (out, 2, 1), col, 7, 256); //0.02826017254 -> negligible + avoid conflicts with other rotations for this odd scale

   //alphagrad (outmatrix_ref (out, 1, 2), col, 7, 256); //0.02826017254

}

static void blend_corner_4x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   //model a round corner

   alphagrad (outmatrix_ref (out, 3, 3), col, 68, 100); //exact: 0.6848532563

   alphagrad (outmatrix_ref (out, 3, 2), col, 9, 100); //0.08677704501

   alphagrad (outmatrix_ref (out, 2, 3), col, 9, 100); //0.08677704501

}

static void blend_corner_5x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   // model a round corner

   alphagrad (outmatrix_ref (out, 4, 4), col, 86, 100); //exact: 0.8631434088

   alphagrad (outmatrix_ref (out, 4, 3), col, 23, 100); //0.2306749731

   alphagrad (outmatrix_ref (out, 3, 4), col, 23, 100); //0.2306749731

   //alphagrad (outmatrix_ref (out, 4, 2), col, 1, 64); //0.01676812367 -> negligible + avoid conflicts with other rotations for this odd scale

   //alphagrad (outmatrix_ref (out, 2, 4), col, 1, 64); //0.01676812367

}

static void blend_corner_6x (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

{

   //model a round corner

   alphagrad (outmatrix_ref (out, 5, 5), col, 97, 100); //exact: 0.9711013910

   alphagrad (outmatrix_ref (out, 4, 5), col, 42, 100); //0.4236372243

   alphagrad (outmatrix_ref (out, 5, 4), col, 42, 100); //0.4236372243

   alphagrad (outmatrix_ref (out, 5, 3), col, 6, 100); //0.05652034508

   alphagrad (outmatrix_ref (out, 3, 5), col, 6, 100); //0.05652034508

}

/////////////////////////////////////

// scaler objects for various factors

static const scaler_t scalers[] =

{

   { 2, blend_line_shallow_2x, blend_line_steep_2x, blend_line_steep_and_shallow_2x, blend_line_diagonal_2x, blend_corner_2x },

   { 3, blend_line_shallow_3x, blend_line_steep_3x, blend_line_steep_and_shallow_3x, blend_line_diagonal_3x, blend_corner_3x },

   { 4, blend_line_shallow_4x, blend_line_steep_4x, blend_line_steep_and_shallow_4x, blend_line_diagonal_4x, blend_corner_4x },

   { 5, blend_line_shallow_5x, blend_line_steep_5x, blend_line_steep_and_shallow_5x, blend_line_diagonal_5x, blend_corner_5x },

   { 6, blend_line_shallow_6x, blend_line_steep_6x, blend_line_steep_and_shallow_6x, blend_line_diagonal_6x, blend_corner_6x },

};

static FORCE_INLINE void preProcessCorners (blendresult_t *result, const kernel_4x4_t *ker, dist_func dist)

{

   // detect blend direction

   // result: F, G, J, K corners of "GradientType"

   // 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 |

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

   memset (result, 0, sizeof (blendresult_t));

   if (((ker->f == ker->g) && (ker->j == ker->k)) || ((ker->f == ker->j) && (ker->g == ker->k)))

      return;

   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;

}

// compress four blend types into a single byte

#define getTopL(b)    ((BlendType) (0x3 & ((unsigned char) (b) >> 0)))

#define getTopR(b)    ((BlendType) (0x3 & ((unsigned char) (b) >> 2)))

#define getBottomR(b) ((BlendType) (0x3 & ((unsigned char) (b) >> 4)))

#define getBottomL(b) ((BlendType) (0x3 & ((unsigned char) (b) >> 6)))

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

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

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

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

FORCE_INLINE void blend_pixel (const scaler_t *scaler, const kernel_3x3_t *ker, uint32_t *target, int trgWidth, unsigned char blendInfo, alphagrad_func alphagrad, dist_func dist, int rotDeg) //result of preprocessing all four corners of pixel "e"

{

   // input kernel area naming convention:

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

   // | A | B | C |

   // ----|---|---|

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

   // ----|---|---|

   // | G | H | I |

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

   uint32_t

      a, b, c,

      d, e, f,

      g, h, i;

   unsigned char blend;

   if      (rotDeg == 270) { a = ker->c; b = ker->f; c = ker->i; d = ker->b; e = ker->e; f = ker->h; g = ker->a; h = ker->d; i = ker->g; blend = ((blendInfo << 6) | (blendInfo >> 2)) & 0xff; }

   else if (rotDeg == 180) { a = ker->i; b = ker->h; c = ker->g; d = ker->f; e = ker->e; f = ker->d; g = ker->c; h = ker->b; i = ker->a; blend = ((blendInfo << 4) | (blendInfo >> 4)) & 0xff; }

   else if (rotDeg == 90)  { a = ker->g; b = ker->d; c = ker->a; d = ker->h; e = ker->e; f = ker->b; g = ker->i; h = ker->f; i = ker->c; blend = ((blendInfo << 2) | (blendInfo >> 6)) & 0xff; }

   else                    { a = ker->a; b = ker->b; c = ker->c; d = ker->d; e = ker->e; f = ker->f; g = ker->g; h = ker->h; i = ker->i; blend = ((blendInfo << 0) | (blendInfo >> 8)) & 0xff; }

   if (getBottomR (blend) >= BLEND_NORMAL)

   {

      outmatrix_t out;

      uint32_t px;

      bool doLineBlend;

      if (getBottomR (blend) >= BLEND_DOMINANT)

         doLineBlend = true;

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

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

      else if (getBottomL (blend) != BLEND_NONE && (dist (e, c) >= XBRZ_CFG_EQUAL_COLOR_TOLERANCE))

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

      else if ((dist (e, i) >= XBRZ_CFG_EQUAL_COLOR_TOLERANCE)

         && (dist (g, h) < XBRZ_CFG_EQUAL_COLOR_TOLERANCE)

         && (dist (h, i) < XBRZ_CFG_EQUAL_COLOR_TOLERANCE)

         && (dist (i, f) < XBRZ_CFG_EQUAL_COLOR_TOLERANCE)

         && (dist (f, c) < XBRZ_CFG_EQUAL_COLOR_TOLERANCE))

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

      else

         doLineBlend = true;

      outmatrix_create (&out, scaler->factor, target, trgWidth, rotDeg);

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

      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->blend_line_steep_and_shallow (px, &out, alphagrad);

            else

               scaler->blend_line_shallow (px, &out, alphagrad);

         }

         else

         {

            if (haveSteepLine)

               scaler->blend_line_steep (px, &out, alphagrad);

            else

               scaler->blend_line_diagonal (px, &out, alphagrad);

         }

      }

      else

         scaler->blend_corner (px, &out, alphagrad);

   }

}

void scale_image (const scaler_t *scaler, const uint32_t *src, uint32_t *trg, int srcWidth, int srcHeight, int yFirst, int yLast, alphagrad_func alphagrad, dist_func dist)

{

   yFirst = MAX (yFirst, 0);

   yLast = MIN (yLast, srcHeight);

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

      return;

   const int trgWidth = srcWidth * scaler->factor;

   //"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 = (unsigned char *) (trg + yLast * scaler->factor * trgWidth) - bufferSize;

   memset (preProcBuffer, 0, bufferSize);

   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 * MAX (y - 1, 0);

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

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

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

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

      {

         blendresult_t res;