../cdk-pixbuf/io-jpeg.c

Bug Summary

File:	_build/../cdk-pixbuf/io-jpeg.c
Warning:	line 382, column 2 Null pointer passed to 1st parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name io-jpeg.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/_build -fcoverage-compilation-dir=/rootdir/_build -resource-dir /usr/lib/llvm-21/lib/clang/21 -I cdk-pixbuf/libstaticpixbufloader-jpeg.a.p -I cdk-pixbuf -I ../cdk-pixbuf -I . -I .. -I /usr/include/libpng16 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/librsvg-2.0 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/glycin-2 -I /usr/include/cairo -I /usr/include/libxml2 -I /usr/include/pango-1.0 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/pixman-1 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -D _FILE_OFFSET_BITS=64 -D _POSIX_C_SOURCE=200809L -D _DEFAULT_SOURCE -D _XOPEN_SOURCE=700 -D HAVE_CONFIG_H=1 -D G_LOG_STRUCTURED=1 -D G_LOG_DOMAIN="CdkPixbuf" -D CDK_PIXBUF_COMPILATION -D CDK_PIXBUF_PREFIX="/usr/local" -D CDK_PIXBUF_LOCALEDIR="/usr/local/share/locale" -D CDK_PIXBUF_LIBDIR="/usr/local/lib/x86_64-linux-gnu" -D CDK_PIXBUF_BINARY_VERSION="2.10.0" -D CDK_PIXBUF_ENABLE_BACKEND -D PIXBUF_LIBDIR="/usr/local/lib/x86_64-linux-gnu/cdk-pixbuf-2.0/2.10.0/loaders" -D BUILT_MODULES_DIR="/rootdir/_build/cdk-pixbuf" -D INCLUDE_jpeg -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-int-conversion -Wno-uninitialized -Wno-discarded-qualifiers -std=gnu99 -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-checker deadcode.DeadStores -analyzer-checker security.ArrayBound -analyzer-checker unix.cstring.NotNullTerminated -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2026-06-02-072008-8532-1 -x c ../cdk-pixbuf/io-jpeg.c
1/* -*- mode: C; c-file-style: "linux" -*- */
2/* CdkPixbuf library - JPEG image loader
*
* Copyright (C) 1999 Michael Zucchi
* Copyright (C) 1999 The Free Software Foundation
* 
* Progressive loading code Copyright (C) 1999 Red Hat, Inc.
*
* Authors: Michael Zucchi <zucchi@zedzone.mmc.com.au>
*          Federico Mena-Quintero <federico@gimp.org>
*          Michael Fulbright <drmike@redhat.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/


28#include "config.h"
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <setjmp.h>
33#include <jpeglib.h>
34#include <jerror.h>
35#include <math.h>
36#include <glib/gi18n-lib.h>
37#include "cdk-pixbuf-io.h"
38#include "fallback-c89.c"

40#ifndef HAVE_SIGSETJMP
41#define sigjmp_buf jmp_buf
42#define sigsetjmp(jb, x)__sigsetjmp (jb, x) setjmp(jb)_setjmp (jb)
43#define siglongjmp longjmp
44#endif
45

47/* Helper macros to convert between density units */
48#define DPCM_TO_DPI(value)((int) round ((value) * 2.54)) ((int) round ((value) * 2.54))

50/* we are a "source manager" as far as libjpeg is concerned */
51#define JPEG_PROG_BUF_SIZE65536 65536

53typedef struct {
struct jpeg_source_mgr pub;   /* public fields */

JOCTET buffer[JPEG_PROG_BUF_SIZE65536];              /* start of buffer */
long  skip_next;              /* number of bytes to skip next read */

59} my_source_mgr;

61typedef my_source_mgr * my_src_ptr;

63/* error handler data */
64struct error_handler_data {
struct jpeg_error_mgr pub;
sigjmp_buf setjmp_buffer;
      GError **error;
68};

70/* progressive loader context */
71typedef struct {
      CdkPixbufModuleSizeFunc     size_func;
CdkPixbufModuleUpdatedFunc  updated_func;
CdkPixbufModulePreparedFunc prepared_func;
gpointer                    user_data;

CdkPixbuf                *pixbuf;
guchar                   *dptr;   /* current position in pixbuf */

gboolean                 did_prescan;  /* are we in image data yet? */
gboolean                 got_header;  /* have we loaded jpeg header? */
gboolean                 src_initialized;/* TRUE when jpeg lib initialized */
gboolean                 in_output;   /* did we get suspended in an output pass? */
struct jpeg_decompress_struct cinfo;
struct error_handler_data     jerr;
86} JpegProgContext;

88/* EXIF context */
89typedef struct {
gint			 orientation;
gchar			*icc_profile;
gsize			 icc_profile_size;
gsize			 icc_profile_size_allocated;
94} JpegExifContext;

96#ifndef NO_MODULE_ENTRIES
97static CdkPixbuf *cdk_pixbuf__jpeg_image_load (FILE *f, GError **error);
98static gpointer cdk_pixbuf__jpeg_image_begin_load (CdkPixbufModuleSizeFunc           func0,
                                                 CdkPixbufModulePreparedFunc func1, 
                                                 CdkPixbufModuleUpdatedFunc func2,
                                                 gpointer user_data,
                                                 GError **error);
103static gboolean cdk_pixbuf__jpeg_image_stop_load (gpointer context, GError **error);
104static gboolean cdk_pixbuf__jpeg_image_load_increment(gpointer context,
                                                    const guchar *buf, guint size,
                                                    GError **error);
107static gboolean cdk_pixbuf__jpeg_image_load_lines (JpegProgContext  *context,
                                                 GError          **error);
109#endif

111static void
112fatal_error_handler (j_common_ptr cinfo)
113{
struct error_handler_data *errmgr;
      char buffer[JMSG_LENGTH_MAX200];
      
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((void*)0)) {
              g_set_error (errmgr->error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           cinfo->err->msg_code == JERR_OUT_OF_MEMORY 
	     ? CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY 
	     : CDK_PIXBUF_ERROR_CORRUPT_IMAGE,
                           _("Error interpreting JPEG image file (%s)")((char *) g_dgettext ("cdk-pixbuf", "Error interpreting JPEG image file (%s)"
)),
                           buffer);
      }
      
siglongjmp (errmgr->setjmp_buffer, 1);

      g_assert_not_reached ()do { g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 137, ((const char*) (__func__)), ((void*)0)); } while (0);
138}

140static void
141output_message_handler (j_common_ptr cinfo)
142{
/* This method keeps libjpeg from dumping crap to stderr */

/* do nothing */
146}

148#ifndef NO_MODULE_ENTRIES
149/* explode gray image data from jpeg library into rgb components in pixbuf */
150static void
151explode_gray_into_buf (struct jpeg_decompress_struct *cinfo,
       guchar **lines) 
153{
gint i, j;
guint w;

g_return_if_fail (cinfo != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_26
 = 0; if (cinfo != ((void*)0)) _g_boolean_var_26 = 1; _g_boolean_var_26
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "cinfo != NULL"); return; } } while
 (0);
g_return_if_fail (cinfo->output_components == 1)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_27
 = 0; if (cinfo->output_components == 1) _g_boolean_var_27
 = 1; _g_boolean_var_27; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cinfo->output_components == 1"
); return; } } while (0);
g_return_if_fail (cinfo->out_color_space == JCS_GRAYSCALE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_28
 = 0; if (cinfo->out_color_space == JCS_GRAYSCALE) _g_boolean_var_28
 = 1; _g_boolean_var_28; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cinfo->out_color_space == JCS_GRAYSCALE"
); return; } } while (0);

/* Expand grey->colour.  Expand from the end of the
* memory down, so we can use the same buffer.
*/
w = cinfo->output_width;
for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {
guchar *from, *to;

from = lines[i] + w - 1;
to = lines[i] + (w - 1) * 3;
for (j = w - 1; j >= 0; j--) {
	to[0] = from[0];
	to[1] = from[0];
	to[2] = from[0];
	to -= 3;
	from--;
}
}
178}


181static void
182convert_cmyk_to_rgb (struct jpeg_decompress_struct *cinfo,
     guchar **lines) 
184{
gint i, j;

g_return_if_fail (cinfo != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_29
 = 0; if (cinfo != ((void*)0)) _g_boolean_var_29 = 1; _g_boolean_var_29
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "cinfo != NULL"); return; } } while
 (0);
g_return_if_fail (cinfo->output_components == 4)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_30
 = 0; if (cinfo->output_components == 4) _g_boolean_var_30
 = 1; _g_boolean_var_30; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cinfo->output_components == 4"
); return; } } while (0);
g_return_if_fail (cinfo->out_color_space == JCS_CMYK)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_31
 = 0; if (cinfo->out_color_space == JCS_CMYK) _g_boolean_var_31
 = 1; _g_boolean_var_31; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cinfo->out_color_space == JCS_CMYK"
); return; } } while (0);

for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {
guchar *p;

p = lines[i];
for (j = 0; j < cinfo->output_width; j++) {
	int c, m, y, k;
	c = p[0];
	m = p[1];
	y = p[2];
	k = p[3];

	/* We now assume that all CMYK JPEG files
	 * use inverted CMYK, as Photoshop does
	 * See https://bugzilla.gnome.org/show_bug.cgi?id=618096 */
	p[0] = k*c / 255;
	p[1] = k*m / 255;
	p[2] = k*y / 255;
	p[3] = 255;
	p += 4;
}
}
212}

