jpeg-load.c 58.9 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* The GIMP -- an image manipulation program
 * 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 2 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, write to the Free Software
16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Elliot Lee's avatar
Elliot Lee committed
17
18
19
20
21
22
23
24
25
26
 */

/* JPEG loading and saving file filter for the GIMP
 *  -Peter Mattis
 *
 * This filter is heavily based upon the "example.c" file in libjpeg.
 * In fact most of the loading and saving code was simply cut-and-pasted
 *  from that file. The filter, therefore, also uses libjpeg.
 */

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/* 11-JAN-99 - Added support for JPEG comments and Progressive saves.
 *  -pete whiting <pwhiting@sprint.net>
 *
 * Comments of size up to 32k can be stored in the header of jpeg
 * files.  (They are not compressed.)  The JPEG specs and libraries
 * support the storing of multiple comments.  The behavior of this
 * code is to merge all comments in a loading image into a single
 * comment (putting \n between each) and attach that string as a
 * parasite - gimp-comment - to the image.  When saving, the image is
 * checked to see if it has the gimp-comment parasite - if so, that is
 * used as the default comment in the save dialog.  Further, the other
 * jpeg parameters (quaility, smoothing, compression and progressive)
 * are attached to the image as a parasite.  This allows the
 * parameters to remain consistent between saves.  I was not able to
 * figure out how to determine the quaility, smoothing or compression
 * values of an image as it is being loaded, but the code is there to
 * support it if anyone knows how.  Progressive mode is a method of
 * saving the image such that as a browser (or other app supporting
 * progressive loads - gimp doesn't) loads the image it first gets a
 * low res version displayed and then the image is progressively
 * enhanced until you get the final version.  It doesn't add any size
48
49
50
 * to the image (actually it often results in smaller file size) - the
 * only draw backs are that progressive jpegs are not supported by some
 * older viewers/browsers, and some might find it annoying.
51
52
 */

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/* 
 * 21-AUG-99 - Added support for JPEG previews, subsampling,
 *             non-baseline JPEGs, restart markers and DCT method choice
 * - Steinar H. Gunderson <sgunderson@bigfoot.com>
 *
 * A small preview appears and changes according to the changes to the
 * compression options. The image itself works as a much bigger preview.
 * For slower machines, the save operation (not the load operation) is
 * done in the background, with a standard GTK+ idle loop, which turned
 * out to be the most portable way. Win32 porters shouldn't have much
 * difficulty porting my changes (at least I hope so...).
 *
 * Subsampling is a pretty obscure feature, but I thought it might be nice
 * to have it in anyway, for people to play with :-) Does anybody have
 * any better suggestions than the ones I've put in the menu? (See wizard.doc
 * from the libjpeg distribution for a tiny bit of information on subsampling.)
 *
 * A baseline JPEG is often larger and/or of worse quality than a non-baseline
 * one (especially at low quality settings), but all decoders are guaranteed
 * to read baseline JPEGs (I think). Not all will read a non-baseline one.
 *
 * Restart markers are useful if you are transmitting the image over an
 * unreliable network. If a file gets corrupted, it will only be corrupted
 * up to the next restart marker. Of course, if there are no restart markers,
 * the rest of the image will be corrupted. Restart markers take up extra
 * space. The libjpeg developers recommend a restart every 1 row for
 * transmitting images over unreliable networks, such as Usenet.
 *
 * The DCT method is said by the libjpeg docs to _only_ influence quality vs.
 * speed, and nothing else. However, I've found that there _are_ size
 * differences. Fast integer, on the other hand, is faster than integer,
 * which in turn is faster than FP. According to the libjpeg docs (and I
 * believe it's true), FP has only a theoretical advantage in quality, and
 * will be slower than the two other methods, unless you're blessed with
 * very a fast FPU. (In addition, images might not be identical on
 * different types of FP hardware.)
 *
 * ...and thus ends my additions to the JPEG plug-in. I hope. *sigh* :-)
 */

93
94
95
96
97
98
99
100
101
102
103
104
105
/* 
 * 21-AUG-99 - Bunch O' Fixes.
 * - Adam D. Moss <adam@gimp.org>
 *
 * We now correctly create an alpha-padded layer for our preview --
 * having a non-background non-alpha layer is a no-no in GIMP.
 *
 * I've also tweaked the GIMP undo API a little and changed the JPEG
 * plugin to use gimp_image_{freeze,thaw}_undo so that it doesn't store
 * up a whole load of superfluous tile data every time the preview is
 * changed.
 */

106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/*
 * 22-DEC-99 - volatiles added
 * - Austin Donnelly <austin@gimp.org>
 *
 * When gcc complains a variable may be clobbered by a longjmp or
 * vfork, it means the following: setjmp() was called by the JPEG
 * library for error recovery purposes, but gcc is keeping some
 * variables in registers without updating the memory locations on the
 * stack consistently.  If JPEG error recovery is every invoked, the
 * values of these variable will be inconsistent.  This is almost
 * always a bug, but not one that's commonly seen unless JPEG recovery
 * code is exercised frequently.  The correct solution is to tell gcc
 * to keep the stack version of the affected variables up to date, by
 * using the "volatile" keyword.   Here endeth the lesson.
 */


Tor Lillqvist's avatar
Tor Lillqvist committed
123
124
125
126
127
#include "config.h"		/* configure cares about HAVE_PROGRESSIVE_JPEG */

#include <glib.h>		/* We want glib.h first because of some
				 * pretty obscure Win32 compilation issues.
				 */
