commit 2040285ce94949e91d4df57973ecaded59db45d2
parent 345195a3ef2cefd2f3109fbe68cac783554f88b9
Author: Pandora <Pandora@techfo.xyz>
Date: Wed, 6 Dec 2017 13:57:07 -0500
revert back to better blurring behaviour
Diffstat:
| M | blur.c | | | 159 | +++++++++++++++++++++++++++++++++++++------------------------------------------ |
| M | blur.h | | | 14 | ++++++++------ |
| M | blur_simd.c | | | 276 | ++++++++++--------------------------------------------------------------------- |
| M | configure.ac | | | 4 | +--- |
4 files changed, 119 insertions(+), 334 deletions(-)
diff --git a/blur.c b/blur.c
@@ -1,6 +1,6 @@
/*
- * Copyright © 2008 Kristian Høgsberg
- * Copyright © 2009 Chris Wilson
+ * Copyright © 2008 Kristian Høgsberg
+ * Copyright © 2009 Chris Wilson
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
@@ -23,12 +23,9 @@
#include <math.h>
#include "blur.h"
-
-#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
-
-/* Performs a simple 2D Gaussian blur of radius @radius on surface @surface. */
+/* Performs a simple 2D Gaussian blur of standard devation @sigma surface @surface. */
void
-blur_image_surface (cairo_surface_t *surface, int radius)
+blur_image_surface (cairo_surface_t *surface, int sigma)
{
cairo_surface_t *tmp;
int width, height;
@@ -63,92 +60,86 @@ blur_image_surface (cairo_surface_t *surface, int radius)
return;
src = (uint32_t*)cairo_image_surface_get_data (surface);
-
dst = (uint32_t*)cairo_image_surface_get_data (tmp);
-
-#ifdef __SSE3__
- blur_impl_ssse3(src, dst, width, height, 4.5);
-#elif __SSE2__
- blur_impl_sse2(src, dst, width, height, 4.5);
+
+ // according to a paper by Peter Kovesi [1], box filter of width w, equals to Gaussian blur of following sigma:
+ // σ_av = sqrt((w*w-1)/12)
+ // for our 7x7 filter we have σ_av = 2.0.
+ // applying the same Gaussian filter n times results in σ_n = sqrt(n*σ_av*σ_av) [2]
+ // after some trivial math, we arrive at n = ((σ_d)/(σ_av))^2
+ // since it's a box blur filter, n >= 3
+ //
+ // [1]: http://www.peterkovesi.com/papers/FastGaussianSmoothing.pdf
+ // [2]: https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics
+
+ int n = lrintf((sigma*sigma)/(SIGMA_AV*SIGMA_AV));
+ if (n < 3) n = 3;
+
+ for (int i = 0; i < n; i++)
+ {
+ // horizontal pass includes image transposition:
+ // instead of writing pixel src[x] to dst[x],
+ // we write it to transposed location.
+ // (to be exact: dst[height * current_column + current_row])
+#ifdef __SSE2__
+ blur_impl_horizontal_pass_sse2(src, dst, width, height);
+ blur_impl_horizontal_pass_sse2(dst, src, height, width);
#else
- int src_stride = cairo_image_surface_get_stride (surface);
- int dst_stride = cairo_image_surface_get_stride (tmp);
- blur_impl_naive(src, dst, width, height, src_stride, dst_stride, 10000);
+ blur_impl_horizontal_pass_generic(src, dst, width, height);
+ blur_impl_horizontal_pass_generic(dst, src, height, width);
#endif
+ }
+
cairo_surface_destroy (tmp);
cairo_surface_flush (surface);
cairo_surface_mark_dirty (surface);
}
-void blur_impl_naive(uint32_t* _src, uint32_t* _dst, int width, int height, int src_stride, int dst_stride, int radius)
-{
- int x, y, z, w;
- uint32_t *s, *d, a, p;
- int i, j, k;
- uint8_t kernel[17];
- const int size = ARRAY_LENGTH (kernel);
- const int half = size / 2;
-
- uint8_t *src = (uint8_t*)_src;
- uint8_t *dst = (uint8_t*)_dst;
-
- a = 0;
- for (i = 0; i < size; i++) {
- double f = i - half;
- a += kernel[i] = exp (- f * f / 30.0) * 80;
- }
-
- /* Horizontally blur from surface -> tmp */
- for (i = 0; i < height; i++) {
- s = (uint32_t *) (src + i * src_stride);
- d = (uint32_t *) (dst + i * dst_stride);
- for (j = 0; j < width; j++) {
- if (radius < j && j < width - radius) {
- d[j] = s[j];
- continue;
- }
-
- x = y = z = w = 0;
- for (k = 0; k < size; k++) {
- if (j - half + k < 0 || j - half + k >= width)
- continue;
-
- p = s[j - half + k];
-
- x += ((p >> 24) & 0xff) * kernel[k];
- y += ((p >> 16) & 0xff) * kernel[k];
- z += ((p >> 8) & 0xff) * kernel[k];
- w += ((p >> 0) & 0xff) * kernel[k];
- }
- d[j] = (x / a << 24) | (y / a << 16) | (z / a << 8) | w / a;
- }
- }
-
- /* Then vertically blur from tmp -> surface */
- for (i = 0; i < height; i++) {
- s = (uint32_t *) (dst + i * dst_stride);
- d = (uint32_t *) (src + i * src_stride);
- for (j = 0; j < width; j++) {
- if (radius <= i && i < height - radius) {
- d[j] = s[j];
- continue;
+void blur_impl_horizontal_pass_generic(uint32_t *src, uint32_t *dst, int width, int height) {
+ for (int row = 0; row < height; row++) {
+ for (int column = 0; column < width; column++, src++) {
+ uint32_t rgbaIn[KERNEL_SIZE];
+
+ // handle borders
+ int leftBorder = column < HALF_KERNEL;
+ int rightBorder = column > width - HALF_KERNEL;
+ int i = 0;
+ if (leftBorder) {
+ // for kernel size 7x7 and column == 0, we have:
+ // x x x P0 P1 P2 P3
+ // first loop mirrors P{0..3} to fill x's,
+ // second one loads P{0..3}
+ for (; i < HALF_KERNEL - column; i++)
+ rgbaIn[i] = *(src + (HALF_KERNEL - i));
+ for (; i < KERNEL_SIZE; i++)
+ rgbaIn[i] = *(src - (HALF_KERNEL - i));
+ } else if (rightBorder) {
+ for (; i < width - column; i++)
+ rgbaIn[i] = *(src + i);
+ for (int k = 0; i < KERNEL_SIZE; i++, k++)
+ rgbaIn[i] = *(src - k);
+ } else {
+ for (; i < KERNEL_SIZE; i++)
+ rgbaIn[i] = *(src + i - HALF_KERNEL);
+ }
+
+ uint32_t acc[4] = {0};
+
+ for (i = 0; i < KERNEL_SIZE; i++) {
+ acc[0] += (rgbaIn[i] & 0xFF000000) >> 24;
+ acc[1] += (rgbaIn[i] & 0x00FF0000) >> 16;
+ acc[2] += (rgbaIn[i] & 0x0000FF00) >> 8;
+ acc[3] += (rgbaIn[i] & 0x000000FF) >> 0;
+ }
+
+ for(i = 0; i < 4; i++)
+ acc[i] *= 1.0/KERNEL_SIZE;
+
+ *(dst + height * column + row) = (acc[0] << 24) |
+ (acc[1] << 16) |
+ (acc[2] << 8 ) |
+ (acc[3] << 0);
}
-
- x = y = z = w = 0;
- for (k = 0; k < size; k++) {
- if (i - half + k < 0 || i - half + k >= height)
- continue;
-
- s = (uint32_t *) (dst + (i - half + k) * dst_stride);
- p = s[j];
-
- x += ((p >> 24) & 0xff) * kernel[k];
- y += ((p >> 16) & 0xff) * kernel[k];
- z += ((p >> 8) & 0xff) * kernel[k];
- w += ((p >> 0) & 0xff) * kernel[k];
- }
- d[j] = (x / a << 24) | (y / a << 16) | (z / a << 8) | w / a;
- }
}
}
diff --git a/blur.h b/blur.h
@@ -4,12 +4,14 @@
#include <stdint.h>
#include <cairo.h>
-void blur_image_surface (cairo_surface_t *surface, int radius);
-void blur_impl_naive(uint32_t* src, uint32_t* dst, int width, int height, int src_stride, int dst_stride, int radius);
-void blur_impl_sse2(uint32_t* src, uint32_t* dst, int width, int height, float sigma);
-void blur_impl_horizontal_pass_sse2(uint32_t *src, uint32_t *dst, float *kernel, int width, int height);
-void blur_impl_ssse3(uint32_t* src, uint32_t* dst, int width, int height, float sigma);
-void blur_impl_horizontal_pass_ssse3(uint32_t *src, uint32_t *dst, int8_t *kernel, int width, int height);
+#define KERNEL_SIZE 7
+#define SIGMA_AV 2
+#define HALF_KERNEL KERNEL_SIZE / 2
+
+void blur_image_surface(cairo_surface_t *surface, int sigma);
+void blur_impl_horizontal_pass_sse2(uint32_t *src, uint32_t *dst, int width, int height);
+void blur_impl_horizontal_pass_generic(uint32_t *src, uint32_t *dst, int width, int height);
#endif
+
diff --git a/blur_simd.c b/blur_simd.c
@@ -1,56 +1,19 @@
/*
* vim:ts=4:sw=4:expandtab
*
- * © 2016 Sebastian Frysztak
+ * © 2016 Sebastian Frysztak
*
* See LICENSE for licensing information
*
*/
#include "blur.h"
-#include <math.h>
#include <xmmintrin.h>
-#include <tmmintrin.h>
-#include <stdio.h>
-
-#define ALIGN16 __attribute__((aligned(16)))
-#define KERNEL_SIZE 15
-#define HALF_KERNEL KERNEL_SIZE / 2
-
-// number of xmm registers needed to store
-// input pixels for given kernel size
+// number of xmm registers needed to store input pixels for given kernel size
#define REGISTERS_CNT (KERNEL_SIZE + 4/2) / 4
-// scaling factor for kernel coefficients.
-// higher values cause desaturation.
-// used in SSSE3 implementation.
-#define SCALE_FACTOR 7
-
-void blur_impl_sse2(uint32_t *src, uint32_t *dst, int width, int height, float sigma) {
- // prepare kernel
- float kernel[KERNEL_SIZE];
- float coeff = 1.0 / sqrtf(2 * M_PI * sigma * sigma), sum = 0;
-
- for (int i = 0; i < KERNEL_SIZE; i++) {
- float x = HALF_KERNEL - i;
- kernel[i] = coeff * expf(-x * x / (2.0 * sigma * sigma));
- sum += kernel[i];
- }
-
- // normalize kernel
- for (int i = 0; i < KERNEL_SIZE; i++)
- kernel[i] /= sum;
-
- // horizontal pass includes image transposition:
- // instead of writing pixel src[x] to dst[x],
- // we write it to transposed location.
- // (to be exact: dst[height * current_column + current_row])
- blur_impl_horizontal_pass_sse2(src, dst, kernel, width, height);
- blur_impl_horizontal_pass_sse2(dst, src, kernel, height, width);
-}
-
-void blur_impl_horizontal_pass_sse2(uint32_t *src, uint32_t *dst, float *kernel, int width, int height) {
+void blur_impl_horizontal_pass_sse2(uint32_t *src, uint32_t *dst, int width, int height) {
uint32_t* o_src = src;
for (int row = 0; row < height; row++) {
for (int column = 0; column < width; column++, src++) {
@@ -59,227 +22,58 @@ void blur_impl_horizontal_pass_sse2(uint32_t *src, uint32_t *dst, float *kernel,
// handle borders
int leftBorder = column < HALF_KERNEL;
int rightBorder = column > width - HALF_KERNEL;
- if (leftBorder || rightBorder) {
- uint32_t _rgbaIn[KERNEL_SIZE + 1] ALIGN16;
- int i = 0;
- if (leftBorder) {
- // for kernel size 7x7 and column == 0, we have:
- // x x x P0 P1 P2 P3
- // first loop mirrors P{0..3} to fill x's,
- // second one loads P{0..3}
- for (; i < HALF_KERNEL - column; i++)
- _rgbaIn[i] = *(src + (HALF_KERNEL - i));
- for (; i < KERNEL_SIZE; i++)
- _rgbaIn[i] = *(src - (HALF_KERNEL - i));
- } else {
- for (; i < width - column; i++)
- _rgbaIn[i] = *(src + i);
- for (int k = 0; i < KERNEL_SIZE; i++, k++)
- _rgbaIn[i] = *(src - k);
- }
+ uint32_t _rgbaIn[KERNEL_SIZE + 1] __attribute__((aligned(16)));
+ int i = 0;
+ if (leftBorder) {
+ // for kernel size 7x7 and column == 0, we have:
+ // x x x P0 P1 P2 P3
+ // first loop mirrors P{0..3} to fill x's,
+ // second one loads P{0..3}
+ for (; i < HALF_KERNEL - column; i++)
+ _rgbaIn[i] = *(src + (HALF_KERNEL - i));
+ for (; i < KERNEL_SIZE; i++)
+ _rgbaIn[i] = *(src - (HALF_KERNEL - i));
for (int k = 0; k < REGISTERS_CNT; k++)
rgbaIn[k] = _mm_load_si128((__m128i*)(_rgbaIn + 4*k));
- } else {
- for (int k = 0; k < REGISTERS_CNT; k++) {
-#if 0
- printf("%p -> %p (%ld) || %p->%p\n",
- o_src,
- o_src + (height * width),
- o_src + (height * width) - src,
- src + 4*k - HALF_KERNEL,
- ((__m128i*)src + 4*k - HALF_KERNEL) + 1
- );
-#endif
- // if this copy would go out of bounds, break
- if ((long long) (((__m128i*) src + 4*k - HALF_KERNEL) + 1)
- > (long long) (o_src + (height * width)))
- break;
- rgbaIn[k] = _mm_loadu_si128((__m128i*)(src + 4*k - HALF_KERNEL));
- }
- }
-
- // unpack each pixel, convert to float,
- // multiply by corresponding kernel value
- // and add to accumulator
- __m128i tmp;
- __m128i zero = _mm_setzero_si128();
- __m128 rgba_ps;
- __m128 acc = _mm_setzero_ps();
- int counter = 0;
-
- for (int i = 0; i < 3; i++)
- {
- tmp = _mm_unpacklo_epi8(rgbaIn[i], zero);
- rgba_ps = _mm_cvtepi32_ps(_mm_unpacklo_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
- rgba_ps = _mm_cvtepi32_ps(_mm_unpackhi_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
-
- tmp = _mm_unpackhi_epi8(rgbaIn[i], zero);
- rgba_ps = _mm_cvtepi32_ps(_mm_unpacklo_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
- rgba_ps = _mm_cvtepi32_ps(_mm_unpackhi_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
- }
-
- tmp = _mm_unpacklo_epi8(rgbaIn[3], zero);
- rgba_ps = _mm_cvtepi32_ps(_mm_unpacklo_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
- rgba_ps = _mm_cvtepi32_ps(_mm_unpackhi_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
-
- tmp = _mm_unpackhi_epi8(rgbaIn[3], zero);
- rgba_ps = _mm_cvtepi32_ps(_mm_unpacklo_epi16(tmp, zero));
- acc = _mm_add_ps(acc, _mm_mul_ps(rgba_ps, _mm_set1_ps(kernel[counter++])));
-
- __m128i rgbaOut = _mm_cvtps_epi32(acc);
- rgbaOut = _mm_packs_epi32(rgbaOut, zero);
- rgbaOut = _mm_packus_epi16(rgbaOut, zero);
- *(dst + height * column + row) = _mm_cvtsi128_si32(rgbaOut);
- }
- }
-}
+ } else if (rightBorder) {
+ for (; i < width - column; i++)
+ _rgbaIn[i] = *(src + i);
+ for (int k = 0; i < KERNEL_SIZE; i++, k++)
+ _rgbaIn[i] = *(src - k);
-void blur_impl_ssse3(uint32_t *src, uint32_t *dst, int width, int height, float sigma) {
- // prepare kernel
- float kernelf[KERNEL_SIZE];
- int8_t kernel[KERNEL_SIZE + 1];
- float coeff = 1.0 / sqrtf(2 * M_PI * sigma * sigma), sum = 0;
-
- for (int i = 0; i < KERNEL_SIZE; i++) {
- float x = HALF_KERNEL - i;
- kernelf[i] = coeff * expf(-x * x / (2.0 * sigma * sigma));
- sum += kernelf[i];
- }
-
- // normalize kernel
- for (int i = 0; i < KERNEL_SIZE; i++)
- kernelf[i] /= sum;
-
- // round to nearest integer and convert to int
- for (int i = 0; i < KERNEL_SIZE; i++)
- kernel[i] = (int8_t)rintf(kernelf[i] * (1 << SCALE_FACTOR));
- kernel[KERNEL_SIZE] = 0;
-
- // horizontal pass includes image transposition:
- // instead of writing pixel src[x] to dst[x],
- // we write it to transposed location.
- // (to be exact: dst[height * current_column + current_row])
- blur_impl_horizontal_pass_ssse3(src, dst, kernel, width, height);
- blur_impl_horizontal_pass_ssse3(dst, src, kernel, height, width);
-}
-
-
-void blur_impl_horizontal_pass_ssse3(uint32_t *src, uint32_t *dst, int8_t *kernel, int width, int height) {
- uint32_t* o_src = src;
- __m128i _kern = _mm_loadu_si128((__m128i*)kernel);
- __m128i rgbaIn[REGISTERS_CNT];
-
- for (int row = 0; row < height; row++) {
- for (int column = 0; column < width; column++, src++) {
- uint32_t _rgbaIn[KERNEL_SIZE + 1] ALIGN16;
-#if 0
- for (int j = 0; j < KERNEL_SIZE; ++j) {
- printf("_rgbaIn[%d]: %p->%p\n", j, &_rgbaIn[j], &_rgbaIn[j] + 1);
- }
-#endif
- // handle borders
- int leftBorder = column < HALF_KERNEL;
- int rightBorder = column > width - HALF_KERNEL;
- if (leftBorder || rightBorder) {
- int i = 0;
- if (leftBorder) {
- // for kernel size 7x7 and column == 0, we have:
- // x x x P0 P1 P2 P3
- // first loop mirrors P{0..3} to fill x's,
- // second one loads P{0..3}
- for (; i < HALF_KERNEL - column; i++)
- _rgbaIn[i] = *(src + (HALF_KERNEL - i));
- for (; i < KERNEL_SIZE; i++)
- _rgbaIn[i] = *(src - (HALF_KERNEL - i));
- } else {
- for (; i < width - column; i++)
- _rgbaIn[i] = *(src + i);
- for (int k = 0; i < KERNEL_SIZE; i++, k++)
- _rgbaIn[i] = *(src - k);
- }
-
- for (int k = 0; k < REGISTERS_CNT; k++) {
-#if 0
- printf("K: %d; p: %p, p+4*k: %p, end of p: %p\n", k, _rgbaIn, _rgbaIn+4*k, ((__m128i*) (_rgbaIn +4*k)) + 1);
-#endif
+ for (int k = 0; k < REGISTERS_CNT; k++)
rgbaIn[k] = _mm_load_si128((__m128i*)(_rgbaIn + 4*k));
- }
} else {
for (int k = 0; k < REGISTERS_CNT; k++) {
- if ((long long) (((__m128i*) src + 4*k - HALF_KERNEL) + 1)
+ if ((long long) (((__m128i*) src + 4*k - HALF_KERNEL) + 1)
> (long long) (o_src + (height * width)))
break;
-#if 0
- printf("K: %d; p: %p -> %p\n", k, src+4*k - HALF_KERNEL, ((__m128i*) (src +4*k - HALF_KERNEL)) + 1);
- printf("%p->%p, %p->%p (%ld)\n", (__m128i*) src + 4*k - HALF_KERNEL, ((__m128i*) src + 4*k - HALF_KERNEL) + 1, o_src, o_src + (width * height), o_src + (width * height) - src);
-#endif
rgbaIn[k] = _mm_loadu_si128((__m128i*)(src + 4*k - HALF_KERNEL));
}
}
- // basis of this implementation is _mm_maddubs_epi16 (aka pmaddubsw).
- // 'rgba' holds 16 unsigned bytes, so 4 pixels.
- // 'kern' holds 16 signed bytes kernel values multiplied by (1 << SCALE_FACTOR).
- // before multiplication takes place, vectors need to be prepared:
- // 'rgba' is shuffled from R1B1G1A1...R4B4G4A4 to R1R2R3R4...A1A2A3A4
- // 'kern' is shuffled from w1w2w3w4...w13w14w15w16 to w1w2w3w4 repeated 4 times
- // then we call _mm_maddubs_epi16 and we get:
- // --------------------------------------------------------------------------------------
- // | R1*w1 + R2*w2 | R3*w3 + R4*w4 | G1*w1 + G2*w2 | G3*w3 + G4*w4 | repeat for B and A |
- // --------------------------------------------------------------------------------------
- // each 'rectangle' is a 16-byte signed int.
- // then we repeat the process for the rest of input pixels,
- // call _mm_hadds_epi16 to add adjacent ints and shift right to scale by SCALE_FACTOR.
-
- __m128i rgba, kern;
__m128i zero = _mm_setzero_si128();
__m128i acc = _mm_setzero_si128();
- const __m128i rgba_shuf_mask = _mm_setr_epi8(0, 4, 8, 12,
- 1, 5, 9, 13,
- 2, 6, 10, 14,
- 3, 7, 11, 15);
-
- const __m128i kern_shuf_mask = _mm_setr_epi8(0, 1, 2, 3,
- 0, 1, 2, 3,
- 0, 1, 2, 3,
- 0, 1, 2, 3);
-
- rgba = _mm_shuffle_epi8(rgbaIn[0], rgba_shuf_mask);
- kern = _mm_shuffle_epi8(_kern, kern_shuf_mask);
- acc = _mm_adds_epi16(acc, _mm_maddubs_epi16(rgba, kern));
+ acc = _mm_add_epi16(acc, _mm_unpacklo_epi8(rgbaIn[0], zero));
+ acc = _mm_add_epi16(acc, _mm_unpackhi_epi8(rgbaIn[0], zero));
+ acc = _mm_add_epi16(acc, _mm_unpacklo_epi8(rgbaIn[1], zero));
- rgba = _mm_shuffle_epi8(rgbaIn[1], rgba_shuf_mask);
- kern = _mm_shuffle_epi8(_mm_srli_si128(_kern, 4), kern_shuf_mask);
- acc = _mm_adds_epi16(acc, _mm_maddubs_epi16(rgba, kern));
+ // kernel size equals to 7, but we can only load multiples of 4 pixels
+ // we have to set 8th pixel to zero
+ acc = _mm_add_epi16(acc, _mm_andnot_si128(_mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0, 0),
+ _mm_unpackhi_epi8(rgbaIn[1], zero)));
+ acc = _mm_add_epi32(_mm_unpacklo_epi16(acc, zero),
+ _mm_unpackhi_epi16(acc, zero));
- rgba = _mm_shuffle_epi8(rgbaIn[2], rgba_shuf_mask);
- kern = _mm_shuffle_epi8(_mm_srli_si128(_kern, 8), kern_shuf_mask);
- acc = _mm_adds_epi16(acc, _mm_maddubs_epi16(rgba, kern));
+ // multiplication is significantly faster than division
+ acc = _mm_cvtps_epi32(_mm_mul_ps(_mm_cvtepi32_ps(acc),
+ _mm_set1_ps(1.0/KERNEL_SIZE)));
- rgba = _mm_shuffle_epi8(rgbaIn[3], rgba_shuf_mask);
- kern = _mm_shuffle_epi8(_mm_srli_si128(_kern, 12), kern_shuf_mask);
- acc = _mm_adds_epi16(acc, _mm_maddubs_epi16(rgba, kern));
-
- acc = _mm_hadds_epi16(acc, zero);
- acc = _mm_srai_epi16(acc, SCALE_FACTOR);
-
- // Cairo sets alpha channel to 255
- // (or -1, depending how you look at it)
- // this quickly overflows accumulator,
- // and alpha is calculated completely wrong.
- // I assume most people don't use semi-transparent
- // lock screen images, so no one will mind if we
- // 'correct it' by setting alpha to 255.
*(dst + height * column + row) =
- _mm_cvtsi128_si32(_mm_packus_epi16(acc, zero)) | 0xFF000000;
+ _mm_cvtsi128_si32(_mm_packus_epi16(_mm_packs_epi32(acc, zero), zero));
}
}
}
+
diff --git a/configure.ac b/configure.ac
@@ -101,10 +101,8 @@ AC_PROG_LN_S
AM_PROG_AR
AX_FLAGS_WARN_ALL
-AX_APPEND_FLAG([-march=native], [AM_CFLAGS])
- AX_APPEND_FLAG([-O2], [AM_CFLAGS])
+AX_APPEND_FLAG([-O2], [AM_CFLAGS])
AX_APPEND_FLAG([-funroll-loops], [AM_CFLAGS])
-AX_APPEND_FLAG([-std=gnu99], [AM_CFLAGS])
AX_CHECK_COMPILE_FLAG([-Wunused-value], [AX_APPEND_FLAG([-Wunused-value], [AM_CFLAGS])])
AC_SUBST(AM_CFLAGS)
