perf/test-compression.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 3 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  14  *
  15  * Copyright (C) 2018 Ell
  16  */
  17
  18 #include "test-common.h"
  19 #include "buffer/gegl-compression.h"
  20
  21 #define SUCCESS  0
  22 #define FAILURE -1
  23
  24 static gpointer
  25 load_png (const gchar *path,
  26           const Babl  *format,
  27           gint        *n)
  28 {
  29   GeglNode   *node;
  30   GeglNode   *node_source;
  31   GeglNode   *node_sink;
  32   GeglBuffer *buffer = NULL;
  33   gpointer    data;
  34
  35   node = gegl_node_new ();
  36
  37   node_source = gegl_node_new_child (node,
  38                                      "operation", "gegl:load",
  39                                      "path",      path,
  40                                      NULL);
  41   node_sink   = gegl_node_new_child (node,
  42                                      "operation", "gegl:buffer-sink",
  43                                      "buffer",    &buffer,
  44                                      NULL);
  45
  46   gegl_node_link (node_source, node_sink);
  47
  48   gegl_node_process (node_sink);
  49
  50   g_object_unref (node);
  51
  52   *n   = gegl_buffer_get_width (buffer) * gegl_buffer_get_height (buffer);
  53   data = g_malloc (*n * babl_format_get_bytes_per_pixel (format));
  54
  55   gegl_buffer_get (buffer, NULL, 1.0, format, data,
  56                    GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
  57
  58   g_object_unref (buffer);
  59
  60   return data;
  61 }
  62
  63 gint
  64 main (gint    argc,
  65       gchar **argv)
  66 {
  67   const Babl   *format;
  68   gint          bpp;
  69   gchar        *path;
  70   gpointer      data;
  71   gint          n;
  72   gint          size;
  73   guint8       *compressed;
  74   gint          max_compressed_size;
  75   guint8       *decompressed;
  76   const gchar **algorithms;
  77   gint          i;
  78   gint          result = FAILURE;
  79
  80   gegl_init (&argc, &argv);
  81
  82   format = babl_format ("R'G'B'A u8");
  83   bpp    = babl_format_get_bytes_per_pixel (format);
  84
  85   path = g_build_filename (g_getenv ("ABS_TOP_SRCDIR"),
  86                            "tests", "compositions", "data", "car-stack.png",
  87                            NULL);
  88
  89   data = load_png (path, format, &n);
  90   size = n * bpp;
  91
  92   g_free (path);
  93
  94   max_compressed_size = 2 * n * bpp;
  95   compressed          = g_malloc (max_compressed_size);
  96   decompressed        = g_malloc (size);
  97
  98   algorithms = gegl_compression_list ();
  99
 100   for (i = 0; algorithms[i]; i++)
 101     {
 102       const GeglCompression *compression = gegl_compression (algorithms[i]);
 103       gchar                 *id;
 104       gint                   compressed_size;
 105       gint                   j;
 106
 107       id = g_strdup_printf ("%s compress", algorithms[i]);
 108       test_start ();
 109
 110       for (j = 0; j < ITERATIONS && converged < BAIL_COUNT; j++)
 111         {
 112           test_start_iter();
 113
 114           if (! gegl_compression_compress (compression, format,
 115                                            data, n,
 116                                            compressed, &compressed_size,
 117                                            max_compressed_size))
 118             {
 119               goto end;
 120             }
 121
 122           test_end_iter();
 123         }
 124
 125       test_end (id, (gdouble) size * ITERATIONS);
 126       g_free (id);
 127
 128       id = g_strdup_printf ("%s decompress", algorithms[i]);
 129       test_start ();
 130
 131       for (j = 0; j < ITERATIONS && converged < BAIL_COUNT; j++)
 132         {
 133           test_start_iter();
 134
 135           if (! gegl_compression_decompress (compression, format,
 136                                              decompressed, n,
 137                                              compressed, compressed_size))
 138             {
 139               goto end;
 140             }
 141
 142           test_end_iter();
 143         }
 144
 145       test_end (id, (gdouble) size * ITERATIONS);
 146       g_free (id);
 147     }
 148
 149   result = SUCCESS;
 150
 151 end:
 152   g_free (algorithms);
 153
 154   g_free (compressed);
 155   g_free (decompressed);
 156
 157   g_free (data);
 158
 159   gegl_exit ();
 160
 161   return result;
 162 }