Elliot Lee's avatar
Elliot Lee committed
128
129
130
131
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
132
#include <sys/types.h>
133
#include <sys/stat.h>
Tor Lillqvist's avatar
Tor Lillqvist committed
134
#ifdef HAVE_UNISTD_H
135
#include <unistd.h>
Tor Lillqvist's avatar
Tor Lillqvist committed
136
#endif
Elliot Lee's avatar
Elliot Lee committed
137
#include <jpeglib.h>
138
#include <jerror.h>
139

Michael Natterer's avatar
Michael Natterer committed
140
141
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
142

143
144
#include "libgimp/stdplugins-intl.h"

145
#include <signal.h>
Elliot Lee's avatar
Elliot Lee committed
146

Sven Neumann's avatar
Sven Neumann committed
147
#define SCALE_WIDTH         125
Elliot Lee's avatar
Elliot Lee committed
148

149
150
/* if you are not compiling this from inside the gimp tree, you have to  */
/* take care yourself if your JPEG library supports progressive mode     */
151
/* #undef HAVE_PROGRESSIVE_JPEG   if your library doesn't support it     */
152
153
/* #define HAVE_PROGRESSIVE_JPEG  if your library knows how to handle it */

Sven Neumann's avatar
Sven Neumann committed
154
155
156
#define DEFAULT_QUALITY     0.75
#define DEFAULT_SMOOTHING   0.0
#define DEFAULT_OPTIMIZE    1
157
#define DEFAULT_PROGRESSIVE 0
Sven Neumann's avatar
Sven Neumann committed
158
159
160
161
162
#define DEFAULT_BASELINE    1
#define DEFAULT_SUBSMP      0
#define DEFAULT_RESTART     0
#define DEFAULT_DCT         0
#define DEFAULT_PREVIEW     1
163

Sven Neumann's avatar
Sven Neumann committed
164
#define DEFAULT_COMMENT     "Created with The GIMP"
165

166
/* sg - these should not be global... */
167
168
169
static gint32 volatile  image_ID_global = -1, orig_image_ID_global, drawable_ID_global = -1, layer_ID_global = -1;
static GtkWidget       *preview_size = NULL;
static GDrawable       *drawable_global = NULL;
170

Elliot Lee's avatar
Elliot Lee committed
171
172
173
174
typedef struct
{
  gdouble quality;
  gdouble smoothing;
175
176
177
178
179
180
181
  gint    optimize;
  gint    progressive;
  gint    baseline;
  gint    subsmp;
  gint    restart;
  gint    dct;
  gint    preview;
Elliot Lee's avatar
Elliot Lee committed
182
183
184
185
186
187
188
} JpegSaveVals;

typedef struct
{
  gint  run;
} JpegSaveInterface;

189
190
191
typedef struct 
{
  struct jpeg_compress_struct cinfo;
192
193
194
195
196
197
198
  gint       tile_height;
  FILE      *outfile;
  gint       has_alpha;
  gint       rowstride;
  guchar    *temp;
  guchar    *data;
  guchar    *src;
199
  GDrawable *drawable;
200
201
202
  GPixelRgn  pixel_rgn;
  gchar     *file_name;
  gint       abort_me;
203
} preview_persistent;
Sven Neumann's avatar
Sven Neumann committed
204

205
206
gint *abort_me = NULL;

Elliot Lee's avatar
Elliot Lee committed
207
208
/* Declare local functions.
 */
Sven Neumann's avatar
Sven Neumann committed
209
static void   query                     (void);
Michael Natterer's avatar
Michael Natterer committed
210
211
212
213
214
215
216
217
218
219
220
221
222
static void   run                       (gchar         *name,
					 gint           nparams,
					 GParam        *param,
					 gint          *nreturn_vals,
					 GParam       **return_vals);
static gint32 load_image                (gchar         *filename, 
					 GRunModeType   runmode, 
					 gint           preview);
static gint   save_image                (gchar         *filename,
					 gint32         image_ID,
					 gint32         drawable_ID,
					 gint32         orig_image_ID,
					 gint           preview);
Sven Neumann's avatar
Sven Neumann committed
223
224
225
226

static void   add_menu_item             (GtkWidget *menu,
					 char *label,
					 guint op_no,
227
					 GtkSignalFunc callback);
Sven Neumann's avatar
Sven Neumann committed
228
229
230
231
232
233
234
235
236
237

static void   init_gtk                   (void);
static gint   save_dialog                (void);

static void   save_close_callback        (GtkWidget *widget,
					  gpointer   data);
static void   save_ok_callback           (GtkWidget *widget,
					  gpointer   data);
static void   save_scale_update          (GtkAdjustment *adjustment,
					  double        *scale_val);
238
239
static void   save_restart_toggle_update (GtkWidget     *toggle,
					  GtkAdjustment *adjustment);
Sven Neumann's avatar
Sven Neumann committed
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
static void   save_restart_update        (GtkAdjustment *adjustment,
					  GtkWidget     *toggle);
static void   save_optimize_update       (GtkWidget *widget,
					  gpointer   data);
static void   save_progressive_toggle    (GtkWidget *widget,
					  gpointer   data);
static void   save_baseline_toggle       (GtkWidget *widget,
					  gpointer   data);
static void   save_preview_toggle        (GtkWidget *widget,
					  gpointer  data);


static void   make_preview               (void);
static void   destroy_preview            (void);

static void   subsmp_callback            (GtkWidget *widget, 
					  gpointer data);
static void   dct_callback               (GtkWidget *widget, 
					  gpointer data);
Elliot Lee's avatar
Elliot Lee committed
259
260
261

GPlugInInfo PLUG_IN_INFO =
{
262
263
264
265
  NULL,  /* init_proc  */
  NULL,  /* quit_proc  */
  query, /* query_proc */
  run,   /* run_proc   */
Elliot Lee's avatar
Elliot Lee committed
266
267
268
269
};

