Merged changes in the trunk up to revision 52118.

Conflicts resolved:
source/blender/makesrna/intern/rna_scene.c

12 files changed, 461 insertions, 22 deletions

diff --git a/source/blender/blenlib/BLI_math.h b/source/blender/blenlib/BLI_math.h
index 89c37daae84..db2fed433da 100644
--- a/source/blender/blenlib/BLI_math.h
+++ b/source/blender/blenlib/BLI_math.h
@@ -58,6 +58,7 @@
 #include "BLI_math_rotation.h"
 #include "BLI_math_vector.h"
 #include "BLI_math_geom.h"
+#include "BLI_math_interp.h"
 
 #endif /* __BLI_MATH_H__ */
 
diff --git a/source/blender/blenlib/BLI_math_interp.h b/source/blender/blenlib/BLI_math_interp.h
new file mode 100644
index 00000000000..21975763779
--- /dev/null
+++ b/source/blender/blenlib/BLI_math_interp.h
@@ -0,0 +1,44 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2012 by Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+#ifndef BLI_MATH_INTERP
+#define BLI_MATH_INTERP
+
+void BLI_bicubic_interpolation_fl(const float *buffer, float *output, int width, int height,
+                                  int components, float u, float v);
+
+void BLI_bicubic_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height,
+                                    int components, float u, float v);
+
+void BLI_bilinear_interpolation_fl(const float *buffer, float *output, int width, int height,
+                                   int components, float u, float v);
+
+void BLI_bilinear_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height,
+                                     int components, float u, float v);
+
+#endif
diff --git a/source/blender/blenlib/BLI_math_matrix.h b/source/blender/blenlib/BLI_math_matrix.h
index 0783a7981ea..f51bd1cf840 100644
--- a/source/blender/blenlib/BLI_math_matrix.h
+++ b/source/blender/blenlib/BLI_math_matrix.h
@@ -36,14 +36,18 @@ extern "C" {
 
 /********************************* Init **************************************/
 
-#define MAT4_UNITY {{ 1.0, 0.0, 0.0, 0.0}, \
-					{ 0.0, 1.0, 0.0, 0.0}, \
-					{ 0.0, 0.0, 1.0, 0.0}, \
-					{ 0.0, 0.0, 0.0, 1.0}}
-
-#define MAT3_UNITY {{ 1.0, 0.0, 0.0}, \
-					{ 0.0, 1.0, 0.0}, \
-					{ 0.0, 0.0, 1.0}}
+#define MAT4_UNITY  {      \
+	{ 1.0, 0.0, 0.0, 0.0}, \
+	{ 0.0, 1.0, 0.0, 0.0}, \
+	{ 0.0, 0.0, 1.0, 0.0}, \
+	{ 0.0, 0.0, 0.0, 1.0}  \
+}
+
+#define MAT3_UNITY  { \
+	{ 1.0, 0.0, 0.0}, \
+	{ 0.0, 1.0, 0.0}, \
+	{ 0.0, 0.0, 1.0}  \
+}
 
 void zero_m3(float R[3][3]);
 void zero_m4(float R[4][4]);
diff --git a/source/blender/blenlib/BLI_pbvh.h b/source/blender/blenlib/BLI_pbvh.h
index 9483d068bb9..59ecdb359c9 100644
--- a/source/blender/blenlib/BLI_pbvh.h
+++ b/source/blender/blenlib/BLI_pbvh.h
@@ -153,7 +153,8 @@ void BLI_pbvh_update(PBVH *bvh, int flags, float (*face_nors)[3]);
 void BLI_pbvh_redraw_BB(PBVH * bvh, float bb_min[3], float bb_max[3]);
 void BLI_pbvh_get_grid_updates(PBVH *bvh, int clear, void ***gridfaces, int *totface);
 void BLI_pbvh_grids_update(PBVH *bvh, struct CCGElem **grid_elems,
-                           struct DMGridAdjacency *gridadj, void **gridfaces);
+                           struct DMGridAdjacency *gridadj, void **gridfaces,
+                           struct DMFlagMat *flagmats, unsigned int **grid_hidden);
 
 /* vertex deformer */
 float (*BLI_pbvh_get_vertCos(struct PBVH *pbvh))[3];
