2011-06-16  Leandro Pereira  <leandro@profusion.mobi>

        Reviewed by NOBODY (OOPS!).

        [EFL] Add ImageDiff implementation.

        Build system changes will be made as soon as the complete

        DumpRenderTree implementation is upstreamed.

        https://bugs.webkit.org/show_bug.cgi?id=61942

        * DumpRenderTree/efl: Added.

        * DumpRenderTree/efl/ImageDiff.cpp: Added.

        (differenceImageFromDifferenceBuffer):

        (calculateDifference):

        (getTemporaryFile):

        (printImage):

        (printImageDifferences):

        (readImageFromStdin):

        (parseCommandLineOptions):

        (resizeEcoreEvasIfNeeded):

        (shutdownEfl):

        (abortWithErrorMessage):

        (initEfl):

        (readImageFromStdinIfEmpty):

        (printDifferencesAndCleanup):

        (main):

/*

 * Copyright (C) 2009 Zan Dobersek <zandobersek@gmail.com>

 * Copyright (C) 2010 Igalia S.L.

 * Copyright (C) 2011 ProFUSION Embedded Systems

 * Copyright (C) 2011 Samsung Electronics

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include <Ecore.h>

#include <Ecore_Evas.h>

#include <Evas.h>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <getopt.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include <wtf/OwnArrayPtr.h>

static Ecore_Evas* ecoreEvas = 0;

static double tolerance = 0;

static void abortWithErrorMessage(const char* errorMessage);

static Evas_Object* differenceImageFromDifferenceBuffer(Evas* evas, unsigned char* buffer, int width, int height)

{

    Evas_Object* image = evas_object_image_filled_add(evas);

    if (!image)

        abortWithErrorMessage("could not create difference image");

    evas_object_image_size_set(image, width, height);

    evas_object_image_colorspace_set(image, EVAS_COLORSPACE_ARGB8888);

    unsigned char* diffPixels = static_cast<unsigned char*>(evas_object_image_data_get(image, EINA_TRUE));

    const int rowStride = evas_object_image_stride_get(image);

    for (int x = 0; x < width; x++) {

        for (int y = 0; y < height; y++) {

            unsigned char* diffPixel = diffPixels + (y * rowStride) + (x * 4);

            diffPixel[0] = diffPixel[1] = diffPixel[2] = *buffer++;

            diffPixel[3] = 0xff; // Alpha channel

        }

    }

    return image;

}

static float calculateDifference(Evas_Object* baselineImage, Evas_Object* actualImage, Evas_Object** differenceImage)

{

    int width, height, baselineWidth, baselineHeight;

    evas_object_image_size_get(actualImage, &width, &height);

    evas_object_image_size_get(baselineImage, &baselineWidth, &baselineHeight);

    if (width != baselineWidth

        || height != baselineHeight

        || evas_object_image_alpha_get(actualImage) != evas_object_image_alpha_get(baselineImage)) {

        printf("Error, test and reference image have different properties.\n");

        return 100; // Completely different.

    }

    evas_object_image_colorspace_set(actualImage, EVAS_COLORSPACE_ARGB8888);

    evas_object_image_colorspace_set(baselineImage, EVAS_COLORSPACE_ARGB8888);

    OwnArrayPtr<unsigned char> diffBuffer = adoptArrayPtr(new unsigned char[width * height]);

    if (!diffBuffer)

        abortWithErrorMessage("could not create difference buffer");

    const int numberOfChannels = 4; // Alpha + R + G + B

    const int actualRowStride = evas_object_image_stride_get(actualImage);

    const int baseRowStride = evas_object_image_stride_get(baselineImage);

    float count = 0;

    float sum = 0;

    float maxDistance = 0;

    unsigned char* actualPixels = static_cast<unsigned char*>(evas_object_image_data_get(actualImage, EINA_FALSE));

    unsigned char* basePixels = static_cast<unsigned char*>(evas_object_image_data_get(baselineImage, EINA_FALSE));

    unsigned char* currentDiffPixel = diffBuffer.get();

    for (int x = 0; x < width; x++) {

        for (int y = 0; y < height; y++) {

            unsigned char* actualPixel = actualPixels + (y * actualRowStride) + (x * numberOfChannels);

            unsigned char* basePixel = basePixels + (y * baseRowStride) + (x * numberOfChannels);

            float red = (actualPixel[0] - basePixel[0]) / std::max<float>(255 - basePixel[0], basePixel[0]);

            float green = (actualPixel[1] - basePixel[1]) / std::max<float>(255 - basePixel[1], basePixel[1]);

            float blue = (actualPixel[2] - basePixel[2]) / std::max<float>(255 - basePixel[2], basePixel[2]);

            float alpha = (actualPixel[3] - basePixel[3]) / std::max<float>(255 - basePixel[3], basePixel[3]);

            float distance = sqrtf(red * red + green * green + blue * blue + alpha * alpha) / 2.0f;

            *currentDiffPixel++ = static_cast<unsigned char>(distance * 255.0f);

            if (distance >= 1.0f / 255.0f) {

                count += 1.0f;

                sum += distance;

                maxDistance = std::max<float>(maxDistance, distance);

            }

        }

    }

    // Compute the difference as a percentage combining both the number of

    // different pixels and their difference amount i.e. the average distance

    // over the entire image

    float difference = 0;

    if (count > 0.0f)

        difference = 100.0f * sum / (height * width);

    if (difference <= tolerance)

        difference = 0;

    else {

        difference = roundf(difference * 100.0f) / 100.0f;

        difference = std::max(difference, 0.01f); // round to 2 decimal places

        *differenceImage = differenceImageFromDifferenceBuffer(evas_object_evas_get(baselineImage), diffBuffer.get(), width, height);

    }

    return difference;

}

static int getTemporaryFile(char *fileName, size_t fileNameLength)

{

    if (getenv("TMPDIR"))

        snprintf(fileName, fileNameLength, "%s/ImageDiffXXXXXX.png", getenv("TMPDIR"));

    else if (getenv("TEMP"))

        snprintf(fileName, fileNameLength, "%s/ImageDiffXXXXXX.png", getenv("TEMP"));

    else {

#if __linux__

        strcpy(fileName, "/dev/shm/ImageDiffXXXXXX.png");

        int fileDescriptor = mkstemps(fileName, sizeof(".png") - 1);

        if (fileDescriptor >= 0)

            return fileDescriptor;

#endif // __linux__

        strcpy(fileName, "ImageDiffXXXXXX.png");

    }

    return mkstemps(fileName, sizeof(".png") - 1);

}

static void printImage(Evas_Object* image)

{

    char fileName[PATH_MAX];

    const int tempImageFd = getTemporaryFile(fileName, PATH_MAX);

    if (tempImageFd == -1)

        abortWithErrorMessage("could not create temporary file");

    if (evas_object_image_save(image, fileName, 0, 0)) {

        struct stat fileInfo;

        if (!stat(fileName, &fileInfo)) {

            printf("Content-Length: %ld\n", fileInfo.st_size);

            fflush(stdout);

            unsigned char buffer[2048];

            ssize_t bytesRead;

            while ((bytesRead = read(tempImageFd, buffer, sizeof(buffer))) > 0)

                write(1, buffer, bytesRead);

        }

    }

    close(tempImageFd);

    unlink(fileName);

}

static void printImageDifferences(Evas_Object* baselineImage, Evas_Object* actualImage)

{

    Evas_Object* differenceImage = 0;

    float difference = calculateDifference(baselineImage, actualImage, &differenceImage);

    if (difference > 0.0f) {

        if (differenceImage) {

            printImage(differenceImage);

            evas_object_del(differenceImage);

        }

        printf("diff: %01.2f%% failed\n", difference);

    } else

        printf("diff: %01.2f%% passed\n", difference);

}

static Evas_Object* readImageFromStdin(Evas* evas, long imageSize, int *width, int *height)

{

    OwnArrayPtr<unsigned char> imageBuffer = adoptArrayPtr(new unsigned char[imageSize]);

    if (!imageBuffer)

        abortWithErrorMessage("cannot allocate image");

    Evas_Object* image = evas_object_image_filled_add(evas);

    const size_t bytesRead = fread(imageBuffer.get(), 1, imageSize, stdin);

    if (bytesRead > 0)

        evas_object_image_memfile_set(image, imageBuffer.get(), bytesRead, 0, 0);

    else {

        evas_object_del(image);

        return 0;

    }

    evas_object_image_size_get(image, width, height);

    return image;

}

static bool parseCommandLineOptions(int argc, char** argv)

{

    static const option options[] = {

        { "tolerance", required_argument, 0, 't' },

        { 0, 0, 0, 0 }

    };

    int option;

    while ((option = getopt_long(argc, (char* const*)argv, "t:", options, 0)) != -1) {

        switch (option) {

        case 't':

            tolerance = atof(optarg);

            break;

        case '?':

        case ':':

            return false;

        }

    }

    return true;

}

static void resizeEcoreEvasIfNeeded(int newWidth, int newHeight)

{

    int currentWidth, currentHeight;

    ecore_evas_screen_geometry_get(ecoreEvas, 0, 0, &currentWidth, &currentHeight);

    if (newWidth > currentWidth)

        currentWidth = newWidth;

    if (newHeight > currentHeight)

        currentHeight = newHeight;

    ecore_evas_resize(ecoreEvas, currentWidth, currentHeight);

}

static void shutdownEfl()

{

    if (ecoreEvas)

        ecore_evas_free(ecoreEvas);

    ecore_evas_shutdown();

    ecore_shutdown();

    evas_shutdown();

}

static void abortWithErrorMessage(const char* errorMessage)

{

    shutdownEfl();

    printf("Error, %s\n", errorMessage);

    exit(EXIT_FAILURE);

}

static Evas* initEfl()

{

    evas_init();

    ecore_init();

    ecore_evas_init();

    ecoreEvas = ecore_evas_buffer_new(1, 1);

    Evas* evas = ecore_evas_get(ecoreEvas);

    if (!evas)

        abortWithErrorMessage("could not create Ecore_Evas buffer");

    return evas;

}

static bool readImageFromStdinIfEmpty(Evas* evas, Evas_Object** image, long imageSize)

{

    Evas_Object* newImage = *image;

    if (!newImage) {

        int width, height;

        newImage = readImageFromStdin(evas, imageSize, &width, &height);

        if (!newImage)

            abortWithErrorMessage("could not read image from standard input");

        resizeEcoreEvasIfNeeded(width, height);

        *image = newImage;

        return true;

    }

    return false;

}

static void printDifferencesAndCleanup(Evas_Object** actualImage, Evas_Object** baselineImage)

{

    printImageDifferences(*baselineImage, *actualImage);

    evas_object_del(*actualImage);

    evas_object_del(*baselineImage);

    *actualImage = 0;

    *baselineImage = 0;

}

int main(int argc, char* argv[])

{

    if (!parseCommandLineOptions(argc, argv))

        return 1;

    Evas* evas = initEfl();

    Evas_Object* actualImage = 0;

    Evas_Object* baselineImage = 0;

    char buffer[2048];

    while (fgets(buffer, sizeof(buffer), stdin)) {

        char* contentLengthStart = strstr(buffer, "Content-Length: ");

        if (!contentLengthStart)

            continue;

        long imageSize;

        if (sscanf(contentLengthStart, "Content-Length: %ld", &imageSize) == 1) {

            if (imageSize <= 0)

                abortWithErrorMessage("image size must be specified");

            if (readImageFromStdinIfEmpty(evas, &actualImage, imageSize))

                continue;

            if (readImageFromStdinIfEmpty(evas, &baselineImage, imageSize))

                printDifferencesAndCleanup(&actualImage, &baselineImage);

        }

        fflush(stdout);

    }

    shutdownEfl();

    return EXIT_SUCCESS;

}