static JpegSaveVals jsvals =
{
270
271
272
  DEFAULT_QUALITY,
  DEFAULT_SMOOTHING,
  DEFAULT_OPTIMIZE,
273
274
275
276
277
278
  DEFAULT_PROGRESSIVE,
  DEFAULT_BASELINE,
  DEFAULT_SUBSMP,
  DEFAULT_RESTART,
  DEFAULT_DCT,
  DEFAULT_PREVIEW
Elliot Lee's avatar
Elliot Lee committed
279
280
281
282
283
284
285
};

static JpegSaveInterface jsint =
{
  FALSE   /*  run  */
};

286
char *image_comment=NULL;
Elliot Lee's avatar
Elliot Lee committed
287

288
289
290
static GtkWidget *restart_markers_scale = NULL;
static GtkWidget *restart_markers_label = NULL;

Elliot Lee's avatar
Elliot Lee committed
291
292
293
MAIN ()

static void
294
query (void)
Elliot Lee's avatar
Elliot Lee committed
295
296
297
{
  static GParamDef load_args[] =
  {
Sven Neumann's avatar
Sven Neumann committed
298
299
300
    { PARAM_INT32,    "run_mode",     "Interactive, non-interactive" },
    { PARAM_STRING,   "filename",     "The name of the file to load" },
    { PARAM_STRING,   "raw_filename", "The name of the file to load" },
Elliot Lee's avatar
Elliot Lee committed
301
302
303
  };
  static GParamDef load_return_vals[] =
  {
Sven Neumann's avatar
Sven Neumann committed
304
    { PARAM_IMAGE,   "image",         "Output image" },
Elliot Lee's avatar
Elliot Lee committed
305
  };
306
307
308
  static gint nload_args        = sizeof (load_args) / sizeof (load_args[0]);
  static gint nload_return_vals = (sizeof (load_return_vals) /
				   sizeof (load_return_vals[0]));
Elliot Lee's avatar
Elliot Lee committed
309
310
311

  static GParamDef save_args[] =
  {
Sven Neumann's avatar
Sven Neumann committed
312
313
314
315
316
317
318
319
320
321
322
323
324
325
    { PARAM_INT32,    "run_mode",     "Interactive, non-interactive" },
    { PARAM_IMAGE,    "image",        "Input image" },
    { PARAM_DRAWABLE, "drawable",     "Drawable to save" },
    { PARAM_STRING,   "filename",     "The name of the file to save the image in" },
    { PARAM_STRING,   "raw_filename", "The name of the file to save the image in" },
    { PARAM_FLOAT,    "quality",      "Quality of saved image (0 <= quality <= 1)" },
    { PARAM_FLOAT,    "smoothing",    "Smoothing factor for saved image (0 <= smoothing <= 1)" },
    { PARAM_INT32,    "optimize",     "Optimization of entropy encoding parameters (0/1)" },
    { PARAM_INT32,    "progressive",  "Enable progressive jpeg image loading - ignored if not compiled with HAVE_PROGRESSIVE_JPEG (0/1)" },
    { PARAM_STRING,   "comment",      "Image comment" },
    { PARAM_INT32,    "subsmp",       "The subsampling option number" },
    { PARAM_INT32,    "baseline",     "Force creation of a baseline JPEG (non-baseline JPEGs can't be read by all decoders) (0/1)" },
    { PARAM_INT32,    "restart",      "Frequency of restart markers (in rows, 0 = no restart markers)" },
    { PARAM_INT32,    "dct",          "DCT algorithm to use (speed/quality tradeoff)" }
Elliot Lee's avatar
Elliot Lee committed
326
  };
327
  static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]);
Elliot Lee's avatar
Elliot Lee committed
328

329
330
  INIT_I18N();

Elliot Lee's avatar
Elliot Lee committed
331
  gimp_install_procedure ("file_jpeg_load",
Marc Lehmann's avatar
Marc Lehmann committed
332
333
                          "loads files in the JPEG file format",
                          "loads files in the JPEG file format",
334
                          "Spencer Kimball, Peter Mattis & others",
Elliot Lee's avatar
Elliot Lee committed
335
                          "Spencer Kimball & Peter Mattis",
336
                          "1995-1999",
Elliot Lee's avatar
Elliot Lee committed
337
338
339
340
341
342
343
			  "<Load>/Jpeg",
			  NULL,
                          PROC_PLUG_IN,
                          nload_args, nload_return_vals,
                          load_args, load_return_vals);

  gimp_install_procedure ("file_jpeg_save",
Marc Lehmann's avatar
Marc Lehmann committed
344
345
                          "saves files in the JPEG file format",
                          "saves files in the lossy, widely supported JPEG format",
346
                          "Spencer Kimball, Peter Mattis & others",
Elliot Lee's avatar
Elliot Lee committed
347
                          "Spencer Kimball & Peter Mattis",
348
                          "1995-1999",
Elliot Lee's avatar
Elliot Lee committed
349
350
351
352
353
354
                          "<Save>/Jpeg",
			  "RGB*, GRAY*",
                          PROC_PLUG_IN,
                          nsave_args, 0,
                          save_args, NULL);

355
356
357
358
359
360
361
  gimp_register_magic_load_handler ("file_jpeg_load",
				    "jpg,jpeg",
				    "",
				    "6,string,JFIF");
  gimp_register_save_handler       ("file_jpeg_save",
				    "jpg,jpeg",
				    "");
Elliot Lee's avatar
Elliot Lee committed
362
363
364
}

