More general version of image filtering; reworked to be robust and easier to SSE

src/core/SkBitmapFilter.cpp

+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkBitmapProcState.h"
+#include "SkBitmap.h"
+#include "SkColor.h"
+#include "SkColorPriv.h"
+#include "SkUnPreMultiply.h"
+#include "SkShader.h"
+#include "SkRTConf.h"
+#include "SkMath.h"
+
+void highQualityFilter(const SkBitmapProcState& s, int x, int y,

[reed1, 2013/07/09 14:25:47]

is this guy exported? (I don't see static, nor some Sk scoping of the name)

[humper, 2013/07/09 14:47:26]

I suppose it's not; only a function pointer to it is returned.

On 2013/07/09 14:25:47, reed1 wrote:

[humper, 2013/07/09 15:26:30]

ah, actually it is; I look to see if the shader proc is equal to these when
deciding whether or not to set them to their SSE equivalents.

On 2013/07/09 14:47:26, humper wrote:

+                   SkPMColor* SK_RESTRICT colors, int count) {
+
+    const int maxX = s.fBitmap->width() - 1;
+    const int maxY = s.fBitmap->height() - 1;
+
+    while (count-- > 0) {
+        SkPoint srcPt;
+        s.fInvProc(*s.fInvMatrix, SkIntToScalar(x),
+                    SkIntToScalar(y), &srcPt);
+        srcPt.fX -= SK_ScalarHalf;
+        srcPt.fY -= SK_ScalarHalf;
+        SkScalar fractx = srcPt.fX - SkScalarFloorToScalar(srcPt.fX);
+        SkScalar fracty = srcPt.fY - SkScalarFloorToScalar(srcPt.fY);
+
+        int sx = SkScalarFloorToInt(srcPt.fX);
+        int sy = SkScalarFloorToInt(srcPt.fY);
+        
+        SkFixed weight = 0;
+        SkFixed fr = 0, fg = 0, fb = 0, fa = 0;
+        
+        int y0 = SkClampMax(int(ceil(sy-s.fBitmapFilter->width() + 0.5f)), maxY);
+        int y1 = SkClampMax(int(floor(sy+s.fBitmapFilter->width() + 0.5f)), maxY);
+        int x0 = SkClampMax(int(ceil(sx-s.fBitmapFilter->width() + 0.5f)), maxX);
+        int x1 = SkClampMax(int(floor(sx+s.fBitmapFilter->width() + 0.5f)), maxX);
+        
+        for (int src_y = y0; src_y <= y1; src_y++) {
+            SkFixed yweight = s.fBitmapFilter->lookup((srcPt.fY - src_y));
+            
+            for (int src_x = x0; src_x <= x1 ; src_x++) {
+                SkFixed xweight = s.fBitmapFilter->lookup((srcPt.fX - src_x));
+                
+                SkFixed combined_weight = SkFixedMul(xweight, yweight);
+                
+                SkPMColor c = *s.fBitmap->getAddr32(src_x, src_y);
+                fr += combined_weight * SkGetPackedR32(c);
+                fg += combined_weight * SkGetPackedG32(c);
+                fb += combined_weight * SkGetPackedB32(c);
+                fa += combined_weight * SkGetPackedA32(c);
+                weight += combined_weight;
+            }
+        }
+
+        fr = SkFixedDiv(fr, weight);
+        fg = SkFixedDiv(fg, weight);
+        fb = SkFixedDiv(fb, weight);
+        fa = SkFixedDiv(fa, weight);
+
+        int a = SkClampMax(SkFixedRoundToInt(fa), 255);
+        int r = SkClampMax(SkFixedRoundToInt(fr), a);
+        int g = SkClampMax(SkFixedRoundToInt(fg), a);
+        int b = SkClampMax(SkFixedRoundToInt(fb), a);
+
+        *colors++ = SkPackARGB32(a, r, g, b);
+
+        x++;
+    }
+}
+
+void highQualityFilter_ScaleOnly(const SkBitmapProcState &s, int x, int y,
+                             SkPMColor *SK_RESTRICT colors, int count) {
+     const int maxX = s.fBitmap->width() - 1;
+     const int maxY = s.fBitmap->height() - 1;
+     
+     SkPoint srcPt;
+     
+     s.fInvProc(*s.fInvMatrix, SkIntToScalar(x),
+                 SkIntToScalar(y), &srcPt);
+     srcPt.fY -= SK_ScalarHalf;
+     SkScalar fracty = srcPt.fY - SkScalarFloorToScalar(srcPt.fY);
+     int sy = SkScalarFloorToInt(srcPt.fY);
+     int y0 = SkClampMax(int(ceil(sy-s.fBitmapFilter->width() + 0.5f)), maxY);
+     int y1 = SkClampMax(int(floor(sy+s.fBitmapFilter->width() + 0.5f)), maxY);
+
+     while (count-- > 0) {
+         s.fInvProc(*s.fInvMatrix, SkIntToScalar(x),
+                     SkIntToScalar(y), &srcPt);
+         srcPt.fX -= SK_ScalarHalf;
+         srcPt.fY -= SK_ScalarHalf;
+         SkScalar fractx = srcPt.fX - SkScalarFloorToScalar(srcPt.fX);
+
+         int sx = SkScalarFloorToInt(srcPt.fX);
+
+         SkFixed weight = 0;
+         SkFixed fr = 0, fg = 0, fb = 0, fa = 0;
+
+         int x0 = SkClampMax(int(ceil(sx-s.fBitmapFilter->width() + 0.5f)), maxX);
+         int x1 = SkClampMax(int(floor(sx+s.fBitmapFilter->width() + 0.5f)), maxX);
+
+         for (int src_y = y0; src_y <= y1; src_y++) {
+             SkFixed yweight = s.fBitmapFilter->lookup((srcPt.fY - src_y));
+
+             for (int src_x = x0; src_x <= x1 ; src_x++) {
+                 SkFixed xweight = s.fBitmapFilter->lookup((srcPt.fX - src_x));
+
+                 SkFixed combined_weight = SkFixedMul(xweight, yweight);
+
+                 SkPMColor c = *s.fBitmap->getAddr32(src_x, src_y);
+                 fr += combined_weight * SkGetPackedR32(c);
+                 fg += combined_weight * SkGetPackedG32(c);
+                 fb += combined_weight * SkGetPackedB32(c);
+                 fa += combined_weight * SkGetPackedA32(c);
+                 weight += combined_weight;
+             }
+         }
+
+         fr = SkFixedDiv(fr, weight);
+         fg = SkFixedDiv(fg, weight);
+         fb = SkFixedDiv(fb, weight);
+         fa = SkFixedDiv(fa, weight);
+
+         int a = SkClampMax(SkFixedRoundToInt(fa), 255);
+         int r = SkClampMax(SkFixedRoundToInt(fr), a);
+         int g = SkClampMax(SkFixedRoundToInt(fg), a);
+         int b = SkClampMax(SkFixedRoundToInt(fb), a);
+
+         *colors++ = SkPackARGB32(a, r, g, b);
+
+         x++;
+     }                                 
+}
+
+SK_CONF_DECLARE(const char *, c_bitmapFilter, "bitmap.filter", "mitchell", "Which bitmap filter to use [mitchell, sinc, gaussian, triangle, box]");
+
+static SkBitmapFilter *allocateBitmapFilter() {
+    if (!strcmp(c_bitmapFilter, "mitchell")) {
+        return SkNEW_ARGS(SkMitchellFilter,(1.f/3.f,1.f/3.f));
+    } else if (!strcmp(c_bitmapFilter, "sinc")) {
+        return SkNEW_ARGS(SkSincFilter,(3));
+    } else if (!strcmp(c_bitmapFilter, "gaussian")) {
+        return SkNEW_ARGS(SkGaussianFilter,(2));
+    } else if (!strcmp(c_bitmapFilter, "triangle")) {
+        return SkNEW(SkTriangleFilter);
+    } else if (!strcmp(c_bitmapFilter, "box")) {
+        return SkNEW(SkBoxFilter);
+    } else {
+        SkASSERT(!!!"Unknown filter type");
+    }
+    
+    return NULL;
+}
+
+SkBitmapProcState::ShaderProc32
+SkBitmapProcState::chooseBitmapFilterProc(const SkPaint& paint) {
+    // we need to be requested
+    uint32_t mask = SkPaint::kFilterBitmap_Flag
+                  | SkPaint::kHighQualityFilterBitmap_Flag
+                  ;
+    if ((paint.getFlags() & mask) != mask) {
+        return NULL;
+    }
+
+    // TODO: consider supporting other configs (e.g. 565, A8)
+    if (fBitmap->config() != SkBitmap::kARGB_8888_Config) {
+        return NULL;
+    }
+
+    // TODO: consider supporting repeat and mirror
+    if (SkShader::kClamp_TileMode != fTileModeX || SkShader::kClamp_TileMode != fTileModeY) {
+        return NULL;
+    }
+
+    // TODO: support blending inside our procs
+    if (0xFF != paint.getAlpha()) {
+        return NULL;
+    }
+    
+    if (fInvType & (SkMatrix::kAffine_Mask | SkMatrix::kScale_Mask)) {
+        fBitmapFilter = allocateBitmapFilter();
+    }
+    
+    if (fInvType & SkMatrix::kAffine_Mask) {
+        return highQualityFilter;
+    } else if (fInvType & SkMatrix::kScale_Mask) {
+        return highQualityFilter_ScaleOnly;
+    } else {
+        return NULL;
+    }
+}
+
+static void divideByWeights(SkFixed *sums, SkFixed *weights, SkBitmap *dst) {
+    for (int y = 0 ; y < dst->height() ; y++) {
+        for (int x = 0 ; x < dst->width() ; x++) {
+            SkFixed fr = SkFixedDiv(sums[4*(y*dst->width() + x) + 0], weights[y*dst->width() + x]);
+            SkFixed fg = SkFixedDiv(sums[4*(y*dst->width() + x) + 1], weights[y*dst->width() + x]);
+            SkFixed fb = SkFixedDiv(sums[4*(y*dst->width() + x) + 2], weights[y*dst->width() + x]);
+            SkFixed fa = SkFixedDiv(sums[4*(y*dst->width() + x) + 3], weights[y*dst->width() + x]);
+            int a = SkClampMax(SkFixedRoundToInt(fa), 255);
+            int r = SkClampMax(SkFixedRoundToInt(fr), a);
+            int g = SkClampMax(SkFixedRoundToInt(fg), a);
+            int b = SkClampMax(SkFixedRoundToInt(fb), a);
+
+            *dst->getAddr32(x,y) = SkPackARGB32(a, r, g, b);
+        }
+    }
+}
+
+static void upScaleHoriz(const SkBitmap *src, SkBitmap *dst, float scale, SkBitmapFilter *filter) {
+    for (int y = 0 ; y < src->height() ; y++) {
+        for (int x = 0 ; x < dst->width() ; x++) {
+            float sx = x / scale - 0.5f;
+            int x0 = SkClampMax(int(ceil(sx-filter->width() + 0.5f)), src->width()-1);
+            int x1 = SkClampMax(int(floor(sx+filter->width() + 0.5f)), src->width()-1);
+            
+            SkFixed total_weight = 0;
+            SkFixed fr = 0, fg = 0, fb = 0, fa = 0;
+            
+            for (int src_x = x0 ; src_x <= x1 ; src_x++) {
+                SkFixed weight = filter->lookup(sx - src_x);
+                SkPMColor c = *src->getAddr32(src_x,y);
+                fr += weight * SkGetPackedR32(c);
+                fg += weight * SkGetPackedG32(c);
+                fb += weight * SkGetPackedB32(c);
+                fa += weight * SkGetPackedA32(c);
+                total_weight += weight;
+            }
+            fr = SkFixedDiv(fr, total_weight);
+            fg = SkFixedDiv(fg, total_weight);
+            fb = SkFixedDiv(fb, total_weight);
+            fa = SkFixedDiv(fa, total_weight);
+
+            int a = SkClampMax(SkFixedRoundToInt(fa), 255);
+            int r = SkClampMax(SkFixedRoundToInt(fr), a);
+            int g = SkClampMax(SkFixedRoundToInt(fg), a);
+            int b = SkClampMax(SkFixedRoundToInt(fb), a);
+
+            *dst->getAddr32(x,y) = SkPackARGB32(a, r, g, b);
+        }
+    }
+}
+
+static void downScaleHoriz(const SkBitmap *src, SkBitmap *dst, float scale, SkBitmapFilter *filter) {
+    SkFixed *sums = SkNEW_ARRAY(SkFixed, dst->width() * dst->height() * 4);
+    SkFixed *weights = SkNEW_ARRAY(SkFixed, dst->width() * dst->height());
+    
+    SkAutoTDeleteArray<SkFixed> ada1(sums);
+    SkAutoTDeleteArray<SkFixed> ada2(weights);
+
+    memset(sums, 0, dst->width() * dst->height() * sizeof(SkFixed) * 4);
+    memset(weights, 0, dst->width() * dst->height() * sizeof(SkFixed));
+    
+    for (int y = 0 ; y < src->height() ; y++) {
+        for (int x = 0 ; x < src->width() ; x++) {
+            // splat each source pixel into the destination image
+            float dx = (x + 0.5f) * scale;
+            int x0 = SkClampMax(int(ceil(dx-filter->width() + 0.5f)), dst->width()-1);
+            int x1 = SkClampMax(int(floor(dx+filter->width() + 0.5f)), dst->width()-1);
+            
+            SkPMColor c = *src->getAddr32(x,y);
+            
+            for (int dst_x = x0 ; dst_x <= x1 ; dst_x++) {
+                SkFixed weight = filter->lookup(dx - dst_x);
+                sums[4*(y*dst->width() + dst_x) + 0] += weight*SkGetPackedR32(c);
+                sums[4*(y*dst->width() + dst_x) + 1] += weight*SkGetPackedG32(c);
+                sums[4*(y*dst->width() + dst_x) + 2] += weight*SkGetPackedB32(c);
+                sums[4*(y*dst->width() + dst_x) + 3] += weight*SkGetPackedA32(c);
+                weights[y*dst->width() + dst_x] += weight;
+            }
+        }
+    }
+    
+    divideByWeights(sums, weights, dst);
+}
+
+static void upScaleVert(const SkBitmap *src, SkBitmap *dst, float scale, SkBitmapFilter *filter) {
+    for (int y = 0 ; y < dst->height() ; y++) {
+        for (int x = 0 ; x < dst->width() ; x++) {
+            float sy = y / scale - 0.5f;
+            int y0 = SkClampMax(int(ceil(sy-filter->width() + 0.5f)), src->height()-1);
+            int y1 = SkClampMax(int(floor(sy+filter->width() + 0.5f)), src->height()-1);
+            
+            SkFixed total_weight = 0;
+            SkFixed fr = 0, fg = 0, fb = 0, fa = 0;
+            
+            for (int src_y = y0 ; src_y <= y1 ; src_y++) {
+                SkFixed weight = filter->lookup(sy - src_y);
+                SkPMColor c = *src->getAddr32(x,src_y);
+                fr += weight * SkGetPackedR32(c);
+                fg += weight * SkGetPackedG32(c);
+                fb += weight * SkGetPackedB32(c);
+                fa += weight * SkGetPackedA32(c);
+                total_weight += weight;
+            }
+            fr = SkFixedDiv(fr, total_weight);
+            fg = SkFixedDiv(fg, total_weight);
+            fb = SkFixedDiv(fb, total_weight);
+            fa = SkFixedDiv(fa, total_weight);
+
+            int a = SkClampMax(SkFixedRoundToInt(fa), 255);
+            int r = SkClampMax(SkFixedRoundToInt(fr), a);
+            int g = SkClampMax(SkFixedRoundToInt(fg), a);
+            int b = SkClampMax(SkFixedRoundToInt(fb), a);
+
+            *dst->getAddr32(x,y) = SkPackARGB32(a, r, g, b);
+        }
+    }
+}
+
+static void downScaleVert(const SkBitmap *src, SkBitmap *dst, float scale, SkBitmapFilter *filter) {
+    SkFixed *sums = SkNEW_ARRAY(SkFixed, dst->width() * dst->height() * 4);
+    SkFixed *weights = SkNEW_ARRAY(SkFixed, dst->width() * dst->height());
+    
+    SkAutoTDeleteArray<SkFixed> ada1(sums);
+    SkAutoTDeleteArray<SkFixed> ada2(weights);
+
+    memset(sums, 0, dst->width() * dst->height() * sizeof(SkFixed) * 4);
+    memset(weights, 0, dst->width() * dst->height() * sizeof(SkFixed));
+
+    for (int y = 0 ; y < src->height() ; y++) {
+        for (int x = 0 ; x < src->width() ; x++) {
+            // splat each source pixel into the destination image
+            float dy = (y + 0.5f) * scale;
+            int y0 = SkClampMax(int(ceil(dy-filter->width() + 0.5f)), dst->height()-1);
+            int y1 = SkClampMax(int(floor(dy+filter->width() + 0.5f)), dst->height()-1);
+
+            SkPMColor c = *src->getAddr32(x,y);
+
+            for (int dst_y = y0 ; dst_y <= y1 ; dst_y++) {
+                SkFixed weight = filter->lookup(dy - dst_y);
+                sums[4*(dst_y*dst->width() + x) + 0] += weight*SkGetPackedR32(c);
+                sums[4*(dst_y*dst->width() + x) + 1] += weight*SkGetPackedG32(c);
+                sums[4*(dst_y*dst->width() + x) + 2] += weight*SkGetPackedB32(c);
+                sums[4*(dst_y*dst->width() + x) + 3] += weight*SkGetPackedA32(c);
+                weights[dst_y*dst->width() + x] += weight;
+            }
+        }
+    }
+    
+    divideByWeights(sums, weights, dst);
+}
+
+void SkBitmap::scale(SkBitmap *dst) const {
+    
+    SkBitmap horiz_temp;
+    
+    horiz_temp.setConfig(SkBitmap::kARGB_8888_Config, dst->width(), height());
+    horiz_temp.allocPixels();
+    
+    SkBitmapFilter *filter = allocateBitmapFilter();
+    
+    float horiz_scale = float(dst->width()) / width();
+    
+    if (horiz_scale == 1) {
+        this->copyPixelsTo(horiz_temp.getPixels(), getSize());
+    } else if (horiz_scale > 1) {
+        upScaleHoriz(this, &horiz_temp, horiz_scale, filter);
+    } else if (horiz_scale < 1) {
+        downScaleHoriz(this, &horiz_temp, horiz_scale, filter);
+    }
+    
+    float vert_scale = float(dst->height()) / height();
+    
+    if (vert_scale == 1) {
+        horiz_temp.copyPixelsTo(dst->getPixels(), dst->getSize());
+    } else if (vert_scale > 1) {
+        upScaleVert(&horiz_temp, dst, vert_scale, filter);
+    } else if (vert_scale < 1) {
+        downScaleVert(&horiz_temp, dst, vert_scale, filter);
+    }
+    
+    SkDELETE(filter);
+}