214typedef struct {
struct jpeg_source_mgr pub;	/* public fields */

FILE * infile;		/* source stream */
JOCTET * buffer;		/* start of buffer */
boolean start_of_file;	/* have we gotten any data yet? */
220} stdio_source_mgr;

222typedef stdio_source_mgr * stdio_src_ptr;

224static void
225stdio_init_source (j_decompress_ptr cinfo)
226{
stdio_src_ptr src = (stdio_src_ptr)cinfo->src;
src->start_of_file = FALSE0;
229}

231static boolean
232stdio_fill_input_buffer (j_decompress_ptr cinfo)
233{
stdio_src_ptr src = (stdio_src_ptr) cinfo->src;
size_t nbytes;

nbytes = fread (src->buffer, 1, JPEG_PROG_BUF_SIZE65536, src->infile);

if (nbytes <= 0) {
240#if 0
  if (src->start_of_file)	/* Treat empty input file as fatal error */
    ERREXIT(cinfo, JERR_INPUT_EMPTY)((cinfo)->err->msg_code = (JERR_INPUT_EMPTY), (*(cinfo)
->err->error_exit) ((j_common_ptr)(cinfo)));
  WARNMS(cinfo, JWRN_JPEG_EOF)((cinfo)->err->msg_code = (JWRN_JPEG_EOF), (*(cinfo)->
err->emit_message) ((j_common_ptr)(cinfo), -1));
244#endif
  /* Insert a fake EOI marker */
  src->buffer[0] = (JOCTET) 0xFF;
  src->buffer[1] = (JOCTET) JPEG_EOI0xD9;
  nbytes = 2;
}

src->pub.next_input_byte = src->buffer;
src->pub.bytes_in_buffer = nbytes;
src->start_of_file = FALSE0;

return TRUE1;
256}

258static void
259stdio_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
260{
stdio_src_ptr src = (stdio_src_ptr) cinfo->src;

if (num_bytes > 0) {
  while (num_bytes > (long) src->pub.bytes_in_buffer) {
    num_bytes -= (long) src->pub.bytes_in_buffer;
    (void)stdio_fill_input_buffer(cinfo);
  }
  src->pub.next_input_byte += (size_t) num_bytes;
  src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
271}

273static void
274stdio_term_source (j_decompress_ptr cinfo)
275{
276}

278static gchar *
279colorspace_name (const J_COLOR_SPACE jpeg_color_space) 
280{
switch (jpeg_color_space) {
   case JCS_UNKNOWN: return "UNKNOWN"; 
   case JCS_GRAYSCALE: return "GRAYSCALE"; 
   case JCS_RGB: return "RGB"; 
   case JCS_YCbCr: return "YCbCr"; 
   case JCS_CMYK: return "CMYK"; 
   case JCS_YCCK: return "YCCK";
   default: return "invalid";
}
290}

292#define DE_ENDIAN16(val)endian == 4321 ? (((((guint16) ( (guint16) ((guint16) (val) >>
 8) | (guint16) ((guint16) (val) << 8)))))) : (((guint16
) (val))) endian == G_BIG_ENDIAN4321 ? GUINT16_FROM_BE(val)(((((guint16) ( (guint16) ((guint16) (val) >> 8) | (guint16
) ((guint16) (val) << 8)))))) : GUINT16_FROM_LE(val)(((guint16) (val)))
293#define DE_ENDIAN32(val)endian == 4321 ? ((((__extension__ ({ guint32 __v, __x = ((guint32
) (val)); if (__builtin_constant_p (__x)) __v = ((guint32) ( (
((guint32) (__x) & (guint32) 0x000000ffU) << 24) | (
((guint32) (__x) & (guint32) 0x0000ff00U) << 8) | (
((guint32) (__x) & (guint32) 0x00ff0000U) >> 8) | (
((guint32) (__x) & (guint32) 0xff000000U) >> 24)));
 else __asm__ ("bswapl %0" : "=r" (__v) : "0" (__x)); __v; })
)))) : (((guint32) (val))) endian == G_BIG_ENDIAN4321 ? GUINT32_FROM_BE(val)((((__extension__ ({ guint32 __v, __x = ((guint32) (val)); if
 (__builtin_constant_p (__x)) __v = ((guint32) ( (((guint32) (
__x) & (guint32) 0x000000ffU) << 24) | (((guint32) (
__x) & (guint32) 0x0000ff00U) << 8) | (((guint32) (
__x) & (guint32) 0x00ff0000U) >> 8) | (((guint32) (
__x) & (guint32) 0xff000000U) >> 24))); else __asm__
 ("bswapl %0" : "=r" (__v) : "0" (__x)); __v; }))))) : GUINT32_FROM_LE(val)(((guint32) (val)))

295#define ENDIAN16_IT(val)endian == 4321 ? ((((guint16) ( (guint16) ((guint16) (val) >>
 8) | (guint16) ((guint16) (val) << 8))))) : ((guint16)
 (val)) endian == G_BIG_ENDIAN4321 ? GUINT16_TO_BE(val)((((guint16) ( (guint16) ((guint16) (val) >> 8) | (guint16
) ((guint16) (val) << 8))))) : GUINT16_TO_LE(val)((guint16) (val))
296#define ENDIAN32_IT(val)endian == 4321 ? (((__extension__ ({ guint32 __v, __x = ((guint32
) (val)); if (__builtin_constant_p (__x)) __v = ((guint32) ( (
((guint32) (__x) & (guint32) 0x000000ffU) << 24) | (
((guint32) (__x) & (guint32) 0x0000ff00U) << 8) | (
((guint32) (__x) & (guint32) 0x00ff0000U) >> 8) | (
((guint32) (__x) & (guint32) 0xff000000U) >> 24)));
 else __asm__ ("bswapl %0" : "=r" (__v) : "0" (__x)); __v; })
))) : ((guint32) (val)) endian == G_BIG_ENDIAN4321 ? GUINT32_TO_BE(val)(((__extension__ ({ guint32 __v, __x = ((guint32) (val)); if (
__builtin_constant_p (__x)) __v = ((guint32) ( (((guint32) (__x
) & (guint32) 0x000000ffU) << 24) | (((guint32) (__x
) & (guint32) 0x0000ff00U) << 8) | (((guint32) (__x
) & (guint32) 0x00ff0000U) >> 8) | (((guint32) (__x
) & (guint32) 0xff000000U) >> 24))); else __asm__ (
"bswapl %0" : "=r" (__v) : "0" (__x)); __v; })))) : GUINT32_TO_LE(val)((guint32) (val))

298static unsigned short de_get16(void *ptr, guint endian)
299{
     unsigned short val;

     memcpy(&val, ptr, sizeof(val));
     val = DE_ENDIAN16(val)endian == 4321 ? (((((guint16) ( (guint16) ((guint16) (val) >>
 8) | (guint16) ((guint16) (val) << 8)))))) : (((guint16
) (val)));

     return val;
306}

308static unsigned int de_get32(void *ptr, guint endian)
309{
     unsigned int val;

     memcpy(&val, ptr, sizeof(val));
     val = DE_ENDIAN32(val)endian == 4321 ? ((((__extension__ ({ guint32 __v, __x = ((guint32
) (val)); if (__builtin_constant_p (__x)) __v = ((guint32) ( (
((guint32) (__x) & (guint32) 0x000000ffU) << 24) | (
((guint32) (__x) & (guint32) 0x0000ff00U) << 8) | (
((guint32) (__x) & (guint32) 0x00ff0000U) >> 8) | (
((guint32) (__x) & (guint32) 0xff000000U) >> 24)));
 else __asm__ ("bswapl %0" : "=r" (__v) : "0" (__x)); __v; })
)))) : (((guint32) (val)));

     return val;
316}

