WebSVN – Games.Rick Dangerous – Diff – //src/xbrz.c

 #define XBRZ_CFG_DOMINANT_DIRECTION_THRESHOLD 3.6
 #define XBRZ_CFG_STEEP_DIRECTION_THRESHOLD 2.2
 // blend types
-#define BLEND_NONE 0
+#define BLEND_NONE     0
-#define BLEND_NORMAL 1 // a normal indication to blend
+#define BLEND_NORMAL   1 // a normal indication to blend
 #define BLEND_DOMINANT 2 // a strong indication to blend
 // handy macros
 #ifndef MIN
 static void blend_line_steep_and_shallow_2x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    color_format->alphagrad (outmatrix_ref (out, 1, 0), col, 1, 4);
    color_format->alphagrad (outmatrix_ref (out, 0, 1), col, 1, 4);
-   color_format->alphagrad (outmatrix_ref (out, 1, 1), col, 5, 6); //[!] fixes 7/8 used in xBR
+   color_format->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, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    color_format->alphagrad (outmatrix_ref (out, 2, 0), col, 1, 4);
    color_format->alphagrad (outmatrix_ref (out, 0, 2), col, 1, 4);
+{
    color_format->alphagrad (outmatrix_ref (out, 3, 1), col, 3, 4);
    color_format->alphagrad (outmatrix_ref (out, 1, 3), col, 3, 4);
    color_format->alphagrad (outmatrix_ref (out, 3, 0), col, 1, 4);
    color_format->alphagrad (outmatrix_ref (out, 0, 3), col, 1, 4);
-   color_format->alphagrad (outmatrix_ref (out, 2, 2), col, 1, 3); //[!] fixes 1/4 used in xBR
+   color_format->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, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    color_format->alphagrad (outmatrix_ref (out, 1, 1), col, 1, 2);
+}
 static void blend_line_diagonal_3x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
-   color_format->alphagrad (outmatrix_ref (out, 1, 2), col, 1, 8); //conflict with other rotations for this odd scale
+   color_format->alphagrad (outmatrix_ref (out, 1, 2), col, 1, 8); // conflict with other rotations for this odd scale
    color_format->alphagrad (outmatrix_ref (out, 2, 1), col, 1, 8);
-   color_format->alphagrad (outmatrix_ref (out, 2, 2), col, 7, 8); //
+   color_format->alphagrad (outmatrix_ref (out, 2, 2), col, 7, 8);
+}
 static void blend_line_diagonal_4x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    color_format->alphagrad (outmatrix_ref (out, 4 - 1, 4 / 2), col, 1, 2);
    color_format->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, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
-   color_format->alphagrad (outmatrix_ref (out, 5 - 1, 5 / 2 + 0), col, 1, 8); //conflict with other rotations for this odd scale
+   color_format->alphagrad (outmatrix_ref (out, 5 - 1, 5 / 2 + 0), col, 1, 8); // conflict with other rotations for this odd scale
    color_format->alphagrad (outmatrix_ref (out, 5 - 2, 5 / 2 + 1), col, 1, 8);
-   color_format->alphagrad (outmatrix_ref (out, 5 - 3, 5 / 2 + 2), col, 1, 8); //
+   color_format->alphagrad (outmatrix_ref (out, 5 - 3, 5 / 2 + 2), col, 1, 8);
    color_format->alphagrad (outmatrix_ref (out, 4, 3), col, 7, 8);
    color_format->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, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
 // corner scaling functions
 static void blend_corner_2x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    // model a round corner
-   color_format->alphagrad (outmatrix_ref (out, 1, 1), col, 21, 100); //exact: 1 - pi/4 = 0.2146018366
+   color_format->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, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    // model a round corner
-   color_format->alphagrad (outmatrix_ref (out, 2, 2), col, 45, 100); //exact: 0.4545939598
+   color_format->alphagrad (outmatrix_ref (out, 2, 2), col, 45, 100); // exact: 0.4545939598
-   //color_format->alphagrad (outmatrix_ref (out, 2, 1), col, 7, 256); //0.02826017254 -> negligible + avoid conflicts with other rotations for this odd scale
+   //color_format->alphagrad (outmatrix_ref (out, 2, 1), col,  7, 256); // 0.02826017254 -> negligible + avoid conflicts with other rotations for this odd scale
-   //color_format->alphagrad (outmatrix_ref (out, 1, 2), col, 7, 256); //0.02826017254
+   //color_format->alphagrad (outmatrix_ref (out, 1, 2), col,  7, 256); // 0.02826017254
+}
 static void blend_corner_4x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    // model a round corner
-   color_format->alphagrad (outmatrix_ref (out, 3, 3), col, 68, 100); //exact: 0.6848532563
+   color_format->alphagrad (outmatrix_ref (out, 3, 3), col, 68, 100); // exact: 0.6848532563
-   color_format->alphagrad (outmatrix_ref (out, 3, 2), col, 9, 100); //0.08677704501
+   color_format->alphagrad (outmatrix_ref (out, 3, 2), col,  9, 100); // 0.08677704501
-   color_format->alphagrad (outmatrix_ref (out, 2, 3), col, 9, 100); //0.08677704501
+   color_format->alphagrad (outmatrix_ref (out, 2, 3), col,  9, 100); // 0.08677704501
+}
 static void blend_corner_5x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    // model a round corner