diff --git a/source/blender/blenlib/BLI_string_utf8.h b/source/blender/blenlib/BLI_string_utf8.h
index 73f138a750d..ecbc4cb1cd4 100644
--- a/source/blender/blenlib/BLI_string_utf8.h
+++ b/source/blender/blenlib/BLI_string_utf8.h
@@ -37,6 +37,7 @@ int          BLI_utf8_invalid_byte(const char *str, int length);
 int          BLI_utf8_invalid_strip(char *str, int length);
 
 int          BLI_str_utf8_size(const char *p); /* warning, can return -1 on bad chars */
+int          BLI_str_utf8_size_safe(const char *p);
 /* copied from glib */
 unsigned int BLI_str_utf8_as_unicode(const char *p);
 unsigned int BLI_str_utf8_as_unicode_and_size(const char *__restrict p, size_t *__restrict index);
diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt
index 3aa0ffc3eaa..cd3a934d816 100644
--- a/source/blender/blenlib/CMakeLists.txt
+++ b/source/blender/blenlib/CMakeLists.txt
@@ -71,6 +71,7 @@ set(SRC
 	intern/math_color_inline.c
 	intern/math_geom.c
 	intern/math_geom_inline.c
+	intern/math_interp.c
 	intern/math_matrix.c
 	intern/math_rotation.c
 	intern/math_vector.c
diff --git a/source/blender/blenlib/PIL_time.h b/source/blender/blenlib/PIL_time.h
index b8f895c5c82..c3e7e8486d9 100644
--- a/source/blender/blenlib/PIL_time.h
+++ b/source/blender/blenlib/PIL_time.h
@@ -20,7 +20,7 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Campbell Barton
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -76,6 +76,17 @@ void    PIL_sleep_ms(int ms);
 	fflush(stdout);                                                           \
 } (void)0
 