318/* application specific data segment */
319static gboolean
320jpeg_parse_exif_app2_segment (JpegExifContext *context, jpeg_saved_marker_ptr marker)
321{
guint ret = FALSE0;
guint sequence_number;
guint number_of_chunks;
guint chunk_size;
guint offset;

/* do we have enough data? */
if (marker->data_length < 16)
31
←
Assuming field 'data_length' is >= 16→
32
←
Taking false branch→
56
←
Assuming field 'data_length' is >= 16→
57
←
Taking false branch→
goto out;

/* unique identification string */
if (memcmp (marker->data, "ICC_PROFILE\0", 12) != 0)
33
←
Assuming the condition is false→
34
←
Taking false branch→
58
←
Assuming the condition is false→
59
←
Taking false branch→
goto out;

/* get data about this segment */
sequence_number = marker->data[12];
number_of_chunks = marker->data[13];

/* this is invalid, the base offset is 1 */
if (sequence_number == 0)
35
←
Assuming 'sequence_number' is not equal to 0→
36
←
Taking false branch→
60
←
Assuming 'sequence_number' is not equal to 0→
61
←
Taking false branch→
goto out;

/* this is invalid, the base offset is 1 */
if (sequence_number > number_of_chunks)
37
←
Assuming 'sequence_number' is <= 'number_of_chunks'→
38
←
Taking false branch→
62
←
Assuming 'sequence_number' is <= 'number_of_chunks'→
63
←
Taking false branch→
goto out;

/* size includes the id (12 bytes), length field (1 byte), and sequence field (1 byte) */
chunk_size = marker->data_length - 14;
offset = (sequence_number - 1) * 0xffef;

/* Deal with the trivial profile (99% of images) to avoid allocating
* 64kb when we might only use a few kb. */
if (number_of_chunks == 1) {
39
←
Assuming 'number_of_chunks' is not equal to 1→
40
←
Taking false branch→
64
←
Assuming 'number_of_chunks' is not equal to 1→
65
←
Taking false branch→
if (context->icc_profile_size_allocated > 0)
	goto out;
context->icc_profile_size = chunk_size;
context->icc_profile_size_allocated = chunk_size;
context->icc_profile = g_new (gchar, chunk_size)(gchar *) (__extension__ ({ gsize __n = (gsize) (chunk_size);
 gsize __s = sizeof (gchar); gpointer __p; if (__s == 1) __p =
 g_malloc (__n); else if (__builtin_constant_p (__n) &&
 (__s == 0 || __n <= (9223372036854775807L *2UL+1UL) / __s
)) __p = g_malloc (__n * __s); else __p = g_malloc_n (__n, __s
); __p; }));
/* copy the segment data to the profile space */
memcpy (context->icc_profile, marker->data + 14, chunk_size);
              ret = TRUE1;
goto out;
}

/* There is no promise the APP2 segments are going to be in order, so we
* have to allocate a huge swathe of memory and fill in the gaps when
* (if) we get the segment.
* Theoretically this could be as much as 16Mb, but display profiles are
* vary rarely above 100kb, and printer profiles are usually less than
* 2Mb */
if (context->icc_profile_size_allocated40.1
Field 'icc_profile_size_allocated' is equal to 0
1
Field 'icc_profile_size_allocated' is not equal to 0
 == 0) {
41
←
Taking true branch→
66
←
Taking false branch→
context->icc_profile_size_allocated = number_of_chunks * 0xffff;
context->icc_profile = g_new0 (gchar, number_of_chunks * 0xffff)(gchar *) (__extension__ ({ gsize __n = (gsize) (number_of_chunks
 * 0xffff); gsize __s = sizeof (gchar); gpointer __p; if (__s
 == 1) __p = g_malloc0 (__n); else if (__builtin_constant_p (
__n) && (__s == 0 || __n <= (9223372036854775807L *
2UL+1UL) / __s)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n
 (__n, __s); __p; }));
42
←
Taking true branch→
}

/* check the data will fit in our previously allocated buffer */
if (offset + chunk_size > context->icc_profile_size_allocated)
43
←
Assuming the condition is true→
44
←
Taking true branch→
67
←
Assuming the condition is false→
68
←
Taking false branch→
goto out;
45
←
Control jumps to line 389→

/* copy the segment data to the profile space */
memcpy (context->icc_profile + offset, marker->data + 14, chunk_size);
69
←
Null pointer passed to 1st parameter expecting 'nonnull'

      context->icc_profile_size = MAX (context->icc_profile_size, offset + chunk_size)(((context->icc_profile_size) > (offset + chunk_size)) ?
 (context->icc_profile_size) : (offset + chunk_size));

/* success */
ret = TRUE1;
388out:
      if (!ret45.1
'ret' is 0
) {
46
←
Taking true branch→
              g_free (context->icc_profile);
              context->icc_profile = NULL((void*)0);
47
←
Null pointer value stored to 'exif_context.icc_profile'→
      }
return ret;
394}

396static gboolean
397jpeg_parse_exif_app1 (JpegExifContext *context, jpeg_saved_marker_ptr marker)
398{
guint i;
guint ret = FALSE0;
guint offset;
guint tags;	   /* number of tags in current ifd */
guint endian = 0;	/* detected endian of data */
const char leth[]  = {0x49, 0x49, 0x2a, 0x00};	// Little endian TIFF header
const char beth[]  = {0x4d, 0x4d, 0x00, 0x2a};	// Big endian TIFF header

/* do we have enough data? */
if (marker->data_length < 4)
goto out;

/* unique identification string */
if (memcmp (marker->data, "Exif", 4) != 0)
goto out;

/* do we have enough data? */
if (marker->data_length < 32)
goto out;

/* Just skip data until TIFF header - it should be within 16 bytes from marker start.
  Normal structure relative to APP1 marker -
0x0000: APP1 marker entry = 2 bytes
0x0002: APP1 length entry = 2 bytes
0x0004: Exif Identifier entry = 6 bytes
0x000A: Start of TIFF header (Byte order entry) - 4 bytes
	- This is what we look for, to determine endianess.
0x000E: 0th IFD offset pointer - 4 bytes

marker->data points to the first data after the APP1 marker
and length entries, which is the exif identification string.
The TIFF header should thus normally be found at i=6, below,
and the pointer to IFD0 will be at 6+4 = 10.
*/

for (i=0; i<16; i++) {
/* little endian TIFF header */
if (memcmp (&marker->data[i], leth, 4) == 0) {
	endian = G_LITTLE_ENDIAN1234;
	ret = TRUE1;
	break;
}

/* big endian TIFF header */
if (memcmp (&marker->data[i], beth, 4) == 0) {
	endian = G_BIG_ENDIAN4321;
	ret = TRUE1;
	break;
}
}

/* could not find header */
if (!ret)
goto out;

/* read out the offset pointer to IFD0 */
offset  = de_get32(&marker->data[i] + 4, endian);
i = i + offset;

/* check that we still are within the buffer and can read the tag count */
{
   const size_t new_i = i + 2;
   if (new_i < i || new_i > marker->data_length) {
    ret = FALSE0;
    goto out;
   }

   /* find out how many tags we have in IFD0. As per the TIFF spec, the first
      two bytes of the IFD contain a count of the number of tags. */
   tags = de_get16(&marker->data[i], endian);
   i = new_i;
}

/* check that we still have enough data for all tags to check. The tags
  are listed in consecutive 12-byte blocks. The tag ID, type, size, and
  a pointer to the actual value, are packed into these 12 byte entries. */
{
   const size_t new_i = i + tags * 12;
   if (new_i < i || new_i > marker->data_length) {
ret = FALSE0;
goto out;
   }
}

/* check through IFD0 for tags */
while (tags--) {
size_t new_i;

/* We check for integer overflow before the loop and
 * at the end of each iteration */
guint tag   = de_get16(&marker->data[i + 0], endian);
guint type  = de_get16(&marker->data[i + 2], endian);
guint count = de_get32(&marker->data[i + 4], endian);

/* orientation tag? */
if (tag == 0x112){

	/* The orientation field should consist of a single 2-byte integer,
	 * but might be a signed long.
	 * Values of types smaller than 4 bytes are stored directly in the
	 * Value Offset field */
	if (type == 0x3 && count == 1) {
		guint short_value = de_get16(&marker->data[i + 8], endian);

		context->orientation = short_value <= 8 ? short_value : 0;
	} else if (type == 0x9 && count == 1) {
		guint long_value = de_get32(&marker->data[i + 8], endian);

		context->orientation = long_value <= 8 ? long_value : 0;
	}
}
/* move the pointer to the next 12-byte tag field. */
new_i = i + 12;
if (new_i < i || new_i > marker->data_length) {
	ret = FALSE0;
	goto out;
}
i = new_i;
}

519out:
return ret;
521}

523static void
524jpeg_parse_exif (JpegExifContext *context, j_decompress_ptr cinfo)
525{
jpeg_saved_marker_ptr cmarker;

/* check for interesting Exif markers */
cmarker = cinfo->marker_list;
while (cmarker != NULL((void*)0)) {
24
←
Assuming 'cmarker' is not equal to NULL→
25
←
Loop condition is true.  Entering loop body→
49
←
Assuming 'cmarker' is not equal to NULL→
50
←
Loop condition is true.  Entering loop body→
if (cmarker->marker == JPEG_APP00xE0+1)
26
←
Assuming the condition is false→
27
←
Taking false branch→
51
←
Assuming the condition is false→
52
←
Taking false branch→
	jpeg_parse_exif_app1 (context, cmarker);
else if (cmarker->marker == JPEG_APP00xE0+2)
28
←
Assuming the condition is true→
29
←
Taking true branch→
53
←
Assuming the condition is true→
54
←
Taking true branch→
	jpeg_parse_exif_app2_segment (context, cmarker);
30
←
Calling 'jpeg_parse_exif_app2_segment'→
48
←
Returning from 'jpeg_parse_exif_app2_segment'→
55
←
Calling 'jpeg_parse_exif_app2_segment'→
cmarker = cmarker->next;
}
537}

539static gchar *
540jpeg_get_comment (j_decompress_ptr cinfo)
541{
jpeg_saved_marker_ptr cmarker;

cmarker = cinfo->marker_list;
while (cmarker != NULL((void*)0)) {
if (cmarker->marker == JPEG_COM0xFE)
	return g_strndup ((const gchar *) cmarker->data, cmarker->data_length);
cmarker = cmarker->next;
}

return NULL((void*)0);
552}

554static void
555jpeg_destroy_exif_context (JpegExifContext *context)
556{
g_free (context->icc_profile);
558}
559#endif /* !NO_MODULE_ENTRIES */

561#ifndef NO_MODULE_ENTRIES
562/* Shared library entry point */
563static CdkPixbuf *
564cdk_pixbuf__real_jpeg_image_load (FILE *f, struct jpeg_decompress_struct *cinfo, GError **error)
565{
gint   i;
char   otag_str[5];
char  *density_str;
CdkPixbuf * volatile pixbuf = NULL((void*)0);
guchar *dptr;
guchar *lines[4]; /* Used to expand rows, via rec_outbuf_height, 
                         * from the header file: 
                         * " Usually rec_outbuf_height will be 1 or 2, 
                         * at most 4."
	   */
guchar **lptr;
struct error_handler_data jerr;
stdio_src_ptr src;
gchar *icc_profile_base64;
gchar *comment;
JpegExifContext exif_context = { 0, };

/* setup error handler */
cinfo->err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = fatal_error_handler;
      jerr.pub.output_message = output_message_handler;
      jerr.error = error;
      
if (sigsetjmp (jerr.setjmp_buffer, 1)__sigsetjmp (jerr.setjmp_buffer, 1)) {
/* Whoops there was a jpeg error */
if (pixbuf)
	g_object_unref (pixbuf);

jpeg_destroy_decompress (cinfo);
jpeg_destroy_exif_context (&exif_context);

/* error should have been set by fatal_error_handler () */
return NULL((void*)0);
}

/* load header, setup */
jpeg_create_decompress (cinfo)jpeg_CreateDecompress((cinfo), 62, (size_t)sizeof(struct jpeg_decompress_struct
));

cinfo->src = (struct jpeg_source_mgr *)
 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT0,
		  sizeof (stdio_source_mgr));
src = (stdio_src_ptr) cinfo->src;
src->buffer = (JOCTET *)
 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT0,
		      JPEG_PROG_BUF_SIZE65536 * sizeof (JOCTET));