-   color_format->alphagrad (outmatrix_ref (out, 4, 4), col, 86, 100); //exact: 0.8631434088
+   color_format->alphagrad (outmatrix_ref (out, 4, 4), col, 86, 100); // exact: 0.8631434088
-   color_format->alphagrad (outmatrix_ref (out, 4, 3), col, 23, 100); //0.2306749731
+   color_format->alphagrad (outmatrix_ref (out, 4, 3), col, 23, 100); // 0.2306749731
-   color_format->alphagrad (outmatrix_ref (out, 3, 4), col, 23, 100); //0.2306749731
+   color_format->alphagrad (outmatrix_ref (out, 3, 4), col, 23, 100); // 0.2306749731
-   //color_format->alphagrad (outmatrix_ref (out, 4, 2), col, 1, 64); //0.01676812367 -> negligible + avoid conflicts with other rotations for this odd scale
+   //color_format->alphagrad (outmatrix_ref (out, 4, 2), col,  1,  64); // 0.01676812367 -> negligible + avoid conflicts with other rotations for this odd scale
-   //color_format->alphagrad (outmatrix_ref (out, 2, 4), col, 1, 64); //0.01676812367
+   //color_format->alphagrad (outmatrix_ref (out, 2, 4), col,  1,  64); // 0.01676812367
+}
 static void blend_corner_6x (uint32_t col, outmatrix_t *out, colorformat_t *color_format, outmatrixreffunc_t outmatrix_ref)
+{
    // model a round corner
-   color_format->alphagrad (outmatrix_ref (out, 5, 5), col, 97, 100); //exact: 0.9711013910
+   color_format->alphagrad (outmatrix_ref (out, 5, 5), col, 97, 100); // exact: 0.9711013910
-   color_format->alphagrad (outmatrix_ref (out, 4, 5), col, 42, 100); //0.4236372243
+   color_format->alphagrad (outmatrix_ref (out, 4, 5), col, 42, 100); // 0.4236372243
-   color_format->alphagrad (outmatrix_ref (out, 5, 4), col, 42, 100); //0.4236372243
+   color_format->alphagrad (outmatrix_ref (out, 5, 4), col, 42, 100); // 0.4236372243
-   color_format->alphagrad (outmatrix_ref (out, 5, 3), col, 6, 100); //0.05652034508
+   color_format->alphagrad (outmatrix_ref (out, 5, 3), col,  6, 100); // 0.05652034508
-   color_format->alphagrad (outmatrix_ref (out, 3, 5), col, 6, 100); //0.05652034508
+   color_format->alphagrad (outmatrix_ref (out, 3, 5), col,  6, 100); // 0.05652034508
+}
 /////////////////////////////////////
 // scaler objects for various factors
 /////////////////////////////////////////////////////
 // color distance functions for various color formats
 static double dist24 (uint32_t pix1, uint32_t pix2)
