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

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

enum RotationDegree //clock-wise

{

   ROT_0 = 0,

   ROT_90,

   ROT_180,

   ROT_270

};

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;

   RotationDegree rotDeg;

} outmatrix_t;

static void outmatrix_create (outmatrix_t *mat, size_t size, uint32_t *ptr, int stride, RotationDegree 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 == ROT_270) { I_old = J;                 J_old = mat->size - 1 - I; }

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

   else if (mat->rotDeg == ROT_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);

}

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

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

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

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

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

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

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

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

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

namespace

{

   template <class Scaler>

   FORCE_INLINE void blendPixel (const int scale_factor, const kernel_3x3_t *ker, uint32_t *target, int trgWidth, unsigned char blendInfo, alphagrad_func alphagrad, dist_func dist, RotationDegree 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 == ROT_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 == ROT_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 == ROT_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, scale_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::blendLineSteepAndShallow (px, &out, alphagrad);

               else

                  Scaler::blendLineShallow (px, &out, alphagrad);

            }

            else

            {

               if (haveSteepLine)

                  Scaler::blendLineSteep (px, &out, alphagrad);

               else

                  Scaler::blendLineDiagonal (px, &out, alphagrad);

            }

         }

         else

            Scaler::blendCorner (px, &out, alphagrad);

      }

   }

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

   void scaleImage (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::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;

      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;

            const int x_m1 = MAX (x - 1, 0);

            const int x_p1 = MIN (x + 1, srcWidth - 1);

            const int x_p2 = MIN (x + 2, srcWidth - 1);

            kernel_4x4_t 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];

            preProcessCorners (&res, &ker, dist);

            /*

            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 * 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);

         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 = MAX (x - 1, 0); //perf: prefer array indexing to additional pointers!

            const int x_p1 = MIN (x + 1, srcWidth - 1);

            const int x_p2 = MIN (x + 2, srcWidth - 1);

            kernel_4x4_t 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];

            ker4.k = s_p1[x_p1];

            ker4.l = s_p1[x_p2];

            ker4.m = s_p2[x_m1];

            ker4.n = s_p2[x];

            ker4.o = s_p2[x_p1];

            ker4.p = s_p2[x_p2];

            //evaluate the four corners on bottom-right of current pixel

            unsigned char blend_xy = 0; //for current (x, y) position

            {

               blendresult_t res;

               preProcessCorners (&res, &ker4, dist);

               /*

               preprocessing blend result:

               ---------

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

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

               | J | K |

               ---------

               */

               blend_xy = preProcBuffer[x];

               setBottomR (blend_xy, res.blend_f); //all four corners of (x, y) have been determined at this point due to processing sequence!

               setTopR (blend_xy1, res.blend_j); //set 2nd known corner for (x, y + 1)

               preProcBuffer[x] = blend_xy1; //store on current buffer position for use on next row

               blend_xy1 = 0;

               setTopL (blend_xy1, res.blend_k); //set 1st known corner for (x + 1, y + 1) and buffer for use on next column

               if (x + 1 < bufferSize) //set 3rd known corner for (x + 1, y)

                  setBottomL (preProcBuffer[x + 1], res.blend_g);

            }

            //fill block of size scale * scale with the given color

            {

               uint32_t *blk = out;

               for (int _blk_y = 0; _blk_y < Scaler::scale; ++_blk_y, blk = (uint32_t *) BYTE_ADVANCE (blk, trgWidth * sizeof (uint32_t)))

                  for (int _blk_x = 0; _blk_x < Scaler::scale; ++_blk_x)

                     blk[_blk_x] = ker4.f;

            }

            //place *after* preprocessing step, to not overwrite the results while processing the the last pixel!

            //blend four corners of current pixel

            if (blend_xy != 0) //good 5% perf-improvement

            {

               kernel_3x3_t ker3; //perf: initialization is negligible

               ker3.a = ker4.a;

               ker3.b = ker4.b;

               ker3.c = ker4.c;

               ker3.d = ker4.e;

               ker3.e = ker4.f;

               ker3.f = ker4.g;

               ker3.g = ker4.i;

               ker3.h = ker4.j;

               ker3.i = ker4.k;

               blendPixel<Scaler> (Scaler::scale, &ker3, out, trgWidth, blend_xy, alphagrad, dist, ROT_0);

               blendPixel<Scaler> (Scaler::scale, &ker3, out, trgWidth, blend_xy, alphagrad, dist, ROT_90);

               blendPixel<Scaler> (Scaler::scale, &ker3, out, trgWidth, blend_xy, alphagrad, dist, ROT_180);

               blendPixel<Scaler> (Scaler::scale, &ker3, out, trgWidth, blend_xy, alphagrad, dist, ROT_270);

            }

         }

      }

   }

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

   struct Scaler2x

   {

      static const int scale = 2;

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

      {

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

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

      }

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

      {

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

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

      }

      static void blendLineSteepAndShallow (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 blendLineDiagonal (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

      {

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

      }

      static void blendCorner (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

      }

   };

   struct Scaler3x

   {

      static const int scale = 3;

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

      {

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

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

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

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

      }

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

      {

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

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

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

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

      }

      static void blendLineSteepAndShallow (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 blendLineDiagonal (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 blendCorner (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

      }

   };

   struct Scaler4x

   {

      static const int scale = 4;

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

      {

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

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

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

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

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

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

      }

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

      {

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

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

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

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

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

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

      }

      static void blendLineSteepAndShallow (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 blendLineDiagonal (uint32_t col, outmatrix_t *out, alphagrad_func alphagrad)

      {

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

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

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

      }

      static void blendCorner (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

      }

   };

   struct Scaler5x

   {

      static const int scale = 5;

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

      {

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

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

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

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

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

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

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

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

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

      }

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

      {

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

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

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

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

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

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

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

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

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

      }

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

      {

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

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

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