gtk/gdk-pixbuf/pixops/timescale.c
Alexander Larsson ba46da61a7 Copy data and free data with free().
2001-02-19 Alexander Larsson  <alexl@redhat.com>

	* gdk/linux-fb/gdkimage-fb.c (gdk_image_new_bitmap):
	Copy data and free data with free().

	* gdk-pixbuf/gdk-pixbuf.c:
	* gdk-pixbuf/io-jpeg.c:
	* gdk-pixbuf/io-png.c:
	Use g_try_malloc/g_free instead malloc/free.

	* gdk-pixbuf/test-gdk-pixbuf.c:
	Must... initialize... gobject...

	* gdk-pixbuf/pixops/timescale.c:
	* gtk/gtkcalendar.c:
	Use g_malloc instead of malloc.
2001-02-19 14:35:25 +00:00

233 lines
5.7 KiB
C

#include <glib.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "pixops.h"
static GTimeVal start_time;
void start_timing (void)
{
g_get_current_time (&start_time);
}
double
stop_timing (const char *test, int iterations, int bytes)
{
GTimeVal stop_time;
double msecs;
g_get_current_time (&stop_time);
if (stop_time.tv_usec < start_time.tv_usec)
{
stop_time.tv_usec += 1000000;
stop_time.tv_sec -= 1;
}
msecs = (stop_time.tv_sec - start_time.tv_sec) * 1000. +
(stop_time.tv_usec - start_time.tv_usec) / 1000.;
printf("%s%d\t%.1f\t\t%.2f\t\t%.2f\n",
test, iterations, msecs, msecs / iterations, ((double)bytes * iterations) / (1000*msecs));
return ((double)bytes * iterations) / (1000*msecs);
}
void
init_array (double times[3][3][4])
{
int i, j, k;
for (i=0; i<3; i++)
for (j=0; j<3; j++)
for (k=0; k<4; k++)
times[i][j][k] = -1;
}
void
dump_array (double times[3][3][4])
{
int i, j;
printf(" 3\t4\t4a\n");
for (i=0; i<3; i++)
{
for (j=0; j<4; j++)
{
if (j == 0)
switch (i)
{
case 0:
printf("3 ");
break;
case 1:
printf("4 ");
break;
case 2:
printf("4a ");
break;
}
else
printf(" ");
printf("%6.2f %6.2f %6.2f",
times[i][0][j], times[i][1][j], times[i][2][j]);
switch (j)
{
case GDK_INTERP_NEAREST:
printf (" NEAREST\n");
break;
case GDK_INTERP_TILES:
printf (" TILES\n");
break;
case GDK_INTERP_BILINEAR:
printf (" BILINEAR\n");
break;
case GDK_INTERP_HYPER:
printf (" HYPER\n");
break;
}
}
}
printf("\n");
}
#define ITERS 10
int main (int argc, char **argv)
{
int src_width, src_height, dest_width, dest_height;
char *src_buf, *dest_buf;
int src_index, dest_index;
int i;
double scale_times[3][3][4];
double composite_times[3][3][4];
double composite_color_times[3][3][4];
if (argc == 5)
{
src_width = atoi(argv[1]);
src_height = atoi(argv[2]);
dest_width = atoi(argv[3]);
dest_height = atoi(argv[4]);
}
else if (argc == 1)
{
src_width = 343;
src_height = 343;
dest_width = 711;
dest_height = 711;
}
else
{
fprintf (stderr, "Usage: scale [src_width src_height dest_width dest_height]\n");
exit(1);
}
printf ("Scaling from (%d, %d) to (%d, %d)\n\n", src_width, src_height, dest_width, dest_height);
init_array (scale_times);
init_array (composite_times);
init_array (composite_color_times);
for (src_index = 0; src_index < 3; src_index++)
for (dest_index = 0; dest_index < 3; dest_index++)
{
int src_channels = (src_index == 0) ? 3 : 4;
int src_has_alpha = (src_index == 2);
int dest_channels = (dest_index == 0) ? 3 : 4;
int dest_has_alpha = (dest_index == 2);
int src_rowstride = (src_channels*src_width + 3) & ~3;
int dest_rowstride = (dest_channels *dest_width + 3) & ~3;
int filter_level;
src_buf = g_malloc(src_rowstride * src_height);
memset (src_buf, 0x80, src_rowstride * src_height);
dest_buf = g_malloc(dest_rowstride * dest_height);
memset (dest_buf, 0x80, dest_rowstride * dest_height);
for (filter_level = GDK_INTERP_NEAREST ; filter_level <= GDK_INTERP_HYPER; filter_level++)
{
printf ("src_channels = %d (%s); dest_channels = %d (%s); filter_level=",
src_channels, src_has_alpha ? "alpha" : "no alpha",
dest_channels, dest_has_alpha ? "alpha" : "no alpha");
switch (filter_level)
{
case GDK_INTERP_NEAREST:
printf ("GDK_INTERP_NEAREST\n");
break;
case GDK_INTERP_TILES:
printf ("GDK_INTERP_TILES\n");
break;
case GDK_INTERP_BILINEAR:
printf ("GDK_INTERP_BILINEAR\n");
break;
case GDK_INTERP_HYPER:
printf ("GDK_INTERP_HYPER\n");
break;
}
printf("\t\t\titers\ttotal\t\tmsecs/iter\tMpixels/sec\t\n");
if (!(src_has_alpha && !dest_has_alpha))
{
start_timing ();
for (i = 0; i < ITERS; i++)
{
pixops_scale (dest_buf, 0, 0, dest_width, dest_height, dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha,
(double)dest_width / src_width, (double)dest_height / src_height,
filter_level);
}
scale_times[src_index][dest_index][filter_level] =
stop_timing (" scale\t\t", ITERS, dest_height * dest_width);
}
start_timing ();
for (i = 0; i < ITERS; i++)
{
pixops_composite (dest_buf, 0, 0, dest_width, dest_height, dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha,
(double)dest_width / src_width, (double)dest_height / src_height,
filter_level, 255);
}
composite_times[src_index][dest_index][filter_level] =
stop_timing (" composite\t\t", ITERS, dest_height * dest_width);
start_timing ();
for (i = 0; i < ITERS; i++)
{
pixops_composite_color (dest_buf, 0, 0, dest_width, dest_height, dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha,
(double)dest_width / src_width, (double)dest_height / src_height,
filter_level, 255, 0, 0, 16, 0xaaaaaa, 0x555555);
}
composite_color_times[src_index][dest_index][filter_level] =
stop_timing (" composite color\t", ITERS, dest_height * dest_width);
printf ("\n");
}
printf ("\n");
g_free (src_buf);
g_free (dest_buf);
}
printf ("SCALE\n=====\n\n");
dump_array (scale_times);
printf ("COMPOSITE\n=========\n\n");
dump_array (composite_times);
printf ("COMPOSITE_COLOR\n===============\n\n");
dump_array (composite_color_times);
return 0;
}