add skpdiff tool to compare bitmaps

experimental/skpdiff/SkImageDiffer.cpp

Index: experimental/skpdiff/SkImageDiffer.cpp
diff --git a/experimental/skpdiff/SkImageDiffer.cpp b/experimental/skpdiff/SkImageDiffer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d00d61929da217b7c94cad7114bbbd7d419c36c4
--- /dev/null
+++ b/experimental/skpdiff/SkImageDiffer.cpp
@@ -0,0 +1,230 @@
+#include <cstring>
+#include <iostream>
+#include "SkBitmap.h"
+#include "SkImageDecoder.h"
+#include "SkImageDiffer.h"
+#include "SkStream.h"
+#include "skpdiff_util.h"
+
+
+ImageDiffer::ImageDiffer()
+    : fIsGood(true) {

[djsollen, 2013/06/12 13:32:04]

why do you assume good here and bad in the CLImageDiffer?

[Zach Reizner, 2013/06/12 21:57:47]

By default, differs are good. CLImageDiffer is not good because it is not
initialized on construction.

+
+}
+
+ImageDiffer::~ImageDiffer() {
+
+}
+
+int ImageDiffer::queueDiffOfFile(const char baseline[], const char test[]) {
+    SkBitmap baselineBitmap;
+    SkBitmap testBitmap;
+    if (!SkImageDecoder::DecodeFile(baseline, &baselineBitmap)) {
+        std::cerr << "Failed to load bitmap \"" << baseline << "\"" << std::endl;

[djsollen, 2013/06/12 13:32:04]

As a general rule we don't use stl.  Use SkDebugf() instead.

[Zach Reizner, 2013/06/12 21:57:47]

Done.

+        return -1;
+    }
+    if (!SkImageDecoder::DecodeFile(test, &testBitmap)) {
+        std::cerr << "Failed to load bitmap \"" << test << "\"" << std::endl;
+        return -1;
+    }
+    return this->queueDiff(&baselineBitmap, &testBitmap);
+}
+
+////////////////////////////////////////////////////////////////
+
+CLImageDiffer::CLImageDiffer()
+{
+    fIsGood = false;
+}
+
+
+bool CLImageDiffer::init(cl_device_id device, cl_context context) {
+    fContext = context;
+    fDevice = device;
+
+    cl_int queueErr;
+    fCommandQueue = clCreateCommandQueue(fContext, fDevice, 0, &queueErr);
+    if (CL_SUCCESS != queueErr) {
+        std::cerr << "Command queue creation failed: " << cl_error_to_string(queueErr) << std::endl;
+        fIsGood = false;
+        return false;
+    }
+
+    bool initResult = this->onInit();
+    fIsGood = initResult;
+    return initResult;
+}
+
+bool CLImageDiffer::loadKernelFile(const char file[], const char name[], cl_kernel* kernel) {
+    // Open the kernel source file
+    SkFILEStream sourceStream(file);
+    if (!sourceStream.isValid()) {
+        std::cerr << "Failed to open kernel source file" << std::endl;
+        return false;
+    }
+
+    return loadKernelStream(&sourceStream, name, kernel);
+}
+
+bool CLImageDiffer::loadKernelStream(SkStream* stream, const char name[], cl_kernel* kernel) {
+    // Read the kernel source into memory
+    SkString sourceString;
+    sourceString.resize(stream->getLength());
+    size_t bytesRead = stream->read(sourceString.writable_str(), sourceString.size());
+    if (bytesRead != sourceString.size()) {
+        std::cerr << "Failed to read kernel source file" << std::endl;
+        return false;
+    }
+
+    return loadKernelSource(sourceString.c_str(), name, kernel);
+}
+
+bool CLImageDiffer::loadKernelSource(const char source[], const char name[], cl_kernel* kernel) {
+    // Build the kernel source
+    size_t sourceLen = strlen(source);
+    cl_program program = clCreateProgramWithSource(fContext, 1, &source, &sourceLen, NULL);
+    cl_int programErr = clBuildProgram(program, 1, &fDevice, "", NULL, NULL);
+    if (CL_SUCCESS != programErr) {
+        std::cerr << "Program creation failed: " << cl_error_to_string(programErr) << std::endl;
+
+        // Attempt to get information about why the build failed
+        char buildLog[4096];
+        clGetProgramBuildInfo(program, fDevice, CL_PROGRAM_BUILD_LOG, sizeof(buildLog), buildLog, NULL);
+        std::cerr << "Build log: " << buildLog << std::endl;
+
+        return false;
+    }
+
+    cl_int kernelErr;
+    *kernel = clCreateKernel(program, name, &kernelErr);
+    if (CL_SUCCESS != kernelErr) {
+        std::cerr << "Kernel creation failed: " << cl_error_to_string(kernelErr) << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+bool CLImageDiffer::makeImage2D(SkBitmap* bitmap, cl_mem* image) {
+    cl_int imageErr;
+    cl_image_format bitmapFormat;
+    switch (bitmap->config()) {
+        case SkBitmap::kA8_Config:
+            bitmapFormat.image_channel_order = CL_A;
+            bitmapFormat.image_channel_data_type = CL_UNSIGNED_INT8;
+            break;
+        case SkBitmap::kRGB_565_Config:
+            bitmapFormat.image_channel_order = CL_RGB;
+            bitmapFormat.image_channel_data_type = CL_UNORM_SHORT_565;
+            break;
+        case SkBitmap::kARGB_8888_Config:
+            bitmapFormat.image_channel_order = CL_RGBA;
+            bitmapFormat.image_channel_data_type = CL_UNSIGNED_INT8;
+            break;
+        default:
+            std::cerr << "Image format is unsupported" << std::endl;
+            return false;
+    }
+
+    // Upload the bitmap data to OpenCL
+    bitmap->lockPixels();
+    *image = clCreateImage2D(fContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+                             &bitmapFormat, bitmap->width(), bitmap->height(),
+                             bitmap->rowBytes(), bitmap->getPixels(),
+                             &imageErr);
+    bitmap->unlockPixels();
+
+    if (CL_SUCCESS != imageErr) {
+        std::cerr << "Input image creation failed: " << cl_error_to_string(imageErr) << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////
+
+const char* DifferentPixelsImageDiffer::getName() {
+    return "Find Different Pixels";
+}
+
+int DifferentPixelsImageDiffer::queueDiff(SkBitmap * baseline, SkBitmap * test) {
+    int diffID = fQueuedDiffs.count();
+    double startTime = get_seconds();
+    LocalQueuedDiff* diff = fQueuedDiffs.push();
+
+    // Ensure the images are comparable
+    if (baseline->width() != test->width() || baseline->height() != test->height() ||
+                    baseline->width() <= 0 || baseline->height() <= 0) {
+        diff->finished = true;
+        diff->result = 0.0;
+        return diffID;
+    }
+
+    // Upload images to the CL device
+    if (!this->makeImage2D(baseline, &diff->baseline) || !this->makeImage2D(test, &diff->test))
+    {
+        diff->finished = true;
+        diff->result = 0.0;
+        fIsGood = false;
+        return -1;
+    }
+
+    diff->result = 1.0 / ((double)baseline->width() * baseline->height());
+
+    // Make a buffer to store results into
+    int numDiffPixels = 0;
+    diff->resultsBuffer = clCreateBuffer(fContext, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
+                                         sizeof(int), &numDiffPixels, NULL);
+
+    // Set all kernel arguments
+    cl_int setArgErr = clSetKernelArg(fKernel, 0, sizeof(cl_mem), &diff->baseline);
+    setArgErr       |= clSetKernelArg(fKernel, 1, sizeof(cl_mem), &diff->test);
+    setArgErr       |= clSetKernelArg(fKernel, 2, sizeof(cl_mem), &diff->resultsBuffer);
+    if (CL_SUCCESS != setArgErr) {
+        std::cerr << "Set arg failed: " << cl_error_to_string(setArgErr) << std::endl;
+        fIsGood = false;
+        return -1;
+    }
+
+    // Queue this diff on the CL device
+    cl_event event;
+    const size_t workSize[] = { baseline->width(), baseline->height() };
+    cl_int enqueueErr;
+    enqueueErr = clEnqueueNDRangeKernel(fCommandQueue, fKernel, 2, NULL, workSize, NULL, 0, NULL, &event);
+    if (CL_SUCCESS != enqueueErr) {
+        std::cerr << "Enqueue failed: " << cl_error_to_string(enqueueErr) << std::endl;
+        fIsGood = false;
+        return -1;
+    }
+
+    // This makes things totally synchronous. Actual queue is not ready yet
+    clWaitForEvents(1, &event);
+    diff->finished = true;
+
+    // Immediate read back the results
+    clEnqueueReadBuffer(fCommandQueue, diff->resultsBuffer, CL_TRUE, 0, sizeof(int), &numDiffPixels, 0, NULL, NULL);
+    diff->result *= (double)numDiffPixels;
+    diff->result = (1.0 - diff->result);
+    std::cerr << "Time: " << (get_seconds() - startTime) << std::endl;
+
+    return diffID;
+}
+
+bool DifferentPixelsImageDiffer::isFinished(int id) {
+    return fQueuedDiffs[id].finished;
+}
+
+double DifferentPixelsImageDiffer::getResult(int id) {
+    return fQueuedDiffs[id].result;
+}
+
+
+bool DifferentPixelsImageDiffer::onInit() {
+    if (!loadKernelFile("experimental/skpdiff/diff_pixels.cl", "diff", &fKernel)) {
+        return false;
+    }
+
+    return true;
+}