static gboolean image_save_jpeg(image_output out, float quality, float smoothing, gboolean entropy, gboolean progressive, gchar* comment, int subsampling, gboolean baseline, int markers, int dct)
{
gint nreturn_vals;
int final_drawable = gimp_image_merge_visible_layers(out->image_id, GIMP_CLIP_TO_IMAGE);
// "file_jpeg_save" doesn't support indexed images
if (gimp_drawable_is_indexed(final_drawable)) {
gimp_image_convert_rgb(out->image_id);
}
GimpParam *return_vals = gimp_run_procedure(
"file_jpeg_save",
&nreturn_vals,
GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
GIMP_PDB_IMAGE, out->image_id,
GIMP_PDB_DRAWABLE, final_drawable,
GIMP_PDB_STRING, out->filepath,
GIMP_PDB_STRING, out->filename,
GIMP_PDB_FLOAT, quality >= 3 ? quality/100 : 0.03, // Quality of saved image (0 <= quality <= 1) + small fix because final image doesn't change when quality < 3
GIMP_PDB_FLOAT, smoothing, // Smoothing factor for saved image (0 <= smoothing <= 1)
GIMP_PDB_INT32, entropy ? 1 : 0, // Optimization of entropy encoding parameters (0/1)
GIMP_PDB_INT32, progressive ? 1 : 0, // Enable progressive jpeg image loading - ignored if not compiled with HAVE_PROGRESSIVE_JPEG (0/1)
GIMP_PDB_STRING, comment, // Image comment
GIMP_PDB_INT32, subsampling, // The subsampling option number
GIMP_PDB_INT32, baseline ? 1 : 0, // Force creation of a baseline JPEG (non-baseline JPEGs can't be read by all decoders) (0/1)
GIMP_PDB_INT32, markers, // Frequency of restart markers (in rows, 0 = no restart markers)
GIMP_PDB_INT32, dct, // DCT algorithm to use (speed/quality tradeoff)
GIMP_PDB_END
);
return TRUE;
}
static void
export_convert_bitmap (gint32 image_ID,
gint32 *drawable_ID)
{
if (gimp_image_base_type (image_ID) == GIMP_INDEXED)
gimp_image_convert_rgb (image_ID);
gimp_image_convert_indexed (image_ID, GIMP_FS_DITHER,
GIMP_MAKE_PALETTE, 2, FALSE, FALSE, "");
}
static gboolean apply_color(color_settings settings, image_output out)
{
gboolean success = TRUE;
int default_drawable = out->drawable_ids[0];
if (settings->brightness != 0 || settings->contrast != 0) {
// brightness or contrast have been modified, apply the manipulation
if (!gimp_drawable_is_rgb(default_drawable)) {
gimp_image_convert_rgb(out->image_id);
}
int i;
for (i = 0; i < out->drawable_count; i++) {
success = gimp_brightness_contrast(
out->drawable_ids[i],
settings->brightness,
settings->contrast
);
}
}
if (settings->grayscale && !gimp_drawable_is_gray(default_drawable)) {
// do grayscale conversion
success = gimp_image_convert_grayscale(out->image_id);
}
if (settings->levels_auto) {
// do levels correction
int i;
for (i = 0; i < out->drawable_count; i++) {
success = gimp_levels_stretch(out->drawable_ids[i]);
}
}
if (settings->curve_file != NULL && !gimp_drawable_is_indexed(default_drawable)) {
// apply curve
if (!colorcurve_init) { // read from the curve file only the first time
success = parse_curve_file(
settings->curve_file,
&colorcurve_num_points_v, &colorcurve_ctr_points_v,
&colorcurve_num_points_r, &colorcurve_ctr_points_r,
&colorcurve_num_points_g, &colorcurve_ctr_points_g,
&colorcurve_num_points_b, &colorcurve_ctr_points_b,
&colorcurve_num_points_a, &colorcurve_ctr_points_a
);
colorcurve_init = TRUE;
}
else success = TRUE;
if (success) {
int i;
for (i = 0; i < out->drawable_count; i++) {
if (colorcurve_num_points_v >= 4 && colorcurve_num_points_v <= 34) {
success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_VALUE, colorcurve_num_points_v, colorcurve_ctr_points_v);
}
if (colorcurve_num_points_r >= 4 && colorcurve_num_points_r <= 34) {
success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_RED, colorcurve_num_points_r, colorcurve_ctr_points_r);
}
if (colorcurve_num_points_g >= 4 && colorcurve_num_points_g <= 34) {
success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_GREEN, colorcurve_num_points_g, colorcurve_ctr_points_g);
}
if (colorcurve_num_points_b >= 4 && colorcurve_num_points_b <= 34) {
success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_BLUE, colorcurve_num_points_b, colorcurve_ctr_points_b);
}
if (colorcurve_num_points_a >= 4 && colorcurve_num_points_a <= 34) {
success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_ALPHA, colorcurve_num_points_a, colorcurve_ctr_points_a);
}
}
}
}
return success;
}
GimpPDBStatusType
SaveICNS (const gchar *file_name,
gint32 image_ID)
{
// Horrible awful temporary hack
ResourceHeader icnsHeader;
ResourceHeader it32Header;
ResourceHeader t8mkHeader;
guchar *compData, *alphaData;
FILE *outfile;
guchar *pixels;
gint dataSize;
if (gimp_image_base_type (image_ID) != GIMP_RGB)
{
if (! gimp_image_convert_rgb (image_ID))
return GIMP_PDB_EXECUTION_ERROR;
}
gint *layers;
gint nlayers;
GimpPixelRgn region;
layers = gimp_image_get_layers (image_ID, &nlayers);
GimpDrawable *drawable = gimp_drawable_get (layers[0]);
pixels = g_new (guchar, 128*128*4);
gimp_pixel_rgn_init (®ion, drawable, 0, 0, 128, 128, TRUE, FALSE);
gimp_pixel_rgn_get_rect (®ion, pixels, 0, 0, 128, 128);
compData = icns_compress (128, 128, pixels, &dataSize);
alphaData = icns_get_alpha (128, 128, pixels);
it32Header.type = GUINT32_TO_BE ('it32');
it32Header.size = GUINT32_TO_BE (sizeof (ResourceHeader) + dataSize);
t8mkHeader.type = GUINT32_TO_BE ('t8mk');
t8mkHeader.size = GUINT32_TO_BE (sizeof (ResourceHeader) + 128*128);
icnsHeader.type = GUINT32_TO_BE ('icns');
icnsHeader.size = dataSize + 128*128 + 3 * sizeof (ResourceHeader);
outfile = fopen (file_name, "wb");
if (outfile)
{
fwrite (&icnsHeader, 1, sizeof (ResourceHeader), outfile);
fwrite (&it32Header, 1, sizeof (ResourceHeader), outfile);
fwrite (compData, 1, dataSize, outfile);
fwrite (&t8mkHeader, 1, sizeof (ResourceHeader), outfile);
fwrite (alphaData, 1, 128*128, outfile);
fclose (outfile);
}
else
{
g_warning ("SaveICNS: couldn't open output file");
}
g_free (pixels);
g_free (compData);
g_free (alphaData);
return GIMP_PDB_SUCCESS;
}
static gboolean
webx_pipeline_check_update (WebxPipeline *pipeline)
{
gint *layers;
gint num_layers;
gint i;
g_return_val_if_fail (WEBX_IS_PIPELINE (pipeline), FALSE);
if (pipeline->rgb_image != -1)
{
gimp_image_delete (pipeline->rgb_image);
pipeline->rgb_image = -1;
}
if (pipeline->indexed_image != -1)
{
gimp_image_delete (pipeline->indexed_image);
pipeline->indexed_image = -1;
}
if (pipeline->background)
{
g_object_unref (pipeline->background);
pipeline->background = NULL;
}
pipeline->rgb_image = gimp_image_duplicate (pipeline->user_image);
gimp_image_undo_disable (pipeline->rgb_image);
pipeline->rgb_layer =
gimp_image_merge_visible_layers (pipeline->rgb_image,
GIMP_CLIP_TO_IMAGE);
/* make sure there is only one layer, where all visible layers were merged */
layers = gimp_image_get_layers (pipeline->rgb_image, &num_layers);
for (i = 0; i < num_layers; i++)
{
if (layers[i] != pipeline->rgb_layer)
gimp_image_remove_layer (pipeline->rgb_image, layers[i]);
}
g_free (layers);
/* we don't want layer to be smaller than image */
gimp_layer_resize_to_image_size (pipeline->rgb_layer);
gimp_image_scale (pipeline->rgb_image,
pipeline->resize_width, pipeline->resize_height);
webx_pipeline_create_background (pipeline);
pipeline->crop_offsx *= pipeline->crop_scale_x;
pipeline->crop_offsy *= pipeline->crop_scale_y;
pipeline->crop_width *= pipeline->crop_scale_x;
pipeline->crop_height *= pipeline->crop_scale_y;
pipeline->crop_scale_x = 1.0;
pipeline->crop_scale_y = 1.0;
webx_pipeline_crop_clip (pipeline);
if (pipeline->crop_width != pipeline->resize_width
|| pipeline->crop_height != pipeline->resize_height )
{
gimp_image_crop (pipeline->rgb_image,
pipeline->crop_width, pipeline->crop_height,
pipeline->crop_offsx, pipeline->crop_offsy);
}
if (gimp_drawable_is_indexed (pipeline->rgb_layer))
{
pipeline->indexed_image = gimp_image_duplicate (pipeline->rgb_image);
gimp_image_undo_disable (pipeline->indexed_image);
pipeline->indexed_layer =
gimp_image_merge_visible_layers (pipeline->indexed_image,
GIMP_CLIP_TO_IMAGE);
}
else
{
pipeline->indexed_image = -1;
pipeline->indexed_layer = -1;
}
if ( ! gimp_drawable_is_rgb (pipeline->rgb_layer))
gimp_image_convert_rgb (pipeline->rgb_image);
return TRUE;
}
static gint32
ReadImage (FILE *fd,
const gchar *filename,
gint len,
gint height,
CMap cmap,
gint ncols,
gint format,
gint interlace,
gint number,
guint leftpos,
guint toppos,
guint screenwidth,
guint screenheight)
{
static gint32 image_ID = -1;
static gint frame_number = 1;
gint32 layer_ID;
GimpPixelRgn pixel_rgn;
GimpDrawable *drawable;
guchar *dest, *temp;
guchar c;
gint xpos = 0, ypos = 0, pass = 0;
gint cur_progress, max_progress;
gint v;
gint i, j;
gchar *framename;
gchar *framename_ptr;
gboolean alpha_frame = FALSE;
static gint previous_disposal;
/* Guard against bogus frame size */
if (len < 1 || height < 1)
{
g_message ("Bogus frame dimensions");
return -1;
}
/*
** Initialize the Compression routines
*/
if (! ReadOK (fd, &c, 1))
{
g_message ("EOF / read error on image data");
return -1;
}
if (LZWReadByte (fd, TRUE, c) < 0)
{
g_message ("Error while reading");
return -1;
}
if (frame_number == 1)
{
/* Guard against bogus logical screen size values */
if (screenwidth == 0)
screenwidth = len;
if (screenheight == 0)
screenheight = height;
image_ID = gimp_image_new (screenwidth, screenheight, GIMP_INDEXED);
gimp_image_set_filename (image_ID, filename);
for (i = 0, j = 0; i < ncols; i++)
{
used_cmap[0][i] = gimp_cmap[j++] = cmap[0][i];
used_cmap[1][i] = gimp_cmap[j++] = cmap[1][i];
used_cmap[2][i] = gimp_cmap[j++] = cmap[2][i];
}
gimp_image_set_colormap (image_ID, gimp_cmap, ncols);
if (Gif89.delayTime < 0)
framename = g_strdup (_("Background"));
else
framename = g_strdup_printf (_("Background (%d%s)"),
10 * Gif89.delayTime, "ms");
previous_disposal = Gif89.disposal;
if (Gif89.transparent == -1)
{
layer_ID = gimp_layer_new (image_ID, framename,
len, height,
GIMP_INDEXED_IMAGE, 100, GIMP_NORMAL_MODE);
}
else
{
layer_ID = gimp_layer_new (image_ID, framename,
len, height,
GIMP_INDEXEDA_IMAGE, 100, GIMP_NORMAL_MODE);
alpha_frame=TRUE;
}
g_free (framename);
}
else /* NOT FIRST FRAME */
{
gimp_progress_set_text_printf (_("Opening '%s' (frame %d)"),
gimp_filename_to_utf8 (filename),
frame_number);
gimp_progress_pulse ();
/* If the colourmap is now different, we have to promote to RGB! */
if (! promote_to_rgb)
{
for (i = 0; i < ncols; i++)
{
if ((used_cmap[0][i] != cmap[0][i]) ||
(used_cmap[1][i] != cmap[1][i]) ||
(used_cmap[2][i] != cmap[2][i]))
{
/* Everything is RGB(A) from now on... sigh. */
promote_to_rgb = TRUE;
/* Promote everything we have so far into RGB(A) */
#ifdef GIFDEBUG
g_print ("GIF: Promoting image to RGB...\n");
#endif
gimp_image_convert_rgb (image_ID);
break;
}
}
}
if (Gif89.delayTime < 0)
framename = g_strdup_printf (_("Frame %d"), frame_number);
else
framename = g_strdup_printf (_("Frame %d (%d%s)"),
frame_number, 10 * Gif89.delayTime, "ms");
switch (previous_disposal)
{
case 0x00:
break; /* 'don't care' */
case 0x01:
framename_ptr = framename;
framename = g_strconcat (framename, " (combine)", NULL);
g_free (framename_ptr);
break;
case 0x02:
framename_ptr = framename;
framename = g_strconcat (framename, " (replace)", NULL);
g_free (framename_ptr);
break;
case 0x03: /* Rarely-used, and unhandled by many
loaders/players (including GIMP: we treat as
'combine' mode). */
framename_ptr = framename;
framename = g_strconcat (framename, " (combine) (!)", NULL);
g_free (framename_ptr);
break;
case 0x04: /* I've seen a composite of this type. stvo_online_banner2.gif */
case 0x05:
case 0x06: /* I've seen a composite of this type. bn31.Gif */
case 0x07:
framename_ptr = framename;
framename = g_strconcat (framename, " (unknown disposal)", NULL);
g_free (framename_ptr);
g_message (_("GIF: Undocumented GIF composite type %d is "
"not handled. Animation might not play or "
"re-save perfectly."),
previous_disposal);
break;
default:
g_message ("Disposal word got corrupted. Bug.");
break;
}
previous_disposal = Gif89.disposal;
layer_ID = gimp_layer_new (image_ID, framename,
len, height,
promote_to_rgb ?
GIMP_RGBA_IMAGE : GIMP_INDEXEDA_IMAGE,
100, GIMP_NORMAL_MODE);
alpha_frame = TRUE;
g_free (framename);
}
frame_number++;
gimp_image_insert_layer (image_ID, layer_ID, -1, 0);
gimp_layer_translate (layer_ID, (gint) leftpos, (gint) toppos);
drawable = gimp_drawable_get (layer_ID);
cur_progress = 0;
max_progress = height;
if (alpha_frame)
dest = (guchar *) g_malloc (len * height * (promote_to_rgb ? 4 : 2));
else
dest = (guchar *) g_malloc (len * height);
#ifdef GIFDEBUG
g_print ("GIF: reading %d by %d%s GIF image, ncols=%d\n",
len, height, interlace ? " interlaced" : "", ncols);
#endif
if (! alpha_frame && promote_to_rgb)
{
/* I don't see how one would easily construct a GIF in which
this could happen, but it's a mad mad world. */
g_message ("Ouch! Can't handle non-alpha RGB frames.\n"
"Please file a bug report in GIMP's bugzilla.");
gimp_quit ();
}
while ((v = LZWReadByte (fd, FALSE, c)) >= 0)
{
if (alpha_frame)
{
if (((guchar) v > highest_used_index) && !(v == Gif89.transparent))
highest_used_index = (guchar) v;
if (promote_to_rgb)
{
temp = dest + ( (ypos * len) + xpos ) * 4;
*(temp ) = (guchar) cmap[0][v];
*(temp+1) = (guchar) cmap[1][v];
*(temp+2) = (guchar) cmap[2][v];
*(temp+3) = (guchar) ((v == Gif89.transparent) ? 0 : 255);
}
else
{
temp = dest + ( (ypos * len) + xpos ) * 2;
*temp = (guchar) v;
*(temp+1) = (guchar) ((v == Gif89.transparent) ? 0 : 255);
}
}
else
{
if ((guchar) v > highest_used_index)
highest_used_index = (guchar) v;
temp = dest + (ypos * len) + xpos;
*temp = (guchar) v;
}
xpos++;
if (xpos == len)
{
xpos = 0;
if (interlace)
{
switch (pass)
{
case 0:
case 1:
ypos += 8;
break;
case 2:
ypos += 4;
break;
case 3:
ypos += 2;
break;
}
if (ypos >= height)
{
pass++;
switch (pass)
{
case 1:
ypos = 4;
break;
case 2:
ypos = 2;
break;
case 3:
ypos = 1;
break;
default:
goto fini;
}
}
}
else
{
ypos++;
}
if (frame_number == 1)
{
cur_progress++;
if ((cur_progress % 16) == 0)
gimp_progress_update ((gdouble) cur_progress /
(gdouble) max_progress);
}
}
if (ypos >= height)
break;
}
fini:
if (LZWReadByte (fd, FALSE, c) >= 0)
g_print ("GIF: too much input data, ignoring extra...\n");
gimp_pixel_rgn_init (&pixel_rgn, drawable,
0, 0, drawable->width, drawable->height, TRUE, FALSE);
gimp_pixel_rgn_set_rect (&pixel_rgn, dest,
0, 0, drawable->width, drawable->height);
g_free (dest);
gimp_drawable_flush (drawable);
gimp_drawable_detach (drawable);
return image_ID;
}
static void
ico_dialog_update_icon_preview (GtkWidget *dialog,
gint32 layer,
gint bpp)
{
GtkWidget *preview = ico_dialog_get_layer_preview (dialog, layer);
GdkPixbuf *pixbuf;
gint w = gimp_drawable_width (layer);
gint h = gimp_drawable_height (layer);
if (! preview)
return;
if (bpp <= 8)
{
GimpDrawable *drawable;
GimpDrawable *tmp;
GimpPixelRgn src_pixel_rgn, dst_pixel_rgn;
gint32 image;
gint32 tmp_image;
gint32 tmp_layer;
guchar *buffer;
guchar *cmap;
gint num_colors;
image = gimp_item_get_image (layer);
tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
gimp_image_undo_disable (tmp_image);
if (gimp_drawable_is_indexed (layer))
{
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h,
gimp_drawable_type (layer),
100, GIMP_NORMAL_MODE);
gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
drawable = gimp_drawable_get (layer);
tmp = gimp_drawable_get (tmp_layer);
gimp_pixel_rgn_init (&src_pixel_rgn, drawable, 0, 0, w, h, FALSE, FALSE);
gimp_pixel_rgn_init (&dst_pixel_rgn, tmp, 0, 0, w, h, TRUE, FALSE);
buffer = g_malloc (w * h * 4);
gimp_pixel_rgn_get_rect (&src_pixel_rgn, buffer, 0, 0, w, h);
gimp_pixel_rgn_set_rect (&dst_pixel_rgn, buffer, 0, 0, w, h);
gimp_drawable_detach (tmp);
gimp_drawable_detach (drawable);
if (gimp_drawable_is_indexed (layer))
gimp_image_convert_rgb (tmp_image);
gimp_image_convert_indexed (tmp_image,
GIMP_FS_DITHER, GIMP_MAKE_PALETTE,
1 <<bpp, TRUE, FALSE, "dummy");
cmap = gimp_image_get_colormap (tmp_image, &num_colors);
if ( num_colors == (1 << bpp) &&
!ico_cmap_contains_black (cmap, num_colors))
{
/* Windows icons with color maps need the color black.
* We need to eliminate one more color to make room for black.
*/
if (gimp_drawable_is_indexed (layer))
{
g_free (cmap);
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
}
else if (gimp_drawable_is_gray (layer))
{
gimp_image_convert_grayscale (tmp_image);
}
else
{
gimp_image_convert_rgb (tmp_image);
}
tmp = gimp_drawable_get (tmp_layer);
gimp_pixel_rgn_init (&dst_pixel_rgn,
tmp, 0, 0, w, h, TRUE, FALSE);
gimp_pixel_rgn_set_rect (&dst_pixel_rgn, buffer, 0, 0, w, h);
gimp_drawable_detach (tmp);
if (!gimp_drawable_is_rgb (layer))
gimp_image_convert_rgb (tmp_image);
gimp_image_convert_indexed (tmp_image,
GIMP_FS_DITHER, GIMP_MAKE_PALETTE,
(1<<bpp) - 1, TRUE, FALSE, "dummy");
}
g_free (cmap);
g_free (buffer);
pixbuf = gimp_drawable_get_thumbnail (tmp_layer,
MIN (w, 128), MIN (h, 128),
GIMP_PIXBUF_SMALL_CHECKS);
gimp_image_delete (tmp_image);
}
else if (bpp == 24)
{
GimpDrawable *drawable;
GimpDrawable *tmp;
GimpPixelRgn src_pixel_rgn, dst_pixel_rgn;
gint32 image;
gint32 tmp_image;
gint32 tmp_layer;
guchar *buffer;
GimpParam *return_vals;
gint n_return_vals;
image = gimp_item_get_image (layer);
tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
gimp_image_undo_disable (tmp_image);
if (gimp_drawable_is_indexed (layer))
{
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h,
gimp_drawable_type (layer),
100, GIMP_NORMAL_MODE);
gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
drawable = gimp_drawable_get (layer);
tmp = gimp_drawable_get (tmp_layer);
gimp_pixel_rgn_init (&src_pixel_rgn, drawable, 0, 0, w, h, FALSE, FALSE);
gimp_pixel_rgn_init (&dst_pixel_rgn, tmp, 0, 0, w, h, TRUE, FALSE);
buffer = g_malloc (w * h * 4);
gimp_pixel_rgn_get_rect (&src_pixel_rgn, buffer, 0, 0, w, h);
gimp_pixel_rgn_set_rect (&dst_pixel_rgn, buffer, 0, 0, w, h);
g_free (buffer);
gimp_drawable_detach (tmp);
gimp_drawable_detach (drawable);
if (gimp_drawable_is_indexed (layer))
gimp_image_convert_rgb (tmp_image);
return_vals =
gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals,
GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
GIMP_PDB_IMAGE, tmp_image,
GIMP_PDB_DRAWABLE, tmp_layer,
GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD,
GIMP_PDB_END);
gimp_destroy_params (return_vals, n_return_vals);
pixbuf = gimp_drawable_get_thumbnail (tmp_layer,
MIN (w, 128), MIN (h, 128),
GIMP_PIXBUF_SMALL_CHECKS);
gimp_image_delete (tmp_image);
}
else
{
pixbuf = gimp_drawable_get_thumbnail (layer,
MIN (w, 128), MIN (h, 128),
GIMP_PIXBUF_SMALL_CHECKS);
}
gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
g_object_unref (pixbuf);
}
static void
ico_image_get_reduced_buf (guint32 layer,
gint bpp,
gint *num_colors,
guchar **cmap_out,
guchar **buf_out)
{
gint32 tmp_image;
gint32 tmp_layer;
gint w, h;
guchar *buf;
guchar *cmap = NULL;
GeglBuffer *buffer = gimp_drawable_get_buffer (layer);
const Babl *format;
w = gegl_buffer_get_width (buffer);
h = gegl_buffer_get_height (buffer);
switch (gimp_drawable_type (layer))
{
case GIMP_RGB_IMAGE:
format = babl_format ("R'G'B' u8");
break;
case GIMP_RGBA_IMAGE:
format = babl_format ("R'G'B'A u8");
break;
case GIMP_GRAY_IMAGE:
format = babl_format ("Y' u8");
break;
case GIMP_GRAYA_IMAGE:
format = babl_format ("Y'A u8");
break;
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
format = gegl_buffer_get_format (buffer);
default:
g_return_if_reached ();
}
*num_colors = 0;
buf = g_new (guchar, w * h * 4);
if (bpp <= 8 || bpp == 24 || babl_format_get_bytes_per_pixel (format) != 4)
{
gint32 image = gimp_item_get_image (layer);
GeglBuffer *tmp;
tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
gimp_image_undo_disable (tmp_image);
if (gimp_drawable_is_indexed (layer))
{
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
tmp_layer = gimp_layer_new (tmp_image, "tmp", w, h,
gimp_drawable_type (layer),
100, GIMP_NORMAL_MODE);
gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
tmp = gimp_drawable_get_buffer (tmp_layer);
gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0,
format, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_copy (buffer, NULL, GEGL_ABYSS_NONE, tmp, NULL);
g_object_unref (tmp);
if (! gimp_drawable_is_rgb (tmp_layer))
gimp_image_convert_rgb (tmp_image);
if (bpp <= 8)
{
gimp_image_convert_indexed (tmp_image,
GIMP_FS_DITHER, GIMP_MAKE_PALETTE,
1 << bpp, TRUE, FALSE, "dummy");
cmap = gimp_image_get_colormap (tmp_image, num_colors);
if (*num_colors == (1 << bpp) &&
! ico_cmap_contains_black (cmap, *num_colors))
{
/* Windows icons with color maps need the color black.
* We need to eliminate one more color to make room for black.
*/
if (gimp_drawable_is_indexed (layer))
{
g_free (cmap);
cmap = gimp_image_get_colormap (image, num_colors);
gimp_image_set_colormap (tmp_image, cmap, *num_colors);
}
else if (gimp_drawable_is_gray (layer))
{
gimp_image_convert_grayscale (tmp_image);
}
else
{
gimp_image_convert_rgb (tmp_image);
}
tmp = gimp_drawable_get_buffer (tmp_layer);
gegl_buffer_set (tmp, GEGL_RECTANGLE (0, 0, w, h), 0,
format, buf, GEGL_AUTO_ROWSTRIDE);
g_object_unref (tmp);
if (! gimp_drawable_is_rgb (layer))
gimp_image_convert_rgb (tmp_image);
gimp_image_convert_indexed (tmp_image,
GIMP_FS_DITHER, GIMP_MAKE_PALETTE,
(1<<bpp) - 1, TRUE, FALSE, "dummy");
g_free (cmap);
cmap = gimp_image_get_colormap (tmp_image, num_colors);
}
gimp_image_convert_rgb (tmp_image);
}
else if (bpp == 24)
{
GimpParam *return_vals;
gint n_return_vals;
return_vals =
gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals,
GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
GIMP_PDB_IMAGE, tmp_image,
GIMP_PDB_DRAWABLE, tmp_layer,
GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD,
GIMP_PDB_END);
gimp_destroy_params (return_vals, n_return_vals);
}
gimp_layer_add_alpha (tmp_layer);
tmp = gimp_drawable_get_buffer (tmp_layer);
gegl_buffer_get (tmp, GEGL_RECTANGLE (0, 0, w, h), 1.0,
NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
g_object_unref (tmp);
gimp_image_delete (tmp_image);
}
else
{
gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0,
format, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
}
g_object_unref (buffer);
*cmap_out = cmap;
*buf_out = buf;
}
/* Compose a roll film image from several images */
static gint32
film (void)
{
gint width, height;
guchar *hole;
gint film_height, film_width;
gint picture_width, picture_height;
gint picture_space, picture_x0, picture_y0;
gint hole_offset, hole_width, hole_height, hole_space, hole_x;
gint number_height, num_images, num_pictures;
gint j, k, picture_count;
gdouble f;
gint num_layers;
gint32 *image_ID_src, image_ID_dst, layer_ID_src, layer_ID_dst;
gint image_ID_tmp;
gint32 *layers;
GimpDrawable *drawable_dst;
GimpPixelRgn pixel_rgn_dst;
gint new_layer;
gint floating_sel;
/* initialize */
layers = NULL;
num_images = filmvals.num_images;
image_ID_src = filmvals.image;
if (num_images <= 0)
return (-1);
gimp_context_push ();
gimp_context_set_foreground (&filmvals.number_color);
gimp_context_set_background (&filmvals.film_color);
if (filmvals.keep_height) /* Search maximum picture height */
{
picture_height = 0;
for (j = 0; j < num_images; j++)
{
height = gimp_image_height (image_ID_src[j]);
if (height > picture_height) picture_height = height;
}
film_height = (int)(picture_height / filmvals.picture_height + 0.5);
filmvals.film_height = film_height;
}
else
{
film_height = filmvals.film_height;
picture_height = (int)(film_height * filmvals.picture_height + 0.5);
}
picture_space = (int)(film_height * filmvals.picture_space + 0.5);
picture_y0 = (film_height - picture_height)/2;
number_height = film_height * filmvals.number_height;
/* Calculate total film width */
film_width = 0;
num_pictures = 0;
for (j = 0; j < num_images; j++)
{
layers = gimp_image_get_layers (image_ID_src[j], &num_layers);
/* Get scaled image size */
width = gimp_image_width (image_ID_src[j]);
height = gimp_image_height (image_ID_src[j]);
f = ((double)picture_height) / (double)height;
picture_width = width * f;
for (k = 0; k < num_layers; k++)
{
if (gimp_layer_is_floating_sel (layers[k]))
continue;
film_width += (picture_space/2); /* Leading space */
film_width += picture_width; /* Scaled image width */
film_width += (picture_space/2); /* Trailing space */
num_pictures++;
}
g_free (layers);
}
#ifdef FILM_DEBUG
g_printerr ("film_height = %d, film_width = %d\n", film_height, film_width);
g_printerr ("picture_height = %d, picture_space = %d, picture_y0 = %d\n",
picture_height, picture_space, picture_y0);
g_printerr ("Number of pictures = %d\n", num_pictures);
#endif
image_ID_dst = create_new_image (_("Untitled"),
(guint) film_width, (guint) film_height,
GIMP_RGB_IMAGE, &layer_ID_dst,
&drawable_dst, &pixel_rgn_dst);
/* Fill film background */
gimp_drawable_fill (layer_ID_dst, GIMP_FILL_BACKGROUND);
/* Draw all the holes */
hole_offset = film_height * filmvals.hole_offset;
hole_width = film_height * filmvals.hole_width;
hole_height = film_height * filmvals.hole_height;
hole_space = film_height * filmvals.hole_space;
hole_x = hole_space / 2;
#ifdef FILM_DEBUG
g_printerr ("hole_x %d hole_offset %d hole_width %d hole_height %d hole_space %d\n",
hole_x, hole_offset, hole_width, hole_height, hole_space );
#endif
hole = create_hole_rgb (hole_width, hole_height);
if (hole)
{
while (hole_x < film_width)
{
draw_hole_rgb (drawable_dst, hole_x,
hole_offset,
hole_width, hole_height, hole);
draw_hole_rgb (drawable_dst, hole_x,
film_height-hole_offset-hole_height,
hole_width, hole_height, hole);
hole_x += hole_width + hole_space;
}
g_free (hole);
}
gimp_drawable_detach (drawable_dst);
/* Compose all images and layers */
picture_x0 = 0;
picture_count = 0;
for (j = 0; j < num_images; j++)
{
image_ID_tmp = gimp_image_duplicate (image_ID_src[j]);
width = gimp_image_width (image_ID_tmp);
height = gimp_image_height (image_ID_tmp);
f = ((gdouble) picture_height) / (gdouble) height;
picture_width = width * f;
if (gimp_image_base_type (image_ID_tmp) != GIMP_RGB)
gimp_image_convert_rgb (image_ID_tmp);
gimp_image_scale (image_ID_tmp, picture_width, picture_height);
layers = gimp_image_get_layers (image_ID_tmp, &num_layers);
for (k = 0; k < num_layers; k++)
{
if (gimp_layer_is_floating_sel (layers[k]))
continue;
picture_x0 += picture_space / 2;
layer_ID_src = layers[k];
gimp_layer_resize_to_image_size (layer_ID_src);
new_layer = gimp_layer_new_from_drawable (layer_ID_src,
image_ID_dst);
gimp_image_insert_layer (image_ID_dst, new_layer, -1, -1);
gimp_layer_set_offsets (new_layer, picture_x0, picture_y0);
/* Draw picture numbers */
if ((number_height > 0) &&
(filmvals.number_pos[0] || filmvals.number_pos[1]))
{
if (filmvals.number_pos[0])
draw_number (layer_ID_dst,
filmvals.number_start + picture_count,
picture_x0 + picture_width/2,
(hole_offset-number_height)/2, number_height);
if (filmvals.number_pos[1])
draw_number (layer_ID_dst,
filmvals.number_start + picture_count,
picture_x0 + picture_width/2,
film_height - (hole_offset + number_height)/2,
number_height);
}
picture_x0 += picture_width + (picture_space/2);
gimp_progress_update (((gdouble) (picture_count + 1)) /
(gdouble) num_pictures);
picture_count++;
}
g_free (layers);
gimp_image_delete (image_ID_tmp);
}
gimp_progress_update (1.0);
gimp_image_flatten (image_ID_dst);
/* Drawing text/numbers leaves us with a floating selection. Stop it */
floating_sel = gimp_image_get_floating_sel (image_ID_dst);
if (floating_sel != -1)
gimp_floating_sel_anchor (floating_sel);
gimp_context_pop ();
return image_ID_dst;
}
static void
export_convert_rgb (gint32 image_ID,
gint32 *drawable_ID)
{
gimp_image_convert_rgb (image_ID);
}
static void
ico_dialog_update_icon_preview (GtkWidget *dialog,
gint32 layer,
gint bpp)
{
GtkWidget *preview = ico_dialog_get_layer_preview (dialog, layer);
GdkPixbuf *pixbuf;
const Babl *format;
gint w = gimp_drawable_width (layer);
gint h = gimp_drawable_height (layer);
if (! preview)
return;
switch (gimp_drawable_type (layer))
{
case GIMP_RGB_IMAGE:
format = babl_format ("R'G'B' u8");
break;
case GIMP_RGBA_IMAGE:
format = babl_format ("R'G'B'A u8");
break;
case GIMP_GRAY_IMAGE:
format = babl_format ("Y' u8");
break;
case GIMP_GRAYA_IMAGE:
format = babl_format ("Y'A u8");
break;
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
format = gimp_drawable_get_format (layer);
default:
g_return_if_reached ();
}
if (bpp <= 8)
{
GeglBuffer *buffer;
GeglBuffer *tmp;
gint32 image;
gint32 tmp_image;
gint32 tmp_layer;
guchar *buf;
guchar *cmap;
gint num_colors;
image = gimp_item_get_image (layer);
tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
gimp_image_undo_disable (tmp_image);
if (gimp_drawable_is_indexed (layer))
{
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h,
gimp_drawable_type (layer),
100, GIMP_NORMAL_MODE);
gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
buffer = gimp_drawable_get_buffer (layer);
tmp = gimp_drawable_get_buffer (tmp_layer);
buf = g_malloc (w * h * 4);
gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0,
format, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_copy (buffer, NULL, tmp, NULL);
g_object_unref (tmp);
g_object_unref (buffer);
if (gimp_drawable_is_indexed (layer))
gimp_image_convert_rgb (tmp_image);
gimp_image_convert_indexed (tmp_image,
GIMP_FS_DITHER, GIMP_MAKE_PALETTE,
1 << bpp, TRUE, FALSE, "dummy");
cmap = gimp_image_get_colormap (tmp_image, &num_colors);
if (num_colors == (1 << bpp) &&
! ico_cmap_contains_black (cmap, num_colors))
{
/* Windows icons with color maps need the color black.
* We need to eliminate one more color to make room for black.
*/
if (gimp_drawable_is_indexed (layer))
{
g_free (cmap);
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
}
else if (gimp_drawable_is_gray (layer))
{
gimp_image_convert_grayscale (tmp_image);
}
else
{
gimp_image_convert_rgb (tmp_image);
}
tmp = gimp_drawable_get_buffer (tmp_layer);
gegl_buffer_set (tmp, GEGL_RECTANGLE (0, 0, w, h), 0,
format, buf, GEGL_AUTO_ROWSTRIDE);
g_object_unref (tmp);
if (!gimp_drawable_is_rgb (layer))
gimp_image_convert_rgb (tmp_image);
gimp_image_convert_indexed (tmp_image,
GIMP_FS_DITHER, GIMP_MAKE_PALETTE,
(1 << bpp) - 1, TRUE, FALSE, "dummy");
}
g_free (cmap);
g_free (buf);
pixbuf = gimp_drawable_get_thumbnail (tmp_layer,
MIN (w, 128), MIN (h, 128),
GIMP_PIXBUF_SMALL_CHECKS);
gimp_image_delete (tmp_image);
}
else if (bpp == 24)
{
GeglBuffer *buffer;
GeglBuffer *tmp;
gint32 image;
gint32 tmp_image;
gint32 tmp_layer;
GimpParam *return_vals;
gint n_return_vals;
image = gimp_item_get_image (layer);
tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
gimp_image_undo_disable (tmp_image);
if (gimp_drawable_is_indexed (layer))
{
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image, &num_colors);
gimp_image_set_colormap (tmp_image, cmap, num_colors);
g_free (cmap);
}
tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h,
gimp_drawable_type (layer),
100, GIMP_NORMAL_MODE);
gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0);
buffer = gimp_drawable_get_buffer (layer);
tmp = gimp_drawable_get_buffer (tmp_layer);
gegl_buffer_copy (buffer, NULL, tmp, NULL);
g_object_unref (tmp);
g_object_unref (buffer);
if (gimp_drawable_is_indexed (layer))
gimp_image_convert_rgb (tmp_image);
return_vals =
gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals,
GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
GIMP_PDB_IMAGE, tmp_image,
GIMP_PDB_DRAWABLE, tmp_layer,
GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD,
GIMP_PDB_END);
gimp_destroy_params (return_vals, n_return_vals);
pixbuf = gimp_drawable_get_thumbnail (tmp_layer,
MIN (w, 128), MIN (h, 128),
GIMP_PIXBUF_SMALL_CHECKS);
gimp_image_delete (tmp_image);
}
else
{
pixbuf = gimp_drawable_get_thumbnail (layer,
MIN (w, 128), MIN (h, 128),
GIMP_PIXBUF_SMALL_CHECKS);
}
gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
g_object_unref (pixbuf);
}