src->pub.init_source = stdio_init_source;
src->pub.fill_input_buffer = stdio_fill_input_buffer;
src->pub.skip_input_data = stdio_skip_input_data;
src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
src->pub.term_source = stdio_term_source;
src->infile = f;
src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
src->pub.next_input_byte = NULL((void*)0); /* until buffer loaded */

jpeg_save_markers (cinfo, JPEG_APP00xE0+1, 0xffff);
jpeg_save_markers (cinfo, JPEG_APP00xE0+2, 0xffff);
jpeg_save_markers (cinfo, JPEG_COM0xFE, 0xffff);
jpeg_read_header (cinfo, TRUE1);

/* parse exif data */
jpeg_parse_exif (&exif_context, cinfo);

jpeg_start_decompress (cinfo);
cinfo->do_fancy_upsampling = FALSE0;
cinfo->do_block_smoothing = FALSE0;

pixbuf = cdk_pixbuf_new (CDK_COLORSPACE_RGB, 
		 cinfo->out_color_components == 4 ? TRUE1 : FALSE0, 
		 8,
                               cinfo->output_width,
                               cinfo->output_height);
     
if (!pixbuf) {
              /* broken check for *error == NULL for robustness against
               * crappy JPEG library
               */
              if (error && *error == NULL((void*)0)) {
                      g_set_error_literal (error,
                                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                           CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                           _("Insufficient memory to load image, try exiting some applications to free memory")((char *) g_dgettext ("cdk-pixbuf", "Insufficient memory to load image, try exiting some applications to free memory"
)));
              }
             
goto out; 
}

comment = jpeg_get_comment (cinfo);
if (comment != NULL((void*)0)) {
cdk_pixbuf_set_option (pixbuf, "comment", comment);
g_free (comment);
}

switch (cinfo->density_unit) {
case 1:
/* Dots per inch (no conversion required) */
density_str = g_strdup_printf ("%d", cinfo->X_density);
cdk_pixbuf_set_option (pixbuf, "x-dpi", density_str);
g_free (density_str);
density_str = g_strdup_printf ("%d", cinfo->Y_density);
cdk_pixbuf_set_option (pixbuf, "y-dpi", density_str);
g_free (density_str);
break;
case 2:
/* Dots per cm - convert into dpi */
density_str = g_strdup_printf ("%d", DPCM_TO_DPI (cinfo->X_density)((int) round ((cinfo->X_density) * 2.54)));
cdk_pixbuf_set_option (pixbuf, "x-dpi", density_str);
g_free (density_str);
density_str = g_strdup_printf ("%d", DPCM_TO_DPI (cinfo->Y_density)((int) round ((cinfo->Y_density) * 2.54)));
cdk_pixbuf_set_option (pixbuf, "y-dpi", density_str);
g_free (density_str);
break;
}

/* if orientation tag was found */
if (exif_context.orientation != 0) {
g_snprintf (otag_str, sizeof (otag_str), "%d", exif_context.orientation);
cdk_pixbuf_set_option (pixbuf, "orientation", otag_str);
}

/* if icc profile was found */
if (exif_context.icc_profile != NULL((void*)0)) {
icc_profile_base64 = g_base64_encode ((const guchar *) exif_context.icc_profile, exif_context.icc_profile_size);
cdk_pixbuf_set_option (pixbuf, "icc-profile", icc_profile_base64);
g_free (icc_profile_base64);
}

dptr = cdk_pixbuf_get_pixels (pixbuf);

/* decompress all the lines, a few at a time */
while (cinfo->output_scanline < cinfo->output_height) {
lptr = lines;
for (i = 0; i < cinfo->rec_outbuf_height; i++) {
	*lptr++ = dptr;
	dptr += cdk_pixbuf_get_rowstride (pixbuf);
}

jpeg_read_scanlines (cinfo, lines, cinfo->rec_outbuf_height);

switch (cinfo->out_color_space) {
    case JCS_GRAYSCALE:
      explode_gray_into_buf (cinfo, lines);
      break;
    case JCS_RGB:
      /* do nothing */
      break;
    case JCS_CMYK:
      convert_cmyk_to_rgb (cinfo, lines);
      break;
    default:
      g_clear_object (&pixbuf)do { _Static_assert (sizeof *((&pixbuf)) == sizeof (gpointer
), "Expression evaluates to false"); __typeof__ (((&pixbuf
))) _pp = ((&pixbuf)); __typeof__ (*((&pixbuf))) _ptr
 = *_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref) (_ptr)
; } while (0);
                    g_set_error (error,
                                 CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
		   CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
		   _("Unsupported JPEG color space (%s)")((char *) g_dgettext ("cdk-pixbuf", "Unsupported JPEG color space (%s)"
)),
		   colorspace_name (cinfo->out_color_space));
      goto out;
}
}

726out:
jpeg_finish_decompress (cinfo);
jpeg_destroy_decompress (cinfo);
jpeg_destroy_exif_context (&exif_context);

return pixbuf;
732}
733#endif /* !NO_MODULE_ENTRIES */

735#ifndef NO_MODULE_ENTRIES
736static CdkPixbuf *
737cdk_pixbuf__jpeg_image_load (FILE *f, GError **error)
738{
      struct jpeg_decompress_struct cinfo;

      return cdk_pixbuf__real_jpeg_image_load (f, &cinfo, error);
742}
743#endif /* !NO_MODULE_ENTRIES */

745/**** Progressive image loading handling *****/

747#ifndef NO_MODULE_ENTRIES
748/* these routines required because we are acting as a source manager for */
749/* libjpeg. */
750static void
751init_source (j_decompress_ptr cinfo)
752{
my_src_ptr src = (my_src_ptr) cinfo->src;

src->skip_next = 0;
756}


759static void
760term_source (j_decompress_ptr cinfo)
761{
/* XXXX - probably should scream something has happened */
763}


766/* for progressive loading (called "I/O Suspension" by libjpeg docs) */
767/* we do nothing except return "FALSE"                               */
768static boolean
769fill_input_buffer (j_decompress_ptr cinfo)
770{
return FALSE0;
772}

774static void
775skip_input_data (j_decompress_ptr cinfo, long num_bytes)
776{
my_src_ptr src = (my_src_ptr) cinfo->src;
long   num_can_do;

/* move as far as we can into current buffer */
/* then set skip_next to catch the rest      */
if (num_bytes > 0) {
num_can_do = MIN (src->pub.bytes_in_buffer, num_bytes)(((src->pub.bytes_in_buffer) < (num_bytes)) ? (src->
pub.bytes_in_buffer) : (num_bytes));
src->pub.next_input_byte += (size_t) num_can_do;
src->pub.bytes_in_buffer -= (size_t) num_can_do;

src->skip_next = num_bytes - num_can_do;
}
789}
790#endif /* !NO_MODULE_ENTRIES */

792#ifndef NO_MODULE_ENTRIES
793/* 
* func - called when we have pixmap created (but no image data)
* user_data - passed as arg 1 to func
* return context (opaque to user)
*/
798static gpointer
799cdk_pixbuf__jpeg_image_begin_load (CdkPixbufModuleSizeFunc size_func,
		   CdkPixbufModulePreparedFunc prepared_func, 
		   CdkPixbufModuleUpdatedFunc updated_func,
		   gpointer user_data,
                                 GError **error)
804{
JpegProgContext *context;
my_source_mgr   *src;

g_assert (size_func != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_32
 = 0; if (size_func != ((void*)0)) _g_boolean_var_32 = 1; _g_boolean_var_32
; }), 1)) ; else g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 808, ((const char*) (__func__)), "size_func != NULL"); } while
 (0);
