/* -*- Mode: C; c-basic-offset: 2; -*- */
/* GdkPixbuf library - test loaders
*
* Copyright (C) 2014 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
*
* Author: Matthias Clasen
*/
#include "config.h"
#include "test-common.h"
#include "gdk-pixbuf/gdk-pixbuf.h"
#include <string.h>
/* Checkerboard of black and white pxels (actually (1,1,1) and (255,255,255)
* so they average to (128,128,128)) */
GdkPixbuf *
make_checkerboard (int width, int height)
{
GdkPixbuf *checkerboard;
guint x, y;
guchar *row; /* Pointer to start of row of pixels within the image */
guchar *pixel; /* Pointer to current pixel data in row */
checkerboard = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, width, height);
g_assert_nonnull (checkerboard);
for (y = 0, row = gdk_pixbuf_get_pixels (checkerboard);
y < height;
y++, row += gdk_pixbuf_get_rowstride (checkerboard))
{
for (x = 0, pixel = row;
x < width;
x++, pixel += gdk_pixbuf_get_n_channels (checkerboard))
{
pixel[0] = pixel[1] = pixel[2] = (x ^ y) & 1 ? 1 : 255;
}
}
return checkerboard;
}
/* Image where all the pixels have different colours */
GdkPixbuf *
make_rg (int width, int height)
{
GdkPixbuf *pixbuf;
guint x, y;
guchar *row; /* Pointer to start of row of pixels within the image */
guchar *pixel; /* Pointer to current pixel data in row */
/* Make a source image whose pixels are all of different colors */
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, width, height);
g_assert_nonnull (pixbuf);
for (y = 0, row = gdk_pixbuf_get_pixels (pixbuf);
y < height;
y++, row += gdk_pixbuf_get_rowstride (pixbuf))
{
for (x = 0, pixel = row;
x < width;
x++, pixel += gdk_pixbuf_get_n_channels (pixbuf))
{
pixel[0] = x & 255; pixel[1] = y & 255;
/* If image > 256 pixels wide/high put the extra bits in the last pixel */
pixel[2] = ((x >> 8) & 15) | ((( y >> 8) & 15) << 4);
}
}
return pixbuf;
}
gboolean
format_supported (const gchar *filename)
{
GSList *formats, *l;
gboolean retval;
retval = FALSE;
formats = gdk_pixbuf_get_formats ();
for (l = formats; l; l = l->next)
{
GdkPixbufFormat *format = l->data;
char **extensions = gdk_pixbuf_format_get_extensions (format);
gint i;
for (i = 0; extensions[i]; i++)
{
if (g_str_has_suffix (filename, extensions[i]))
{
retval = TRUE;
break;
}
}
g_free (extensions);
if (retval)
break;
}
g_slist_free (formats);
return retval;
}
gboolean
file_supported (GFile *file)
{
char *uri;
gboolean result;
uri = g_file_get_uri (file);
result = format_supported (uri);
g_free (uri);
return result;
}
gboolean
skip_if_insufficient_memory (GError **err)
{
if (*err && g_error_matches (*err, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY))
{
g_test_skip ((*err)->message);
g_error_free (*err);
*err = NULL;
return TRUE;
}
return FALSE;
}
gboolean
pixdata_equal (GdkPixbuf *test,
GdkPixbuf *ref,
GError **error)
{
if (gdk_pixbuf_get_colorspace (test) != gdk_pixbuf_get_colorspace (ref))
{
g_set_error (error, GDK_PIXBUF_ERROR, 0, "Image colorspace is %d but should be %d",
gdk_pixbuf_get_colorspace (test), gdk_pixbuf_get_colorspace (ref));
return FALSE;
}
if (gdk_pixbuf_get_n_channels (test) != gdk_pixbuf_get_n_channels (ref))
{
g_set_error (error, GDK_PIXBUF_ERROR, 0,
"has %u channels but should have %u",
gdk_pixbuf_get_n_channels (test), gdk_pixbuf_get_n_channels (ref));
return FALSE;
}
if (gdk_pixbuf_get_bits_per_sample (test) != gdk_pixbuf_get_bits_per_sample (ref))
{
g_set_error (error, GDK_PIXBUF_ERROR, 0,
"Image is %u bits per sample but should be %u bits per sample",
gdk_pixbuf_get_bits_per_sample (test), gdk_pixbuf_get_bits_per_sample (ref));
return FALSE;
}
if (gdk_pixbuf_get_width (test) != gdk_pixbuf_get_width (ref) ||
gdk_pixbuf_get_height (test) != gdk_pixbuf_get_height (ref))
{
g_set_error (error, GDK_PIXBUF_ERROR, 0,
"Image size is %dx%d but should be %dx%d",
gdk_pixbuf_get_width (test), gdk_pixbuf_get_height (test),
gdk_pixbuf_get_width (ref), gdk_pixbuf_get_height (ref));
return FALSE;
}
if (gdk_pixbuf_get_rowstride (test) != gdk_pixbuf_get_rowstride (ref))
{
g_set_error (error, GDK_PIXBUF_ERROR, 0,
"Image rowstrides is %u bytes but should be %u bytes",
gdk_pixbuf_get_rowstride (test), gdk_pixbuf_get_rowstride (ref));
return FALSE;
}
if (memcmp (gdk_pixbuf_get_pixels (test), gdk_pixbuf_get_pixels (ref),
gdk_pixbuf_get_byte_length (test)) != 0)
{
gint x, y, width, height, n_channels, rowstride;
const guchar *test_pixels, *ref_pixels;
rowstride = gdk_pixbuf_get_rowstride (test);
n_channels = gdk_pixbuf_get_n_channels (test);
width = gdk_pixbuf_get_width (test);
height = gdk_pixbuf_get_height (test);
test_pixels = gdk_pixbuf_get_pixels (test);
ref_pixels = gdk_pixbuf_get_pixels (ref);
g_assert_cmpint (width, >=, 0);
g_assert_cmpint (height, >=, 0);
g_assert_cmpint (n_channels, >=, 0);
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
if (memcmp (&test_pixels[x * n_channels], &ref_pixels[x * n_channels], n_channels) != 0)
{
if (n_channels == 4)
{
g_set_error (error, GDK_PIXBUF_ERROR, 0, "Image data at %ux%u is #%02X%02X%02X%02X, but should be #%02X%02X%02X%02X",
x, y,
test_pixels[x * n_channels + 0], test_pixels[x * n_channels + 1], test_pixels[x * n_channels + 2], test_pixels[x * n_channels + 3],
ref_pixels[x * n_channels + 0], ref_pixels[x * n_channels + 1], ref_pixels[x * n_channels + 2], ref_pixels[x * n_channels + 3]);
}
else if (n_channels == 3)
{
g_set_error (error, GDK_PIXBUF_ERROR, 0, "Image data at %ux%u is #%02X%02X%02X, but should be #%02X%02X%02X",
x, y,
test_pixels[x * n_channels + 0], test_pixels[x * n_channels + 1], test_pixels[x * n_channels + 2],
ref_pixels[x * n_channels + 0], ref_pixels[x * n_channels + 1], ref_pixels[x * n_channels + 2]);
}
else
{
g_set_error (error, GDK_PIXBUF_ERROR, 0, "Image data differ at %ux%u", x, y);
}
return FALSE;
}
}
test_pixels += rowstride;
ref_pixels += rowstride;
}
}
return TRUE;
}
static int
compare_files (gconstpointer a, gconstpointer b)
{
GFile *file1 = G_FILE (a);
GFile *file2 = G_FILE (b);
char *uri1, *uri2;
int result;
uri1 = g_file_get_uri (file1);
uri2 = g_file_get_uri (file2);
result = strcmp (uri1, uri2);
g_free (uri1);
g_free (uri2);
return result;
}
void
add_test_for_all_images (const gchar *prefix,
GFile *base,
GFile *file,
GTestDataFunc test_func,
AddTestFunc add_test_func)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GList *l, *files;
GError *error = NULL;
if (g_file_query_file_type (file, 0, NULL) != G_FILE_TYPE_DIRECTORY)
{
gchar *test_path;
gchar *relative_path;
if (base)
relative_path = g_file_get_relative_path (base, file);
else
relative_path = g_file_get_path (file);
test_path = g_strconcat (prefix, "/", relative_path, NULL);
g_test_add_data_func_full (test_path, g_object_ref (file), test_func, g_object_unref);
return;
}
enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
g_assert_no_error (error);
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
{
GFile *next_file = g_file_get_child (file, g_file_info_get_name (info));
if (add_test_func == NULL || add_test_func (next_file))
{
files = g_list_prepend (files, g_object_ref (next_file));
}
g_object_unref (next_file);
g_object_unref (info);
}
g_assert_no_error (error);
g_object_unref (enumerator);
files = g_list_sort (files, compare_files);
for (l = files; l; l = l->next)
{
add_test_for_all_images (prefix, base, l->data, test_func, add_test_func);
}
g_list_free_full (files, g_object_unref);
}