cairo-image-surface-jpeg.c 15.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/*
 *  GThumb
 *
 *  Copyright (C) 2011 Free Software Foundation, Inc.
 *
 *  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, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <setjmp.h>
#include <jpeglib.h>
#include <gthumb.h>
#include <extensions/jpeg_utils/jmemorysrc.h>
Paolo Bacchilega's avatar
Paolo Bacchilega committed
30
#include <extensions/jpeg_utils/jpeg-info.h>
31
#include "cairo-image-surface-jpeg.h"
32 33 34 35


/* error handler data */

36

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
struct error_handler_data {
	struct jpeg_error_mgr   pub;
	sigjmp_buf              setjmp_buffer;
        GError                **error;
};


static void
fatal_error_handler (j_common_ptr cinfo)
{
	struct error_handler_data *errmgr;
        char buffer[JMSG_LENGTH_MAX];

	errmgr = (struct error_handler_data *) cinfo->err;

        /* Create the message */
        (* cinfo->err->format_message) (cinfo, buffer);

        /* broken check for *error == NULL for robustness against
         * crappy JPEG library
         */
        if (errmgr->error && *errmgr->error == NULL) {
                g_set_error (errmgr->error,
                             GDK_PIXBUF_ERROR,
                             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
62
			     _("Error interpreting JPEG image file: %s"),
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
                             buffer);
        }

	siglongjmp (errmgr->setjmp_buffer, 1);

        g_assert_not_reached ();
}


static void
output_message_handler (j_common_ptr cinfo)
{
	/* This method keeps libjpeg from dumping crap to stderr */
	/* do nothing */
}


80 81 82 83 84 85 86 87
/* tables with pre-multiplied values */


static unsigned char *CMYK_Tab = NULL;
static int           *YCbCr_R_Cr_Tab = NULL;
static int           *YCbCr_G_Cb_Tab = NULL;
static int           *YCbCr_G_Cr_Tab = NULL;
static int           *YCbCr_B_Cb_Tab = NULL;
88
static GStaticMutex   Tables_Mutex = G_STATIC_MUTEX_INIT;
89 90 91 92 93 94 95 96 97 98 99


#define SCALE_FACTOR   16
#define SCALE_UP(x)    ((gint32) ((x) * (1L << SCALE_FACTOR) + 0.5))
#define SCALE_DOWN(x)  ((x) >> SCALE_FACTOR)
#define ONE_HALF       ((gint32) (1 << (SCALE_FACTOR - 1)))


static void
CMYK_table_init (void)
{
100 101
	g_static_mutex_lock (&Tables_Mutex);

102 103 104 105 106 107 108 109 110 111 112 113 114 115
	if (CMYK_Tab == NULL) {
		int    v, k, i;
		double k1;

		/* tab[k * 256 + v] = v * k / 255.0 */

		CMYK_Tab = g_new (unsigned char, 256 * 256);
		i = 0;
		for (k = 0; k <= 255; k++) {
			k1 = (double) k / 255.0;
			for (v = 0; v <= 255; v++)
				CMYK_Tab[i++] = (double) v * k1;
		}
	}
116 117

	g_static_mutex_unlock (&Tables_Mutex);
118 119 120 121 122 123
}


static void
YCbCr_tables_init (void)
{
124 125
	g_static_mutex_lock (&Tables_Mutex);

126 127 128 129 130 131 132 133 134
	if (YCbCr_R_Cr_Tab == NULL) {
		int i, v;

		YCbCr_R_Cr_Tab = g_new (int, 256);
		YCbCr_G_Cb_Tab = g_new (int, 256);
		YCbCr_G_Cr_Tab = g_new (int, 256);
		YCbCr_B_Cb_Tab = g_new (int, 256);

		for (i = 0, v = -128; i <= 255; i++, v++) {
135
			YCbCr_R_Cr_Tab[i] = SCALE_DOWN (SCALE_UP (1.402) * v + ONE_HALF);
136 137
			YCbCr_G_Cb_Tab[i] = - SCALE_UP (0.34414) * v;
			YCbCr_G_Cr_Tab[i] = - SCALE_UP (0.71414) * v + ONE_HALF;
138
			YCbCr_B_Cb_Tab[i] = SCALE_DOWN (SCALE_UP (1.77200) * v + ONE_HALF);
139 140
		}
	}
141 142

	g_static_mutex_unlock (&Tables_Mutex);
143 144 145
}