g_assert (prepared_func != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_33
 = 0; if (prepared_func != ((void*)0)) _g_boolean_var_33 = 1;
 _g_boolean_var_33; }), 1)) ; else g_assertion_message_expr (
"CdkPixbuf", "../cdk-pixbuf/io-jpeg.c", 809, ((const char*) (
__func__)), "prepared_func != NULL"); } while (0);
g_assert (updated_func != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_34
 = 0; if (updated_func != ((void*)0)) _g_boolean_var_34 = 1; _g_boolean_var_34
; }), 1)) ; else g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 810, ((const char*) (__func__)), "updated_func != NULL"); }
 while (0);

context = g_new0 (JpegProgContext, 1)(JpegProgContext *) (__extension__ ({ gsize __n = (gsize) (1)
; gsize __s = sizeof (JpegProgContext); gpointer __p; if (__s
 == 1) __p = g_malloc0 (__n); else if (__builtin_constant_p (
__n) && (__s == 0 || __n <= (9223372036854775807L *
2UL+1UL) / __s)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n
 (__n, __s); __p; }));
context->size_func = size_func;
context->prepared_func = prepared_func;
context->updated_func  = updated_func;
context->user_data = user_data;
context->pixbuf = NULL((void*)0);
context->got_header = FALSE0;
context->did_prescan = FALSE0;
context->src_initialized = FALSE0;
context->in_output = FALSE0;

      /* From jpeglib.h: "NB: you must set up the error-manager
       * BEFORE calling jpeg_create_xxx". */
context->cinfo.err = jpeg_std_error (&context->jerr.pub);
context->jerr.pub.error_exit = fatal_error_handler;
      context->jerr.pub.output_message = output_message_handler;
      context->jerr.error = error;

      if (sigsetjmp (context->jerr.setjmp_buffer, 1)__sigsetjmp (context->jerr.setjmp_buffer, 1)) {
              jpeg_destroy_decompress (&context->cinfo);
              g_free(context);
              /* error should have been set by fatal_error_handler () */
              return NULL((void*)0);
      }

/* create libjpeg structures */
jpeg_create_decompress (&context->cinfo)jpeg_CreateDecompress((&context->cinfo), 62, (size_t)sizeof
(struct jpeg_decompress_struct));

context->cinfo.src = (struct jpeg_source_mgr *) g_try_malloc (sizeof (my_source_mgr));
if (!context->cinfo.src) {
g_set_error_literal (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                   _("Couldn’t allocate memory for loading JPEG file")((char *) g_dgettext ("cdk-pixbuf", "Couldn’t allocate memory for loading JPEG file"
)));
return NULL((void*)0);
}
memset (context->cinfo.src, 0, sizeof (my_source_mgr));

src = (my_src_ptr) context->cinfo.src;
src->pub.init_source = init_source;
src->pub.fill_input_buffer = fill_input_buffer;
src->pub.skip_input_data = skip_input_data;
src->pub.resync_to_restart = jpeg_resync_to_restart;
src->pub.term_source = term_source;
src->pub.bytes_in_buffer = 0;
src->pub.next_input_byte = NULL((void*)0);

      context->jerr.error = NULL((void*)0);
      
return (gpointer) context;
862}
863#endif /* NO_MODULE_ENTRIES */

865#ifndef NO_MODULE_ENTRIES
866/*
* context - returned from image_begin_load
*
* free context, unref cdk_pixbuf
*/
871static gboolean
872cdk_pixbuf__jpeg_image_stop_load (gpointer data, GError **error)
873{
JpegProgContext *context = (JpegProgContext *) data;
struct           jpeg_decompress_struct *cinfo;
      gboolean retval;

g_return_val_if_fail (context != NULL, TRUE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_35
 = 0; if (context != ((void*)0)) _g_boolean_var_35 = 1; _g_boolean_var_35
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "context != NULL"); return (1); } }
 while (0);

cinfo = &context->cinfo;

context->jerr.error = error;
if (!sigsetjmp (context->jerr.setjmp_buffer, 1)__sigsetjmp (context->jerr.setjmp_buffer, 1)) {
/* Try to finish loading truncated files */
if (context->pixbuf &&
    cinfo->output_scanline < cinfo->output_height) {
	my_src_ptr src = (my_src_ptr) cinfo->src;

	/* But only if there's enough buffer space left */
	if (src->skip_next < sizeof(src->buffer) - 2) {
		/* Insert a fake EOI marker */
		src->buffer[src->skip_next] = (JOCTET) 0xFF;
		src->buffer[src->skip_next + 1] = (JOCTET) JPEG_EOI0xD9;
		src->pub.next_input_byte = src->buffer + src->skip_next;
		src->pub.bytes_in_buffer = 2;

		cdk_pixbuf__jpeg_image_load_lines (context, NULL((void*)0));
	}
}
}

      /* FIXME this thing needs to report errors if
       * we have unused image data
       */
      
if (context->pixbuf)
g_object_unref (context->pixbuf);

/* if we have an error? */
context->jerr.error = error;
if (sigsetjmp (context->jerr.setjmp_buffer, 1)__sigsetjmp (context->jerr.setjmp_buffer, 1)) {
              retval = FALSE0;
} else {
jpeg_finish_decompress (cinfo);
              retval = TRUE1;
}

      jpeg_destroy_decompress (&context->cinfo);

if (cinfo->src) {
my_src_ptr src = (my_src_ptr) cinfo->src;
g_free (src);
}

g_free (context);

      return retval;
928}
929#endif /* !NO_MODULE_ENTRIES */

931#ifndef NO_MODULE_ENTRIES
932static gboolean
933cdk_pixbuf__jpeg_image_load_lines (JpegProgContext  *context,
                                 GError          **error)
935{
      struct jpeg_decompress_struct *cinfo = &context->cinfo;
      guchar *lines[4];
      guchar **lptr;
      guchar *rowptr;
      gint   nlines, i;

      /* keep going until we've done all scanlines */
      while (cinfo->output_scanline < cinfo->output_height) {
              lptr = lines;
              rowptr = context->dptr;
              for (i=0; i < cinfo->rec_outbuf_height; i++) {
                      *lptr++ = rowptr;
                      rowptr += cdk_pixbuf_get_rowstride (context->pixbuf);
              }

              nlines = jpeg_read_scanlines (cinfo, lines,
                                            cinfo->rec_outbuf_height);
              if (nlines == 0)
                      break;

              switch (cinfo->out_color_space) {
              case JCS_GRAYSCALE:
                      explode_gray_into_buf (cinfo, lines);
                      break;
              case JCS_RGB:
                      /* do nothing */
                      break;
              case JCS_CMYK:
                      convert_cmyk_to_rgb (cinfo, lines);
                      break;
              default:
                      g_set_error (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                                   _("Unsupported JPEG color space (%s)")((char *) g_dgettext ("cdk-pixbuf", "Unsupported JPEG color space (%s)"
)),
                                   colorspace_name (cinfo->out_color_space));

                      return FALSE0;
              }

              context->dptr += (gsize)nlines * cdk_pixbuf_get_rowstride (context->pixbuf);

              /* send updated signal */
(* context->updated_func) (context->pixbuf,
			   0,
			   cinfo->output_scanline - 1,
			   cinfo->image_width,
			   nlines,
			   context->user_data);
      }

      return TRUE1;
988}
989#endif /* NO_MODULE_ENTRIES */

991#ifndef NO_MODULE_ENTRIES
992/*
* context - from image_begin_load
* buf - new image data
* size - length of new image data
*
* append image data onto incrementally built output image
*/
999static gboolean
1000cdk_pixbuf__jpeg_image_load_increment (gpointer data,
                                     const guchar *buf, guint size,
                                     GError **error)
1003{
JpegProgContext *context = (JpegProgContext *)data;
struct           jpeg_decompress_struct *cinfo;
my_src_ptr       src;
guint            num_left, num_copy;
guint            last_num_left, last_bytes_left;
guint            spinguard;
gboolean         first;
const guchar    *bufhd;
gint             width, height;
char             otag_str[5];
gchar 		*icc_profile_base64;
char            *density_str;
JpegExifContext  exif_context = { 0, };
gboolean	 retval;

g_return_val_if_fail (context != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_36
 = 0; if (context != ((void*)0)) _g_boolean_var_36 = 1; _g_boolean_var_36
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "context != NULL"); return (0); } }
 while (0);
1
Assuming 'context' is not equal to null→
2
←
Taking true branch→
3
←
Taking true branch→
4
←
Loop condition is false.  Exiting loop→
g_return_val_if_fail (buf != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_37
 = 0; if (buf != ((void*)0)) _g_boolean_var_37 = 1; _g_boolean_var_37
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "buf != NULL"); return (0); } } while
 (0);
5
←
Assuming 'buf' is not equal to null→
6
←
Taking true branch→
7
←
Taking true branch→
8
←
Loop condition is false.  Exiting loop→

src = (my_src_ptr) context->cinfo.src;

cinfo = &context->cinfo;

      context->jerr.error = error;
      
/* check for fatal error */
if (sigsetjmp (context->jerr.setjmp_buffer, 1)__sigsetjmp (context->jerr.setjmp_buffer, 1)) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
retval = FALSE0;
goto out;
}

