/* imagediff - Compare two images

 *

 * Copyright © 2004 Richard D. Worth

 *

 * Permission to use, copy, modify, distribute, and sell this software

 * and its documentation for any purpose is hereby granted without

 * fee, provided that the above copyright notice appear in all copies

 * and that both that copyright notice and this permission notice

 * appear in supporting documentation, and that the name of Richard Worth

 * not be used in advertising or publicity pertaining to distribution

 * of the software without specific, written prior permission.

 * Richard Worth makes no representations about the suitability of this

 * software for any purpose.  It is provided "as is" without express

 * or implied warranty.

 *

 * RICHARD WORTH DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN

 * NO EVENT SHALL RICHARD WORTH BE LIABLE FOR ANY SPECIAL, INDIRECT OR

 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 *

 * Author: Richard D. Worth <richard@theworths.org> */

#include "config.h"

#include <assert.h>

#include <stdio.h>

#include <stdlib.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <string.h>

#include <pixman.h>

#include "cairo-test.h"

#include "pdiff.h"

#include "buffer-diff.h"

/* Don't allow any differences greater than this value, even if pdiff

 * claims that the images are identical */

#define PERCEPTUAL_DIFF_THRESHOLD 25

/* Compare two buffers, returning the number of pixels that are

 * different and the maximum difference of any single color channel in

 * result_ret.

 *

 * This function should be rewritten to compare all formats supported by

 * cairo_format_t.

 */

static void

		  const unsigned char *_buf_b, int stride_b, cairo_format_t format_b,

		  unsigned char *_buf_diff, int stride_diff, cairo_format_t format_diff,

		  int		width,

		  int		height,

		  buffer_diff_result_t *result_ret)

{

    int x, y;

	    /* convert pixel data to ARGB32 if necessary */

	    /* check if the pixels are the same */

		int channel;

		/* calculate a difference value for all 4 channels */

		    unsigned int diff;

		}

		    /* alpha only difference, convert to luminance */

		}

	    } else {

	    }

	}

    }

/* Compares two image surfaces

 *

 * Provides number of pixels changed and maximum single-channel

 * difference in result.

 *

 * Also fills in a "diff" surface intended to visually show where the

 * images differ.

 */

static void

	          cairo_surface_t	*surface_a,

		  cairo_surface_t	*surface_b,

		  cairo_surface_t	*surface_diff,

		  buffer_diff_result_t	*result)

{

    /* These default values were taken straight from the

     * perceptualdiff program. We'll probably want to tune these as

     * necessary. */

    int discernible_pixels_changed;

    /* First, we run cairo's old buffer_diff algorithm which looks for

     * pixel-perfect images, (we do this first since the test suite

     * runs about 3x slower if we run pdiff_compare first).

     */

		      cairo_image_surface_get_stride (surface_a),

		      cairo_image_surface_get_format (surface_a),

		      cairo_image_surface_get_stride (surface_b),

		      cairo_image_surface_get_format (surface_b),

		      cairo_image_surface_get_data (surface_diff),

		      cairo_image_surface_get_stride (surface_diff),

		      cairo_image_surface_get_format (surface_diff),

		      cairo_image_surface_get_width (surface_a),

		      cairo_image_surface_get_height (surface_a),

		      result);

	            "%d pixels differ (with maximum difference of %d) from reference image\n",

		    result->pixels_changed, result->max_diff);

    /* Then, if there are any different pixels, we give the pdiff code

     * a crack at the images. If it decides that there are no visually

     * discernible differences in any pixels, then we accept this

     * result as good enough.

     *

     * Only let pdiff have a crack at the comparison if the max difference

     * is lower than a threshold, otherwise some problems could be masked.

     */

                                                    gamma, luminance, field_of_view);

		            "But perceptual diff finds no visually discernible difference.\n"

                            "Accepting result.\n");

        }

    }

}

void

		     const unsigned char *buf_b,

		     unsigned char *buf_diff,

		     int	   width,

		     int	   height,

		     int	   stride,

		     buffer_diff_result_t *result)

{

		     buf_b, stride, CAIRO_FORMAT_RGB24,

		     buf_diff, stride, CAIRO_FORMAT_RGB24,

		     width, height,

		     result);

static cairo_bool_t

{

    unsigned int width_a, height_a;

    unsigned int width_b, height_b;

}

/* Image comparison code courtesy of Richard Worth <richard@theworths.org>

 * Returns number of pixels changed, (or -1 on error).

 * Also saves a "diff" image intended to visually show where the

 * images differ.

 *

 * The return value simply indicates whether a check was successfully

 * made, (as opposed to a file-not-found condition or similar). It

 * does not indicate anything about how much the images differ. For

 * that, see result.

 *

 * One failure mode is if the two images provided do not have the same

 * dimensions. In this case, this function will return

 * CAIRO_STATUS_SURFACE_TYPE_MISMATCH (which is a bit of an abuse, but

 * oh well).

 */

cairo_status_t

	    cairo_surface_t *surface_a,

	    cairo_surface_t *surface_b,

	    cairo_surface_t *surface_diff,

	    buffer_diff_result_t *result)

{

    {

    }

}

cairo_bool_t

                       unsigned int                tolerance)

{

}