+{
-   //30% perf boost compared to plain distYCbCr()!
+   // 30% perf boost compared to plain distYCbCr()!
-   //consumes 64 MB memory; using double is only 2% faster, but takes 128 MB
+   // consumes 64 MB memory; using double is only 2% faster, but takes 128 MB
-   static float diffToDist[256 * 256 * 256];
+   static float diffToDist[256 * 256 * 256] = { 0 };
    static bool is_initialized = false;
    if (!is_initialized)
+   {
       for (uint32_t i = 0; i < 256 * 256 * 256; ++i) //startup time: 114 ms on Intel Core i5 (four cores)
+      {
    const int r_diff = (int) GET_RED (pix1) - (int) GET_RED (pix2);
    const int g_diff = (int) GET_GREEN (pix1) - (int) GET_GREEN (pix2);
    const int b_diff = (int) GET_BLUE (pix1) - (int) GET_BLUE (pix2);
-   return diffToDist[(((r_diff + 0xFF) / 2) << 16) | //slightly reduce precision (division by 2) to squeeze value into single byte
+   return (diffToDist[  (((r_diff + 0xFF) / 2) << 16) // slightly reduce precision (division by 2) to squeeze value into single byte
-      (((g_diff + 0xFF) / 2) << 8) |
+                      | (((g_diff + 0xFF) / 2) <<  8)
-      (((b_diff + 0xFF) / 2) << 0)];
+                      | (((b_diff + 0xFF) / 2) <<  0)]);
+}
 static double dist32 (uint32_t pix1, uint32_t pix2)
+{
    // Requirements for a color distance handling alpha channel: with a1, a2 in [0, 1]
    //    1. if a1 = a2, distance should be: a1 * distYCbCr()
    //    2. if a1 = 0,  distance should be: a2 * distYCbCr(black, white) = a2 * 255
    //    3. if a1 = 1,  ??? maybe: 255 * (1 - a2) + a2 * distYCbCr()
-   //return MIN (a1, a2) * distYCbCrBuffered(pix1, pix2) + 255 * abs(a1 - a2);
+   // return MIN (a1, a2) * distYCbCrBuffered(pix1, pix2) + 255 * abs(a1 - a2);
-   //=> following code is 15% faster:
+   // => following code is 15% faster:
    const double d = dist24 (pix1, pix2);
    const double a1 = GET_ALPHA (pix1) / 255.0;
    const double a2 = GET_ALPHA (pix2) / 255.0;
    return (a1 < a2 ? a1 * d + 255 * (a2 - a1) : a2 * d + 255 * (a1 - a2));
+}
    const int weight = 4;
    double jg = color_format->dist (ker->i, ker->f) + color_format->dist (ker->f, ker->c) + color_format->dist (ker->n, ker->k) + color_format->dist (ker->k, ker->h) + weight * color_format->dist (ker->j, ker->g);
    double fk = color_format->dist (ker->e, ker->j) + color_format->dist (ker->j, ker->o) + color_format->dist (ker->b, ker->g) + color_format->dist (ker->g, ker->l) + weight * color_format->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
+   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;
+{
    // input kernel area naming convention:
    // -------------
    // | A | B | C |
    // ----|---|---|
-   // | D | E | F | //input pixel is at position E
+   // | D | E | F | // input pixel is at position E
    // ----|---|---|
    // | G | H | I |
    // -------------
    uint32_t
       outmatrix_t out;
       out.size = scaler->factor;
       out.ptr = target;
       out.stride = trgWidth;
-      px = (color_format->dist (e, f) <= color_format->dist (e, h) ? f : h); //choose most similar color
+      px = (color_format->dist (e, f) <= color_format->dist (e, h) ? f : h); // choose most similar color
       if (doLineBlend)
+      {
-         const double fg = color_format->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 fg = color_format->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 = color_format->dist (h, c); //
+         const double hc = color_format->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)
+         {
          preprocess_corners (&res, &ker, color_format);
          // preprocessing blend result:
          // ---------
-         // | F | G |   //evalute corner between F, G, J, K
+         // | F | G |   // evalute corner between F, G, J, K
-         // ----|---|   //input pixel is at position F
+         // ----|---|   // input pixel is at position F
          // | J | K |
          // ---------
          setTopR (&preProcBuffer[x], res.blend_j);
          if (x + 1 < bufferSize)
+   }
    //------------------------------------------------------------------------------------
    for (int y = yFirst; y < yLast; ++y)
+   {
-      uint32_t *out = trg + scaler->factor * y * trgWidth; //consider MT "striped" access
+      uint32_t *out = trg + scaler->factor * 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_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);
       uint8_t blend_xy1 = 0; // corner blending for current (x, y + 1) position
       for (int x = 0; x < srcWidth; ++x, out += scaler->factor)
+      {
          // 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_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
+         kernel_4x4_t ker4; // perf: initialization is negligible
          ker4.a = s_m1[x_m1]; ker4.b = s_m1[x]; ker4.c = s_m1[x_p1]; ker4.d = s_m1[x_p2]; // read sequentially from memory as far as possible
          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
-         uint8_t blend_xy = 0; //for current (x, y) position
+         uint8_t blend_xy = 0; // for current (x, y) position
+         {
             blendresult_t res;
             preprocess_corners (&res, &ker4, color_format);
             // preprocessing blend result:
             // ---------
-            // | F | G |   //evalute corner between F, G, J, K
+            // | F | G |   // evalute corner between F, G, J, K
-            // ----|---|   //current input pixel is at position F
+            // ----|---|   // 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!
+            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)
+            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
+            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
+            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)
+            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
+         // fill block of size scale * scale with the given color
          uint32_t *blk = out;
          for (int _blk_y = 0; _blk_y < scaler->factor; ++_blk_y, blk = (uint32_t *) BYTE_ADVANCE (blk, trgWidth * sizeof (uint32_t)))
             for (int _blk_x = 0; _blk_x < scaler->factor; ++_blk_x)
                blk[_blk_x] = ker4.f;
-         //place *after* preprocessing step, to not overwrite the results while processing the the last pixel!
+         // place *after* preprocessing step, to not overwrite the results while processing the the last pixel!
-         //blend four corners of current pixel
+         // blend four corners of current pixel
-         if (blend_xy != 0) //good 5% perf-improvement
+         if (blend_xy != 0) // good 5% perf-improvement
+         {
-            kernel_3x3_t ker3; //perf: initialization is negligible
+            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;
             blend_pixel (scaler, &ker3, out, trgWidth, blend_xy, color_format, outmatrixref_0);
+   {
       //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_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 yTrg_last = ((y + 1) * trgHeight + srcHeight - 1) / srcHeight; // = ceil(((y + 1) * trgHeight) / srcHeight)
       const int blockHeight = yTrg_last - yTrg_first;
       if (blockHeight > 0)
+      {
          const uint32_t *srcLine = (const uint32_t *) BYTE_ADVANCE (src, y * srcPitch);

Subversion Repositories Games.Rick Dangerous

Games.Rick Dangerous//src/xbrz.c – Rev 7 → 13