2011-06-02  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.

        * DumpRenderTree/efl: Added.

        * DumpRenderTree/efl/ImageDiff.cpp: Added.

        (differenceImageFromDifferenceBuffer):

        (calculateDifference):

        (getTemporaryFile):

        (printImage):

        (printImageDifferences):

        (readImageFromStdin):

        (parseCommandLineOptions):

        (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 <Ecore.h>

#include <Ecore_Evas.h>

#include <Evas.h>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <cstring>

#include <getopt.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

using namespace std;

static double tolerance = 0;

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

{

    Evas_Object* image = evas_object_image_filled_add(evas);

    if (!image)

        return 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;

}

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);

    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* diffBuffer = static_cast<unsigned char*>(malloc(width * height));

    unsigned char* currentDiffPixel = diffBuffer;

    if (!diffBuffer) {

        printf("Error, couldn't allocate difference buffer.\n");

        return 100;

    }

    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]) / max<float>(255 - basePixel[0], basePixel[0]);

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

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

            float alpha = (actualPixel[3] - basePixel[3]) / 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 = 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 = max(difference, 0.01f); // round to 2 decimal places

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

    }

    free(diffBuffer);

    return difference;

}

int getTemporaryFile(char *fileName, size_t fileNameLen)

{

    if (getenv("TMPDIR"))

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

    else if (getenv("TEMP"))

        snprintf(fileName, fileNameLen, "%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, "/tmp/ImageDiffXXXXXX.png");

    }

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

}

void printImage(Evas_Object* image)

{

    char* buffer;

    size_t bufferSize;

    char fileName[PATH_MAX];

    int tempImageFd;

    tempImageFd = getTemporaryFile(fileName, PATH_MAX);

    if (tempImageFd < 0)

        return;

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

        struct stat fileInfo;

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

            unsigned char buffer[2048];

            ssize_t bytesRead;

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

            fflush(stdout);

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

                write(1, buffer, bytesRead);

        }

    }

    close(tempImageFd);

    unlink(fileName);

}

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);

}

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

{

    Evas_Object* image;

    unsigned char* imageBuffer;

    imageBuffer = static_cast<unsigned char *>(malloc(imageSize));

    if (!imageBuffer)

        return 0;

    image = evas_object_image_filled_add(evas);

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

    if (bytesRead > 0)

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

    else {

        free(imageBuffer);

        evas_object_del(image);

        return 0;

    }

    free(imageBuffer);

    evas_object_image_size_get(image, width, height);

    return image;

}

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;

}

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

{

    Evas_Object* actualImage = 0;

    Evas_Object* baselineImage = 0;

    Ecore_Evas* ecoreEvas = 0;

    Evas* evas = 0;

    char buffer[2048];

    int returnValue = 0;

    int bufferWidth = 1;

    int bufferHeight = 1;

    if (!parseCommandLineOptions(argc, argv))

        return 1;

    evas_init();

    ecore_init();

    ecore_evas_init();

    ecoreEvas = ecore_evas_buffer_new(bufferWidth, bufferHeight);

    evas = ecore_evas_get(ecoreEvas);

    if (!evas) {

        printf("Error, couldn't create ecore evas buffer.\n");

        returnValue = 1;

        goto shutdown;

    }

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

        char* newLineCharacter = strchr(buffer, '\n');

        if (newLineCharacter)

            *newLineCharacter = '\0';

        if (!strncmp("Content-Length: ", buffer, 16)) {

            long imageSize;

            int width, height;

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

                printf("Error, image size must be specified.\n");

                returnValue = 1;

                goto shutdown;

            }

            if (imageSize > 0) {

                if (!actualImage) {

                    if (!(actualImage = readImageFromStdin(evas, imageSize, &width, &height))) {

                        printf("Error, could not read actual image.\n");

                        returnValue = 1;

                        goto shutdown;

                    }

                    if (width > bufferWidth)

                        bufferWidth = width;

                    if (height > bufferHeight)

                        bufferWidth = width;

                    ecore_evas_resize(ecoreEvas, bufferWidth, bufferHeight);

                } else if (!baselineImage) {

                    if (!(baselineImage = readImageFromStdin(evas, imageSize, &width, &height))) {

                        printf("Error, could not read baseline image.\n");

                        returnValue = 1;

                        goto shutdown;

                    }

                    if (width > bufferWidth)

                        bufferWidth = width;

                    if (height > bufferHeight)

                        bufferWidth = width;

                    ecore_evas_resize(ecoreEvas, bufferWidth, bufferHeight);

                }

            } else {

                printf("Error, image size must be specified.\n");

                returnValue = 1;

                goto shutdown;

            }

        }

        if (actualImage && baselineImage) {

            printImageDifferences(baselineImage, actualImage);

            evas_object_del(actualImage);

            evas_object_del(baselineImage);

            actualImage = 0;

            baselineImage = 0;

        }

        fflush(stdout);

    }

shutdown:

    if (ecoreEvas)

        ecore_evas_free(ecoreEvas);

    ecore_evas_shutdown();

    ecore_shutdown();

    evas_shutdown();

    return returnValue;

}