num_left = size;
bufhd = buf;

if (num_left == 0) {
11
←
Assuming 'num_left' is not equal to 0→
12
←
Taking false branch→
retval = TRUE1;
goto out;
}

last_num_left = num_left;
last_bytes_left = 0;
spinguard = 0;
first = TRUE1;
while (TRUE1) {
/* skip over data if requested, handle unsigned int sizes cleanly */
/* only can happen if we've already called jpeg_get_header        */
if (context->src_initialized && src->skip_next) {
13
←
Assuming field 'src_initialized' is 0→
	if (src->skip_next >= num_left) {
		src->skip_next -= num_left;
		retval = TRUE1;
		goto out;
	} else {
		num_left -= src->skip_next;
		bufhd += src->skip_next;
		src->skip_next = 0;
	}
}

/* handle any data from caller we haven't processed yet */
if (num_left13.1
'num_left' is > 0
 > 0) {
	if(src->pub.bytes_in_buffer && 
14
←
Assuming field 'bytes_in_buffer' is 0→
	   src->pub.next_input_byte != src->buffer)
		memmove(src->buffer, src->pub.next_input_byte,
			src->pub.bytes_in_buffer);


	num_copy = MIN (JPEG_PROG_BUF_SIZE - src->pub.bytes_in_buffer,(((65536 - src->pub.bytes_in_buffer) < (num_left)) ? (65536
 - src->pub.bytes_in_buffer) : (num_left))
15
←
Assuming the condition is false→
16
←
'?' condition is false→
			num_left)(((65536 - src->pub.bytes_in_buffer) < (num_left)) ? (65536
 - src->pub.bytes_in_buffer) : (num_left));

	memcpy(src->buffer + src->pub.bytes_in_buffer, bufhd,num_copy);
	src->pub.next_input_byte = src->buffer;
	src->pub.bytes_in_buffer += num_copy;
	bufhd += num_copy;
	num_left -= num_copy;
}

              /* did anything change from last pass, if not return */
              if (first16.1
'first' is 1
) {
17
←
Taking true branch→
                      last_bytes_left = src->pub.bytes_in_buffer;
                      first = FALSE0;
              } else if (src->pub.bytes_in_buffer == last_bytes_left
	   && num_left == last_num_left) {
                      spinguard++;
} else {
                      last_bytes_left = src->pub.bytes_in_buffer;
	last_num_left = num_left;
}

/* should not go through twice and not pull bytes out of buf */
if (spinguard17.1
'spinguard' is <= 2
 > 2) {
18
←
Taking false branch→
	retval = TRUE1;
	goto out;
}

/* try to load jpeg header */
if (!context->got_header) {
19
←
Assuming field 'got_header' is 0→
20
←
Taking true branch→
	int rc;
	gchar* comment;
	gboolean has_alpha;

	jpeg_save_markers (cinfo, JPEG_APP00xE0+1, 0xffff);
	jpeg_save_markers (cinfo, JPEG_APP00xE0+2, 0xffff);
	jpeg_save_markers (cinfo, JPEG_COM0xFE, 0xffff);
	rc = jpeg_read_header (cinfo, TRUE1);
	context->src_initialized = TRUE1;

                      /* Limit to 1GB to avoid OOM with large images */
                      cinfo->mem->max_memory_to_use = 1024 * 1024 * 1024;
	
	if (rc == JPEG_SUSPENDED0)
21
←
Assuming 'rc' is not equal to JPEG_SUSPENDED→
22
←
Taking false branch→
		continue;
	
	context->got_header = TRUE1;

	/* parse exif data */
	jpeg_parse_exif (&exif_context, cinfo);
23
←
Calling 'jpeg_parse_exif'→

	width = cinfo->image_width;
	height = cinfo->image_height;
	(* context->size_func) (&width, &height, context->user_data);
	if (width == 0 || height == 0) {
		g_set_error_literal (error,
				     CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
				     CDK_PIXBUF_ERROR_CORRUPT_IMAGE,
				     _("Transformed JPEG has zero width or height.")((char *) g_dgettext ("cdk-pixbuf", "Transformed JPEG has zero width or height."
)));
		retval = FALSE0;
		goto out;
	}
	
	cinfo->scale_num = 1;
	for (cinfo->scale_denom = 2; cinfo->scale_denom <= 8; cinfo->scale_denom *= 2) {
		jpeg_calc_output_dimensions (cinfo);
		if (cinfo->output_width < width || cinfo->output_height < height) {
			cinfo->scale_denom /= 2;
			break;
		}
	}
	jpeg_calc_output_dimensions (cinfo);

	if (cinfo->output_components == 3) {
		has_alpha = FALSE0;
	} else if (cinfo->output_components == 4) {
		has_alpha = TRUE1;
	} else if (cinfo->output_components == 1 &&
		   cinfo->out_color_space == JCS_GRAYSCALE) {
		has_alpha = FALSE0;
	} else {
		g_set_error (error,
			     CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
			     CDK_PIXBUF_ERROR_CORRUPT_IMAGE,
			     _("Unsupported number of color components (%d)")((char *) g_dgettext ("cdk-pixbuf", "Unsupported number of color components (%d)"
)),
			     cinfo->output_components);
		retval = FALSE0;
		goto out;
	}

	context->pixbuf = cdk_pixbuf_new (CDK_COLORSPACE_RGB,
					  has_alpha,
					  8,
					  cinfo->output_width,
					  cinfo->output_height);

	if (context->pixbuf == NULL((void*)0)) {
                              g_set_error_literal (error,
                                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                                   CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                                   _("Couldn’t allocate memory for loading JPEG file")((char *) g_dgettext ("cdk-pixbuf", "Couldn’t allocate memory for loading JPEG file"
)));
                              retval = FALSE0;
		goto out;
	}

	comment = jpeg_get_comment (cinfo);
	if (comment != NULL((void*)0)) {
		cdk_pixbuf_set_option (context->pixbuf, "comment", comment);
		g_free (comment);
	}

	switch (cinfo->density_unit) {
	case 1:
		/* Dots per inch (no conversion required) */
		density_str = g_strdup_printf ("%d", cinfo->X_density);
		cdk_pixbuf_set_option (context->pixbuf, "x-dpi", density_str);
		g_free (density_str);
		density_str = g_strdup_printf ("%d", cinfo->Y_density);
		cdk_pixbuf_set_option (context->pixbuf, "y-dpi", density_str);
		g_free (density_str);
		break;
	case 2:
		/* Dots per cm - convert into dpi */
		density_str = g_strdup_printf ("%d", DPCM_TO_DPI (cinfo->X_density)((int) round ((cinfo->X_density) * 2.54)));
		cdk_pixbuf_set_option (context->pixbuf, "x-dpi", density_str);
		g_free (density_str);
		density_str = g_strdup_printf ("%d", DPCM_TO_DPI (cinfo->Y_density)((int) round ((cinfo->Y_density) * 2.54)));
		cdk_pixbuf_set_option (context->pixbuf, "y-dpi", density_str);
		g_free (density_str);
		break;
	}

        /* if orientation tag was found set an option to remember its value */
	if (exif_context.orientation != 0) {
		g_snprintf (otag_str, sizeof (otag_str), "%d", exif_context.orientation);
                cdk_pixbuf_set_option (context->pixbuf, "orientation", otag_str);
        }
	/* if icc profile was found */
	if (exif_context.icc_profile != NULL((void*)0)) {
		icc_profile_base64 = g_base64_encode ((const guchar *) exif_context.icc_profile, exif_context.icc_profile_size);
		cdk_pixbuf_set_option (context->pixbuf, "icc-profile", icc_profile_base64);
		g_free (icc_profile_base64);
	}


	/* Use pixbuf buffer to store decompressed data */
	context->dptr = cdk_pixbuf_get_pixels (context->pixbuf);
	
	/* Notify the client that we are ready to go */
	(* context->prepared_func) (context->pixbuf,
				    NULL((void*)0),
				    context->user_data);
	
} else if (!context->did_prescan) {
	int rc;			
	
	/* start decompression */
	cinfo->buffered_image = cinfo->progressive_mode;
	rc = jpeg_start_decompress (cinfo);
	cinfo->do_fancy_upsampling = FALSE0;
	cinfo->do_block_smoothing = FALSE0;

	if (rc == JPEG_SUSPENDED0)
		continue;

	context->did_prescan = TRUE1;
} else if (!cinfo->buffered_image) {
                      /* we're decompressing unbuffered so
                       * simply get scanline by scanline from jpeg lib
                       */
                      if (! cdk_pixbuf__jpeg_image_load_lines (context,
                                                               error)) {
                              retval = FALSE0;
		goto out;
	}

	if (cinfo->output_scanline >= cinfo->output_height) {
		retval = TRUE1;
		goto out;
	}
} else {
                      /* we're decompressing buffered (progressive)
                       * so feed jpeg lib scanlines
                       */

	/* keep going until we've done all passes */
	while (!jpeg_input_complete (cinfo)) {
		if (!context->in_output) {
			if (jpeg_start_output (cinfo, cinfo->input_scan_number)) {
				context->in_output = TRUE1;
				context->dptr = cdk_pixbuf_get_pixels (context->pixbuf);
			}
			else
				break;
		}

                              /* get scanlines from jpeg lib */
                              if (! cdk_pixbuf__jpeg_image_load_lines (context,
                                                                       error)) {
                                      retval = FALSE0;
			goto out;
		}

		if (cinfo->output_scanline >= cinfo->output_height &&
		    jpeg_finish_output (cinfo))
			context->in_output = FALSE0;
		else
			break;
	}
	if (jpeg_input_complete (cinfo)) {
		/* did entire image */
		retval = TRUE1;
		goto out;
	}
	else
		continue;
}
}
1287out:
jpeg_destroy_exif_context (&exif_context);
return retval;
1290}
1291#endif /* !NO_MODULE_ENTRIES */

