fix bug with awesome filtered images sometimes being slightly offset.

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,
                    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);
+        s.fInvProc(*s.fInvMatrix, SkFloatToScalar(x + 0.5),
+                    SkFloatToScalar(y + 0.5), &srcPt);
         srcPt.fX -= SK_ScalarHalf;
         srcPt.fY -= SK_ScalarHalf;
 
         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.getBitmapFilter()->width() + 0.5f)), maxY);
-        int y1 = SkClampMax(int(floor(sy+s.getBitmapFilter()->width() + 0.5f)), maxY);
-        int x0 = SkClampMax(int(ceil(sx-s.getBitmapFilter()->width() + 0.5f)), maxX);
-        int x1 = SkClampMax(int(floor(sx+s.getBitmapFilter()->width() + 0.5f)), maxX);
+        int y0 = SkClampMax(int(ceil(SkScalarToFloat(srcPt.fY)-s.getBitmapFilter()->width())), maxY);
+        int y1 = SkClampMax(int(floor(SkScalarToFloat(srcPt.fY)+s.getBitmapFilter()->width())), maxY);
+        int x0 = SkClampMax(int(ceil(SkScalarToFloat(srcPt.fX)-s.getBitmapFilter()->width())), maxX);
+        int x1 = SkClampMax(int(floor(SkScalarToFloat(srcPt.fX)+s.getBitmapFilter()->width())), maxX);
 
         for (int src_y = y0; src_y <= y1; src_y++) {
             SkFixed yweight = s.getBitmapFilter()->lookup((srcPt.fY - src_y));
 
             for (int src_x = x0; src_x <= x1 ; src_x++) {
                 SkFixed xweight = s.getBitmapFilter()->lookup((srcPt.fX - src_x));
 
                 SkFixed combined_weight = SkFixedMul(xweight, yweight);
 
                 SkPMColor c = *s.fBitmap->getAddr32(src_x, src_y);
@@ skipping 21 matching lines @@
     }
 }
 
 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);
+     s.fInvProc(*s.fInvMatrix, SkFloatToScalar(x + 0.5),
+                 SkFloatToScalar(y + 0.5), &srcPt);
      srcPt.fY -= SK_ScalarHalf;
      int sy = SkScalarFloorToInt(srcPt.fY);
-     int y0 = SkClampMax(int(ceil(sy-s.getBitmapFilter()->width() + 0.5f)), maxY);
-     int y1 = SkClampMax(int(floor(sy+s.getBitmapFilter()->width() + 0.5f)), maxY);
+     int y0 = SkClampMax(int(ceil(SkScalarToFloat(srcPt.fY)-s.getBitmapFilter()->width())), maxY);
+     int y1 = SkClampMax(int(floor(SkScalarToFloat(srcPt.fY)+s.getBitmapFilter()->width())), maxY);
 
      while (count-- > 0) {
-         s.fInvProc(*s.fInvMatrix, SkIntToScalar(x),
-                     SkIntToScalar(y), &srcPt);
+         s.fInvProc(*s.fInvMatrix, SkFloatToScalar(x + 0.5),
+                     SkFloatToScalar(y + 0.5), &srcPt);
          srcPt.fX -= SK_ScalarHalf;
          srcPt.fY -= SK_ScalarHalf;
 
          int sx = SkScalarFloorToInt(srcPt.fX);
 
          SkFixed weight = 0;
          SkFixed fr = 0, fg = 0, fb = 0, fa = 0;
 
-         int x0 = SkClampMax(int(ceil(sx-s.getBitmapFilter()->width() + 0.5f)), maxX);
-         int x1 = SkClampMax(int(floor(sx+s.getBitmapFilter()->width() + 0.5f)), maxX);
+         int x0 = SkClampMax(int(ceil(SkScalarToFloat(srcPt.fX)-s.getBitmapFilter()->width())), maxX);

[reed1, 2013/07/10 20:56:12]

sk_float_ceil2int
sk_float_floor2int

These guys will
1. avoid the implicit up-scale to double that ceil does
2. encapsulate the cast to int for you

If your starting with SkScalar (as you are), those are already wrapped as
well...

SkScalarCeilToInt
SkScalarFloorToInt

+         int x1 = SkClampMax(int(floor(SkScalarToFloat(srcPt.fX)+s.getBitmapFilter()->width())), maxX);
 
          for (int src_y = y0; src_y <= y1; src_y++) {
              SkFixed yweight = s.getBitmapFilter()->lookup((srcPt.fY - src_y));
 
              for (int src_x = x0; src_x <= x1 ; src_x++) {
                  SkFixed xweight = s.getBitmapFilter()->lookup((srcPt.fX - src_x));
 
                  SkFixed combined_weight = SkFixedMul(xweight, yweight);
 
                  SkPMColor c = *s.fBitmap->getAddr32(src_x, src_y);
@@ skipping 92 matching lines @@
             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);
+            float sx = (x + 0.5f) / scale - 0.5f;
+            int x0 = SkClampMax(int(ceil(sx-filter->width())), src->width()-1);
+            int x1 = SkClampMax(int(floor(sx+filter->width())), 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);
@@ skipping 21 matching lines @@
 
     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);
+            float dx = (x + 0.5f) * scale - 0.5f;
+            int x0 = SkClampMax(int(ceil(dx-filter->width())), dst->width()-1);
+            int x1 = SkClampMax(int(floor(dx+filter->width())), 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;
+            float sy = (y + 0.5f) / 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);
@@ skipping 23 matching lines @@
 
     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;
+            float dy = (y + 0.5f) * scale - 0.5f;
             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);
@@ skipping 30 matching lines @@
     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);
 }