Filter: use direct float cast instead of i2f helper

_i2f is a compatibility shim for `(float)` for pre-2015 versions of GCC
(added in 2017 in ef1df61).

Compilers can presumably optimize `(float)` better than an inline function call.

The helper is then unused and removed.

Author: akx

src/libImaging/Filter.c

@@ -113,20 +113,18 @@ kernel_i16(int size, UINT8 *in0, int x, const float *kernel, int bigendian) {
     int half_size = (size - 1) / 2;
     for (i = 0; i < size; i++) {
         int x1 = x + i - half_size;
-        result += _i2f(
-                      in0[x1 * 2 + (bigendian ? 1 : 0)] +
-                      (in0[x1 * 2 + (bigendian ? 0 : 1)] >> 8)
-                  ) *
+        result += (float)(in0[x1 * 2 + (bigendian ? 1 : 0)] +
+                          (in0[x1 * 2 + (bigendian ? 0 : 1)] >> 8)) *
                   kernel[i];
     }
     return result;
 }
 
 static void
 ImagingFilter3x3(Imaging imOut, Imaging im, const float *kernel, float offset) {
-#define KERNEL1x3(in0, x, kernel, d)                               \
-    (_i2f(in0[x - d]) * (kernel)[0] + _i2f(in0[x]) * (kernel)[1] + \
-     _i2f(in0[x + d]) * (kernel)[2])
+#define KERNEL1x3(in0, x, kernel, d)                                     \
+    ((float)(in0[x - d]) * (kernel)[0] + (float)(in0[x]) * (kernel)[1] + \
+     (float)(in0[x + d]) * (kernel)[2])
 
     int x = 0, y = 0;
     // restrict safety: assert im and imOut to be separate,
@@ -275,10 +273,10 @@ ImagingFilter3x3(Imaging imOut, Imaging im, const float *kernel, float offset) {
 
 static void
 ImagingFilter5x5(Imaging imOut, Imaging im, const float *kernel, float offset) {
-#define KERNEL1x5(in0, x, kernel, d)                                       \
-    (_i2f(in0[x - d - d]) * (kernel)[0] + _i2f(in0[x - d]) * (kernel)[1] + \
-     _i2f(in0[x]) * (kernel)[2] + _i2f(in0[x + d]) * (kernel)[3] +         \
-     _i2f(in0[x + d + d]) * (kernel)[4])
+#define KERNEL1x5(in0, x, kernel, d)                                             \
+    ((float)(in0[x - d - d]) * (kernel)[0] + (float)(in0[x - d]) * (kernel)[1] + \
+     (float)(in0[x]) * (kernel)[2] + (float)(in0[x + d]) * (kernel)[3] +         \
+     (float)(in0[x + d + d]) * (kernel)[4])
 
     int x = 0, y = 0;
 

src/libImaging/ImagingUtils.h

@@ -28,17 +28,3 @@
 #define CLIP8(v) ((v) <= 0 ? 0 : (v) < 256 ? (v) : 255)
 
 #define CLIP16(v) ((v) <= 0 ? 0 : (v) < 65536 ? (v) : 65535)
-
-/* This is to work around a bug in GCC prior 4.9 in 64 bit mode.
-   GCC generates code with partial dependency which is 3 times slower.
-   See: https://stackoverflow.com/a/26588074/253146 */
-#if defined(__x86_64__) && defined(__SSE__) && !defined(__NO_INLINE__) && \
-    !defined(__clang__) && defined(GCC_VERSION) && (GCC_VERSION < 40900)
-static float __attribute__((always_inline)) inline _i2f(int v) {
-    float x;
-    __asm__("xorps %0, %0; cvtsi2ss %1, %0" : "=x"(x) : "r"(v));
-    return x;
-}
-#else
-static float inline _i2f(int v) { return (float)v; }
-#endif