1293/* Save */

1295#define TO_FUNCTION_BUF_SIZE4096 4096

1297typedef struct {
struct jpeg_destination_mgr pub;
JOCTET             *buffer;
CdkPixbufSaveFunc   save_func;
gpointer            user_data;
GError            **error;
1303} ToFunctionDestinationManager;

1305void
1306to_callback_init (j_compress_ptr cinfo)
1307{
ToFunctionDestinationManager *destmgr;

destmgr	= (ToFunctionDestinationManager*) cinfo->dest;
destmgr->pub.next_output_byte = destmgr->buffer;
destmgr->pub.free_in_buffer = TO_FUNCTION_BUF_SIZE4096;
1313}

1315static void
1316to_callback_do_write (j_compress_ptr cinfo, gsize length)
1317{
ToFunctionDestinationManager *destmgr;

destmgr	= (ToFunctionDestinationManager*) cinfo->dest;
      if (!destmgr->save_func ((gchar *)destmgr->buffer,
		 length,
		 destmgr->error,
		 destmgr->user_data)) {
struct error_handler_data *errmgr;
      
errmgr = (struct error_handler_data *) cinfo->err;
/* Use a default error message if the callback didn't set one,
 * which it should have.
 */
if (errmgr->error && *errmgr->error == NULL((void*)0)) {
	g_set_error_literal (errmgr->error,
                                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                           CDK_PIXBUF_ERROR_CORRUPT_IMAGE,
                                           "write function failed");
}
siglongjmp (errmgr->setjmp_buffer, 1);
g_assert_not_reached ()do { g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 1338, ((const char*) (__func__)), ((void*)0)); } while (0);
      }
1340}

1342static boolean
1343to_callback_empty_output_buffer (j_compress_ptr cinfo)
1344{
ToFunctionDestinationManager *destmgr;

destmgr	= (ToFunctionDestinationManager*) cinfo->dest;
to_callback_do_write (cinfo, TO_FUNCTION_BUF_SIZE4096);
destmgr->pub.next_output_byte = destmgr->buffer;
destmgr->pub.free_in_buffer = TO_FUNCTION_BUF_SIZE4096;
return TRUE1;
1352}

1354void
1355to_callback_terminate (j_compress_ptr cinfo)
1356{
ToFunctionDestinationManager *destmgr;

destmgr	= (ToFunctionDestinationManager*) cinfo->dest;
to_callback_do_write (cinfo, TO_FUNCTION_BUF_SIZE4096 - destmgr->pub.free_in_buffer);
1361}

1363static gboolean
1364real_save_jpeg (CdkPixbuf          *pixbuf,
gchar             **keys,
gchar             **values,
GError            **error,
gboolean            to_callback,
FILE               *f,
CdkPixbufSaveFunc   save_func,
gpointer            user_data)
1372{
      /* FIXME error handling is broken */
      
     struct jpeg_compress_struct cinfo;
     guchar *buf = NULL((void*)0);
     guchar *ptr;
     guchar *pixels = NULL((void*)0);
     JSAMPROW *jbuf;
     volatile int quality = 75; /* default; must be between 0 and 100 */
     int i, j;
     int w, h = 0;
     int rowstride = 0;
     int n_channels;
     struct error_handler_data jerr;
     ToFunctionDestinationManager to_callback_destmgr;
     int x_density = 0;
     int y_density = 0;
     gchar *icc_profile = NULL((void*)0);
     gchar *data;
     gint retval = TRUE1;
     gsize icc_profile_size = 0;

     to_callback_destmgr.buffer = NULL((void*)0);

     if (keys && *keys) {
             gchar **kiter = keys;
             gchar **viter = values;

             while (*kiter) {
                     if (strcmp (*kiter, "quality") == 0) {
                             char *endptr = NULL((void*)0);
                             quality = strtol (*viter, &endptr, 10);

                             if (endptr == *viter) {
                                     g_set_error (error,
                                                  CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                                  CDK_PIXBUF_ERROR_BAD_OPTION,
                                                  _("JPEG quality must be a value between 0 and 100; value “%s” could not be parsed.")((char *) g_dgettext ("cdk-pixbuf", "JPEG quality must be a value between 0 and 100; value “%s” could not be parsed."
)),
                                                  *viter);

                                     retval = FALSE0;
                                     goto cleanup;
                             }
                             
                             if (quality < 0 ||
                                 quality > 100) {
                                     /* This is a user-visible error;
                                      * lets people skip the range-checking
                                      * in their app.
                                      */
                                     g_set_error (error,
                                                  CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                                  CDK_PIXBUF_ERROR_BAD_OPTION,
                                                  _("JPEG quality must be a value between 0 and 100; value “%d” is not allowed.")((char *) g_dgettext ("cdk-pixbuf", "JPEG quality must be a value between 0 and 100; value “%d” is not allowed."
)),
                                                  quality);

                                     retval = FALSE0;
                                     goto cleanup;
                             }
                     } else if (strcmp (*kiter, "x-dpi") == 0) {
                             char *endptr = NULL((void*)0);
                             x_density = strtol (*viter, &endptr, 10);
                             if (endptr == *viter)
                                     x_density = -1;

                             if (x_density <= 0 ||
                                 x_density > 65535) {
                                     /* This is a user-visible error;
                                      * lets people skip the range-checking
                                      * in their app.
                                      */
                                     g_set_error (error,
                                                  CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                                  CDK_PIXBUF_ERROR_BAD_OPTION,
                                                  _("JPEG x-dpi must be a value between 1 and 65535; value “%s” is not allowed.")((char *) g_dgettext ("cdk-pixbuf", "JPEG x-dpi must be a value between 1 and 65535; value “%s” is not allowed."
)),
                                                  *viter);

                                     retval = FALSE0;
                                     goto cleanup;
                             }
                     } else if (strcmp (*kiter, "y-dpi") == 0) {
                             char *endptr = NULL((void*)0);
                             y_density = strtol (*viter, &endptr, 10);
                             if (endptr == *viter)
                                     y_density = -1;

                             if (y_density <= 0 ||
                                 y_density > 65535) {
                                     /* This is a user-visible error;
                                      * lets people skip the range-checking
                                      * in their app.
                                      */
                                     g_set_error (error,
                                                  CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                                  CDK_PIXBUF_ERROR_BAD_OPTION,
                                                  _("JPEG y-dpi must be a value between 1 and 65535; value “%s” is not allowed.")((char *) g_dgettext ("cdk-pixbuf", "JPEG y-dpi must be a value between 1 and 65535; value “%s” is not allowed."
)),
                                                  *viter);

                                     retval = FALSE0;
                                     goto cleanup;
                             }
                     } else if (strcmp (*kiter, "icc-profile") == 0) {
                             /* decode from base64 */
                             icc_profile = (gchar*) g_base64_decode (*viter, &icc_profile_size);
                             if (icc_profile_size < 127) {
                                     /* This is a user-visible error */
                                     g_set_error (error,
                                                  CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                                  CDK_PIXBUF_ERROR_BAD_OPTION,
                                                  _("Color profile has invalid length “%u”.")((char *) g_dgettext ("cdk-pixbuf", "Color profile has invalid length “%u”."
)),
                                                  (guint) icc_profile_size);
                                     retval = FALSE0;
                                     goto cleanup;
                             }
                     } else {
                             g_warning ("Unrecognized parameter (%s) passed to JPEG saver.", *kiter);
                     }
             
                     ++kiter;
                     ++viter;
             }
     }
     
     rowstride = cdk_pixbuf_get_rowstride (pixbuf);
     n_channels = cdk_pixbuf_get_n_channels (pixbuf);

     w = cdk_pixbuf_get_width (pixbuf);
     h = cdk_pixbuf_get_height (pixbuf);
     pixels = cdk_pixbuf_get_pixels (pixbuf);

     /* Guaranteed by the caller. */
     g_assert (w >= 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_38
 = 0; if (w >= 0) _g_boolean_var_38 = 1; _g_boolean_var_38
; }), 1)) ; else g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 1503, ((const char*) (__func__)), "w >= 0"); } while (0);
     g_assert (h >= 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_39
 = 0; if (h >= 0) _g_boolean_var_39 = 1; _g_boolean_var_39
; }), 1)) ; else g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 1504, ((const char*) (__func__)), "h >= 0"); } while (0);
     g_assert (rowstride >= 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_40
 = 0; if (rowstride >= 0) _g_boolean_var_40 = 1; _g_boolean_var_40
; }), 1)) ; else g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 1505, ((const char*) (__func__)), "rowstride >= 0"); } while
 (0);
     g_assert (n_channels >= 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_41
 = 0; if (n_channels >= 0) _g_boolean_var_41 = 1; _g_boolean_var_41
; }), 1)) ; else g_assertion_message_expr ("CdkPixbuf", "../cdk-pixbuf/io-jpeg.c"
, 1506, ((const char*) (__func__)), "n_channels >= 0"); } while
 (0);

     /* Allocate a small buffer to convert image data,
* and a larger buffer if doing to_callback save.
*/
     buf = g_try_malloc (w * 3 * sizeof (guchar));
     if (!buf) {
      g_set_error_literal (error,
                                  CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                  CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                  _("Couldn’t allocate memory for loading JPEG file")((char *) g_dgettext ("cdk-pixbuf", "Couldn’t allocate memory for loading JPEG file"
)));
      retval = FALSE0;
      goto cleanup;
     }
     if (to_callback) {
      to_callback_destmgr.buffer = g_try_malloc (TO_FUNCTION_BUF_SIZE4096);
      if (!to_callback_destmgr.buffer) {
       g_set_error_literal (error,
                                          CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                          CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                          _("Couldn’t allocate memory for loading JPEG file")((char *) g_dgettext ("cdk-pixbuf", "Couldn’t allocate memory for loading JPEG file"
)));
       retval = FALSE0;
       goto cleanup;
      }
     }

     /* set up error handling */
     cinfo.err = jpeg_std_error (&(jerr.pub));
     jerr.pub.error_exit = fatal_error_handler;
     jerr.pub.output_message = output_message_handler;
     jerr.error = error;
     
     if (sigsetjmp (jerr.setjmp_buffer, 1)__sigsetjmp (jerr.setjmp_buffer, 1)) {
             jpeg_destroy_compress (&cinfo);
      retval = FALSE0;
      goto cleanup;
     }

     /* setup compress params */
     jpeg_create_compress (&cinfo)jpeg_CreateCompress((&cinfo), 62, (size_t)sizeof(struct jpeg_compress_struct
));
     if (to_callback) {
      to_callback_destmgr.pub.init_destination    = to_callback_init;
      to_callback_destmgr.pub.empty_output_buffer = to_callback_empty_output_buffer;
      to_callback_destmgr.pub.term_destination    = to_callback_terminate;
      to_callback_destmgr.error = error;
      to_callback_destmgr.save_func = save_func;
      to_callback_destmgr.user_data = user_data;
      cinfo.dest = (struct jpeg_destination_mgr*) &to_callback_destmgr;
     } else {
      jpeg_stdio_dest (&cinfo, f);
     }
     cinfo.image_width      = w;
     cinfo.image_height     = h;
     cinfo.input_components = 3; 
     cinfo.in_color_space   = JCS_RGB;

     /* set up jepg compression parameters */
     jpeg_set_defaults (&cinfo);
     jpeg_set_quality (&cinfo, quality, TRUE1);

     /* set density information */
     if (x_density > 0 && y_density > 0) {
         cinfo.density_unit = 1; /* Dots per inch */
         cinfo.X_density = x_density;
         cinfo.Y_density = y_density;
     }

     jpeg_start_compress (&cinfo, TRUE1);