static void
365
366
run (gchar   *name,
     gint     nparams,
Elliot Lee's avatar
Elliot Lee committed
367
     GParam  *param,
368
     gint    *nreturn_vals,
Elliot Lee's avatar
Elliot Lee committed
369
370
371
     GParam **return_vals)
{
  static GParam values[2];
372
373
374
375
376
377
  GRunModeType  run_mode;
  GStatusType   status = STATUS_SUCCESS;
  gint32        image_ID;
  gint32        drawable_ID;
  gint32        orig_image_ID;
  gint32        display_ID = -1;
378
#ifdef GIMP_HAVE_PARASITES
379
  Parasite     *parasite;
380
#endif /* GIMP_HAVE_PARASITES */
381
  gint          err;
Sven Neumann's avatar
Sven Neumann committed
382
  GimpExportReturnType export = EXPORT_CANCEL;
Elliot Lee's avatar
Elliot Lee committed
383
384
385
386

  run_mode = param[0].data.d_int32;

  *nreturn_vals = 1;
387
388
389
  *return_vals  = values;
  values[0].type          = PARAM_STATUS;
  values[0].data.d_status = STATUS_EXECUTION_ERROR;
390

Elliot Lee's avatar
Elliot Lee committed
391
392
  if (strcmp (name, "file_jpeg_load") == 0)
    {
393
394
      INIT_I18N();

395
      image_ID = load_image (param[1].data.d_string, run_mode, FALSE);
Elliot Lee's avatar
Elliot Lee committed
396
397
398
399

      if (image_ID != -1)
	{
	  *nreturn_vals = 2;
400
	  values[1].type         = PARAM_IMAGE;
Elliot Lee's avatar
Elliot Lee committed
401
402
403
404
	  values[1].data.d_image = image_ID;
	}
      else
	{
405
	  status = STATUS_EXECUTION_ERROR;
Elliot Lee's avatar
Elliot Lee committed
406
407
408
409
	}
    }
  else if (strcmp (name, "file_jpeg_save") == 0)
    {
Manish Singh's avatar
Manish Singh committed
410
      INIT_I18N_UI();
411

Sven Neumann's avatar
Sven Neumann committed
412
413
414
415
416
417
418
419
420
421
      image_ID = orig_image_ID = param[1].data.d_int32;
      drawable_ID = param[2].data.d_int32;

       /*  eventually export the image */ 
      switch (run_mode)
	{
	case RUN_INTERACTIVE:
	case RUN_WITH_LAST_VALS:
	  init_gtk ();
	  export = gimp_export_image (&image_ID, &drawable_ID, "JPEG", 
422
423
				      (CAN_HANDLE_RGB |
				       CAN_HANDLE_GRAY));
Sven Neumann's avatar
Sven Neumann committed
424
	  switch (export)
Sven Neumann's avatar
Sven Neumann committed
425
	    {
Sven Neumann's avatar
Sven Neumann committed
426
	    case EXPORT_EXPORT: 
Sven Neumann's avatar
Sven Neumann committed
427
	      display_ID = gimp_display_new (image_ID);
428
	      gimp_image_set_filename (image_ID, _("Export Preview"));
Sven Neumann's avatar
Sven Neumann committed
429
	      gimp_displays_flush ();
Sven Neumann's avatar
Sven Neumann committed
430
431
432
433
	      break;
	    case EXPORT_IGNORE:
	      break;
	    case EXPORT_CANCEL:
434
	      values[0].data.d_status = STATUS_CANCEL;
Sven Neumann's avatar
Sven Neumann committed
435
436
	      return;
	      break;
Sven Neumann's avatar
Sven Neumann committed
437
438
439
440
441
	    }
	  break;
	default:
	  break;
	}
442

Sven Neumann's avatar
Sven Neumann committed
443
444
445
446
447
      if (image_comment) 
	{
	  g_free (image_comment);
	  image_comment = NULL;
	}
448
#ifdef GIMP_HAVE_PARASITES
Marc Lehmann's avatar
Marc Lehmann committed
449
      parasite = gimp_image_parasite_find (orig_image_ID, "gimp-comment");
Sven Neumann's avatar
Sven Neumann committed
450
451
452
453
454
      if (parasite) 
	{
	  image_comment = g_strdup (parasite->data);
	  parasite_free (parasite);
	}
455
#endif /* GIMP_HAVE_PARASITES */
Sven Neumann's avatar
Sven Neumann committed
456
457
458
      if (!image_comment) 
	image_comment = g_strdup (DEFAULT_COMMENT);

459
460
461
      jsvals.quality     = DEFAULT_QUALITY;
      jsvals.smoothing   = DEFAULT_SMOOTHING;
      jsvals.optimize    = DEFAULT_OPTIMIZE;
462
      jsvals.progressive = DEFAULT_PROGRESSIVE;
463
464
465
466
467
468
      jsvals.baseline    = DEFAULT_BASELINE;
      jsvals.subsmp      = DEFAULT_SUBSMP;
      jsvals.restart     = DEFAULT_RESTART;
      jsvals.dct         = DEFAULT_DCT;
      jsvals.preview     = DEFAULT_PREVIEW;

Elliot Lee's avatar
Elliot Lee committed
469
470
471
472
473
474
      switch (run_mode)
	{
	case RUN_INTERACTIVE:
	  /*  Possibly retrieve data  */
	  gimp_get_data ("file_jpeg_save", &jsvals);

475
476
#ifdef GIMP_HAVE_PARASITES
	  /* load up the previously used values */
477
478
	  parasite = gimp_image_parasite_find (orig_image_ID,
					       "jpeg-save-options");
479
	  if (parasite)
Sven Neumann's avatar
Sven Neumann committed
480
481
482
483
484
485
486
487
488
489
490
491
	    {
	      jsvals.quality     = ((JpegSaveVals *)parasite->data)->quality;
	      jsvals.smoothing   = ((JpegSaveVals *)parasite->data)->smoothing;
	      jsvals.optimize    = ((JpegSaveVals *)parasite->data)->optimize;
	      jsvals.progressive = ((JpegSaveVals *)parasite->data)->progressive;
	      jsvals.baseline    = ((JpegSaveVals *)parasite->data)->baseline;
	      jsvals.subsmp      = ((JpegSaveVals *)parasite->data)->subsmp;
	      jsvals.restart     = ((JpegSaveVals *)parasite->data)->restart;
	      jsvals.dct         = ((JpegSaveVals *)parasite->data)->dct;
	      jsvals.preview     = ((JpegSaveVals *)parasite->data)->preview;
	      parasite_free(parasite);
	    }
492
#endif /* GIMP_HAVE_PARASITES */
493

494
495
496
497
498
499
	  /* we start an undo_group and immediately freeze undo saving
	     so that we can avoid sucking up tile cache with our unneeded
	     preview steps. */
      	  gimp_undo_push_group_start (image_ID);
      	  gimp_image_undo_freeze (image_ID);

500
501
	  /* prepare for the preview */
	  image_ID_global = image_ID;
Sven Neumann's avatar
Sven Neumann committed
502
503
	  orig_image_ID_global = orig_image_ID;
	  drawable_ID_global = drawable_ID;
504
 
Elliot Lee's avatar
Elliot Lee committed
505
	  /*  First acquire information with a dialog  */
506
	  err = save_dialog ();
Sven Neumann's avatar
Sven Neumann committed
507
 
508
509
510
	  /* thaw undo saving and end the undo_group. */
	  gimp_image_undo_thaw (image_ID);
	  gimp_undo_push_group_end (image_ID); 
511
512

          if (!err)
513
	    status = STATUS_CANCEL;
Elliot Lee's avatar
Elliot Lee committed
514
515
516
517
	  break;

	case RUN_NONINTERACTIVE:
	  /*  Make sure all the arguments are there!  */
518
	  /*  pw - added two more progressive and comment */
519
	  /*  sg - added subsampling, preview, baseline, restarts and DCT */
Sven Neumann's avatar
Sven Neumann committed
520
	  if (nparams != 14)
521
522
523
524
	    {
	      status = STATUS_CALLING_ERROR;
	    }
	  else
Elliot Lee's avatar
Elliot Lee committed
525
	    {
Sven Neumann's avatar
Sven Neumann committed
526
527
528
	      jsvals.quality     = param[5].data.d_float;
	      jsvals.smoothing   = param[6].data.d_float;
	      jsvals.optimize    = param[7].data.d_int32;
529
530
531
#ifdef HAVE_PROGRESSIVE_JPEG
	      jsvals.progressive = param[8].data.d_int32;
#endif /* HAVE_PROGRESSIVE_JPEG */
Sven Neumann's avatar
Sven Neumann committed
532
533
534
535
536
	      jsvals.baseline    = param[11].data.d_int32;
	      jsvals.subsmp      = param[10].data.d_int32;
	      jsvals.restart     = param[12].data.d_int32;
	      jsvals.dct         = param[13].data.d_int32;
	      jsvals.preview     = FALSE;
537

538
	      /* free up the default -- wasted some effort earlier */
Sven Neumann's avatar
Sven Neumann committed
539
540
541
	      if (image_comment) 
		g_free (image_comment);
	      image_comment = g_strdup (param[9].data.d_string);
542
543
544
545
546
547
548
549
550

	      if (jsvals.quality < 0.0 || jsvals.quality > 1.0)
		status = STATUS_CALLING_ERROR;
	      else if (jsvals.smoothing < 0.0 || jsvals.smoothing > 1.0)
		status = STATUS_CALLING_ERROR;
	      else if (jsvals.subsmp < 0 || jsvals.subsmp > 2)
		status = STATUS_CALLING_ERROR;
	      else if (jsvals.dct < 0 || jsvals.dct > 2)
		status = STATUS_CALLING_ERROR;
Elliot Lee's avatar
Elliot Lee committed
551
	    }
Manish Singh's avatar
Manish Singh committed
552
	  break;
Elliot Lee's avatar
Elliot Lee committed
553
554
555
556

	case RUN_WITH_LAST_VALS:
	  /*  Possibly retrieve data  */
	  gimp_get_data ("file_jpeg_save", &jsvals);
557
#ifdef GIMP_HAVE_PARASITES
558
559
	  parasite = gimp_image_parasite_find (orig_image_ID,
					       "jpeg-save-options");
560
	  if (parasite)
Sven Neumann's avatar
Sven Neumann committed
561
562
563
564
565
566
567
568
569
570
571
572
	    {
	      jsvals.quality     = ((JpegSaveVals *)parasite->data)->quality;
	      jsvals.smoothing   = ((JpegSaveVals *)parasite->data)->smoothing;
	      jsvals.optimize    = ((JpegSaveVals *)parasite->data)->optimize;
	      jsvals.progressive = ((JpegSaveVals *)parasite->data)->progressive;
	      jsvals.baseline    = ((JpegSaveVals *)parasite->data)->baseline;
	      jsvals.subsmp      = ((JpegSaveVals *)parasite->data)->subsmp;
	      jsvals.restart     = ((JpegSaveVals *)parasite->data)->restart;
	      jsvals.dct         = ((JpegSaveVals *)parasite->data)->dct;
	      jsvals.preview     = FALSE;
	      parasite_free(parasite);
	    }
573
#endif /* GIMP_HAVE_PARASITES */
Elliot Lee's avatar
Elliot Lee committed
574
575
576
577
578
579
	  break;

	default:
	  break;
	}

580
      if (status == STATUS_SUCCESS)
Elliot Lee's avatar
Elliot Lee committed
581
	{
582
583
584
585
586
587
588
589
590
591
592
593
594
	  if (save_image (param[3].data.d_string,
			  image_ID,
			  drawable_ID,
			  orig_image_ID,
			  FALSE))
	    {
	      /*  Store mvals data  */
	      gimp_set_data ("file_jpeg_save", &jsvals, sizeof (JpegSaveVals));
	    }
	  else
	    {
	      status = STATUS_EXECUTION_ERROR;
	    }
Elliot Lee's avatar
Elliot Lee committed
595
	}
596

Sven Neumann's avatar
Sven Neumann committed
597
      if (export == EXPORT_EXPORT)
Sven Neumann's avatar
Sven Neumann committed
598
	{
Sven Neumann's avatar
Sven Neumann committed
599
600
	  /* If the image was exported, delete the new display. */
	  /* This also deletes the image.                       */
601

Sven Neumann's avatar
Sven Neumann committed
602
603
604
605
606
607
	  if (display_ID > -1)
	    gimp_display_delete (display_ID);
	  else
	    gimp_image_delete (image_ID);
	}

608
609
610
611
612
#ifdef GIMP_HAVE_PARASITES
      /* pw - now we need to change the defaults to be whatever
       * was used to save this image.  Dump the old parasites
       * and add new ones. */
      
Marc Lehmann's avatar
Marc Lehmann committed
613
      gimp_image_parasite_detach (orig_image_ID, "gimp-comment");
Sven Neumann's avatar
Sven Neumann committed
614
615
616
617
618
619
      if (strlen (image_comment)) 
	{
	  parasite = parasite_new ("gimp-comment",
				   PARASITE_PERSISTENT,
				   strlen (image_comment) + 1,
				   image_comment);
Marc Lehmann's avatar
Marc Lehmann committed
620
	  gimp_image_parasite_attach (orig_image_ID, parasite);
Sven Neumann's avatar
Sven Neumann committed
621
	  parasite_free (parasite);
Sven Neumann's avatar
Sven Neumann committed
622
	}
Marc Lehmann's avatar
Marc Lehmann committed
623
      gimp_image_parasite_detach (orig_image_ID, "jpeg-save-options");
624
      
Sven Neumann's avatar
Sven Neumann committed
625
      parasite = parasite_new ("jpeg-save-options", 0, sizeof (jsvals), &jsvals);
Marc Lehmann's avatar
Marc Lehmann committed
626
      gimp_image_parasite_attach (orig_image_ID, parasite);
Sven Neumann's avatar
Sven Neumann committed
627
628
      parasite_free (parasite);
#endif /* Have Parasites */  
Elliot Lee's avatar
Elliot Lee committed
629
    }
630
631
632
633
  else
    {
      status = STATUS_CALLING_ERROR;
    }
Elliot Lee's avatar
Elliot Lee committed
634

635
636
  values[0].data.d_status = status;
}
Elliot Lee's avatar
Elliot Lee committed
637

