improve convolve speed of skpdiff using direct pointers

experimental/skpdiff/SkPMetric.cpp

 #include <cmath>
 
 #include "SkBitmap.h"
 #include "skpdiff_util.h"
 #include "SkPMetric.h"
 
 struct RGB {
     float r, g, b;
 };
 
@@ skipping 20 matching lines @@
     }
 
     void readPixel(int x, int y, T* pixel) const {
         SkASSERT(x >= 0);
         SkASSERT(y >= 0);
         SkASSERT(x < width);
         SkASSERT(y < height);
         *pixel = image[y * width + x];
     }
 
+    T * getRow(int y) const {

[djsollen, 2013/07/12 18:07:10]

T* no space

+        return &image[y * width];
+    }
+
     void writePixel(int x, int y, const T& pixel) {
         SkASSERT(x >= 0);
         SkASSERT(y >= 0);
         SkASSERT(x < width);
         SkASSERT(y < height);
         image[y * width + x] = pixel;
     }
 };
 
 typedef Image2D<float> ImageL;
@@ skipping 138 matching lines @@
         }
     }
 }
 
 /// Convolves an image with the given filter in one direction and saves it to the output image
 static void convolve(const ImageL* imageL,
                      bool vertical, const float* matrix, int radius,
                      ImageL* outImageL) {
     SkASSERT(imageL->width == outImageL->width);
     SkASSERT(imageL->height == outImageL->height);
+
+    // Keep track of what rows are being operated on for quick access.
+    int filterCount = radius * 2 + 1;
+    float * rowPtrs[8];

[djsollen, 2013/07/12 18:07:10]

float* here and on 210

+    for (int y = radius; y < filterCount; y++) {
+        rowPtrs[y] = imageL->getRow(y - radius);

[djsollen, 2013/07/12 18:07:10]

how can you ensure that y is never greater than 7?

[Zach Reizner, 2013/07/12 18:51:43]

convolve is static and only ever called from pmetric. The filter always has a
size of 5. Thinking about it now, I may as well keep the filter here and avoid
future misuse of convolve.

+    }
+    float * writeRow = outImageL->getRow(0);
+
+
     for (int y = 0; y < imageL->height; y++) {
         for (int x = 0; x < imageL->width; x++) {
             float lSum = 0.0f;
-            float l;
             for (int xx = -radius; xx <= radius; xx++) {
                 int nx = x;
                 int ny = y;
 
                 // We mirror at edges so that edge pixels that the filter weighting still makes
                 // sense.
                 if (vertical) {
                     ny += xx;
                     if (ny < 0) {
                         ny = -ny;
                     }
                     if (ny >= imageL->height) {
                         ny = imageL->height + (imageL->height - ny - 1);
                     }
                 } else {
                     nx += xx;
                     if (nx < 0) {
                         nx = -nx;
                     }
                     if (nx >= imageL->width) {
                         nx = imageL->width + (imageL->width - nx - 1);
                     }
                 }
 
-                imageL->readPixel(nx, ny, &l);
                 float weight = matrix[xx + radius];
-                lSum += l * weight;
+                lSum += rowPtrs[ny - y + radius][nx] * weight;
             }
-            outImageL->writePixel(x, y, lSum);
+            writeRow[x] = lSum;
         }
+        // As we move down, scroll the row pointers down with us
+        for (int y = 0; y < filterCount - 1; y++)
+        {
+            rowPtrs[y] = rowPtrs[y + 1];
+        }
+        rowPtrs[filterCount - 1] += imageL->width;
+        writeRow += imageL->width;
     }
 }
 
 float pmetric(const ImageLAB* baselineLAB, const ImageLAB* testLAB, SkTDArray<SkIPoint>* poi) {
     int width = baselineLAB->width;
     int height = baselineLAB->height;
     int maxLevels = (int)log2(width < height ? width : height);
 
     const float fov = M_PI / 180.0f * 45.0f;
     float contrastSensitivityMax = contrast_sensitivity(3.248f, 100.0f);
@@ skipping 182 matching lines @@
     return fQueuedDiffs[id].result;
 }
 
 int SkPMetric::getPointsOfInterestCount(int id) {
     return fQueuedDiffs[id].poi.count();
 }
 
 SkIPoint* SkPMetric::getPointsOfInterest(int id) {
     return fQueuedDiffs[id].poi.begin();
 }