146
GthImage *
147 148
_cairo_image_surface_create_from_jpeg (GInputStream  *istream,
				       GthFileData   *file_data,
149 150 151 152 153 154 155 156
				       int            requested_size,
				       int           *original_width,
				       int           *original_height,
				       gpointer       user_data,
				       GCancellable  *cancellable,
				       GError       **error)
{
	GthImage                      *image;
157
	gboolean                       load_scaled;
158 159 160 161 162 163
	GthTransform                   orientation;
	int                            destination_width;
	int                            destination_height;
	int                            line_start;
	int                            line_step;
	int                            pixel_step;
164 165 166 167 168
	void                          *in_buffer;
	gsize                          in_buffer_size;
	struct error_handler_data      jsrcerr;
	struct jpeg_decompress_struct  srcinfo;
	cairo_surface_t               *surface;
169
	cairo_surface_metadata_t      *metadata;
170 171 172
	unsigned char                 *surface_row;
	JSAMPARRAY                     buffer;
	int                            buffer_stride;
173
	JDIMENSION                     n_lines;
174
	JSAMPARRAY                     buffer_row;
175
	int                            l;
176
	unsigned char                 *p_surface;
177 178
	guchar                         r, g, b;
	guint32                        pixel;
179
	unsigned char                 *p_buffer;
180
	int                            x;
181 182 183

	image = gth_image_new ();

184 185 186 187 188
	if (! _g_input_stream_read_all (istream,
			      	        &in_buffer,
			      	        &in_buffer_size,
			      	        cancellable,
			      	        error))
189 190 191 192
	{
		return image;
	}

193 194 195 196 197 198 199 200
	srcinfo.err = jpeg_std_error (&(jsrcerr.pub));
	jsrcerr.pub.error_exit = fatal_error_handler;
	jsrcerr.pub.output_message = output_message_handler;
	jsrcerr.error = error;

	jpeg_create_decompress (&srcinfo);

	if (sigsetjmp (jsrcerr.setjmp_buffer, 1)) {
Paolo Bacchilega's avatar
Paolo Bacchilega committed
201
		g_free (in_buffer);
202 203 204 205 206 207 208 209
		jpeg_destroy_decompress (&srcinfo);
		return image;
	}

	_jpeg_memory_src (&srcinfo, in_buffer, in_buffer_size);

	jpeg_read_header (&srcinfo, TRUE);

210 211
	srcinfo.out_color_space = srcinfo.jpeg_color_space; /* make all the color space conversions manually */

212 213 214
	load_scaled = (requested_size > 0) && (requested_size < srcinfo.image_width) && (requested_size < srcinfo.image_height);
	if (load_scaled) {
		for (srcinfo.scale_denom = 1; srcinfo.scale_denom <= 16; srcinfo.scale_denom++) {
215 216
			jpeg_calc_output_dimensions (&srcinfo);
			if ((srcinfo.output_width < requested_size) || (srcinfo.output_height < requested_size)) {
217
				srcinfo.scale_denom -= 1;
218 219 220 221 222 223 224 225
				break;
			}
		}

		if (srcinfo.scale_denom == 0)
			srcinfo.scale_denom = srcinfo.scale_num;
	}

226 227 228 229 230
	jpeg_calc_output_dimensions (&srcinfo);

	buffer_stride = srcinfo.output_width * srcinfo.output_components;
	buffer = (*srcinfo.mem->alloc_sarray) ((j_common_ptr) &srcinfo, JPOOL_IMAGE, buffer_stride, srcinfo.rec_outbuf_height);

231 232
	jpeg_start_decompress (&srcinfo);

233 234
	orientation = _jpeg_exif_orientation (in_buffer, in_buffer_size);
	_cairo_image_surface_transform_get_steps (CAIRO_FORMAT_ARGB32,
235 236
						  MIN (srcinfo.output_width, CAIRO_MAX_IMAGE_SIZE),
						  MIN (srcinfo.output_height, CAIRO_MAX_IMAGE_SIZE),
237 238 239 240 241 242 243
						  orientation,
						  &destination_width,
						  &destination_height,
						  &line_start,
						  &line_step,
						  &pixel_step);

244 245 246 247 248 249 250 251 252
#if 0
	g_print ("requested: %d, original [%d, %d] ==> load at [%d, %d]\n",
			requested_size,
			srcinfo.image_width,
			srcinfo.image_height,
			destination_width,
			destination_height);
#endif

253 254 255
	surface = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32, destination_width, destination_height);
	if (surface == NULL) {
		jpeg_destroy_decompress (&srcinfo);
256 257 258 259
		g_free (in_buffer);

		return image;
	}
