1110 lines
35 KiB
C
1110 lines
35 KiB
C
/* PIKA - Photo and Image Kooker Application
|
|
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
|
|
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
|
|
*
|
|
* Original copyright, applying to most contents (license remains unchanged):
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <setjmp.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <glib/gstdio.h>
|
|
|
|
#include <jpeglib.h>
|
|
#include <jerror.h>
|
|
|
|
#include <libpika/pika.h>
|
|
#include <libpika/pikaui.h>
|
|
|
|
#include "libpika/stdplugins-intl.h"
|
|
|
|
#include "jpeg.h"
|
|
#include "jpeg-icc.h"
|
|
#include "jpeg-load.h"
|
|
#include "jpeg-save.h"
|
|
#include "jpeg-settings.h"
|
|
|
|
/* See bugs #63610 and #61088 for a discussion about the quality settings */
|
|
#define DEFAULT_RESTART_MCU_ROWS 16
|
|
|
|
|
|
typedef struct
|
|
{
|
|
struct jpeg_compress_struct cinfo;
|
|
struct jpeg_error_mgr jerr;
|
|
gint tile_height;
|
|
FILE *outfile;
|
|
gboolean has_alpha;
|
|
gint rowstride;
|
|
guchar *data;
|
|
guchar *src;
|
|
GeglBuffer *buffer;
|
|
const Babl *format;
|
|
GFile *file;
|
|
gboolean abort_me;
|
|
guint source_id;
|
|
} PreviewPersistent;
|
|
|
|
|
|
static void make_preview (PikaProcedureConfig *config);
|
|
|
|
static void quality_changed (PikaProcedureConfig *config);
|
|
static void subsampling_changed (PikaProcedureConfig *config,
|
|
const GParamSpec *pspec,
|
|
GtkWidget *smoothing_scale);
|
|
static void use_orig_qual_changed (PikaProcedureConfig *config);
|
|
static void use_orig_qual_changed_rgb (PikaProcedureConfig *config);
|
|
|
|
|
|
static GtkWidget *preview_size = NULL;
|
|
static PreviewPersistent *prev_p = NULL;
|
|
|
|
|
|
/*
|
|
* sg - This is the best I can do, I'm afraid... I think it will fail
|
|
* if something bad really happens (but it might not). If you have a
|
|
* better solution, send it ;-)
|
|
*/
|
|
static void
|
|
background_error_exit (j_common_ptr cinfo)
|
|
{
|
|
if (prev_p)
|
|
prev_p->abort_me = TRUE;
|
|
(*cinfo->err->output_message) (cinfo);
|
|
}
|
|
|
|
static gboolean
|
|
background_jpeg_save (PreviewPersistent *pp)
|
|
{
|
|
gint yend;
|
|
|
|
if (pp->abort_me || (pp->cinfo.next_scanline >= pp->cinfo.image_height))
|
|
{
|
|
/* clean up... */
|
|
if (pp->abort_me)
|
|
{
|
|
jpeg_abort_compress (&(pp->cinfo));
|
|
}
|
|
else
|
|
{
|
|
jpeg_finish_compress (&(pp->cinfo));
|
|
}
|
|
|
|
fclose (pp->outfile);
|
|
jpeg_destroy_compress (&(pp->cinfo));
|
|
|
|
g_free (pp->data);
|
|
|
|
if (pp->buffer)
|
|
g_object_unref (pp->buffer);
|
|
|
|
/* display the preview stuff */
|
|
if (! pp->abort_me)
|
|
{
|
|
GFileInfo *info;
|
|
gchar *text;
|
|
GError *error = NULL;
|
|
|
|
info = g_file_query_info (pp->file,
|
|
G_FILE_ATTRIBUTE_STANDARD_SIZE,
|
|
G_FILE_QUERY_INFO_NONE,
|
|
NULL, &error);
|
|
|
|
if (info)
|
|
{
|
|
goffset size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
|
|
gchar *size_text;
|
|
|
|
size_text = g_format_size (size);
|
|
text = g_strdup_printf (_("File size: %s"), size_text);
|
|
g_free (size_text);
|
|
|
|
g_object_unref (info);
|
|
}
|
|
else
|
|
{
|
|
text = g_strdup_printf (_("File size: %s"), error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
|
|
gtk_label_set_text (GTK_LABEL (preview_size), text);
|
|
g_free (text);
|
|
|
|
/* and load the preview */
|
|
load_image (pp->file, PIKA_RUN_NONINTERACTIVE,
|
|
TRUE, NULL, NULL, NULL);
|
|
}
|
|
|
|
/* we cleanup here (load_image doesn't run in the background) */
|
|
g_file_delete (pp->file, NULL, NULL);
|
|
g_object_unref (pp->file);
|
|
|
|
g_free (pp);
|
|
prev_p = NULL;
|
|
|
|
pika_displays_flush ();
|
|
gdk_display_flush (gdk_display_get_default ());
|
|
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if ((pp->cinfo.next_scanline % pp->tile_height) == 0)
|
|
{
|
|
yend = pp->cinfo.next_scanline + pp->tile_height;
|
|
yend = MIN (yend, pp->cinfo.image_height);
|
|
gegl_buffer_get (pp->buffer,
|
|
GEGL_RECTANGLE (0, pp->cinfo.next_scanline,
|
|
pp->cinfo.image_width,
|
|
(yend - pp->cinfo.next_scanline)),
|
|
1.0,
|
|
pp->format,
|
|
pp->data,
|
|
GEGL_AUTO_ROWSTRIDE,
|
|
GEGL_ABYSS_NONE);
|
|
pp->src = pp->data;
|
|
}
|
|
|
|
jpeg_write_scanlines (&(pp->cinfo), (JSAMPARRAY) &(pp->src), 1);
|
|
pp->src += pp->rowstride;
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
save_image (GFile *file,
|
|
PikaProcedureConfig *config,
|
|
PikaImage *image,
|
|
PikaDrawable *drawable,
|
|
PikaImage *orig_image,
|
|
gboolean preview,
|
|
GError **error)
|
|
{
|
|
static struct jpeg_compress_struct cinfo;
|
|
static struct my_error_mgr jerr;
|
|
|
|
PikaImageType drawable_type;
|
|
GeglBuffer *buffer;
|
|
const gchar *encoding;
|
|
const Babl *format;
|
|
const Babl *space;
|
|
JpegSubsampling subsampling;
|
|
FILE * volatile outfile;
|
|
guchar *data;
|
|
guchar *src;
|
|
PikaColorProfile *profile = NULL;
|
|
PikaColorProfile *cmyk_profile = NULL;
|
|
|
|
gboolean has_alpha;
|
|
gboolean out_linear = FALSE;
|
|
gint rowstride, yend;
|
|
|
|
gint quality;
|
|
gdouble dquality = 1.0;
|
|
gdouble smoothing;
|
|
gboolean optimize;
|
|
gboolean progressive;
|
|
gboolean cmyk;
|
|
gint subsmp;
|
|
gboolean baseline;
|
|
gint restart;
|
|
gint dct;
|
|
gboolean save_profile = TRUE;
|
|
gboolean save_comment;
|
|
gboolean use_orig_quality = FALSE;
|
|
gint orig_num_quant_tables = -1;
|
|
gboolean use_arithmetic_coding = FALSE;
|
|
gboolean use_restart = FALSE;
|
|
gchar *comment;
|
|
|
|
g_object_get (config,
|
|
"quality", &dquality,
|
|
"smoothing", &smoothing,
|
|
"optimize", &optimize,
|
|
"progressive", &progressive,
|
|
"cmyk", &cmyk,
|
|
"sub-sampling", &subsmp,
|
|
"baseline", &baseline,
|
|
"restart", &restart,
|
|
"dct", &dct,
|
|
|
|
/* Original quality settings. */
|
|
"use-original-quality", &use_orig_quality,
|
|
"original-num-quant-tables", &orig_num_quant_tables,
|
|
|
|
"use-arithmetic-coding", &use_arithmetic_coding,
|
|
"use-restart", &use_restart,
|
|
|
|
"save-color-profile", &save_profile,
|
|
"save-comment", &save_comment,
|
|
"pika-comment", &comment,
|
|
|
|
NULL);
|
|
|
|
quality = (gint) (dquality * 100.0 + 0.5);
|
|
|
|
drawable_type = pika_drawable_type (drawable);
|
|
buffer = pika_drawable_get_buffer (drawable);
|
|
space = pika_drawable_get_format (drawable);
|
|
|
|
if (! preview)
|
|
pika_progress_init_printf (_("Exporting '%s'"),
|
|
pika_file_get_utf8_name (file));
|
|
|
|
/* Step 1: allocate and initialize JPEG compression object */
|
|
|
|
/* We have to set up the error handler first, in case the initialization
|
|
* step fails. (Unlikely, but it could happen if you are out of memory.)
|
|
* This routine fills in the contents of struct jerr, and returns jerr's
|
|
* address which we place into the link field in cinfo.
|
|
*/
|
|
cinfo.err = jpeg_std_error (&jerr.pub);
|
|
jerr.pub.error_exit = my_error_exit;
|
|
|
|
outfile = NULL;
|
|
/* Establish the setjmp return context for my_error_exit to use. */
|
|
if (setjmp (jerr.setjmp_buffer))
|
|
{
|
|
/* If we get here, the JPEG code has signaled an error.
|
|
* We need to clean up the JPEG object, close the input file, and return.
|
|
*/
|
|
jpeg_destroy_compress (&cinfo);
|
|
if (outfile)
|
|
fclose (outfile);
|
|
if (buffer)
|
|
g_object_unref (buffer);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Now we can initialize the JPEG compression object. */
|
|
jpeg_create_compress (&cinfo);
|
|
|
|
/* Step 2: specify data destination (eg, a file) */
|
|
/* Note: steps 2 and 3 can be done in either order. */
|
|
|
|
/* Here we use the library-supplied code to send compressed data to a
|
|
* stdio stream. You can also write your own code to do something else.
|
|
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
|
|
* requires it in order to write binary files.
|
|
*/
|
|
outfile = g_fopen (g_file_peek_path (file), "wb");
|
|
|
|
if (! outfile)
|
|
{
|
|
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
|
|
_("Could not open '%s' for writing: %s"),
|
|
pika_file_get_utf8_name (file), g_strerror (errno));
|
|
return FALSE;
|
|
}
|
|
|
|
/* When we don't save profiles, we convert data to sRGB because
|
|
* that's what most/all readers expect on a no-profile JPEG.
|
|
* If we save an assigned profile, let's just follow its TRC.
|
|
* If we save the default linear profile (i.e. no assigned
|
|
* profile), we convert it to sRGB, except when it is 8-bit linear.
|
|
*/
|
|
if (save_profile)
|
|
{
|
|
profile = pika_image_get_color_profile (orig_image);
|
|
|
|
/* If a profile is explicitly set, follow its TRC, whatever the
|
|
* storage format.
|
|
*/
|
|
if (profile && pika_color_profile_is_linear (profile))
|
|
out_linear = TRUE;
|
|
|
|
if (! profile)
|
|
{
|
|
/* There is always an effective profile. */
|
|
profile = pika_image_get_effective_color_profile (orig_image);
|
|
|
|
if (pika_color_profile_is_linear (profile))
|
|
{
|
|
if (pika_image_get_precision (image) != PIKA_PRECISION_U8_LINEAR)
|
|
{
|
|
PikaColorProfile *saved_profile;
|
|
|
|
saved_profile = pika_color_profile_new_srgb_trc_from_color_profile (profile);
|
|
g_object_unref (profile);
|
|
profile = saved_profile;
|
|
}
|
|
else
|
|
{
|
|
/* Keep linear profile as-is for 8-bit linear image. */
|
|
out_linear = TRUE;
|
|
}
|
|
}
|
|
}
|
|
space = pika_color_profile_get_space (profile,
|
|
pika_image_get_simulation_intent (image),
|
|
error);
|
|
if (error && *error)
|
|
{
|
|
/* XXX: the profile space should normally be the same one as
|
|
* the drawable's so let's continue with it. We were mostly
|
|
* getting the profile space to be complete. Still let's
|
|
* display the error to standard error channel because if the
|
|
* space could not be extracted, there is a problem somewhere!
|
|
*/
|
|
g_printerr ("%s: error getting the profile space: %s",
|
|
G_STRFUNC, (*error)->message);
|
|
g_clear_error (error);
|
|
space = pika_drawable_get_format (drawable);
|
|
}
|
|
}
|
|
|
|
jpeg_stdio_dest (&cinfo, outfile);
|
|
|
|
/* Get the input image and a pointer to its data.
|
|
*/
|
|
switch (drawable_type)
|
|
{
|
|
case PIKA_RGB_IMAGE:
|
|
/* # of color components per pixel */
|
|
cinfo.input_components = 3;
|
|
has_alpha = FALSE;
|
|
|
|
if (out_linear)
|
|
encoding = "RGB u8";
|
|
else
|
|
encoding = "R'G'B' u8";
|
|
break;
|
|
|
|
case PIKA_GRAY_IMAGE:
|
|
/* # of color components per pixel */
|
|
cinfo.input_components = 1;
|
|
has_alpha = FALSE;
|
|
|
|
if (out_linear)
|
|
encoding = "Y u8";
|
|
else
|
|
encoding = "Y' u8";
|
|
break;
|
|
|
|
case PIKA_RGBA_IMAGE:
|
|
/* # of color components per pixel (minus the PIKA alpha channel) */
|
|
cinfo.input_components = 4 - 1;
|
|
has_alpha = TRUE;
|
|
|
|
if (out_linear)
|
|
encoding = "RGB u8";
|
|
else
|
|
encoding = "R'G'B' u8";
|
|
break;
|
|
|
|
case PIKA_GRAYA_IMAGE:
|
|
/* # of color components per pixel (minus the PIKA alpha channel) */
|
|
cinfo.input_components = 2 - 1;
|
|
has_alpha = TRUE;
|
|
if (out_linear)
|
|
encoding = "Y u8";
|
|
else
|
|
encoding = "Y' u8";
|
|
break;
|
|
|
|
case PIKA_INDEXED_IMAGE:
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
if (cmyk)
|
|
{
|
|
if (save_profile)
|
|
{
|
|
GError *err = NULL;
|
|
|
|
cmyk_profile = pika_image_get_simulation_profile (image);
|
|
if (! cmyk_profile && err)
|
|
g_printerr ("%s: no soft-proof profile: %s\n", G_STRFUNC, err->message);
|
|
|
|
if (cmyk_profile && ! pika_color_profile_is_cmyk (cmyk_profile))
|
|
g_clear_object (&cmyk_profile);
|
|
|
|
g_clear_error (&err);
|
|
}
|
|
|
|
/* As far as I know, without access to JPEG specifications, we
|
|
* should encode as proper "CMYK" encoding scheme. But every other
|
|
* program where I test this JPEG, the color are inverted, so I
|
|
* use the "cmyk" encoding where 0.0 is full ink coverage vs. 1.0
|
|
* being no ink.
|
|
* libjpeg-turbo says that Photoshop is wrongly inverting the data
|
|
* in JPEG files in a 1994 commit! We might imagine that since
|
|
* then it became the de-facto encoding?
|
|
* See: https://github.com/libjpeg-turbo/libjpeg-turbo/blob/dfc63d42ee3d1ae8eacb921e89e64ac57861dff6/libjpeg.txt#L1425-L1438
|
|
*/
|
|
encoding = "cmyk u8";
|
|
|
|
if (cmyk_profile)
|
|
space = pika_color_profile_get_space (cmyk_profile,
|
|
PIKA_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
|
|
error);
|
|
else
|
|
/* The NULL space will fallback to a naive CMYK conversion. */
|
|
space = NULL;
|
|
}
|
|
|
|
format = babl_format_with_space (encoding, space);
|
|
|
|
/* Step 3: set parameters for compression */
|
|
|
|
/* First we supply a description of the input image.
|
|
* Four fields of the cinfo struct must be filled in:
|
|
*/
|
|
/* image width and height, in pixels */
|
|
cinfo.image_width = gegl_buffer_get_width (buffer);
|
|
cinfo.image_height = gegl_buffer_get_height (buffer);
|
|
/* colorspace of input image */
|
|
if (cmyk)
|
|
{
|
|
cinfo.input_components = 4;
|
|
cinfo.in_color_space = JCS_CMYK;
|
|
cinfo.jpeg_color_space = JCS_CMYK;
|
|
}
|
|
else
|
|
{
|
|
cinfo.in_color_space = (drawable_type == PIKA_RGB_IMAGE ||
|
|
drawable_type == PIKA_RGBA_IMAGE)
|
|
? JCS_RGB : JCS_GRAYSCALE;
|
|
}
|
|
/* Now use the library's routine to set default compression parameters.
|
|
* (You must set at least cinfo.in_color_space before calling this,
|
|
* since the defaults depend on the source color space.)
|
|
*/
|
|
jpeg_set_defaults (&cinfo);
|
|
|
|
if (cmyk_profile)
|
|
jpeg_set_colorspace (&cinfo, JCS_CMYK);
|
|
|
|
jpeg_set_quality (&cinfo, quality, baseline);
|
|
|
|
if (use_orig_quality && orig_num_quant_tables > 0)
|
|
{
|
|
guint **quant_tables;
|
|
gint t;
|
|
|
|
/* override tables generated by jpeg_set_quality() with custom tables */
|
|
quant_tables = jpeg_restore_original_tables (image, orig_num_quant_tables);
|
|
if (quant_tables)
|
|
{
|
|
for (t = 0; t < orig_num_quant_tables; t++)
|
|
{
|
|
jpeg_add_quant_table (&cinfo, t, quant_tables[t],
|
|
100, baseline);
|
|
g_free (quant_tables[t]);
|
|
}
|
|
g_free (quant_tables);
|
|
}
|
|
}
|
|
|
|
#ifdef C_ARITH_CODING_SUPPORTED
|
|
cinfo.arith_code = use_arithmetic_coding;
|
|
if (! use_arithmetic_coding)
|
|
cinfo.optimize_coding = optimize;
|
|
#else
|
|
cinfo.optimize_coding = optimize;
|
|
#endif
|
|
|
|
subsampling = (pika_drawable_is_rgb (drawable) ?
|
|
subsmp : JPEG_SUBSAMPLING_1x1_1x1_1x1);
|
|
|
|
/* smoothing is not supported with nonstandard sampling ratios */
|
|
if (subsampling != JPEG_SUBSAMPLING_2x1_1x1_1x1 &&
|
|
subsampling != JPEG_SUBSAMPLING_1x2_1x1_1x1)
|
|
{
|
|
cinfo.smoothing_factor = (gint) (smoothing * 100);
|
|
}
|
|
|
|
if (progressive)
|
|
{
|
|
jpeg_simple_progression (&cinfo);
|
|
}
|
|
|
|
switch (subsampling)
|
|
{
|
|
case JPEG_SUBSAMPLING_2x2_1x1_1x1:
|
|
default:
|
|
cinfo.comp_info[0].h_samp_factor = 2;
|
|
cinfo.comp_info[0].v_samp_factor = 2;
|
|
cinfo.comp_info[1].h_samp_factor = 1;
|
|
cinfo.comp_info[1].v_samp_factor = 1;
|
|
cinfo.comp_info[2].h_samp_factor = 1;
|
|
cinfo.comp_info[2].v_samp_factor = 1;
|
|
break;
|
|
|
|
case JPEG_SUBSAMPLING_2x1_1x1_1x1:
|
|
cinfo.comp_info[0].h_samp_factor = 2;
|
|
cinfo.comp_info[0].v_samp_factor = 1;
|
|
cinfo.comp_info[1].h_samp_factor = 1;
|
|
cinfo.comp_info[1].v_samp_factor = 1;
|
|
cinfo.comp_info[2].h_samp_factor = 1;
|
|
cinfo.comp_info[2].v_samp_factor = 1;
|
|
break;
|
|
|
|
case JPEG_SUBSAMPLING_1x1_1x1_1x1:
|
|
cinfo.comp_info[0].h_samp_factor = 1;
|
|
cinfo.comp_info[0].v_samp_factor = 1;
|
|
cinfo.comp_info[1].h_samp_factor = 1;
|
|
cinfo.comp_info[1].v_samp_factor = 1;
|
|
cinfo.comp_info[2].h_samp_factor = 1;
|
|
cinfo.comp_info[2].v_samp_factor = 1;
|
|
break;
|
|
|
|
case JPEG_SUBSAMPLING_1x2_1x1_1x1:
|
|
cinfo.comp_info[0].h_samp_factor = 1;
|
|
cinfo.comp_info[0].v_samp_factor = 2;
|
|
cinfo.comp_info[1].h_samp_factor = 1;
|
|
cinfo.comp_info[1].v_samp_factor = 1;
|
|
cinfo.comp_info[2].h_samp_factor = 1;
|
|
cinfo.comp_info[2].v_samp_factor = 1;
|
|
break;
|
|
}
|
|
|
|
cinfo.restart_interval = 0;
|
|
cinfo.restart_in_rows = use_restart ? restart : 0;
|
|
|
|
switch (dct)
|
|
{
|
|
case 0:
|
|
default:
|
|
cinfo.dct_method = JDCT_ISLOW;
|
|
break;
|
|
|
|
case 1:
|
|
cinfo.dct_method = JDCT_IFAST;
|
|
break;
|
|
|
|
case 2:
|
|
cinfo.dct_method = JDCT_FLOAT;
|
|
break;
|
|
}
|
|
|
|
{
|
|
gdouble xresolution;
|
|
gdouble yresolution;
|
|
|
|
pika_image_get_resolution (orig_image, &xresolution, &yresolution);
|
|
|
|
if (xresolution > 1e-5 && yresolution > 1e-5)
|
|
{
|
|
gdouble factor;
|
|
|
|
factor = pika_unit_get_factor (pika_image_get_unit (orig_image));
|
|
|
|
if (factor == 2.54 /* cm */ ||
|
|
factor == 25.4 /* mm */)
|
|
{
|
|
cinfo.density_unit = 2; /* dots per cm */
|
|
|
|
xresolution /= 2.54;
|
|
yresolution /= 2.54;
|
|
}
|
|
else
|
|
{
|
|
cinfo.density_unit = 1; /* dots per inch */
|
|
}
|
|
|
|
cinfo.X_density = xresolution;
|
|
cinfo.Y_density = yresolution;
|
|
}
|
|
}
|
|
|
|
/* Step 4: Start compressor */
|
|
|
|
/* TRUE ensures that we will write a complete interchange-JPEG file.
|
|
* Pass TRUE unless you are very sure of what you're doing.
|
|
*/
|
|
jpeg_start_compress (&cinfo, TRUE);
|
|
|
|
/* Step 4.1: Write the comment out - pw */
|
|
if (save_comment && comment && *comment)
|
|
{
|
|
#ifdef PIKA_UNSTABLE
|
|
g_print ("jpeg-save: saving image comment (%d bytes)\n",
|
|
(int) strlen (comment));
|
|
#endif
|
|
jpeg_write_marker (&cinfo, JPEG_COM,
|
|
(guchar *) comment, strlen (comment));
|
|
}
|
|
|
|
/* Step 4.2: store the color profile */
|
|
if (save_profile &&
|
|
/* XXX Only case when we don't save a profile even though the
|
|
* option was requested is if we store as CMYK without setting a
|
|
* profile. It would actually be better to generate a profile
|
|
* corresponding to the "naive" CMYK space we use in such case.
|
|
* But it doesn't look like babl can do this yet.
|
|
*/
|
|
(! cmyk || cmyk_profile != NULL))
|
|
{
|
|
const guint8 *icc_data;
|
|
gsize icc_length;
|
|
|
|
icc_data = pika_color_profile_get_icc_profile (cmyk_profile ? cmyk_profile : profile, &icc_length);
|
|
jpeg_icc_write_profile (&cinfo, icc_data, icc_length);
|
|
}
|
|
g_clear_object (&profile);
|
|
g_clear_object (&cmyk_profile);
|
|
|
|
/* Step 5: while (scan lines remain to be written) */
|
|
/* jpeg_write_scanlines(...); */
|
|
|
|
/* Here we use the library's state variable cinfo.next_scanline as the
|
|
* loop counter, so that we don't have to keep track ourselves.
|
|
* To keep things simple, we pass one scanline per call; you can pass
|
|
* more if you wish, though.
|
|
*/
|
|
/* JSAMPLEs per row in image_buffer */
|
|
rowstride = cinfo.input_components * cinfo.image_width;
|
|
data = g_new (guchar, rowstride * pika_tile_height ());
|
|
|
|
/* fault if cinfo.next_scanline isn't initially a multiple of
|
|
* pika_tile_height */
|
|
src = NULL;
|
|
|
|
/*
|
|
* sg - if we preview, we want this to happen in the background -- do
|
|
* not duplicate code in the future; for now, it's OK
|
|
*/
|
|
|
|
if (preview)
|
|
{
|
|
PreviewPersistent *pp = g_new (PreviewPersistent, 1);
|
|
|
|
/* pass all the information we need */
|
|
pp->cinfo = cinfo;
|
|
pp->tile_height = pika_tile_height();
|
|
pp->data = data;
|
|
pp->outfile = outfile;
|
|
pp->has_alpha = has_alpha;
|
|
pp->rowstride = rowstride;
|
|
pp->data = data;
|
|
pp->buffer = buffer;
|
|
pp->format = format;
|
|
pp->src = NULL;
|
|
pp->file = g_object_ref (file);
|
|
pp->abort_me = FALSE;
|
|
|
|
g_warn_if_fail (prev_p == NULL);
|
|
prev_p = pp;
|
|
|
|
pp->cinfo.err = jpeg_std_error(&(pp->jerr));
|
|
pp->jerr.error_exit = background_error_exit;
|
|
|
|
gtk_label_set_text (GTK_LABEL (preview_size),
|
|
_("Calculating file size..."));
|
|
|
|
pp->source_id = g_idle_add ((GSourceFunc) background_jpeg_save, pp);
|
|
|
|
/* background_jpeg_save() will cleanup as needed */
|
|
return TRUE;
|
|
}
|
|
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
{
|
|
if ((cinfo.next_scanline % pika_tile_height ()) == 0)
|
|
{
|
|
yend = cinfo.next_scanline + pika_tile_height ();
|
|
yend = MIN (yend, cinfo.image_height);
|
|
gegl_buffer_get (buffer,
|
|
GEGL_RECTANGLE (0, cinfo.next_scanline,
|
|
cinfo.image_width,
|
|
(yend - cinfo.next_scanline)),
|
|
1.0,
|
|
format,
|
|
data,
|
|
GEGL_AUTO_ROWSTRIDE,
|
|
GEGL_ABYSS_NONE);
|
|
src = data;
|
|
}
|
|
|
|
jpeg_write_scanlines (&cinfo, (JSAMPARRAY) &src, 1);
|
|
src += rowstride;
|
|
|
|
if ((cinfo.next_scanline % 32) == 0)
|
|
pika_progress_update ((gdouble) cinfo.next_scanline /
|
|
(gdouble) cinfo.image_height);
|
|
}
|
|
|
|
/* Step 6: Finish compression */
|
|
jpeg_finish_compress (&cinfo);
|
|
/* After finish_compress, we can close the output file. */
|
|
fclose (outfile);
|
|
|
|
/* Step 7: release JPEG compression object */
|
|
|
|
/* This is an important step since it will release a good deal of memory. */
|
|
jpeg_destroy_compress (&cinfo);
|
|
|
|
/* free the temporary buffer */
|
|
g_free (data);
|
|
|
|
/* And we're done! */
|
|
pika_progress_update (1.0);
|
|
|
|
g_object_unref (buffer);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
make_preview (PikaProcedureConfig *config)
|
|
{
|
|
gboolean show_preview;
|
|
|
|
destroy_preview ();
|
|
|
|
g_object_get (config, "show-preview", &show_preview, NULL);
|
|
|
|
if (show_preview)
|
|
{
|
|
GFile *file = pika_temp_file ("jpeg");
|
|
|
|
if (! undo_touched)
|
|
{
|
|
/* we freeze undo saving so that we can avoid sucking up
|
|
* tile cache with our unneeded preview steps. */
|
|
pika_image_undo_freeze (preview_image);
|
|
|
|
undo_touched = TRUE;
|
|
}
|
|
|
|
save_image (file, config,
|
|
preview_image,
|
|
drawable_global,
|
|
orig_image_global,
|
|
TRUE, NULL);
|
|
|
|
g_object_unref (file);
|
|
|
|
if (separate_display && ! display)
|
|
display = pika_display_new (preview_image);
|
|
}
|
|
else
|
|
{
|
|
gtk_label_set_text (GTK_LABEL (preview_size), _("File size: unknown"));
|
|
|
|
pika_displays_flush ();
|
|
}
|
|
}
|
|
|
|
void
|
|
destroy_preview (void)
|
|
{
|
|
if (prev_p && !prev_p->abort_me)
|
|
{
|
|
guint id = prev_p->source_id;
|
|
prev_p->abort_me = TRUE; /* signal the background save to stop */
|
|
background_jpeg_save (prev_p);
|
|
g_source_remove (id);
|
|
}
|
|
|
|
if (pika_image_is_valid (preview_image) &&
|
|
pika_item_is_valid (PIKA_ITEM (preview_layer)))
|
|
{
|
|
/* assuming that reference counting is working correctly, we do
|
|
* not need to delete the layer, removing it from the image
|
|
* should be sufficient
|
|
*/
|
|
pika_image_remove_layer (preview_image, preview_layer);
|
|
|
|
preview_layer = NULL;
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
save_dialog (PikaProcedure *procedure,
|
|
PikaProcedureConfig *config,
|
|
PikaDrawable *drawable,
|
|
PikaImage *image)
|
|
{
|
|
GtkWidget *dialog;
|
|
GtkWidget *widget;
|
|
GtkWidget *profile_label;
|
|
GtkListStore *store;
|
|
PikaColorProfile *cmyk_profile = NULL;
|
|
gint orig_quality;
|
|
gint restart;
|
|
gboolean run;
|
|
|
|
g_object_get (config,
|
|
"original-quality", &orig_quality,
|
|
"restart", &restart,
|
|
NULL);
|
|
|
|
dialog = pika_save_procedure_dialog_new (PIKA_SAVE_PROCEDURE (procedure),
|
|
PIKA_PROCEDURE_CONFIG (config),
|
|
pika_item_get_image (PIKA_ITEM (drawable)));
|
|
|
|
/* custom quantization tables - now used also for original quality */
|
|
pika_procedure_dialog_set_sensitive (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"use-original-quality",
|
|
(orig_quality > 0), NULL, NULL, FALSE);
|
|
|
|
/* Quality as a PikaScaleEntry. */
|
|
pika_procedure_dialog_get_spin_scale (PIKA_PROCEDURE_DIALOG (dialog), "quality", 100.0);
|
|
|
|
/* changing quality disables custom quantization tables, and vice-versa */
|
|
g_signal_connect (config, "notify::quality",
|
|
G_CALLBACK (quality_changed),
|
|
NULL);
|
|
g_signal_connect (config, "notify::use-original-quality",
|
|
G_CALLBACK (use_orig_qual_changed),
|
|
NULL);
|
|
|
|
/* File size label. */
|
|
preview_size = pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"preview-size", _("File size: unknown"),
|
|
FALSE, FALSE);
|
|
gtk_label_set_xalign (GTK_LABEL (preview_size), 0.0);
|
|
gtk_label_set_ellipsize (GTK_LABEL (preview_size), PANGO_ELLIPSIZE_END);
|
|
pika_label_set_attributes (GTK_LABEL (preview_size),
|
|
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
|
|
-1);
|
|
pika_help_set_help_data (preview_size,
|
|
_("Enable preview to obtain the file size."), NULL);
|
|
|
|
|
|
/* Profile label. */
|
|
profile_label = pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"profile-label", _("No soft-proofing profile"),
|
|
FALSE, FALSE);
|
|
gtk_label_set_xalign (GTK_LABEL (profile_label), 0.0);
|
|
gtk_label_set_ellipsize (GTK_LABEL (profile_label), PANGO_ELLIPSIZE_END);
|
|
pika_label_set_attributes (GTK_LABEL (profile_label),
|
|
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
|
|
-1);
|
|
pika_help_set_help_data (profile_label,
|
|
_("Name of the color profile used for CMYK export."), NULL);
|
|
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"cmyk-frame", "cmyk", FALSE,
|
|
"profile-label");
|
|
cmyk_profile = pika_image_get_simulation_profile (image);
|
|
if (cmyk_profile)
|
|
{
|
|
if (pika_color_profile_is_cmyk (cmyk_profile))
|
|
{
|
|
gchar *label_text;
|
|
|
|
label_text = g_strdup_printf (_("Profile: %s"),
|
|
pika_color_profile_get_label (cmyk_profile));
|
|
gtk_label_set_text (GTK_LABEL (profile_label), label_text);
|
|
pika_label_set_attributes (GTK_LABEL (profile_label),
|
|
PANGO_ATTR_STYLE, PANGO_STYLE_NORMAL,
|
|
-1);
|
|
g_free (label_text);
|
|
}
|
|
g_object_unref (cmyk_profile);
|
|
}
|
|
|
|
#ifdef C_ARITH_CODING_SUPPORTED
|
|
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"arithmetic-frame", "use-arithmetic-coding", TRUE,
|
|
"optimize");
|
|
#endif
|
|
|
|
/* Restart marker. */
|
|
/* TODO: apparently when toggle is unchecked, we want to show the
|
|
* scale as 0.
|
|
*/
|
|
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"restart-frame", "use-restart", FALSE,
|
|
"restart");
|
|
if (restart == 0)
|
|
g_object_set (config,
|
|
"restart", DEFAULT_RESTART_MCU_ROWS,
|
|
"use-restart", FALSE,
|
|
NULL);
|
|
|
|
/* Subsampling */
|
|
store = pika_int_store_new (_("4:4:4 (best quality)"),
|
|
JPEG_SUBSAMPLING_1x1_1x1_1x1,
|
|
_("4:2:2 (chroma halved horizontally)"),
|
|
JPEG_SUBSAMPLING_2x1_1x1_1x1,
|
|
_("4:4:0 (chroma halved vertically)"),
|
|
JPEG_SUBSAMPLING_1x2_1x1_1x1,
|
|
_("4:2:0 (chroma quartered)"),
|
|
JPEG_SUBSAMPLING_2x2_1x1_1x1,
|
|
NULL);
|
|
widget = pika_procedure_dialog_get_int_combo (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"sub-sampling", PIKA_INT_STORE (store));
|
|
widget = pika_label_int_widget_get_widget (PIKA_LABEL_INT_WIDGET (widget));
|
|
|
|
if (! pika_drawable_is_rgb (drawable))
|
|
{
|
|
g_object_set (config, "sub-sampling", JPEG_SUBSAMPLING_1x1_1x1_1x1, NULL);
|
|
gtk_widget_set_sensitive (widget, FALSE);
|
|
}
|
|
|
|
/* DCT method */
|
|
store = pika_int_store_new (_("Fast Integer"), 1,
|
|
_("Integer"), 0,
|
|
_("Floating-Point"), 2,
|
|
NULL);
|
|
pika_procedure_dialog_get_int_combo (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"dct", PIKA_INT_STORE (store));
|
|
|
|
pika_procedure_dialog_get_label (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"advanced-title", _("Advanced Options"),
|
|
FALSE, FALSE);
|
|
widget = pika_procedure_dialog_get_widget (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"smoothing", PIKA_TYPE_SPIN_SCALE);
|
|
pika_help_set_help_data (widget, NULL, "file-jpeg-save-smoothing");
|
|
|
|
/* Add some logics for "Use original quality". */
|
|
if (pika_drawable_is_rgb (drawable))
|
|
{
|
|
g_signal_connect (config, "notify::sub-sampling",
|
|
G_CALLBACK (subsampling_changed),
|
|
widget);
|
|
subsampling_changed (config, NULL, widget);
|
|
g_signal_connect (config, "notify::use-original-quality",
|
|
G_CALLBACK (use_orig_qual_changed_rgb),
|
|
NULL);
|
|
}
|
|
|
|
pika_procedure_dialog_fill_box (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"advanced-options",
|
|
"smoothing",
|
|
"progressive",
|
|
"cmyk-frame",
|
|
#ifdef C_ARITH_CODING_SUPPORTED
|
|
"arithmetic-frame",
|
|
#else
|
|
"optimize",
|
|
#endif
|
|
"restart-frame",
|
|
"sub-sampling",
|
|
"dct",
|
|
NULL);
|
|
pika_procedure_dialog_fill_frame (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"advanced-frame", "advanced-title", FALSE,
|
|
"advanced-options");
|
|
|
|
pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog),
|
|
"quality", "use-original-quality",
|
|
"preview-size", "show-preview",
|
|
"advanced-frame",
|
|
NULL);
|
|
|
|
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
|
|
|
|
/* Run make_preview() when various config are changed. */
|
|
g_signal_connect (config, "notify",
|
|
G_CALLBACK (make_preview),
|
|
NULL);
|
|
|
|
make_preview (config);
|
|
|
|
run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog));
|
|
gtk_widget_destroy (dialog);
|
|
|
|
destroy_preview ();
|
|
|
|
return run;
|
|
}
|
|
|
|
static void
|
|
quality_changed (PikaProcedureConfig *config)
|
|
{
|
|
gboolean use_orig_quality;
|
|
gdouble quality;
|
|
gint orig_quality;
|
|
|
|
g_object_get (config,
|
|
"use-original-quality", &use_orig_quality,
|
|
"original-quality", &orig_quality,
|
|
"quality", &quality,
|
|
NULL);
|
|
|
|
if (use_orig_quality && (gint) (quality * 100.0) != orig_quality)
|
|
g_object_set (config, "use-original-quality", FALSE, NULL);
|
|
}
|
|
|
|
static void
|
|
subsampling_changed (PikaProcedureConfig *config,
|
|
const GParamSpec *pspec,
|
|
GtkWidget *smoothing_scale)
|
|
{
|
|
gboolean use_orig_quality;
|
|
gint orig_subsmp;
|
|
gint subsmp;
|
|
|
|
g_object_get (config,
|
|
"use-original-quality", &use_orig_quality,
|
|
"original-sub-sampling", &orig_subsmp,
|
|
"sub-sampling", &subsmp,
|
|
NULL);
|
|
|
|
/* smoothing is not supported with nonstandard sampling ratios */
|
|
gtk_widget_set_sensitive (smoothing_scale,
|
|
subsmp != JPEG_SUBSAMPLING_2x1_1x1_1x1 &&
|
|
subsmp != JPEG_SUBSAMPLING_1x2_1x1_1x1);
|
|
|
|
if (use_orig_quality && orig_subsmp != subsmp)
|
|
g_object_set (config, "use-original-quality", FALSE, NULL);
|
|
}
|
|
|
|
static void
|
|
use_orig_qual_changed (PikaProcedureConfig *config)
|
|
{
|
|
gboolean use_orig_quality;
|
|
gint orig_quality;
|
|
|
|
g_object_get (config,
|
|
"use-original-quality", &use_orig_quality,
|
|
"original-quality", &orig_quality,
|
|
NULL);
|
|
|
|
if (use_orig_quality && orig_quality > 0)
|
|
{
|
|
g_signal_handlers_block_by_func (config, quality_changed, NULL);
|
|
g_object_set (config, "quality", orig_quality / 100.0, NULL);
|
|
g_signal_handlers_unblock_by_func (config, quality_changed, NULL);
|
|
}
|
|
}
|
|
|
|
static void
|
|
use_orig_qual_changed_rgb (PikaProcedureConfig *config)
|
|
{
|
|
gboolean use_orig_quality;
|
|
gint orig_quality;
|
|
gint orig_subsmp;
|
|
|
|
g_object_get (config,
|
|
"use-original-quality", &use_orig_quality,
|
|
"original-sub-sampling", &orig_subsmp,
|
|
"original-quality", &orig_quality,
|
|
NULL);
|
|
|
|
/* the test is (orig_quality > 0), not (orig_subsmp > 0) - this is normal */
|
|
if (use_orig_quality && orig_quality > 0)
|
|
g_object_set (config, "sub-sampling", orig_subsmp, NULL);
|
|
}
|
