Use std::swap instead of temporary values

[geeqie.git] / src / pixbuf-util.cc

diff --git a/src/pixbuf-util.cc b/src/pixbuf-util.cc
index c5f16ae..0d87b7f 100644 (file)
--- a/src/pixbuf-util.cc
+++ b/src/pixbuf-util.cc
@@ -19,15 +19,28 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#include "main.h"
 #include "pixbuf-util.h"
 
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+
+#include <cairo.h>
+#include <gio/gio.h>
+#include <glib-object.h>
+#include <pango/pangocairo.h>
+
+#include <config.h>
+
+#include "debug.h"
 #include "exif.h"
 #include "filedata.h"
+#include "main-defines.h"
+#include "typedefs.h"
 #include "ui-fileops.h"
 
-#include <cmath>
-
 
 /*
  *-----------------------------------------------------------------------------
@@ -64,7 +77,7 @@ gboolean pixbuf_to_file_as_png(GdkPixbuf *pixbuf, const gchar *filename)
 #pragma GCC diagnostic ignored "-Wunused-function"
 gboolean pixbuf_to_file_as_jpg_unused(GdkPixbuf *pixbuf, const gchar *filename, gint quality)
 {
-       GError *error = NULL;
+       GError *error = nullptr;
        gchar *qbuf;
        gboolean ret;
 
@@ -357,7 +370,8 @@ GdkPixbuf *pixbuf_fallback(FileData *fd, gint requested_width, gint requested_he
 
                if (w > requested_width || h > requested_height)
                        {
-                       gint nw, nh;
+                       gint nw;
+                       gint nh;
 
                        if (pixbuf_scale_aspect(requested_width, requested_height,
                                                          w, h, &nw, &nh))
@@ -411,7 +425,8 @@ static void pixbuf_copy_block_rotate(guchar *src, gint src_row_stride, gint x, g
                                     guchar *dest, gint dest_row_stride, gint w, gint h,
                                     gint bytes_per_pixel, gboolean counter_clockwise)
 {
-       gint i, j;
+       gint i;
+       gint j;
        guchar *sp;
        guchar *dp;
 
@@ -452,8 +467,10 @@ static void pixbuf_copy_block(guchar *src, gint src_row_stride, gint w, gint h,
                }
 }
 
-#define ROTATE_BUFFER_WIDTH 48
-#define ROTATE_BUFFER_HEIGHT 48
+enum {
+       ROTATE_BUFFER_WIDTH = 48,
+       ROTATE_BUFFER_HEIGHT = 48
+};
 
 /*
  * Returns a copy of pixbuf src rotated 90 degrees clockwise or 90 counterclockwise
@@ -463,16 +480,22 @@ GdkPixbuf *pixbuf_copy_rotate_90(GdkPixbuf *src, gboolean counter_clockwise)
 {
        GdkPixbuf *dest;
        gboolean has_alpha;
-       gint sw, sh, srs;
-       gint dw, dh, drs;
+       gint sw;
+       gint sh;
+       gint srs;
+       gint dw;
+       gint dh;
+       gint drs;
        guchar *s_pix;
        guchar *d_pix;
-       gint i, j;
+       gint i;
+       gint j;
        gint a;
        GdkPixbuf *buffer;
        guchar *b_pix;
        gint brs;
-       gint w, h;
+       gint w;
+       gint h;
 
        if (!src) return nullptr;
 
@@ -500,7 +523,8 @@ GdkPixbuf *pixbuf_copy_rotate_90(GdkPixbuf *src, gboolean counter_clockwise)
                w = MIN(ROTATE_BUFFER_WIDTH, (sh - i));
                for (j = 0; j < sw; j += ROTATE_BUFFER_HEIGHT)
                        {
-                       gint x, y;
+                       gint x;
+                       gint y;
 
                        h = MIN(ROTATE_BUFFER_HEIGHT, (sw - j));
                        pixbuf_copy_block_rotate(s_pix, srs, j, i,
@@ -561,13 +585,16 @@ GdkPixbuf *pixbuf_copy_mirror(GdkPixbuf *src, gboolean mirror, gboolean flip)
 {
        GdkPixbuf *dest;
        gboolean has_alpha;
-       gint w, h, srs;
+       gint w;
+       gint h;
+       gint srs;
        gint drs;
        guchar *s_pix;
        guchar *d_pix;
        guchar *sp;
        guchar *dp;
-       gint i, j;
+       gint i;
+       gint j;
        gint a;
 
        if (!src) return nullptr;
@@ -686,10 +713,13 @@ void pixbuf_draw_rect_fill(GdkPixbuf *pb,
                           gint r, gint g, gint b, gint a)
 {
        gboolean has_alpha;
-       gint pw, ph, prs;
+       gint pw;
+       gint ph;
+       gint prs;
        guchar *p_pix;
        guchar *pp;
-       gint i, j;
+       gint i;
+       gint j;
 
        if (!pb) return;
 
@@ -703,18 +733,17 @@ void pixbuf_draw_rect_fill(GdkPixbuf *pb,
        prs = gdk_pixbuf_get_rowstride(pb);
        p_pix = gdk_pixbuf_get_pixels(pb);
 
+       const gint p_step = has_alpha ? 4 : 3;
+
        for (i = 0; i < h; i++)
                {
-               pp = p_pix + (y + i) * prs + (x * (has_alpha ? 4 : 3));
+               pp = p_pix + (y + i) * prs + (x * p_step);
                for (j = 0; j < w; j++)
                        {
-                       *pp = (r * a + *pp * (256-a)) >> 8;
-                       pp++;
-                       *pp = (g * a + *pp * (256-a)) >> 8;
-                       pp++;
-                       *pp = (b * a + *pp * (256-a)) >> 8;
-                       pp++;
-                       if (has_alpha) pp++;
+                       pp[0] = (r * a + pp[0] * (256-a)) >> 8;
+                       pp[1] = (g * a + pp[1] * (256-a)) >> 8;
+                       pp[2] = (b * a + pp[2] * (256-a)) >> 8;
+                       pp += p_step;
                        }
                }
 }
@@ -742,10 +771,13 @@ void pixbuf_set_rect_fill(GdkPixbuf *pb,
                          gint r, gint g, gint b, gint a)
 {
        gboolean has_alpha;
-       gint pw, ph, prs;
+       gint pw;
+       gint ph;
+       gint prs;
        guchar *p_pix;
        guchar *pp;
-       gint i, j;
+       gint i;
+       gint j;
 
        if (!pb) return;
 
@@ -759,9 +791,11 @@ void pixbuf_set_rect_fill(GdkPixbuf *pb,
        prs = gdk_pixbuf_get_rowstride(pb);
        p_pix = gdk_pixbuf_get_pixels(pb);
 
+       const gint p_step = has_alpha ? 4 : 3;
+
        for (i = 0; i < h; i++)
                {
-               pp = p_pix + (y + i) * prs + (x * (has_alpha ? 4 : 3));
+               pp = p_pix + (y + i) * prs + (x * p_step);
                for (j = 0; j < w; j++)
                        {
                        *pp = r; pp++;
@@ -820,18 +854,23 @@ static void pixbuf_copy_font(GdkPixbuf *src, gint sx, gint sy,
                             gint w, gint h,
                             guint8 r, guint8 g, guint8 b, guint8 a)
 {
-       gint sw, sh, srs;
+       gint sw;
+       gint sh;
+       gint srs;
        gboolean s_alpha;
        gint s_step;
        guchar *s_pix;
-       gint dw, dh, drs;
+       gint dw;
+       gint dh;
+       gint drs;
        gboolean d_alpha;
        gint d_step;
        guchar *d_pix;
 
        guchar *sp;
        guchar *dp;
-       gint i, j;
+       gint i;
+       gint j;
 
        if (!src || !dest) return;
 
@@ -898,9 +937,12 @@ void pixbuf_draw_layout(GdkPixbuf *pixbuf, PangoLayout *layout, GtkWidget *,
                        guint8 r, guint8 g, guint8 b, guint8 a)
 {
        GdkPixbuf *buffer;
-       gint w, h;
-       gint sx, sy;
-       gint dw, dh;
+       gint w;
+       gint h;
+       gint sx;
+       gint sy;
+       gint dw;
+       gint dh;
        cairo_surface_t *source;
        cairo_t *cr;
 
@@ -964,23 +1006,12 @@ void pixbuf_draw_layout(GdkPixbuf *pixbuf, PangoLayout *layout, GtkWidget *,
  */
 
 void util_clip_triangle(gint x1, gint y1, gint x2, gint y2, gint x3, gint y3,
-                       gint *rx, gint *ry, gint *rw, gint *rh)
+                        gint &rx, gint &ry, gint &rw, gint &rh)
 {
-       gint tx, ty, tw, th;
-
-       tx = MIN(x1, x2);
-       tx = MIN(tx, x3);
-       ty = MIN(y1, y2);
-       ty = MIN(ty, y3);
-       tw = MAX(abs(x1 - x2), abs(x2 - x3));
-       tw = MAX(tw, abs(x3 - x1));
-       th = MAX(abs(y1 - y2), abs(y2 - y3));
-       th = MAX(th, abs(y3 - y1));
-
-       *rx = tx;
-       *ry = ty;
-       *rw = tw;
-       *rh = th;
+       rx = std::min({x1, x2, x3});
+       ry = std::min({y1, y2, y3});
+       rw = std::max({abs(x1 - x2), abs(x2 - x3), abs(x3 - x1)});
+       rh = std::max({abs(y1 - y2), abs(y2 - y3), abs(y3 - y1)});
 }
 
 void pixbuf_draw_triangle(GdkPixbuf *pb,
@@ -989,19 +1020,31 @@ void pixbuf_draw_triangle(GdkPixbuf *pb,
                          guint8 r, guint8 g, guint8 b, guint8 a)
 {
        gboolean has_alpha;
-       gint pw, ph, prs;
-       gint rx, ry, rw, rh;
-       gint tx, ty, tw, th;
-       gint fx1, fy1;
-       gint fx2, fy2;
-       gint fw, fh;
+       gint pw;
+       gint ph;
+       gint prs;
+       gint rx;
+       gint ry;
+       gint rw;
+       gint rh;
+       gint tx;
+       gint ty;
+       gint tw;
+       gint th;
+       gint fx1;
+       gint fy1;
+       gint fx2;
+       gint fy2;
+       gint fw;
+       gint fh;
        guchar *p_pix;
        guchar *pp;
        gint p_step;
-       gdouble slope1, slope2;
-       gint slope1_x, slope1_y;
+       gdouble slope1;
+       gdouble slope2;
+       gint slope1_x;
+       gint slope1_y;
        gint y;
-       gint t;
        gboolean middle = FALSE;
 
        if (!pb) return;
@@ -1014,7 +1057,7 @@ void pixbuf_draw_triangle(GdkPixbuf *pb,
                              &rx, &ry, &rw, &rh)) return;
 
        util_clip_triangle(x1, y1, x2, y2, x3, y3,
-                          &tx, &ty, &tw, &th);
+                          tx, ty, tw, th);
 
        if (!util_clip_region(rx, ry, rw, rh,
                              tx, ty, tw, th,
@@ -1030,18 +1073,18 @@ void pixbuf_draw_triangle(GdkPixbuf *pb,
 
        if (y1 > y2)
                {
-               t = x1; x1 = x2; x2 = t;
-               t = y1; y1 = y2; y2 = t;
+               std::swap(x1, x2);
+               std::swap(y1, y2);
                }
        if (y2 > y3)
                {
-               t = x2; x2 = x3; x3 = t;
-               t = y2; y2 = y3; y3 = t;
+               std::swap(x2, x3);
+               std::swap(y2, y3);
                }
        if (y1 > y2)
                {
-               t = x1; x1 = x2; x2 = t;
-               t = y1; y1 = y2; y2 = t;
+               std::swap(x1, x2);
+               std::swap(y1, y2);
                }
 
        slope1 = static_cast<gdouble>(y2 - y1);
@@ -1053,7 +1096,8 @@ void pixbuf_draw_triangle(GdkPixbuf *pb,
 
        for (y = fy1; y < fy2; y++)
                {
-               gint xa, xb;
+               gint xa;
+               gint xb;
 
                if (!middle && y > y2)
                        {
@@ -1070,7 +1114,7 @@ void pixbuf_draw_triangle(GdkPixbuf *pb,
 
                if (xa > xb)
                        {
-                       t = xa; xa = xb; xb = t;
+                       std::swap(xa, xb);
                        }
 
                xa = CLAMP(xa, fx1, fx2);
@@ -1080,13 +1124,10 @@ void pixbuf_draw_triangle(GdkPixbuf *pb,
 
                while (xa < xb)
                        {
-                       *pp = (r * a + *pp * (256-a)) >> 8;
-                       pp++;
-                       *pp = (g * a + *pp * (256-a)) >> 8;
-                       pp++;
-                       *pp = (b * a + *pp * (256-a)) >> 8;
-                       pp++;
-                       if (has_alpha) pp++;
+                       pp[0] = (r * a + pp[0] * (256-a)) >> 8;
+                       pp[1] = (g * a + pp[1] * (256-a)) >> 8;
+                       pp[2] = (b * a + pp[2] * (256-a)) >> 8;
+                       pp += p_step;
 
                        xa++;
                        }
@@ -1108,10 +1149,8 @@ static gboolean util_clip_line(gdouble clip_x, gdouble clip_y, gdouble clip_w, g
 
        if (x1 > x2)
                {
-               gdouble t;
-
-               t = x1; x1 = x2; x2 = t;
-               t = y1; y1 = y2; y2 = t;
+               std::swap(x1, x2);
+               std::swap(y1, y2);
                flip = TRUE;
                }
 
@@ -1150,12 +1189,10 @@ static gboolean util_clip_line(gdouble clip_x, gdouble clip_y, gdouble clip_w, g
                }
        else
                {
-               gdouble t;
-
                if (y1 < clip_y || y2 > clip_y + clip_h) return FALSE;
 
-               t = x1; x1 = x2; x2 = t;
-               t = y1; y1 = y2; y2 = t;
+               std::swap(x1, x2);
+               std::swap(y1, y2);
                flip = !flip;
                }
 
@@ -1201,16 +1238,29 @@ void pixbuf_draw_line(GdkPixbuf *pb,
                      guint8 r, guint8 g, guint8 b, guint8 a)
 {
        gboolean has_alpha;
-       gint pw, ph, prs;
-       gint rx, ry, rw, rh;
-       gdouble rx1, ry1, rx2, ry2;
+       gint pw;
+       gint ph;
+       gint prs;
+       gint rx;
+       gint ry;
+       gint rw;
+       gint rh;
+       gdouble rx1;
+       gdouble ry1;
+       gdouble rx2;
+       gdouble ry2;
        guchar *p_pix;
        guchar *pp;
        gint p_step;
        gdouble slope;
-       gdouble x, y;
-       gint px, py;
-       gint cx1, cy1, cx2, cy2;
+       gdouble x;
+       gdouble y;
+       gint px;
+       gint py;
+       gint cx1;
+       gint cy1;
+       gint cx2;
+       gint cy2;
 
        if (!pb) return;
 
@@ -1239,9 +1289,8 @@ void pixbuf_draw_line(GdkPixbuf *pb,
                {
                if (rx1 > rx2)
                        {
-                       gdouble t;
-                       t = rx1; rx1 = rx2; rx2 = t;
-                       t = ry1; ry1 = ry2; ry2 = t;
+                       std::swap(rx1, rx2);
+                       std::swap(ry1, ry2);
                        }
 
                slope = rx2 - rx1;
@@ -1266,9 +1315,8 @@ void pixbuf_draw_line(GdkPixbuf *pb,
                {
                if (ry1 > ry2)
                        {
-                       gdouble t;
-                       t = rx1; rx1 = rx2; rx2 = t;
-                       t = ry1; ry1 = ry2; ry2 = t;
+                       std::swap(rx1, rx2);
+                       std::swap(ry1, ry2);
                        }
 
                slope = ry2 - ry1;
@@ -1305,7 +1353,8 @@ static void pixbuf_draw_fade_linear(guchar *p_pix, gint prs, gboolean has_alpha,
        guchar *pp;
        gint p_step;
        guint8 n = a;
-       gint i, j;
+       gint i;
+       gint j;
 
        p_step = (has_alpha) ? 4 : 3;
        for (j = y1; j < y2; j++)
@@ -1315,13 +1364,10 @@ static void pixbuf_draw_fade_linear(guchar *p_pix, gint prs, gboolean has_alpha,
                for (i = x1; i < x2; i++)
                        {
                        if (vertical) n = a - a * abs(i - s) / border;
-                       *pp = (r * n + *pp * (256-n)) >> 8;
-                       pp++;
-                       *pp = (g * n + *pp * (256-n)) >> 8;
-                       pp++;
-                       *pp = (b * n + *pp * (256-n)) >> 8;
-                       pp++;
-                       if (has_alpha) pp++;
+                       pp[0] = (r * n + pp[0] * (256-n)) >> 8;
+                       pp[1] = (g * n + pp[1] * (256-n)) >> 8;
+                       pp[2] = (b * n + pp[2] * (256-n)) >> 8;
+                       pp += p_step;
                        }
                }
 }
@@ -1333,7 +1379,8 @@ static void pixbuf_draw_fade_radius(guchar *p_pix, gint prs, gboolean has_alpha,
 {
        guchar *pp;
        gint p_step;
-       gint i, j;
+       gint i;
+       gint j;
 
        p_step = (has_alpha) ? 4 : 3;
        for (j = y1; j < y2; j++)
@@ -1346,13 +1393,10 @@ static void pixbuf_draw_fade_radius(guchar *p_pix, gint prs, gboolean has_alpha,
 
                        r = MIN(border, (gint)hypot(i - sx, j - sy));
                        n = a - a * r / border;
-                       *pp = (r * n + *pp * (256-n)) >> 8;
-                       pp++;
-                       *pp = (g * n + *pp * (256-n)) >> 8;
-                       pp++;
-                       *pp = (b * n + *pp * (256-n)) >> 8;
-                       pp++;
-                       if (has_alpha) pp++;
+                       pp[0] = (r * n + pp[0] * (256-n)) >> 8;
+                       pp[1] = (g * n + pp[1] * (256-n)) >> 8;
+                       pp[2] = (b * n + pp[2] * (256-n)) >> 8;
+                       pp += p_step;
                        }
                }
 }
@@ -1363,9 +1407,17 @@ void pixbuf_draw_shadow(GdkPixbuf *pb,
                        guint8 r, guint8 g, guint8 b, guint8 a)
 {
        gint has_alpha;
-       gint pw, ph, prs;
-       gint rx, ry, rw, rh;
-       gint fx, fy, fw, fh;
+       gint pw;
+       gint ph;
+       gint prs;
+       gint rx;
+       gint ry;
+       gint rw;
+       gint rh;
+       gint fx;
+       gint fy;
+       gint fw;
+       gint fh;
        guchar *p_pix;
 
        if (!pb) return;
@@ -1475,10 +1527,13 @@ void pixbuf_desaturate_rect(GdkPixbuf *pb,
                            gint x, gint y, gint w, gint h)
 {
        gboolean has_alpha;
-       gint pw, ph, prs;
+       gint pw;
+       gint ph;
+       gint prs;
        guchar *p_pix;
        guchar *pp;
-       gint i, j;
+       gint i;
+       gint j;
 
        if (!pb) return;
 
@@ -1492,21 +1547,20 @@ void pixbuf_desaturate_rect(GdkPixbuf *pb,
        prs = gdk_pixbuf_get_rowstride(pb);
        p_pix = gdk_pixbuf_get_pixels(pb);
 
+       const gint p_step = has_alpha ? 4 : 3;
+
        for (i = 0; i < h; i++)
                {
-               pp = p_pix + (y + i) * prs + (x * (has_alpha ? 4 : 3));
+               pp = p_pix + (y + i) * prs + (x * p_step);
                for (j = 0; j < w; j++)
                        {
                        guint8 grey;
 
                        grey = (pp[0] + pp[1] + pp[2]) / 3;
-                       *pp = grey;
-                       pp++;
-                       *pp = grey;
-                       pp++;
-                       *pp = grey;
-                       pp++;
-                       if (has_alpha) pp++;
+                       pp[0] = grey;
+                       pp[1] = grey;
+                       pp[2] = grey;
+                       pp += p_step;
                        }
                }
 }
@@ -1518,10 +1572,13 @@ void pixbuf_desaturate_rect(GdkPixbuf *pb,
 void pixbuf_highlight_overunderexposed(GdkPixbuf *pb, gint x, gint y, gint w, gint h)
 {
        gboolean has_alpha;
-       gint pw, ph, prs;
+       gint pw;
+       gint ph;
+       gint prs;
        guchar *p_pix;
        guchar *pp;
-       gint i, j;
+       gint i;
+       gint j;
 
        if (!pb) return;
 
@@ -1535,26 +1592,20 @@ void pixbuf_highlight_overunderexposed(GdkPixbuf *pb, gint x, gint y, gint w, gi
        prs = gdk_pixbuf_get_rowstride(pb);
        p_pix = gdk_pixbuf_get_pixels(pb);
 
+       const gint p_step = has_alpha ? 4 : 3;
+
        for (i = 0; i < h; i++)
                {
-               pp = p_pix + (y + i) * prs + (x * (has_alpha ? 4 : 3));
+               pp = p_pix + (y + i) * prs + (x * p_step);
                for (j = 0; j < w; j++)
                        {
                        if (pp[0] == 255 || pp[1] == 255 || pp[2] == 255 || pp[0] == 0 || pp[1] == 0 || pp[2] == 0)
                                {
-                               *pp = 255;
-                               pp++;
-                               *pp = 0;
-                               pp++;
-                               *pp = 0;
-                               pp++;
-                               if (has_alpha) pp++;
-                               }
-                       else
-                               {
-                               pp = pp + 3;
-                               if (has_alpha) pp++;
+                               pp[0] = 255;
+                               pp[1] = 0;
+                               pp[2] = 0;
                                }
+                       pp += p_step;
                        }
                }
 }
@@ -1568,10 +1619,13 @@ void pixbuf_ignore_alpha_rect(GdkPixbuf *pb,
                  gint x, gint y, gint w, gint h)
 {
    gboolean has_alpha;
-   gint pw, ph, prs;
+   gint pw;
+   gint ph;
+   gint prs;
    guchar *p_pix;
    guchar *pp;
-   gint i, j;
+   gint i;
+   gint j;
 
    if (!pb) return;