/* write ICC profile data */
if (icc_profile != NULL((void*)0)) {
/* optimise for the common case where only one APP2 segment is required */
if (icc_profile_size < 0xffef) {
	data = g_new (gchar, icc_profile_size + 14)(gchar *) (__extension__ ({ gsize __n = (gsize) (icc_profile_size
 + 14); gsize __s = sizeof (gchar); gpointer __p; if (__s == 1
) __p = g_malloc (__n); else if (__builtin_constant_p (__n) &&
 (__s == 0 || __n <= (9223372036854775807L *2UL+1UL) / __s
)) __p = g_malloc (__n * __s); else __p = g_malloc_n (__n, __s
); __p; }));
	memcpy (data, "ICC_PROFILE\000\001\001", 14);
	memcpy (data + 14, icc_profile, icc_profile_size);
	jpeg_write_marker (&cinfo, JPEG_APP00xE0+2, (const JOCTET *) data, icc_profile_size + 14);
	g_free (data);
} else {
	guint segments;
	guint size = 0xffef;
	guint offset;

	segments = (guint) ceilf ((gfloat) icc_profile_size / (gfloat) 0xffef);
	data = g_new (gchar, 0xffff)(gchar *) (__extension__ ({ gsize __n = (gsize) (0xffff); gsize
 __s = sizeof (gchar); gpointer __p; if (__s == 1) __p = g_malloc
 (__n); else if (__builtin_constant_p (__n) && (__s ==
|| __n <= (9223372036854775807L *2UL+1UL) / __s)) __p =
 g_malloc (__n * __s); else __p = g_malloc_n (__n, __s); __p;
 }));
	memcpy (data, "ICC_PROFILE\000", 12);
	data[13] = segments;
	for (i=0; i<=segments; i++) {
		data[12] = i;
		offset = 0xffef * i;

		/* last segment */
		if (i == segments)
			size = icc_profile_size % 0xffef;

		memcpy (data + 14, icc_profile + offset, size);
		jpeg_write_marker (&cinfo, JPEG_APP00xE0+2, (const JOCTET *) data, size + 14);
	}
	g_free (data);
}
}

     /* get the start pointer */
     ptr = pixels;
     /* go one scanline at a time... and save */
     i = 0;
     while (cinfo.next_scanline < cinfo.image_height) {
             /* convert scanline from ARGB to RGB packed */
             for (j = 0; j < w; j++)
                     memcpy (&(buf[j*3]), &(ptr[(gsize)i*rowstride + j*n_channels]), 3);

             /* write scanline */
             jbuf = (JSAMPROW *)(&buf);
             if (jpeg_write_scanlines (&cinfo, jbuf, 1) == 0) {
                    jpeg_destroy_compress (&cinfo);
                    retval = FALSE0;
                    goto cleanup;
             }

             i++;

     }

     /* finish off */
     jpeg_finish_compress (&cinfo);
     jpeg_destroy_compress(&cinfo);
1632cleanup:
g_free (buf);
g_free (to_callback_destmgr.buffer);
g_free (icc_profile);
return retval;
1637}

1639static gboolean
1640cdk_pixbuf__jpeg_image_save (FILE          *f, 
                           CdkPixbuf     *pixbuf, 
                           gchar        **keys,
                           gchar        **values,
                           GError       **error)
1645{
return real_save_jpeg (pixbuf, keys, values, error,
	       FALSE0, f, NULL((void*)0), NULL((void*)0));
1648}

1650static gboolean
1651cdk_pixbuf__jpeg_image_save_to_callback (CdkPixbufSaveFunc   save_func,
			 gpointer            user_data,
			 CdkPixbuf          *pixbuf, 
			 gchar             **keys,
			 gchar             **values,
			 GError            **error)
1657{
return real_save_jpeg (pixbuf, keys, values, error,
	       TRUE1, NULL((void*)0), save_func, user_data);
1660}

1662static gboolean
1663cdk_pixbuf__jpeg_is_save_option_supported (const gchar *option_key)
1664{
      if (g_strcmp0 (option_key, "quality") == 0 ||
          g_strcmp0 (option_key, "icc-profile") == 0)
              return TRUE1;

      return FALSE0;
1670}

1672#ifndef NO_MODULE_ENTRIES

1674#ifndef INCLUDE_jpeg1
1675#define MODULE_ENTRY(function)void _cdk_pixbuf__jpeg_function G_MODULE_EXPORT__attribute__((visibility("default"))) void function
1676#else
1677#define MODULE_ENTRY(function)void _cdk_pixbuf__jpeg_function void _cdk_pixbuf__jpeg_ ## function
1678#endif

1680MODULE_ENTRY (fill_vtable)void _cdk_pixbuf__jpeg_fill_vtable (CdkPixbufModule *module)
1681{
module->load = cdk_pixbuf__jpeg_image_load;
module->begin_load = cdk_pixbuf__jpeg_image_begin_load;
module->stop_load = cdk_pixbuf__jpeg_image_stop_load;
module->load_increment = cdk_pixbuf__jpeg_image_load_increment;
module->save = cdk_pixbuf__jpeg_image_save;
module->save_to_callback = cdk_pixbuf__jpeg_image_save_to_callback;
      module->is_save_option_supported = cdk_pixbuf__jpeg_is_save_option_supported;
1689}

1691MODULE_ENTRY (fill_info)void _cdk_pixbuf__jpeg_fill_info (CdkPixbufFormat *info)
1692{
static const CdkPixbufModulePattern signature[] = {
{ "\xff\xd8", NULL((void*)0), 100 },
{ NULL((void*)0), NULL((void*)0), 0 }
};
static const gchar *mime_types[] = {
"image/jpeg",
NULL((void*)0)
};
static const gchar *extensions[] = {
"jpeg",
"jpe",
"jpg",
NULL((void*)0)
};

info->name = "jpeg";
info->signature = (CdkPixbufModulePattern *) signature;
info->description = NC_("image format", "JPEG")("JPEG");
info->mime_types = (gchar **) mime_types;
info->extensions = (gchar **) extensions;
info->flags = CDK_PIXBUF_FORMAT_WRITABLE | CDK_PIXBUF_FORMAT_THREADSAFE;
info->license = "LGPL";
1715}

1717#endif