260

261 262
	metadata = _cairo_image_surface_get_metadata (surface);
	metadata->has_alpha = FALSE;
263
	surface_row = _cairo_image_surface_flush_and_get_data (surface) + line_start;
264

265 266 267
	switch (srcinfo.out_color_space) {
	case JCS_CMYK:
		{
268 269 270 271 272
			register unsigned char *cmyk_tab;
			int c, m, y, k, ki;

			CMYK_table_init ();
			cmyk_tab = CMYK_Tab;
273 274 275

			while (srcinfo.output_scanline < srcinfo.output_height) {
				if (g_cancellable_is_cancelled (cancellable))
276
					goto stop_loading;
277 278 279 280 281 282 283 284

				n_lines = jpeg_read_scanlines (&srcinfo, buffer, srcinfo.rec_outbuf_height);

				buffer_row = buffer;
				for (l = 0; l < n_lines; l++) {
					p_surface = surface_row;
					p_buffer = buffer_row[l];

285 286 287
					if (g_cancellable_is_cancelled (cancellable))
						goto stop_loading;

288
					for (x = 0; x < srcinfo.output_width; x++) {
289 290 291 292 293 294 295 296 297 298 299 300 301 302
						if (srcinfo.saw_Adobe_marker) {
							c = p_buffer[0];
							m = p_buffer[1];
							y = p_buffer[2];
							k = p_buffer[3];
						}
						else {
							c = 255 - p_buffer[0];
							m = 255 - p_buffer[1];
							y = 255 - p_buffer[2];
							k = 255 - p_buffer[3];
						}

						ki = k << 8; /* ki = k * 256 */
303 304 305
						r = cmyk_tab[ki + c];
						g = cmyk_tab[ki + m];
						b = cmyk_tab[ki + y];
306
						pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, 0xff);
307
						memcpy (p_surface, &pixel, sizeof (guint32));
308

309
						p_surface += pixel_step;
310 311 312
						p_buffer += 4 /*srcinfo.output_components*/;
					}

313
					surface_row += line_step;
314 315
					buffer_row += buffer_stride;
				}
316
			}
317 318 319 320 321 322 323
		}
		break;

	case JCS_GRAYSCALE:
		{
			while (srcinfo.output_scanline < srcinfo.output_height) {
				if (g_cancellable_is_cancelled (cancellable))
324
					goto stop_loading;
325 326 327 328 329 330 331 332

				n_lines = jpeg_read_scanlines (&srcinfo, buffer, srcinfo.rec_outbuf_height);

				buffer_row = buffer;
				for (l = 0; l < n_lines; l++) {
					p_surface = surface_row;
					p_buffer = buffer_row[l];

333 334 335
					if (g_cancellable_is_cancelled (cancellable))
						goto stop_loading;

336
					for (x = 0; x < srcinfo.output_width; x++) {
337
						r = g = b = p_buffer[0];
338
						pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, 0xff);
339
						memcpy (p_surface, &pixel, sizeof (guint32));
340

341
						p_surface += pixel_step;
342 343 344
						p_buffer += 1 /*srcinfo.output_components*/;
					}

345
					surface_row += line_step;
346 347 348 349 350 351 352 353 354 355
					buffer_row += buffer_stride;
				}
			}
		}
		break;

	case JCS_RGB:
		{
			while (srcinfo.output_scanline < srcinfo.output_height) {
				if (g_cancellable_is_cancelled (cancellable))
356
					goto stop_loading;
357 358 359 360 361 362 363 364

				n_lines = jpeg_read_scanlines (&srcinfo, buffer, srcinfo.rec_outbuf_height);

				buffer_row = buffer;
				for (l = 0; l < n_lines; l++) {
					p_surface = surface_row;
					p_buffer = buffer_row[l];

365 366 367
					if (g_cancellable_is_cancelled (cancellable))
						goto stop_loading;

368
					for (x = 0; x < srcinfo.output_width; x++) {
369 370 371
						r = p_buffer[0];
						g = p_buffer[1];
						b = p_buffer[2];
372
						pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, 0xff);
373
						memcpy (p_surface, &pixel, sizeof (guint32));
374

375
						p_surface += pixel_step;
376 377 378
						p_buffer += 3 /*srcinfo.output_components*/;
					}

379
					surface_row += line_step;
380 381 382 383 384 385 386 387
					buffer_row += buffer_stride;
				}
			}
		}
		break;

	case JCS_YCbCr:
		{
388 389 390 391 392 393 394 395 396 397 398 399
			register JSAMPLE *range_limit = srcinfo.sample_range_limit;
			register int     *r_cr_tab;
			register int     *g_cb_tab;
			register int     *g_cr_tab;
			register int     *b_cb_tab;
			int               Y, Cb, Cr;

			YCbCr_tables_init ();
			r_cr_tab = YCbCr_R_Cr_Tab;
			g_cb_tab = YCbCr_G_Cb_Tab;
			g_cr_tab = YCbCr_G_Cr_Tab;
			b_cb_tab = YCbCr_B_Cb_Tab;
400 401 402

			while (srcinfo.output_scanline < srcinfo.output_height) {
				if (g_cancellable_is_cancelled (cancellable))
403
					goto stop_loading;
404 405

				n_lines = jpeg_read_scanlines (&srcinfo, buffer, srcinfo.rec_outbuf_height);
406

407 408 409 410 411
				buffer_row = buffer;
				for (l = 0; l < n_lines; l++) {
					p_surface = surface_row;
					p_buffer = buffer_row[l];

412 413 414
					if (g_cancellable_is_cancelled (cancellable))
						goto stop_loading;

415
					for (x = 0; x < srcinfo.output_width; x++) {
416 417 418
						Y = p_buffer[0];
						Cb = p_buffer[1];
						Cr = p_buffer[2];
419

420 421 422
						r = range_limit[Y + r_cr_tab[Cr]];
						g = range_limit[Y + SCALE_DOWN (g_cb_tab[Cb] + g_cr_tab[Cr])];
						b = range_limit[Y + b_cb_tab[Cb]];
423
						pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, 0xff);
424
						memcpy (p_surface, &pixel, sizeof (guint32));
425

426
						p_surface += pixel_step;
427 428 429
						p_buffer += 3 /*srcinfo.output_components*/;
					}

430
					surface_row += line_step;
431 432 433
					buffer_row += buffer_stride;
				}
			}