638
/* Read next byte */
639
static guint
640
641
642
643
jpeg_getc (j_decompress_ptr cinfo)
{
  struct jpeg_source_mgr * datasrc = cinfo->src;

Sven Neumann's avatar
Sven Neumann committed
644
645
646
647
648
  if (datasrc->bytes_in_buffer == 0) 
    {
      if (! (*datasrc->fill_input_buffer) (cinfo))
	ERREXIT (cinfo, JERR_CANT_SUSPEND);
    }
649
650
651
652
653
654
655
656
657
658
659
660
661
  datasrc->bytes_in_buffer--;
  return *datasrc->next_input_byte++;
}

/* We need our own marker parser, since early versions of libjpeg
 * don't keep a conventient list of the marker's that have been
 * seen. */

/*
 * Marker processor for COM markers.
 * This replaces the library's built-in processor, which just skips the marker.
 * Note this code relies on a non-suspending data source.
 */
Sven Neumann's avatar
Sven Neumann committed
662
static GString *local_image_comments = NULL;
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681

static boolean
COM_handler (j_decompress_ptr cinfo)
{
  int length;
  unsigned int ch;

  length = jpeg_getc (cinfo) << 8;
  length += jpeg_getc (cinfo);
  if (length < 2)
    return FALSE;
  length -= 2;			/* discount the length word itself */

  if (!local_image_comments)
    local_image_comments = g_string_new (NULL);
  else
    g_string_append_c (local_image_comments, '\n');

  while (length-- > 0)
Sven Neumann's avatar
Sven Neumann committed
682
683
684
685
    {
      ch = jpeg_getc (cinfo);
      g_string_append_c (local_image_comments, ch);
    }
686
687
688
689

  return TRUE;
}

