Beispiel #1
0
GeglTile *
gegl_tile_new (gint size)
{
  GeglTile *tile = gegl_tile_new_bare ();

  tile->data = gegl_malloc (size);
  tile->size = size;

  return tile;
}
Beispiel #2
0
GeglTile *
gegl_tile_dup (GeglTile *src)
{
  GeglTile *tile = gegl_tile_new_bare ();

  tile->tile_storage    = src->tile_storage;
  tile->data       = src->data;
  tile->size       = src->size;

  tile->destroy_notify      = src->destroy_notify;
  tile->destroy_notify_data = src->destroy_notify_data;

  tile->next_shared              = src->next_shared;
  src->next_shared               = tile;
  tile->prev_shared              = src;
#ifdef GEGL_USE_TILE_MUTEX
  if (tile->next_shared != src)
    {
      g_mutex_lock (tile->next_shared->mutex);
    }
#endif
  if (tile->next_shared != src)
    {
      g_static_mutex_lock (&cowmutex);
    }

  tile->next_shared->prev_shared = tile;

  if (tile->next_shared != src)
    {
      g_static_mutex_unlock (&cowmutex);
    }
#ifdef GEGL_USE_TILE_MUTEX
  if (tile->next_shared != src)
    {
      g_mutex_unlock (tile->next_shared->mutex);
    }
#endif

  return tile;
}
Beispiel #3
0
GeglBuffer *
gegl_buffer_linear_new_from_data (const gpointer       data,
                                  const Babl          *format,
                                  const GeglRectangle *extent,
                                  gint                 rowstride,
                                  GDestroyNotify       destroy_fn,
                                  gpointer             destroy_fn_data)
{
  GeglBuffer *buffer;
  GeglTile   *tile;
  gint        bpp;

  g_return_val_if_fail (extent, NULL);
  g_return_val_if_fail (format, NULL);

  bpp = babl_format_get_bytes_per_pixel (format);

  if (rowstride == 0)
    {
      rowstride = extent->width;
    }
  else
    {
      g_return_val_if_fail (rowstride > 0, NULL);
      g_return_val_if_fail (rowstride % bpp == 0, NULL);
      rowstride = rowstride / bpp;
    }

  buffer = g_object_new (GEGL_TYPE_BUFFER,
                         "x",          extent->x,
                         "y",          extent->y,
                         "shift-x",    -extent->x,
                         "shift-y",    -extent->y,
                         "width",      extent->width,
                         "height",     extent->height,
                         "tile-width", rowstride,
                         "tile-height", extent->height,
                         "format", format,
                         "path", "RAM",
                         NULL);

  g_object_set_data (G_OBJECT (buffer), "is-linear", (void*)0xf00);

  tile = gegl_tile_new_bare ();

  tile->tile_storage = buffer->tile_storage;
  tile->x = 0;
  tile->y = 0;
  tile->z = 0;
  tile->next_shared = tile;
  tile->prev_shared = tile;
  tile->rev = tile->stored_rev + 1;
  gegl_tile_set_data_full (tile,
                           (gpointer) data,
                           bpp * rowstride * extent->height,
                           destroy_fn,
                           destroy_fn_data);

  if (buffer->tile_storage->cache)
    gegl_tile_handler_cache_insert (buffer->tile_storage->cache, tile, 0, 0, 0);
  gegl_tile_unref (tile);

  return buffer;
}