Improve blur algorithm.

3 files changed, 129 insertions, 85 deletions

diff --git a/include/xcb.h b/include/xcb.h
index a2217ced..77962e51 100644
--- a/include/xcb.h
+++ b/include/xcb.h
@@ -194,5 +194,5 @@ extern WindowManagerQuirk current_window_manager;
  * @returns NULL if window was not found, or unmapped, otherwise returns a cairo_surface.
  */
 cairo_surface_t *x11_helper_get_screenshot_surface_window ( xcb_window_t window, int size );
-void cairo_image_surface_blur(cairo_surface_t* surface, unsigned int radius);
+void cairo_image_surface_blur(cairo_surface_t* surface, double radius, double deviation);
 #endif
diff --git a/source/view.c b/source/view.c
index 4e4abb4e..1006a217 100644
--- a/source/view.c
+++ b/source/view.c
@@ -678,6 +678,7 @@ static void filter_elements ( thread_state *ts, G_GNUC_UNUSED gpointer user_data
         g_mutex_unlock ( t->mutex );
     }
 }
+
 static void rofi_view_setup_fake_transparency ( widget *win, const char* const fake_background )
 {
     if ( CacheState.fake_bg == NULL ) {
@@ -726,7 +727,7 @@ static void rofi_view_setup_fake_transparency ( widget *win, const char* const f
                 cairo_destroy ( dr );
                 cairo_surface_destroy ( s );
                 if ( blur > 0 ){
-                    cairo_image_surface_blur( CacheState.fake_bg, (double)blur );
+                    cairo_image_surface_blur( CacheState.fake_bg, (double)blur, 0 );
                     TICK_N("BLUR");
                 }
             }
diff --git a/source/xcb.c b/source/xcb.c
index a3c3197a..a2ebefb4 100644
--- a/source/xcb.c
+++ b/source/xcb.c
@@ -38,7 +38,7 @@
 #include <glib.h>
 #include <cairo.h>
 #include <cairo-xcb.h>
-
+#include <math.h>
 #include <xcb/xcb.h>
 #include <xcb/xcb_aux.h>
 #include <xcb/randr.h>
@@ -113,101 +113,144 @@ static xcb_visualtype_t * lookup_visual ( xcb_screen_t   *s, xcb_visualid_t visu
     return 0;
 }
 
-typedef union {
-    uint32_t value;
-    struct {
-        uint8_t a,b,c,d;
-    }vals;
-} Pixel __attribute__((packed));
+/* This blur function was originally created my MacSlow and published on his website:
+ * http://macslow.thepimp.net. I'm not entirely sure he's proud of it, but it has
+ * proved immeasurably useful for me. */
 
-typedef struct {
-        uint32_t a,b,c,d;
-} Filter __attribute__((packed));
+static uint32_t* create_kernel(double radius, double deviation, uint32_t *sum2) {
+	int size = 2 * (int)(radius) + 1;
+	uint32_t* kernel = (uint32_t*)(g_malloc(sizeof(uint32_t) * (size + 1)));
+	double radiusf = fabs(radius) + 1.0;
+	double value = -radius;
+	double sum = 0.0;
+	int i;
 
-void cairo_image_surface_blur(cairo_surface_t* surface, unsigned int radius)
-{
-    // Currently we only support argb32
-    if ( cairo_image_surface_get_format ( surface ) != CAIRO_FORMAT_ARGB32 ) {
-        g_warning("Invalid format for blurring.");
-        return;
+    if(deviation == 0.0) {
+        deviation = sqrt( -(radiusf * radiusf) / (2.0 * log(1.0 / 255.0)));
     }
-    // Steve Hanov, 2009
-    // Tweaks by Dave Davenport.
-    // Released into the public domain.
 
-    // get width, height
-    const uint_fast32_t stride = cairo_image_surface_get_stride(surface);
-    if ( stride%4 != 0 ) {
-        g_warning("Stride is not multiple of 4: %lu", stride%4);
-        return;
-    }
-    const uint_fast32_t width  = stride/4;
-    const uint_fast32_t height = cairo_image_surface_get_height(surface);
-    const double mul           = 1.0 / (double)(4.0*radius*radius);
-    Filter* precalc            = (Filter*)g_malloc_n(stride*height,sizeof(Filter));
-    Pixel * src                = (Pixel *)cairo_image_surface_get_data(surface);
-
-    // The number of times to perform the averaging. According to wikipedia,
-    // three iterations is good enough to pass for a gaussian.
-    const uint_fast32_t MAX_ITERATIONS = 3;
-
-    const uint_fast32_t wr1 = width-radius-1;
-    const uint_fast32_t hr1 = height-radius-1;
-    for (uint_fast32_t iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-        Pixel *pixel = (Pixel *)src;
-        Filter *filter = (Filter*)precalc;
-        for (uint_fast32_t y = 0; y < height; y++) {
-            for (uint_fast32_t x = 0; x < width; x++) {
-                Pixel t = pixel[0];
-                filter->a = t.vals.a;
-                filter->b = t.vals.b;
-                filter->c = t.vals.c;
-                filter->d = t.vals.d;
-                if (x!=0) {
-                    filter->a += filter[-1].a;
-                    filter->b += filter[-1].b;
-                    filter->c += filter[-1].c;
-                    filter->d += filter[-1].d;
-                }
-                if (y!=0) {
-                    filter->a += filter[-width].a;
-                    filter->b += filter[-width].b;
-                    filter->c += filter[-width].c;
-                    filter->d += filter[-width].d;
-                }
-                if (x!=0 && y!=0) {
-                    filter->a -= filter[-width-1].a;
-                    filter->b -= filter[-width-1].b;
-                    filter->c -= filter[-width-1].c;
-                    filter->d -= filter[-width-1].d;
+	kernel[0] = size;
+
+	for(i = 0; i < size; i++) {
+        kernel[1 + i] = INT16_MAX / (2.506628275 * deviation) * exp(-((value * value) / (2.0 * (deviation * deviation)))) ;
+
+		sum += kernel[1 + i];
+		value += 1.0;
+	}
+
+    *sum2 = sum;
+
+	return kernel;
+}
+
+void cairo_image_surface_blur(cairo_surface_t* surface, double radius, double deviation)
+{
+    uint32_t* horzBlur;
+    uint32_t * kernel = 0;
+    cairo_format_t format;
+    unsigned int channels;
+
+    if(cairo_surface_status(surface)) return ;
+
+    uint8_t *data = cairo_image_surface_get_data(surface);
+    format = cairo_image_surface_get_format(surface);
+    const int width = cairo_image_surface_get_width(surface);
+    const int height = cairo_image_surface_get_height(surface);
+    const int stride = cairo_image_surface_get_stride(surface);
+
+    if(format == CAIRO_FORMAT_ARGB32) channels = 4;
+    else return ;
+
+    horzBlur = (uint32_t*)(g_malloc(sizeof(uint32_t) * height * stride));
+    TICK();
+    uint32_t sum = 0;
+    kernel = create_kernel(radius, deviation, &sum);
+    TICK_N("BLUR: kernel");
+
+    /* Horizontal pass. */
+    uint32_t *horzBlur_ptr = horzBlur;
+    for(int iY = 0; iY < height; iY++) {
+        const int iYs = iY*stride;
+        for(int iX = 0; iX < width; iX++) {
+            uint32_t red = 0;
+            uint32_t green = 0;
+            uint32_t blue = 0;
+            uint32_t alpha = 0;
+            int offset = (int)(kernel[0]) / -2;
+
+            for(int i = 0; i < (int)(kernel[0]); i++) {
+                int x = iX + offset;
+
+                if(x < 0 || x >= width){
+                    offset++;
+                    continue;
                 }
-                filter++ ;
-                pixel++;
+
+                uint8_t *dataPtr = &data[iYs + x * channels];
+                const uint32_t kernip1 = kernel[i + 1];
+
+                blue  += kernip1 * dataPtr[0];
+                green += kernip1 * dataPtr[1];
+                red   += kernip1 * dataPtr[2];
+                alpha += kernip1 * dataPtr[3];
+                offset++;
             }
+
+
+            *horzBlur_ptr++ = blue/sum;
+            *horzBlur_ptr++ = green/sum;
+            *horzBlur_ptr++ = red/sum;
+            *horzBlur_ptr++ = alpha/sum;
         }
-        pixel = (Pixel *)src;
-        for (uint_fast32_t y = 0; y < (height); y++) {
-            const uint_fast32_t index = width*y;
-            const uint_fast32_t t = (y < radius)? 0: width*(y - radius);
-            const uint_fast32_t b = (y > hr1)? (height-1)*width: (y + radius)*width;
-            for (uint_fast32_t x = 0; x < (width ); x++) {
-                const uint_fast32_t  l = (x < radius)? 0:(x - radius);
-                const uint_fast32_t  r = (x > wr1)? (width-1):(x + radius);
-                int tota = precalc[r+b].a + precalc[l+t].a- precalc[l+b].a - precalc[r+t].a;
-                int totb = precalc[r+b].b + precalc[l+t].b- precalc[l+b].b - precalc[r+t].b;
-                int totc = precalc[r+b].c + precalc[l+t].c- precalc[l+b].c - precalc[r+t].c;
-                int totd = precalc[r+b].d + precalc[l+t].d- precalc[l+b].d - precalc[r+t].d;
-                pixel[index+x].vals.a = (uint8_t)(tota*mul);
-                pixel[index+x].vals.b = (uint8_t)(totb*mul);
-                pixel[index+x].vals.c = (uint8_t)(totc*mul);
-                pixel[index+x].vals.d = (uint8_t)(totd*mul);
+    }
+    TICK_N("BLUR: hori");
+
+    /* Vertical pass. */
+    for(int iY = 0; iY < height; iY++) {
+        for(int iX = 0; iX < width; iX++) {
+            uint32_t red = 0;
+            uint32_t green = 0;
+            uint32_t blue = 0;
+            uint32_t alpha = 0;
+            int offset = (int)(kernel[0]) / -2;
+
+            const int iXs = iX*channels;
+            for(int i = 0; i < (int)(kernel[0]); i++) {
+                int y = iY + offset;
+
+                if(y < 0 || y >= height) {
+                    offset++;
+                    continue;
+                }
+
+                uint32_t *dataPtr = &horzBlur[y * stride + iXs];
+                const uint32_t kernip1 = kernel[i + 1];
+
+                blue  += kernip1 * dataPtr[0];
+                green += kernip1 * dataPtr[1];
+                red   += kernip1 * dataPtr[2];
+                alpha += kernip1 * dataPtr[3];
+
+                offset++;
             }
+
+
+            *data++ = blue/sum;
+            *data++ = green/sum;
+            *data++ = red/sum;
+            *data++ = alpha/sum;
         }
     }
+    TICK_N("BLUR: vert");
 
-    g_free(precalc);
+    free(kernel);
+    free(horzBlur);
+
+    return ;
 }
 
+
+
 cairo_surface_t *x11_helper_get_screenshot_surface_window ( xcb_window_t window, int size )
 {
     xcb_get_geometry_cookie_t cookie;