Elliot Lee's avatar
Elliot Lee committed
690
typedef struct my_error_mgr {
691
  struct jpeg_error_mgr pub;    /* "public" fields */
Elliot Lee's avatar
Elliot Lee committed
692

693
  jmp_buf setjmp_buffer;        /* for return to caller */
Elliot Lee's avatar
Elliot Lee committed
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
} *my_error_ptr;

/*
 * Here's the routine that will replace the standard error_exit method:
 */

static void
my_error_exit (j_common_ptr cinfo)
{
  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
  my_error_ptr myerr = (my_error_ptr) cinfo->err;

  /* Always display the message. */
  /* We could postpone this until after returning, if we chose. */
  (*cinfo->err->output_message) (cinfo);

  /* Return control to the setjmp point */
  longjmp (myerr->setjmp_buffer, 1);
}

static gint32
Sven Neumann's avatar
Sven Neumann committed
715
716
717
load_image (char         *filename, 
	    GRunModeType  runmode, 
	    int           preview)
Elliot Lee's avatar
Elliot Lee committed
718
719
720
{
  GPixelRgn pixel_rgn;
  GDrawable *drawable;
721
  gint32 volatile image_ID;
Elliot Lee's avatar
Elliot Lee committed
722
723
724
725
726
  gint32 layer_ID;
  struct jpeg_decompress_struct cinfo;
  struct my_error_mgr jerr;
  FILE *infile;
  guchar *buf;
727
  guchar * volatile padded_buf = NULL;
Elliot Lee's avatar
Elliot Lee committed
728
729
730
731
732
733
734
735
  guchar **rowbuf;
  char *name;
  int image_type;
  int layer_type;
  int tile_height;
  int scanlines;
  int i, start, end;

736
737
#ifdef GIMP_HAVE_PARASITES
  JpegSaveVals local_save_vals;
738
739
  Parasite * volatile comment_parasite = NULL;
  Parasite * volatile vals_parasite = NULL;
740
#endif /* GIMP_HAVE_PARASITES */
741
742

  
Elliot Lee's avatar
Elliot Lee committed
743
744
745
746
747
748
  /* We set up the normal JPEG error routines. */
  cinfo.err = jpeg_std_error (&jerr.pub);
  jerr.pub.error_exit = my_error_exit;

  if ((infile = fopen (filename, "rb")) == NULL)
    {
749
      g_warning (_("can't open \"%s\"\n"), filename);
Elliot Lee's avatar
Elliot Lee committed
750
751
752
      gimp_quit ();
    }

753
754
  if (runmode != RUN_NONINTERACTIVE)
    {
755
      name = g_strdup_printf (_("Loading %s:"), filename);
756
      gimp_progress_init (name);
757
      g_free (name);
758
    }
Elliot Lee's avatar
Elliot Lee committed
759
760
761
762
763
764
765
766
767
768
769

  image_ID = -1;
  /* 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_decompress (&cinfo);
      if (infile)
	fclose (infile);
770
      if (image_ID != -1 && !preview)
Elliot Lee's avatar
Elliot Lee committed
771
	gimp_image_delete (image_ID);
772
773
      if (preview)
	destroy_preview();
Elliot Lee's avatar
Elliot Lee committed
774
775
776
777
778
779
780
781
782
      gimp_quit ();
    }
  /* Now we can initialize the JPEG decompression object. */
  jpeg_create_decompress (&cinfo);

  /* Step 2: specify data source (eg, a file) */

  jpeg_stdio_src (&cinfo, infile);

783
  /* pw - step 2.1 let the lib know we want the comments. */
784
785

  jpeg_set_marker_processor (&cinfo, JPEG_COM, COM_handler);
786

Elliot Lee's avatar
Elliot Lee committed
787
788
789
790
791
792
793
794
795
  /* Step 3: read file parameters with jpeg_read_header() */

  (void) jpeg_read_header (&cinfo, TRUE);
  /* We can ignore the return value from jpeg_read_header since
   *   (a) suspension is not possible with the stdio data source, and
   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
   * See libjpeg.doc for more info.
   */

796
#ifdef GIMP_HAVE_PARASITES
797
798
  if (!preview) {
    /* if we had any comments then make a parasite for them */
Sven Neumann's avatar
Sven Neumann committed
799
800
801
802
    if (local_image_comments) 
      {
	char *string = local_image_comments->str;
	g_string_free (local_image_comments,FALSE);
803
	local_image_comments = NULL;
Sven Neumann's avatar
Sven Neumann committed
804
805
806
807
808
809
810
	comment_parasite = parasite_new ("gimp-comment", PARASITE_PERSISTENT,
					 strlen (string) + 1, string);
      } 
    else 
      {
	comment_parasite = NULL;
      }
811
  
812
813
814
815
816
    /* pw - figuring out what the saved values were is non-trivial.
     * They don't seem to be in the cinfo structure. For now, I will
     * just use the defaults, but if someone figures out how to derive
     * them this is the place to store them. */

Sven Neumann's avatar
Sven Neumann committed
817
818
819
    local_save_vals.quality     = DEFAULT_QUALITY;
    local_save_vals.smoothing   = DEFAULT_SMOOTHING;
    local_save_vals.optimize    = DEFAULT_OPTIMIZE;
820
821
  
#ifdef HAVE_PROGRESSIVE_JPEG 
Sven Neumann's avatar
Sven Neumann committed
822
    local_save_vals.progressive = cinfo.progressive_mode;
823
#else
Sven Neumann's avatar
Sven Neumann committed
824
    local_save_vals.progressive = 0;
825
#endif /* HAVE_PROGRESSIVE_JPEG */
Sven Neumann's avatar
Sven Neumann committed
826
827
828
829
830
    local_save_vals.baseline    = DEFAULT_BASELINE;
    local_save_vals.subsmp      = DEFAULT_SUBSMP;   /* sg - this _is_ there, but I'm too lazy */ 
    local_save_vals.restart     = DEFAULT_RESTART;
    local_save_vals.dct         = DEFAULT_DCT;
    local_save_vals.preview     = DEFAULT_PREVIEW;
831
  
Sven Neumann's avatar
Sven Neumann committed
832
833
    vals_parasite = parasite_new ("jpeg-save-options", 0,
				  sizeof (local_save_vals), &local_save_vals);
834
  } 
835
836
837
#endif /* GIMP_HAVE_PARASITES */
  
  
Elliot Lee's avatar
Elliot Lee committed
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  /* Step 5: Start decompressor */

  jpeg_start_decompress (&cinfo);

  /* We may need to do some setup of our own at this point before reading
   * the data.  After jpeg_start_decompress() we have the correct scaled
   * output image dimensions available, as well as the output colormap
   * if we asked for color quantization.
   * In this example, we need to make an output work buffer of the right size.
   */
  /* temporary buffer */
  tile_height = gimp_tile_height ();
  buf = g_new (guchar, tile_height * cinfo.output_width * cinfo.output_components);
857
858
859
860
861
  
  if (preview)
    padded_buf = g_new (guchar, tile_height * cinfo.output_width *
			(cinfo.output_components + 1));

Elliot Lee's avatar
Elliot Lee committed
862
863
864
865
866
867
  rowbuf = g_new (guchar*, tile_height);

  for (i = 0; i < tile_height; i++)
    rowbuf[i] = buf + cinfo.output_width * cinfo.output_components * i;

  /* Create a new image of the proper size and associate the filename with it.
868
869
870

     Preview layers, not being on the bottom of a layer stack, MUST HAVE
     AN ALPHA CHANNEL!
Elliot Lee's avatar
Elliot Lee committed
871
872
873
874
875
   */
  switch (cinfo.output_components)
    {
    case 1:
      image_type = GRAY;
876
      layer_type = preview ? GRAYA_IMAGE : GRAY_IMAGE;
Elliot Lee's avatar
Elliot Lee committed
877
878
879
      break;
    case 3:
      image_type = RGB;
880
      layer_type = preview ? RGBA_IMAGE : RGB_IMAGE;
Elliot Lee's avatar
Elliot Lee committed
881
882
      break;
    default:
883
      g_message ("don't know how to load JPEGs\nwith %d color channels",
884
                   cinfo.output_components);
Elliot Lee's avatar
Elliot Lee committed
885
886
887
      gimp_quit ();
    }

Sven Neumann's avatar
Sven Neumann committed
888
889
890
891
892
893
  if (preview) 
    {
      image_ID = image_ID_global;
    } 
  else 
    {
894
895
      image_ID = gimp_image_new (cinfo.output_width, cinfo.output_height,
				 image_type);
Sven Neumann's avatar
Sven Neumann committed
896
897
      gimp_image_set_filename (image_ID, filename);
    }
898

Sven Neumann's avatar
Sven Neumann committed
899
900
901
902
903
904
  if (preview) 
    {
      layer_ID_global = layer_ID = gimp_layer_new (image_ID, _("JPEG preview"),
						   cinfo.output_width,
						   cinfo.output_height,
						   layer_type, 100, NORMAL_MODE);
905
    }
Sven Neumann's avatar
Sven Neumann committed
906
907
908
909
910
911
912
  else 
    {
      layer_ID = gimp_layer_new (image_ID, _("Background"),
				 cinfo.output_width,
				 cinfo.output_height,
				 layer_type, 100, NORMAL_MODE);
    }
Elliot Lee's avatar
Elliot Lee committed
913

914
  drawable_global = drawable = gimp_drawable_get (layer_ID);
915
916
  gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0,
		       drawable->width, drawable->height, TRUE, FALSE);