+/**
+ * Given some function/expression:
+ *   TIMEIT_BENCH(some_function(), some_unique_description);
+ */
+#define TIMEIT_BENCH(expr, id)                                                \
+	{                                                                         \
+		TIMEIT_START(id);                                                     \
+		(expr);                                                               \
+		TIMEIT_END(id);                                                       \
+	} (void)0
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/blenlib/intern/math_color_inline.c b/source/blender/blenlib/intern/math_color_inline.c
index f520b2318e5..4c8bd43ef73 100644
--- a/source/blender/blenlib/intern/math_color_inline.c
+++ b/source/blender/blenlib/intern/math_color_inline.c
@@ -164,7 +164,11 @@ MINLINE void linearrgb_to_srgb_ushort4_predivide(unsigned short srgb[4], const f
 
 	for (i = 0; i < 3; ++i) {
 		t = linear[i] * inv_alpha;
-		srgb[i] = (t < 1.0f) ? (unsigned short) (to_srgb_table_lookup(t) * alpha) : FTOUSHORT(linearrgb_to_srgb(t) * alpha);
+		srgb[i] = (t <= 1.0f) ?
+		          /* warning - converts: float -> short -> float -> short */
+		          (unsigned short) (to_srgb_table_lookup(t) * alpha) :
+		          /* if FTOUSHORT was an inline function this could be done less confusingly */
+		          ((t = linearrgb_to_srgb(t) * alpha), FTOUSHORT(t));
 	}
 
 	srgb[3] = FTOUSHORT(linear[3]);
diff --git a/source/blender/blenlib/intern/math_interp.c b/source/blender/blenlib/intern/math_interp.c
new file mode 100644
index 00000000000..59a1c1f649c
--- /dev/null
+++ b/source/blender/blenlib/intern/math_interp.c
@@ -0,0 +1,351 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2012 by Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Sergey Sharybin
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ */
+
+#include <math.h>
+
+#include "BLI_math.h"
+
+/**************************************************************************
+ *                            INTERPOLATIONS
+ *
+ * Reference and docs:
+ * http://wiki.blender.org/index.php/User:Damiles#Interpolations_Algorithms
+ ***************************************************************************/
+
+/* BICUBIC Interpolation functions
+ *  More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
+ * function assumes out to be zero'ed, only does RGBA */
+
+static float P(float k)
+{
+	float p1, p2, p3, p4;
+	p1 = MAX2(k + 2.0f, 0);
+	p2 = MAX2(k + 1.0f, 0);
+	p3 = MAX2(k, 0);
+	p4 = MAX2(k - 1.0f, 0);
+	return (float)(1.0f / 6.0f) * (p1 * p1 * p1 - 4.0f * p2 * p2 * p2 + 6.0f * p3 * p3 * p3 - 4.0f * p4 * p4 * p4);
+}
+
+
+#if 0
+/* older, slower function, works the same as above */
+static float P(float k)
+{
+	return (float)(1.0f / 6.0f) * (pow(MAX2(k + 2.0f, 0), 3.0f) - 4.0f * pow(MAX2(k + 1.0f, 0), 3.0f) + 6.0f * pow(MAX2(k, 0), 3.0f) - 4.0f * pow(MAX2(k - 1.0f, 0), 3.0f));
+}
+#endif
+
+static void vector_from_float(const float *data, float vector[4], int components)
+{
+	if (components == 1) {
+		vector[0] = data[0];
+	}
+	else if (components == 3) {
+		copy_v3_v3(vector, data);
+	}
+	else {
+		copy_v4_v4(vector, data);
+	}
+}
+
+static void vector_from_byte(const unsigned char *data, float vector[4], int components)
+{
+	if (components == 1) {
+		vector[0] = data[0];
+	}
+	else if (components == 3) {
+		vector[0] = data[0];
+		vector[1] = data[1];
+		vector[2] = data[2];
+	}
+	else {
+		vector[0] = data[0];
+		vector[1] = data[1];
+		vector[2] = data[2];
+		vector[3] = data[3];
+	}
+}
+
+/* BICUBIC INTERPOLATION */
+BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer, const float *float_buffer,
+                                      unsigned char *byte_output, float *float_output, int width, int height,
+                                      int components, float u, float v)
+{
+	int i, j, n, m, x1, y1;
+	float a, b, w, wx, wy[4], out[4];
+
+	/* sample area entirely outside image? */
+	if (ceil(u) < 0 || floor(u) > width - 1 || ceil(v) < 0 || floor(v) > height - 1) {
+		return;
+	}
+
+	i = (int)floor(u);
+	j = (int)floor(v);
+	a = u - i;
+	b = v - j;
+
+	zero_v4(out);
+
+/* Optimized and not so easy to read */
+
+	/* avoid calling multiple times */
+	wy[0] = P(b - (-1));
+	wy[1] = P(b -  0);
+	wy[2] = P(b -  1);
+	wy[3] = P(b -  2);
+
+	for (n = -1; n <= 2; n++) {
+		x1 = i + n;
+		CLAMP(x1, 0, width - 1);
+		wx = P(n - a);
+		for (m = -1; m <= 2; m++) {
+			float data[4];
+
+			y1 = j + m;
+			CLAMP(y1, 0, height - 1);
+			/* normally we could do this */
+			/* w = P(n-a) * P(b-m); */
+			/* except that would call P() 16 times per pixel therefor pow() 64 times, better precalc these */
+			w = wx * wy[m + 1];
+
+			if (float_output) {
+				const float *float_data = float_buffer + width * y1 * 4 + 4 * x1;
+
+				vector_from_float(float_data, data, components);
+			}
+			else {
+				const unsigned char *byte_data = byte_buffer + width * y1 * 4 + 4 * x1;
+
+				vector_from_byte(byte_data, data, components);
+			}
+
+			if (components == 1) {
+				out[0] += data[0] * w;
+			}
+			else if (components == 3) {
+				out[0] += data[0] * w;
+				out[1] += data[1] * w;
+				out[2] += data[2] * w;
+			}
+			else {
+				out[0] += data[0] * w;
+				out[1] += data[1] * w;
+				out[2] += data[2] * w;
+				out[3] += data[3] * w;
+			}
+		}
+	}
+
+/* Done with optimized part */
+
+#if 0
+	/* older, slower function, works the same as above */
+	for (n = -1; n <= 2; n++) {
+		for (m = -1; m <= 2; m++) {
+			x1 = i + n;
+			y1 = j + m;
+			if (x1 > 0 && x1 < width && y1 > 0 && y1 < height) {
+				float data[4];
+
+				if (float_output) {
+					const float *float_data = float_buffer + width * y1 * 4 + 4 * x1;
+
+					vector_from_float(float_data, data, components);
+				}
+				else {
+					const unsigned char *byte_data = byte_buffer + width * y1 * 4 + 4 * x1;
+
+					vector_from_byte(byte_data, data, components);
+				}
+
+				if (components == 1) {
+					out[0] += data[0] * P(n - a) * P(b - m);
+				}
+				else if (components == 3) {
+					out[0] += data[0] * P(n - a) * P(b - m);
+					out[1] += data[1] * P(n - a) * P(b - m);
+					out[2] += data[2] * P(n - a) * P(b - m);
+				}
+				else {
+					out[0] += data[0] * P(n - a) * P(b - m);
+					out[1] += data[1] * P(n - a) * P(b - m);
+					out[2] += data[2] * P(n - a) * P(b - m);
+					out[3] += data[3] * P(n - a) * P(b - m);
+				}
+			}
+		}
+	}
+#endif
+
+	if (float_output) {
+		if (components == 1) {
+			float_output[0] = out[0];
+		}
+		else if (components == 3) {
+			copy_v3_v3(float_output, out);
+		}
+		else {
+			copy_v4_v4(float_output, out);
+		}
+	}
+	else {
+		if (components == 1) {
+			byte_output[0] = out[0];
+		}
+		else if (components == 3) {
+			byte_output[0] = out[0];
+			byte_output[1] = out[1];
+			byte_output[2] = out[2];
+		}
+		else {
+			byte_output[0] = out[0];
+			byte_output[1] = out[1];
+			byte_output[2] = out[2];
+			byte_output[3] = out[3];
+		}
+	}
+}
+
+void BLI_bicubic_interpolation_fl(const float *buffer, float *output, int width, int height,
+                                  int components, float u, float v)
+{
+	bicubic_interpolation(NULL, buffer, NULL, output, width, height, components, u, v);
+}
+
+void BLI_bicubic_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height,
+                                    int components, float u, float v)
+{
+	bicubic_interpolation(buffer, NULL, output, NULL, width, height, components, u, v);
+}
+
+/* BILINEAR INTERPOLATION */
+BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const float *float_buffer,
+                                       unsigned char *byte_output, float *float_output, int width, int height,
+                                       int components, float u, float v)
+{
+	float a, b;
+	float a_b, ma_b, a_mb, ma_mb;
+	int y1, y2, x1, x2;
+
+	/* ImBuf in must have a valid rect or rect_float, assume this is already checked */
+
+	x1 = (int)floor(u);
+	x2 = (int)ceil(u);
+	y1 = (int)floor(v);
+	y2 = (int)ceil(v);
+
+	/* sample area entirely outside image? */
+	if (x2 < 0 || x1 > width - 1 || y2 < 0 || y1 > height - 1) {
+		return;
+	}
+
+	if (float_output) {
+		const float *row1, *row2, *row3, *row4;
+		float empty[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+
+		/* sample including outside of edges of image */
+		if (x1 < 0 || y1 < 0) row1 = empty;
+		else row1 = float_buffer + width * y1 * 4 + 4 * x1;
+
+		if (x1 < 0 || y2 > height - 1) row2 = empty;
+		else row2 = float_buffer + width * y2 * 4 + 4 * x1;
+
+		if (x2 > width - 1 || y1 < 0) row3 = empty;
+		else row3 = float_buffer + width * y1 * 4 + 4 * x2;
+
+		if (x2 > width - 1 || y2 > height - 1) row4 = empty;
+		else row4 = float_buffer + width * y2 * 4 + 4 * x2;
+
+		a = u - floorf(u);
+		b = v - floorf(v);
+		a_b = a * b; ma_b = (1.0f - a) * b; a_mb = a * (1.0f - b); ma_mb = (1.0f - a) * (1.0f - b);
+
+		if (components == 1) {
+			float_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
+		}
+		else if (components == 3) {
+			float_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
+			float_output[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
+			float_output[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
+		}
+		else {
+			float_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
+			float_output[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
+			float_output[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
+			float_output[3] = ma_mb * row1[3] + a_mb * row3[3] + ma_b * row2[3] + a_b * row4[3];
+		}
+	}
+	else {
+		const unsigned char *row1, *row2, *row3, *row4;
+		unsigned char empty[4] = {0, 0, 0, 0};
+
+		/* sample including outside of edges of image */
+		if (x1 < 0 || y1 < 0) row1 = empty;
+		else row1 = byte_buffer + width * y1 * 4 + 4 * x1;
+
+		if (x1 < 0 || y2 > height - 1) row2 = empty;
+		else row2 = byte_buffer + width * y2 * 4 + 4 * x1;
+
+		if (x2 > width - 1 || y1 < 0) row3 = empty;
+		else row3 = byte_buffer + width * y1 * 4 + 4 * x2;
+
+		if (x2 > width - 1 || y2 > height - 1) row4 = empty;
+		else row4 = byte_buffer + width * y2 * 4 + 4 * x2;
+
+		a = u - floorf(u);
+		b = v - floorf(v);
+		a_b = a * b; ma_b = (1.0f - a) * b; a_mb = a * (1.0f - b); ma_mb = (1.0f - a) * (1.0f - b);
+
+		if (components == 1) {
+			byte_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
+		}
+		else if (components == 3) {
+			byte_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
+			byte_output[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
+			byte_output[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
+		}
+		else {
+			byte_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
+			byte_output[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
+			byte_output[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
+			byte_output[3] = ma_mb * row1[3] + a_mb * row3[3] + ma_b * row2[3] + a_b * row4[3];
+		}
+	}
+}
+
+void BLI_bilinear_interpolation_fl(const float *buffer, float *output, int width, int height,
+                                   int components, float u, float v)
+{
+	bilinear_interpolation(NULL, buffer, NULL, output, width, height, components, u, v);
+}
+
+void BLI_bilinear_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height,
+                                     int components, float u, float v)
+{
+	bilinear_interpolation(buffer, NULL, output, NULL, width, height, components, u, v);
+}
diff --git a/source/blender/blenlib/intern/pbvh.c b/source/blender/blenlib/intern/pbvh.c
index 7637c60ec16..e21ce0716d2 100644
--- a/source/blender/blenlib/intern/pbvh.c
+++ b/source/blender/blenlib/intern/pbvh.c
@@ -1707,11 +1707,19 @@ void BLI_pbvh_draw(PBVH *bvh, float (*planes)[4], float (*face_nors)[3],
 	}
 }
 
-void BLI_pbvh_grids_update(PBVH *bvh, CCGElem **grids, DMGridAdjacency *gridadj, void **gridfaces)
+void BLI_pbvh_grids_update(PBVH *bvh, CCGElem **grids, DMGridAdjacency *gridadj, void **gridfaces,
+                           DMFlagMat *flagmats, BLI_bitmap *grid_hidden)
 {
+	int a;
+
 	bvh->grids = grids;
 	bvh->gridadj = gridadj;
 	bvh->gridfaces = gridfaces;
+	bvh->grid_flag_mats = flagmats;
+	bvh->grid_hidden = grid_hidden;
+
+	for (a = 0; a < bvh->totnode; ++a)
+		BLI_pbvh_node_mark_rebuild_draw(&bvh->nodes[a]);
 }
 
 float (*BLI_pbvh_get_vertCos(PBVH * pbvh))[3]
diff --git a/source/blender/blenlib/intern/string_utf8.c b/source/blender/blenlib/intern/string_utf8.c
index 0b737e0eff5..e80f96ee0fe 100644
--- a/source/blender/blenlib/intern/string_utf8.c
+++ b/source/blender/blenlib/intern/string_utf8.c
@@ -317,12 +317,12 @@ size_t BLI_strncpy_wchar_from_utf8(wchar_t *dst_w, const char *src_c, const size
 /* end wchar_t / utf8 functions  */
 /* --------------------------------------------------------------------------*/
 
-/* copied from glib's gutf8.c */
+/* copied from glib's gutf8.c, added 'Err' arg */
 
 /* note, glib uses unsigned int for unicode, best we do the same,
  * though we don't typedef it - campbell */
 
-#define UTF8_COMPUTE(Char, Mask, Len)                                         \
+#define UTF8_COMPUTE(Char, Mask, Len, Err)                                    \
 	if (Char < 128) {                                                         \
 		Len = 1;                                                              \
 		Mask = 0x7f;                                                          \
@@ -348,7 +348,7 @@ size_t BLI_strncpy_wchar_from_utf8(wchar_t *dst_w, const char *src_c, const size
 		Mask = 0x01;                                                          \
 	}                                                                         \
 	else {                                                                    \
-		Len = -1;                                                             \
+		Len = Err;  /* -1 is the typical error value or 1 to skip */          \
 	} (void)0
 
 /* same as glib define but added an 'Err' arg */
@@ -371,7 +371,20 @@ int BLI_str_utf8_size(const char *p)
 	int mask = 0, len;
 	unsigned char c = (unsigned char) *p;
 
-	UTF8_COMPUTE (c, mask, len);
+	UTF8_COMPUTE (c, mask, len, -1);
+
+	(void)mask; /* quiet warning */
+
+	return len;
+}
+
+/* use when we want to skip errors */
+int BLI_str_utf8_size_safe(const char *p)
+{
+	int mask = 0, len;
+	unsigned char c = (unsigned char) *p;
+
+	UTF8_COMPUTE (c, mask, len, 1);
 
 	(void)mask; /* quiet warning */
 
@@ -397,7 +410,7 @@ unsigned int BLI_str_utf8_as_unicode(const char *p)
 	unsigned int result;
 	unsigned char c = (unsigned char) *p;
 
-	UTF8_COMPUTE (c, mask, len);
+	UTF8_COMPUTE (c, mask, len, -1);
 	if (len == -1)
 		return BLI_UTF8_ERR;
 	UTF8_GET (result, p, i, mask, len, BLI_UTF8_ERR);
@@ -412,7 +425,7 @@ unsigned int BLI_str_utf8_as_unicode_and_size(const char *p, size_t *index)
 	unsigned int result;
 	unsigned char c = (unsigned char) *p;
 
-	UTF8_COMPUTE (c, mask, len);
+	UTF8_COMPUTE (c, mask, len, -1);
 	if (len == -1)
 		return BLI_UTF8_ERR;
 	UTF8_GET (result, p, i, mask, len, BLI_UTF8_ERR);
@@ -431,7 +444,7 @@ unsigned int BLI_str_utf8_as_unicode_step(const char *p, size_t *index)
 	p += *index;
 	c = (unsigned char) *p;
 
-	UTF8_COMPUTE (c, mask, len);
+	UTF8_COMPUTE (c, mask, len, -1);
 	if (len == -1) {
 		/* when called with NULL end, result will never be NULL,
 		 * checks for a NULL character */
diff --git a/source/blender/blenlib/intern/voronoi.c b/source/blender/blenlib/intern/voronoi.c
index 0d411038b3e..601b07c9a5d 100644
--- a/source/blender/blenlib/intern/voronoi.c
+++ b/source/blender/blenlib/intern/voronoi.c
@@ -609,9 +609,9 @@ static int voronoi_getNextSideCoord(ListBase *edges, float coord[2], int dim, in
 static void voronoi_createBoundaryEdges(ListBase *edges, int width, int height)
 {
 	const float corners[4][2] = {{width - 1, 0.0f},
-								 {width - 1, height - 1},
-								 {0.0f, height - 1},
-								 {0.0f, 0.0f}};
+	                             {width - 1, height - 1},
+	                             {0.0f, height - 1},
+	                             {0.0f, 0.0f}};
 	int i, dim = 0, dir = 1;
 
 	float coord[2] = {0.0f, 0.0f};