434
		}
435 436 437
		break;

	case JCS_YCCK:
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
		{
			register JSAMPLE *range_limit = srcinfo.sample_range_limit;
			register int     *r_cr_tab;
			register int     *g_cb_tab;
			register int     *g_cr_tab;
			register int     *b_cb_tab;
			register guchar  *cmyk_tab;
			int               Y, Cb, Cr, K, Ki, c, m , y;

			YCbCr_tables_init ();
			r_cr_tab = YCbCr_R_Cr_Tab;
			g_cb_tab = YCbCr_G_Cb_Tab;
			g_cr_tab = YCbCr_G_Cr_Tab;
			b_cb_tab = YCbCr_B_Cb_Tab;

			CMYK_table_init ();
			cmyk_tab = CMYK_Tab;

			while (srcinfo.output_scanline < srcinfo.output_height) {
				if (g_cancellable_is_cancelled (cancellable))
458
					goto stop_loading;
459 460 461 462 463 464 465 466

				n_lines = jpeg_read_scanlines (&srcinfo, buffer, srcinfo.rec_outbuf_height);

				buffer_row = buffer;
				for (l = 0; l < n_lines; l++) {
					p_surface = surface_row;
					p_buffer = buffer_row[l];

467 468 469
					if (g_cancellable_is_cancelled (cancellable))
						goto stop_loading;

470 471 472 473 474 475 476 477 478 479 480
					for (x = 0; x < srcinfo.output_width; x++) {
						Y = p_buffer[0];
						Cb = p_buffer[1];
						Cr = p_buffer[2];
						K = p_buffer[3];

						c = range_limit[255 - (Y + r_cr_tab[Cr])];
						m = range_limit[255 - (Y + SCALE_DOWN (g_cb_tab[Cb] + g_cr_tab[Cr]))];
						y = range_limit[255 - (Y + b_cb_tab[Cb])];

						Ki = K << 8; /* ki = K * 256 */
481 482 483 484

						r = cmyk_tab[Ki + c];
						g = cmyk_tab[Ki + m];
						b = cmyk_tab[Ki + y];
485
						pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, 0xff);
486
						memcpy (p_surface, &pixel, sizeof (guint32));
487

488
						p_surface += pixel_step;
489 490 491
						p_buffer += 4 /*srcinfo.output_components*/;
					}

492
					surface_row += line_step;
493 494 495 496 497 498
					buffer_row += buffer_stride;
				}
			}
		}
		break;

