Changes to make SkPDiff more robost.

tools/skpdiff/SkPMetric.cpp

 #include <cmath>
 
 #include "SkBitmap.h"
 #include "skpdiff_util.h"
 #include "SkPMetric.h"
 #include "SkPMetricUtil_generated.h"
 
 struct RGB {
     float r, g, b;
 };
@@ skipping 105 matching lines @@
         } else {
             f[i] = 7.787f * f[i] + 4.0f / 29.0f;
         }
     }
     lab->l = 116.0f * f[1] - 16.0f;
     lab->a = 500.0f * (f[0] - f[1]);
     lab->b = 200.0f * (f[1] - f[2]);
 }
 
 /// Converts a 8888 bitmap to LAB color space and puts it into the output
-static void bitmap_to_cielab(const SkBitmap* bitmap, ImageLAB* outImageLAB) {
-    SkASSERT(bitmap->config() == SkBitmap::kARGB_8888_Config);
+static bool bitmap_to_cielab(const SkBitmap* bitmap, ImageLAB* outImageLAB) {
+    SkBitmap bm8888;
+    if (bitmap->config() != SkBitmap::kARGB_8888_Config) {
+        if (!bitmap->copyTo(&bm8888, SkBitmap::kARGB_8888_Config)) {
+            return false;
+        }
+        bitmap = &bm8888;
+    }
 
     int width = bitmap->width();
     int height = bitmap->height();
     SkASSERT(outImageLAB->width == width);
     SkASSERT(outImageLAB->height == height);
 
     bitmap->lockPixels();
     RGB rgb;
     LAB lab;
     for (int y = 0; y < height; y++) {
         unsigned char* row = (unsigned char*)bitmap->getAddr(0, y);
         for (int x = 0; x < width; x++) {
             // Perform gamma correction which is assumed to be 2.2
             rgb.r = SkPMetricUtil::get_gamma(row[x * 4 + 2]);
             rgb.g = SkPMetricUtil::get_gamma(row[x * 4 + 1]);
             rgb.b = SkPMetricUtil::get_gamma(row[x * 4 + 0]);
             adobergb_to_cielab(rgb.r, rgb.g, rgb.b, &lab);
             outImageLAB->writePixel(x, y, lab);
         }
     }
     bitmap->unlockPixels();
+    return true;
 }
 
 // From Barten SPIE 1989
 static float contrast_sensitivity(float cyclesPerDegree, float luminance) {
     float a = 440.0f * powf(1.0f + 0.7f / luminance, -0.2f);
     float b = 0.3f * powf(1.0f + 100.0f / luminance, 0.15f);
     return a *
            cyclesPerDegree *
            expf(-b * cyclesPerDegree) *
            sqrtf(1.0f + 0.06f * expf(b * cyclesPerDegree));
@@ skipping 103 matching lines @@
     int width = baselineLAB->width;
     int height = baselineLAB->height;
     int maxLevels = 0;
 
     // Calculates how many levels to make by how many times the image can be divided in two
     int smallerDimension = width < height ? width : height;
     for ( ; smallerDimension > 1; smallerDimension /= 2) {
         maxLevels++;
     }
 
+    // We'll be creating new arrays with maxLevels - 2, and ImageL3D requires maxLevels > 0,
+    // so just return failure if we're less than 3.
+    if (maxLevels <= 2) {
+        return 0.0;
+    }
+
     const float fov = SK_ScalarPI / 180.0f * 45.0f;
     float contrastSensitivityMax = contrast_sensitivity(3.248f, 100.0f);
     float pixelsPerDegree = width / (2.0f * tanf(fov * 0.5f) * 180.0f / SK_ScalarPI);
 
     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);
@@ skipping 161 matching lines @@
     // Ensure the images are comparable
     if (baseline->width() != test->width() || baseline->height() != test->height() ||
                     baseline->width() <= 0 || baseline->height() <= 0) {
         diff.finished = true;
         return diffID;
     }
 
     ImageLAB baselineLAB(baseline->width(), baseline->height());
     ImageLAB testLAB(baseline->width(), baseline->height());
 
-    bitmap_to_cielab(baseline, &baselineLAB);
-    bitmap_to_cielab(test, &testLAB);
+    if (!bitmap_to_cielab(baseline, &baselineLAB) || !bitmap_to_cielab(test, &testLAB)) {
+        return diffID;
+    }
 
     diff.result = pmetric(&baselineLAB, &testLAB, &diff.poi);
 
     SkDebugf("Time: %f\n", (get_seconds() - startTime));
 
     return diffID;
 }
 
 
 void SkPMetric::deleteDiff(int id) {
     // clean up the POI array to save space
     return fQueuedDiffs[id].poi.reset();
 }
 
 bool SkPMetric::isFinished(int id) {
     return fQueuedDiffs[id].finished;
 }
 
 double SkPMetric::getResult(int id) {
     return fQueuedDiffs[id].result;
 }
 
 int SkPMetric::getPointsOfInterestCount(int id) {
     return fQueuedDiffs[id].poi.count();
 }
 
 SkIPoint* SkPMetric::getPointsOfInterest(int id) {
     return fQueuedDiffs[id].poi.begin();
 }