Elliot Lee's avatar
Elliot Lee committed
917

918
#ifdef GIMP_HAVE_RESOLUTION_INFO
919
  /* Step 5.1: if the file had resolution information, set it on the image */
920
  if (!preview && cinfo.saw_JFIF_marker)
921
922
923
924
    {
      gdouble xresolution;
      gdouble yresolution;
      gdouble asymmetry;
925

926
927
      xresolution = cinfo.X_density;
      yresolution = cinfo.Y_density;
928

929
930
931
932
933
934
935
936
937
      switch (cinfo.density_unit)
	{
	case 0: /* unknown -> set the aspect ratio but use the default
		*  image resolution
		*/
	  asymmetry = xresolution / yresolution;
	  gimp_image_get_resolution (image_ID, &xresolution, &yresolution);
	  xresolution *= asymmetry;
	  break;
938

939
940
	case 1: /* dots per inch */
	  break;
941

942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
	case 2: /* dots per cm */
	  xresolution *= 2.54;
	  yresolution *= 2.54;
	  gimp_image_set_unit (image_ID, UNIT_MM);
	  break;

	default:
	  g_message ("unknown density unit %d\nassuming dots per inch",
		     cinfo.density_unit);
	  break;
	}

      gimp_image_set_resolution (image_ID, xresolution, yresolution);
    }