499 500
	case JCS_UNKNOWN:
	default:
501 502 503 504 505
		g_set_error (error,
                             GDK_PIXBUF_ERROR,
                             GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                             _("Unknown JPEG color space (%d)"),
                             srcinfo.out_color_space);
506
		break;
507 508
	}

509
	stop_loading:
510

511
	cairo_surface_mark_dirty (surface);
512

513
	if (! g_cancellable_is_cancelled (cancellable)) {
514

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
		/* Set the original dimensions */

		if ((orientation == GTH_TRANSFORM_ROTATE_90)
		     ||	(orientation == GTH_TRANSFORM_ROTATE_270)
		     ||	(orientation == GTH_TRANSFORM_TRANSPOSE)
		     ||	(orientation == GTH_TRANSFORM_TRANSVERSE))
		{
			if (original_width != NULL)
				*original_width = srcinfo.image_height;
			if (original_height != NULL)
				*original_height = srcinfo.image_width;
		}
		else {
			if (original_width != NULL)
				*original_width = srcinfo.image_width;
			if (original_height != NULL)
				*original_height = srcinfo.image_height;
		}
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
		jpeg_finish_decompress (&srcinfo);
		jpeg_destroy_decompress (&srcinfo);

		/* Scale to the requested size */

		if (load_scaled) {
			cairo_surface_t *scaled;
			int              width;
			int              height;

			width = destination_width;
			height = destination_height;
			scale_keeping_ratio (&width, &height, requested_size, requested_size, TRUE);
			scaled = _cairo_image_surface_scale (surface, width, height, SCALE_FILTER_BEST, NULL);

			cairo_surface_destroy (surface);
			surface = scaled;
		}
551 552 553

		/*_cairo_image_surface_set_attribute_int (surface, "Image::Rotation", rotation); FIXME*/
		/* FIXME _cairo_image_surface_set_attribute (surface, "Jpeg::ColorSpace", jpeg_color_space_name (srcinfo.jpeg_color_space)); */
554

555 556
		gth_image_set_cairo_surface (image, surface);
	}
557
	else {
558
		jpeg_destroy_decompress (&srcinfo);
559 560
		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CANCELLED, "");
	}
561 562 563 564 565 566

	cairo_surface_destroy (surface);
	g_free (in_buffer);

	return image;
}
567 568 569 570 571 572


#undef SCALE_FACTOR
#undef SCALE_UP
#undef SCALE_DOWN
#undef ONE_HALF