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 {
+        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 133 matching lines @@
     for (int y = 0; y < imageLAB->height; y++) {
         for (int x = 0; x < imageLAB->width; x++) {
             LAB lab;
             imageLAB->readPixel(x, y, &lab);
             outImageL->writePixel(x, y, lab.l);
         }
     }
 }
 
 /// 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) {
+static void convolve(const ImageL* imageL, bool vertical, ImageL* outImageL) {
     SkASSERT(imageL->width == outImageL->width);
     SkASSERT(imageL->height == outImageL->height);
+
+    const float matrix[] = { 0.05f, 0.25f, 0.4f, 0.25f, 0.05f };
+    const int matrixCount = sizeof(matrix) / sizeof(float);

[tfarina, 2013/07/16 13:07:26]

SK_ARRAY_COUNT?

+    const int radius = matrixCount / 2;
+
+    // Keep track of what rows are being operated on for quick access.
+    float* rowPtrs[matrixCount]; // Because matrixCount is constant, this won't create a VLA
+    for (int y = radius; y < matrixCount; y++) {
+        rowPtrs[y] = imageL->getRow(y - radius);
+    }
+    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 < matrixCount - 1; y++)
+        {
+            rowPtrs[y] = rowPtrs[y + 1];
+        }
+        rowPtrs[matrixCount - 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);
     float pixelsPerDegree = width / (2.0f * tanf(fov * 0.5f) * 180.0f / M_PI);
 
     ImageL3D baselineL(width, height, maxLevels);
     ImageL3D testL(width, height, maxLevels);
     ImageL scratchImageL(width, height);
     float* cyclesPerDegree = SkNEW_ARRAY(float, maxLevels);
     float* thresholdFactorFrequency = SkNEW_ARRAY(float, maxLevels - 2);
     float* contrast = SkNEW_ARRAY(float, maxLevels - 2);
 
     lab_to_l(baselineLAB, baselineL.getLayer(0));
     lab_to_l(testLAB, testL.getLayer(0));
 
     // Compute cpd - Cycles per degree on the pyramid
     cyclesPerDegree[0] = 0.5f * pixelsPerDegree;
     for (int levelIndex = 1; levelIndex < maxLevels; levelIndex++) {
         cyclesPerDegree[levelIndex] = cyclesPerDegree[levelIndex - 1] * 0.5f;
     }
 
-    const float filterMatrix[] = { 0.05f, 0.25f, 0.4f, 0.25f, 0.05f };
     // Compute G - The convolved lum for the baseline
     for (int levelIndex = 1; levelIndex < maxLevels; levelIndex++) {
-        convolve(baselineL.getLayer(levelIndex - 1), false, filterMatrix, 2, &scratchImageL);
-        convolve(&scratchImageL, true, filterMatrix, 2, baselineL.getLayer(levelIndex));
+        convolve(baselineL.getLayer(levelIndex - 1), false, &scratchImageL);
+        convolve(&scratchImageL, true, baselineL.getLayer(levelIndex));
     }
     for (int levelIndex = 1; levelIndex < maxLevels; levelIndex++) {
-        convolve(testL.getLayer(levelIndex - 1), false, filterMatrix, 2, &scratchImageL);
-        convolve(&scratchImageL, true, filterMatrix, 2, testL.getLayer(levelIndex));
+        convolve(testL.getLayer(levelIndex - 1), false, &scratchImageL);
+        convolve(&scratchImageL, true, testL.getLayer(levelIndex));
     }
 
     // Compute F_freq - The elevation f
     for (int levelIndex = 0; levelIndex < maxLevels - 2; levelIndex++) {
         float cpd = cyclesPerDegree[levelIndex];
         thresholdFactorFrequency[levelIndex] = contrastSensitivityMax /
                                                contrast_sensitivity(cpd, 100.0f);
     }
 
     int failures = 0;
@@ skipping 145 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();
 }