const GimpParasite *
gimp_image_get_icc_parasite (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
return gimp_image_parasite_find (image, GIMP_ICC_PROFILE_PARASITE_NAME);
}
static GValueArray *
image_parasite_find_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
GValueArray *return_vals;
GimpImage *image;
const gchar *name;
GimpParasite *parasite = NULL;
image = gimp_value_get_image (&args->values[0], gimp);
name = g_value_get_string (&args->values[1]);
if (success)
{
parasite = gimp_parasite_copy (gimp_image_parasite_find (image, name));
if (! parasite)
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_take_boxed (&return_vals->values[1], parasite);
return return_vals;
}
static void
file_open_handle_color_profile (GimpImage *image,
GimpContext *context,
GimpProgress *progress,
GimpRunMode run_mode)
{
if (gimp_image_parasite_find (image, "icc-profile"))
{
gimp_image_undo_disable (image);
switch (image->gimp->config->color_profile_policy)
{
case GIMP_COLOR_PROFILE_POLICY_ASK:
if (run_mode == GIMP_RUN_INTERACTIVE)
file_open_profile_apply_rgb (image, context, progress,
GIMP_RUN_INTERACTIVE);
break;
case GIMP_COLOR_PROFILE_POLICY_KEEP:
break;
case GIMP_COLOR_PROFILE_POLICY_CONVERT:
file_open_profile_apply_rgb (image, context, progress,
GIMP_RUN_NONINTERACTIVE);
break;
}
gimp_image_clean_all (image);
gimp_image_undo_enable (image);
}
}
const GimpParasite *
gimp_image_parasite_view_get_parasite (GimpImageParasiteView *view)
{
g_return_val_if_fail (GIMP_IS_IMAGE_PARASITE_VIEW (view), NULL);
return gimp_image_parasite_find (view->image, view->parasite);
}
static void
gimp_image_undo_constructed (GObject *object)
{
GimpImageUndo *image_undo = GIMP_IMAGE_UNDO (object);
GimpImage *image;
G_OBJECT_CLASS (parent_class)->constructed (object);
image = GIMP_UNDO (object)->image;
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_IMAGE_TYPE:
image_undo->base_type = gimp_image_get_base_type (image);
break;
case GIMP_UNDO_IMAGE_PRECISION:
image_undo->precision = gimp_image_get_precision (image);
break;
case GIMP_UNDO_IMAGE_SIZE:
image_undo->width = gimp_image_get_width (image);
image_undo->height = gimp_image_get_height (image);
break;
case GIMP_UNDO_IMAGE_RESOLUTION:
gimp_image_get_resolution (image,
&image_undo->xresolution,
&image_undo->yresolution);
image_undo->resolution_unit = gimp_image_get_unit (image);
break;
case GIMP_UNDO_IMAGE_GRID:
g_assert (GIMP_IS_GRID (image_undo->grid));
break;
case GIMP_UNDO_IMAGE_COLORMAP:
image_undo->num_colors = gimp_image_get_colormap_size (image);
image_undo->colormap = g_memdup (gimp_image_get_colormap (image),
GIMP_IMAGE_COLORMAP_SIZE);
break;
case GIMP_UNDO_IMAGE_METADATA:
image_undo->metadata =
gimp_metadata_duplicate (gimp_image_get_metadata (image));
break;
case GIMP_UNDO_PARASITE_ATTACH:
case GIMP_UNDO_PARASITE_REMOVE:
g_assert (image_undo->parasite_name != NULL);
image_undo->parasite = gimp_parasite_copy
(gimp_image_parasite_find (image, image_undo->parasite_name));
break;
default:
g_assert_not_reached ();
}
}
/* ----------------------------------------------------
* p_drop_image_cache
* ----------------------------------------------------
* drop the image cache.
*/
static void
p_drop_image_cache(void)
{
gint32 *images;
gint nimages;
gint l_idi;
if(gap_debug)
{
printf("p_drop_image_cache START pid:%d\n", (int) gap_base_getpid());
}
images = gimp_image_list(&nimages);
for(l_idi=0; l_idi < nimages; l_idi++)
{
GimpParasite *l_parasite;
l_parasite = gimp_image_parasite_find(images[l_idi], GAP_IMAGE_CACHE_PARASITE);
if(gap_debug)
{
printf("FrameFetcher: CHECK (image_id:%d) name:%s pid:%d\n"
, (int)images[l_idi]
, gimp_image_get_filename(images[l_idi])
, (int)gap_base_getpid()
);
}
if(l_parasite)
{
if(gap_debug)
{
printf("FrameFetcher: DELETE (image_id:%d) name:%s pid:%d\n"
, (int)images[l_idi]
, gimp_image_get_filename(images[l_idi])
, (int)gap_base_getpid()
);
}
/* delete image from the duplicates cache */
gap_image_delete_immediate(images[l_idi]);
gimp_parasite_free(l_parasite);
}
}
if(images)
{
g_free(images);
}
if(gap_debug)
{
printf("p_drop_image_cache END pid:%d\n", (int)gap_base_getpid());
}
} /* end p_drop_image_cache */
/* -------------------------------------------------
* gap_frame_fetch_delete_list_of_duplicated_images
* -------------------------------------------------
* deletes all duplicate imageas that wre created by the specified ffetch_user_id
* (if ffetch_user_id -1 is specified delte all duplicated images)
*/
void
gap_frame_fetch_delete_list_of_duplicated_images(gint32 ffetch_user_id)
{
gint32 *images;
gint nimages;
gint l_idi;
images = gimp_image_list(&nimages);
for(l_idi=0; l_idi < nimages; l_idi++)
{
GimpParasite *l_parasite;
l_parasite = gimp_image_parasite_find(images[l_idi], GAP_IMAGE_DUP_CACHE_PARASITE);
if(gap_debug)
{
printf("FrameFetcher: check (image_id:%d) name:%s pid:%d\n"
, (int)images[l_idi]
, gimp_image_get_filename(images[l_idi])
, (int)gap_base_getpid()
);
}
if(l_parasite)
{
gint32 *ffetch_user_id_ptr;
ffetch_user_id_ptr = (gint32 *) l_parasite->data;
if((*ffetch_user_id_ptr == ffetch_user_id) || (ffetch_user_id < 0))
{
if(gap_debug)
{
printf("FrameFetcher: DELETE duplicate %s (image_id:%d) user_id:%d (%d) name:%s pid:%d\n"
, gimp_image_get_filename(images[l_idi])
, (int)images[l_idi]
, (int)ffetch_user_id
, (int)*ffetch_user_id_ptr
, gimp_image_get_filename(images[l_idi])
, (int)gap_base_getpid()
);
}
/* delete image from the duplicates cache */
gap_image_delete_immediate(images[l_idi]);
}
gimp_parasite_free(l_parasite);
}
}
if(images)
{
g_free(images);
}
} /* end gap_frame_fetch_delete_list_of_duplicated_images */
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (run_mode == GIMP_RUN_INTERACTIVE &&
strcmp (name, SAVE_PROC) == 0)
{
gint32 image_ID = param[1].data.d_int32;
gint32 drawable_ID = param[2].data.d_int32;
GimpParasite *parasite;
gchar *x;
GimpImageType drawable_type = gimp_drawable_type (drawable_ID);
gimp_get_data (SAVE_PROC, &config);
config.prefixed_name = "gimp_image";
config.comment = NULL;
config.file_name = param[3].data.d_string;
config.alpha = (drawable_type == GIMP_RGBA_IMAGE ||
drawable_type == GIMP_GRAYA_IMAGE ||
drawable_type == GIMP_INDEXEDA_IMAGE);
parasite = gimp_image_parasite_find (image_ID, "gimp-comment");
if (parasite)
{
config.comment = g_strndup (gimp_parasite_data (parasite),
gimp_parasite_data_size (parasite));
gimp_parasite_free (parasite);
}
x = config.comment;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "C Source",
/* -------------------------------
* gap_frame_fetch_remove_parasite
* -------------------------------
* removes the image parasite that marks the image as member
* of the gap frame fetcher cache.
*/
void
gap_frame_fetch_remove_parasite(gint32 image_id)
{
GimpParasite *l_parasite;
l_parasite = gimp_image_parasite_find(image_id, GAP_IMAGE_CACHE_PARASITE);
if(l_parasite)
{
gimp_image_parasite_detach(image_id, GAP_IMAGE_CACHE_PARASITE);
if(gap_debug)
{
printf("FrameFetcher: removed parasite from (image_id:%d) pid:%d\n"
, (int)image_id, (int)gap_base_getpid());
}
gimp_parasite_free(l_parasite);
}
} /* end gap_frame_fetch_remove_parasite */
const guint8 *
gimp_image_get_icc_profile (GimpImage *image,
gsize *length)
{
const GimpParasite *parasite;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
parasite = gimp_image_parasite_find (image, GIMP_ICC_PROFILE_PARASITE_NAME);
if (parasite)
{
if (length)
*length = gimp_parasite_data_size (parasite);
return gimp_parasite_data (parasite);
}
if (length)
*length = 0;
return NULL;
}
static void
draw_info_header (GtkPrintContext *context,
cairo_t *cr,
PrintData *data)
{
PangoLayout *layout;
PangoFontDescription *desc;
gdouble text_height;
gdouble text_width;
gdouble fname_text_width;
gint layout_height;
gint layout_width;
gchar date_buffer[100];
GDate *date;
const gchar *name_str;
GimpParasite *parasite;
const gchar *end_ptr;
gchar *filename;
gdouble cr_width;
cairo_save (cr);
cr_width = gtk_print_context_get_width (context);
cairo_rectangle (cr, 0, 0, cr_width, HEADER_HEIGHT);
cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
cairo_fill_preserve (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
layout = gtk_print_context_create_pango_layout (context);
desc = pango_font_description_from_string ("sans 14");
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
pango_layout_set_width (layout, -1);
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
/* image name */
pango_layout_set_text (layout, gimp_image_get_name (data->image_id), -1);
pango_layout_get_size (layout, &layout_width, &layout_height);
text_height = (gdouble) layout_height / PANGO_SCALE;
cairo_move_to (cr, 0.02 * cr_width, (HEADER_HEIGHT - text_height) / 5);
pango_cairo_show_layout (cr, layout);
/* user name */
name_str = g_get_real_name ();
if (name_str && g_utf8_validate (name_str, -1, &end_ptr))
{
pango_layout_set_text (layout, name_str, -1);
pango_layout_get_size (layout, &layout_width, &layout_height);
text_height = (gdouble) layout_height / PANGO_SCALE;
text_width = (gdouble) layout_width / PANGO_SCALE;
cairo_move_to (cr, 0.5 * cr_width - 0.5 * text_width,
(HEADER_HEIGHT - text_height) / 5);
pango_cairo_show_layout (cr, layout);
}
/* date */
date = g_date_new ();
g_date_set_time_t (date, time (NULL));
g_date_strftime (date_buffer, 100, "%x", date);
g_date_free (date);
pango_layout_set_text (layout, date_buffer, -1);
pango_layout_get_size (layout, &layout_width, &layout_height);
text_height = (gdouble) layout_height / PANGO_SCALE;
text_width = (gdouble) layout_width / PANGO_SCALE;
cairo_move_to (cr,
0.98 * cr_width - text_width,
(HEADER_HEIGHT - text_height) / 5);
pango_cairo_show_layout (cr, layout);
/* file name if any */
filename = gimp_image_get_filename (data->image_id);
if (filename)
{
pango_layout_set_text (layout,
gimp_filename_to_utf8 (filename), -1);
g_free (filename);
pango_layout_get_size (layout, &layout_width, &layout_height);
text_height = (gdouble) layout_height / PANGO_SCALE;
fname_text_width = (gdouble) layout_width / PANGO_SCALE;
cairo_move_to (cr,
0.02 * cr_width, 4 * (HEADER_HEIGHT - text_height) / 5);
pango_cairo_show_layout (cr, layout);
}
else
{
fname_text_width = 0;
}
/* image comment if it is short */
parasite = gimp_image_parasite_find (data->image_id, "gimp-comment");
if (parasite)
{
pango_layout_set_text (layout, gimp_parasite_data (parasite), -1);
pango_layout_get_size (layout, &layout_width, &layout_height);
text_height = (gdouble) layout_height / PANGO_SCALE;
text_width = (gdouble) layout_width / PANGO_SCALE;
if (fname_text_width + text_width < 0.8 * cr_width &&
text_height < 0.5 * HEADER_HEIGHT)
{
cairo_move_to (cr, 0.98 * cr_width - text_width,
4 * (HEADER_HEIGHT - text_height) / 5);
pango_cairo_show_layout (cr, layout);
}
gimp_parasite_free (parasite);
}
g_object_unref (layout);
cairo_restore (cr);
}
/**
* jpeg_restore_original_settings:
* @image_ID: the image that may contain original jpeg settings in a parasite.
* @quality: where to store the original jpeg quality.
* @subsmp: where to store the original subsampling type.
* @num_quant_tables: where to store the number of quantization tables found.
*
* Retrieve the original JPEG settings (quality, type of subsampling
* and number of quantization tables) from the parasite attached to
* @image_ID. If the number of quantization tables is greater than
* zero, then these tables can be retrieved from the parasite by
* calling jpeg_restore_original_tables().
*
* Return Value: TRUE if a valid parasite was attached to the image
*/
gboolean
jpeg_restore_original_settings (gint32 image_ID,
gint *quality,
gint *subsmp,
gint *num_quant_tables)
{
GimpParasite *parasite;
const guchar *src;
glong src_size;
gint color_space;
gint q;
gint num_components;
gint num_tables;
guchar h[3];
guchar v[3];
g_return_val_if_fail (quality != NULL, FALSE);
g_return_val_if_fail (subsmp != NULL, FALSE);
g_return_val_if_fail (num_quant_tables != NULL, FALSE);
parasite = gimp_image_parasite_find (image_ID, "jpeg-settings");
if (parasite)
{
src = gimp_parasite_data (parasite);
src_size = gimp_parasite_data_size (parasite);
if (src_size >= 4)
{
color_space = *src++;
q = *src++;
num_components = *src++;
num_tables = *src++;
if (src_size >= (4 + num_components * 2 + num_tables * 128)
&& q <= 100 && num_tables <= 4)
{
*quality = q;
/* the current plug-in can only create grayscale or YCbCr JPEGs */
if (color_space == JCS_GRAYSCALE || color_space == JCS_YCbCr)
*num_quant_tables = num_tables;
else
*num_quant_tables = -1;
/* the current plug-in can only use subsampling for YCbCr (3) */
*subsmp = -1;
if (num_components == 3)
{
h[0] = *src++;
v[0] = *src++;
h[1] = *src++;
v[1] = *src++;
h[2] = *src++;
v[2] = *src++;
if (h[1] == 1 && v[1] == 1 && h[2] == 1 && v[2] == 1)
{
if (h[0] == 1 && v[0] == 1)
*subsmp = 2;
else if (h[0] == 2 && v[0] == 1)
*subsmp = 1;
else if (h[0] == 1 && v[0] == 2)
*subsmp = 3;
else if (h[0] == 2 && v[0] == 2)
*subsmp = 0;
}
}
gimp_parasite_free (parasite);
return TRUE;
}
}
gimp_parasite_free (parasite);
}
*quality = -1;
*subsmp = -1;
*num_quant_tables = 0;
return FALSE;
}
/* ----------------------------
* gap_frame_fetch_dup_image
* ----------------------------
* returns merged or selected layer_id
* (that is the only visible layer in temporary created scratch image)
* the caller is resonsible to delete the scratch image when processing is done.
* this can be done by calling gap_frame_fetch_delete_list_of_duplicated_images()
*/
gint32
gap_frame_fetch_dup_image(gint32 ffetch_user_id
,const char *filename /* full filename of the image (already contains framenr) */
,gint32 stackpos /* 0 pick layer on top of stack, -1 merge visible layers */
,gboolean addToCache /* enable caching */
)
{
gint32 resulting_layer;
gint32 image_id;
gint32 dup_image_id;
resulting_layer = -1;
dup_image_id = -1;
image_id = p_load_cache_image(filename, ffetch_user_id, addToCache);
if (image_id < 0)
{
return(-1);
}
if (stackpos < 0)
{
dup_image_id = gimp_image_duplicate(image_id);
gap_frame_fetch_remove_parasite(dup_image_id);
resulting_layer = gap_image_merge_visible_layers(dup_image_id, GIMP_CLIP_TO_IMAGE);
}
else
{
gint l_nlayers;
gint32 *l_layers_list;
l_layers_list = gimp_image_get_layers(image_id, &l_nlayers);
if(l_layers_list != NULL)
{
if (stackpos < l_nlayers)
{
gint32 src_layer_id;
gdouble l_xresoulution, l_yresoulution;
gint32 l_unit;
src_layer_id = l_layers_list[stackpos];
dup_image_id = gimp_image_new (gimp_image_width(image_id)
, gimp_image_height(image_id)
, gimp_image_base_type(image_id)
);
gimp_image_get_resolution(image_id, &l_xresoulution, &l_yresoulution);
gimp_image_set_resolution(dup_image_id, l_xresoulution, l_yresoulution);
l_unit = gimp_image_get_unit(image_id);
gimp_image_set_unit(dup_image_id, l_unit);
resulting_layer = gap_layer_copy_to_image (dup_image_id, src_layer_id);
}
g_free (l_layers_list);
}
}
p_add_image_to_list_of_duplicated_images(dup_image_id, ffetch_user_id);
if (addToCache != TRUE)
{
GimpParasite *l_parasite;
l_parasite = gimp_image_parasite_find(image_id, GAP_IMAGE_CACHE_PARASITE);
if(l_parasite)
{
gimp_parasite_free(l_parasite);
}
else
{
/* the original image is not cached
* (delete it because the caller gets the preprocessed duplicate)
*/
gap_image_delete_immediate(image_id);
}
}
return(resulting_layer);
} /* end gap_frame_fetch_dup_image */
/* ----------------------------------------------------
* p_load_cache_image
* ----------------------------------------------------
* load an image from cache or from file (in case image is not already cached)
* in case the flag addToCache is TRUE the image will be automatically added
* to the cache after read from file operation.
*/
static gint32
p_load_cache_image(const char* filename, gint32 ffetch_user_id, gboolean addToCache)
{
gint32 l_image_id;
char *l_filename;
gint32 *images;
gint nimages;
gint l_idi;
gint l_number_of_cached_images;
gint32 l_first_cached_image_id;
GimpParasite *l_parasite;
if(filename == NULL)
{
printf("p_load_cache_image: ** ERROR cant load filename == NULL! pid:%d\n", (int)gap_base_getpid());
return -1;
}
l_image_id = -1;
l_first_cached_image_id = -1;
l_number_of_cached_images = 0;
images = gimp_image_list(&nimages);
for(l_idi=0; l_idi < nimages; l_idi++)
{
l_parasite = gimp_image_parasite_find(images[l_idi], GAP_IMAGE_CACHE_PARASITE);
if(l_parasite)
{
gint32 *mtime_ptr;
gint32 *ffetch_id_ptr;
gchar *filename_ptr;
mtime_ptr = (gint32 *) l_parasite->data;
ffetch_id_ptr = (gint32 *)&l_parasite->data[sizeof(gint32)];
filename_ptr = (gchar *)&l_parasite->data[sizeof(gint32) + sizeof(gint32)];
l_number_of_cached_images++;
if (l_first_cached_image_id < 0)
{
l_first_cached_image_id = images[l_idi];
}
if(strcmp(filename, filename_ptr) == 0)
{
gint32 mtimefile;
mtimefile = gap_file_get_mtime(filename);
if(mtimefile == *mtime_ptr)
{
/* image found in cache */
l_image_id = images[l_idi];
}
else
{
/* image found in cache, but has changed modification timestamp
* (delete from cache and reload)
*/
if(gap_debug)
{
printf("FrameFetcher: DELETE because mtime changed : (image_id:%d) ffetchId:%d name:%s mtimefile:%d mtimecache:%d pid:%d\n"
, (int)images[l_idi]
, (int)*ffetch_id_ptr
, gimp_image_get_filename(images[l_idi])
, (int)mtimefile
, (int)*mtime_ptr
, (int)gap_base_getpid()
);
}
gap_image_delete_immediate(images[l_idi]);
}
l_idi = nimages -1; /* force break at next loop iteration */
}
gimp_parasite_free(l_parasite);
}
}
if(images)
{
g_free(images);
}
if (l_image_id >= 0)
{
if(gap_debug)
{
printf("FrameFetcher: p_load_cache_image CACHE-HIT :%s (image_id:%d) pid:%d\n"
, filename, (int)l_image_id, (int)gap_base_getpid());
}
return(l_image_id);
}
l_filename = g_strdup(filename);
l_image_id = gap_lib_load_image(l_filename);
if(gap_debug)
{
printf("FrameFetcher: loaded image from disk:%s (image_id:%d) pid:%d\n"
, l_filename, (int)l_image_id, (int)gap_base_getpid());
}
if((l_image_id >= 0) && (addToCache == TRUE))
{
guchar *parasite_data;
gint32 parasite_size;
gint32 *parasite_mtime_ptr;
gint32 *parasite_ffetch_id_ptr;
gchar *parasite_filename_ptr;
gint32 len_filename0; /* filename length including the terminating 0 */
if (l_number_of_cached_images > p_get_ffetch_max_img_cache_elements())
{
/* the image cache already has more elements than desired,
* drop the 1st cached image
*/
if(gap_debug)
{
printf("FrameFetcher: DELETE because cache is full: (image_id:%d) name:%s number_of_cached_images:%d pid:%d\n"
, (int)l_first_cached_image_id
, gimp_image_get_filename(l_first_cached_image_id)
, (int)l_number_of_cached_images
, (int)gap_base_getpid()
);
}
gap_image_delete_immediate(l_first_cached_image_id);
}
/* build parasite data including mtime and full filename with terminating 0 byte */
len_filename0 = strlen(filename) + 1;
parasite_size = sizeof(gint32) + sizeof(gint32) + len_filename0;
parasite_data = g_malloc0(parasite_size);
parasite_mtime_ptr = (gint32 *)parasite_data;
parasite_ffetch_id_ptr = (gint32 *)¶site_data[sizeof(gint32)];
parasite_filename_ptr = (gchar *)¶site_data[sizeof(gint32) + sizeof(gint32)];
*parasite_mtime_ptr = gap_file_get_mtime(filename);
*parasite_ffetch_id_ptr = ffetch_user_id;
memcpy(parasite_filename_ptr, filename, len_filename0);
/* attach a parasite to mark the image as part of the gap image cache */
l_parasite = gimp_parasite_new(GAP_IMAGE_CACHE_PARASITE
,0 /* GIMP_PARASITE_PERSISTENT 0 for non persistent */
,parasite_size
,parasite_data
);
if(l_parasite)
{
gimp_image_parasite_attach(l_image_id, l_parasite);
gimp_parasite_free(l_parasite);
}
g_free(parasite_data);
}
g_free(l_filename);
return(l_image_id);
} /* end p_load_cache_image */
/* ----------------------------------------------------
* gap_frame_fetch_dump_resources
* ----------------------------------------------------
* print current resource usage to stdout
* this includes information about
* - ALL images currently loaded
* - all video filehandles with memory cache sizes
*
*/
void
gap_frame_fetch_dump_resources()
{
gint32 *images;
gint nimages;
gint l_idi;
gint l_number_of_cached_images;
printf("gap_frame_fetch_dump_resources: START pid:%d\n", (int)gap_base_getpid());
l_number_of_cached_images = 0;
images = gimp_image_list(&nimages);
for(l_idi=0; l_idi < nimages; l_idi++)
{
GimpParasite *l_parasite;
char *l_filename;
char *l_cacheInfoString;
gint32 image_id;
image_id = images[l_idi];
l_filename = gimp_image_get_filename(image_id);
l_parasite = gimp_image_parasite_find(image_id, GAP_IMAGE_CACHE_PARASITE);
if(l_parasite)
{
gint32 *mtime_ptr;
gint32 *ffetch_id_ptr;
gchar *filename_ptr;
mtime_ptr = (gint32 *) l_parasite->data;
ffetch_id_ptr = (gint32 *)&l_parasite->data[sizeof(gint32)];
filename_ptr = (gchar *)&l_parasite->data[sizeof(gint32) + sizeof(gint32)];
l_number_of_cached_images++;
l_cacheInfoString = g_strdup_printf("Cache member: mtime:%d ffetchId:%d %s"
,*mtime_ptr
,*ffetch_id_ptr
,filename_ptr
);
gimp_parasite_free(l_parasite);
}
else
{
l_parasite = gimp_image_parasite_find(images[l_idi], GAP_IMAGE_DUP_CACHE_PARASITE);
if(l_parasite)
{
gint32 *ffetch_user_id_ptr;
ffetch_user_id_ptr = (gint32 *) l_parasite->data;
l_number_of_cached_images++;
l_cacheInfoString = g_strdup_printf("Cache member (merged duplicate): ffetchId:%d"
,*ffetch_user_id_ptr
);
gimp_parasite_free(l_parasite);
}
else
{
l_cacheInfoString = g_strdup_printf("Not cached");
}
}
printf(" FrameFetcher ImgId:%d (%d x %d) %s %s\n"
,(int)image_id
,(int)gimp_image_width(image_id)
,(int)gimp_image_height(image_id)
,l_filename
,l_cacheInfoString
);
g_free(l_cacheInfoString);
if(l_filename != NULL)
{
g_free(l_filename);
}
l_parasite = NULL;
}
if(images)
{
g_free(images);
}
printf(" Number of images currently loaded in gimp total: %d gap_ffetch_max_img_cache_elements:%d marked as cache member:%d\n"
,(int)nimages
,(int)p_get_ffetch_max_img_cache_elements()
,(int)l_number_of_cached_images
);
p_dump_resources_gvahand();
p_dump_process_resource_usage();
} /* end gap_frame_fetch_dump_resources */