#endif /* GIMP_HAVE_RESOLUTION_INFO */
957

Elliot Lee's avatar
Elliot Lee committed
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
  /* Step 6: while (scan lines remain to be read) */
  /*           jpeg_read_scanlines(...); */

  /* Here we use the library's state variable cinfo.output_scanline as the
   * loop counter, so that we don't have to keep track ourselves.
   */
  while (cinfo.output_scanline < cinfo.output_height)
    {
      start = cinfo.output_scanline;
      end = cinfo.output_scanline + tile_height;
      end = MIN (end, cinfo.output_height);
      scanlines = end - start;

      for (i = 0; i < scanlines; i++)
	jpeg_read_scanlines (&cinfo, (JSAMPARRAY) &rowbuf[i], 1);

      /*
      for (i = start; i < end; i++)
	gimp_pixel_rgn_set_row (&pixel_rgn, tilerow[i - start], 0, i, drawable->width);
	*/

979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
      if (preview) /* Add a dummy alpha channel -- convert buf to padded_buf */
	{
	  guchar *dest = padded_buf;
	  guchar *src  = buf;
	  gint num = drawable->width * scanlines;

	  switch (cinfo.output_components)
	    {
	    case 1:
	      for (i=0; i<num; i++)
		{
		  *(dest++) = *(src++);
		  *(dest++) = 255;
		}
	      break;
	    case 3:
	      for (i=0; i<num; i++)
		{
		  *(dest++) = *(src++);
		  *(dest++) = *(src++);
		  *(dest++) = *(src++);
		  *(dest++) = 255;