Initial revision

1 files changed, 621 insertions, 0 deletions

diff --git a/jpegtools.c b/jpegtools.c
new file mode 100644
index 0000000..90ac7dd
--- /dev/null
+++ b/jpegtools.c
@@ -0,0 +1,621 @@
+/*
+ * jpegtran.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ * 
+ * plenty of changes by Gerd Knorr <kraxel@bytesex.org>, with focus on
+ * digital image processing and sane exif handling:
+ *
+ *   - does transformations only (flip/rotate/transpose/transverse).
+ *   - also transforms the exif thumbnail if present.
+ *   - can automatically figure transformation from the
+ *     exif orientation tag.
+ *   - updates the exif orientation tag.
+ *   - updates the exif pixel dimension tags.
+ *
+ * This file contains a command-line user interface for JPEG transcoding.
+ * It is very similar to cjpeg.c, but provides lossless transcoding between
+ * different JPEG file formats.  It also provides some lossless and sort-of-
+ * lossless transformations of JPEG data.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <utime.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <jpeglib.h>
+#include "jpeg/transupp.h"		/* Support routines for jpegtran */
+#include "jpegtools.h"
+
+#include "misc.h"
+
+#include <libexif/exif-data.h>
+#include <libexif/exif-utils.h>
+#include <libexif/exif-ifd.h>
+#include <libexif/exif-tag.h>
+
+static int do_transform(struct jpeg_decompress_struct *src,
+			struct jpeg_compress_struct   *dst,
+			JXFORM_CODE transform,
+			unsigned char *comment,
+			char *thumbnail, int tsize,
+			unsigned int flags);
+
+static JXFORM_CODE transmagic[] = {
+    [ 1 ] = JXFORM_NONE,
+    [ 2 ] = JXFORM_FLIP_H,
+    [ 3 ] = JXFORM_ROT_180,
+    [ 4 ] = JXFORM_FLIP_V,
+    [ 5 ] = JXFORM_TRANSPOSE,
+    [ 6 ] = JXFORM_ROT_90,
+    [ 7 ] = JXFORM_TRANSVERSE,
+    [ 8 ] = JXFORM_ROT_270,
+};
+
+#if 0
+static char *transname[] = {
+    [ JXFORM_NONE ]       = "none",
+    [ JXFORM_FLIP_H ]     = "flip h",
+    [ JXFORM_FLIP_V ]     = "flip v",
+    [ JXFORM_TRANSPOSE ]  = "transpose",
+    [ JXFORM_TRANSVERSE ] = "transverse",
+    [ JXFORM_ROT_90 ]     = "rot 90",
+    [ JXFORM_ROT_180 ]    = "rot 190",
+    [ JXFORM_ROT_270 ]    = "rot 270",
+};
+#endif
+
+/* ---------------------------------------------------------------------- */
+
+/* libjpeg error handler -- exit via longjump */
+struct longjmp_error_mgr {
+    struct jpeg_error_mgr jpeg;
+    jmp_buf setjmp_buffer;
+};
+
+static void longjmp_error_exit(j_common_ptr cinfo)
+{
+    struct longjmp_error_mgr *h = (struct longjmp_error_mgr*)cinfo->err;
+    (*cinfo->err->output_message)(cinfo);
+    longjmp(h->setjmp_buffer, 1);
+}
+
+/* ---------------------------------------------------------------------- */
+
+static long get_int(ExifData *ed, ExifEntry *ee)
+{
+    ExifByteOrder o = exif_data_get_byte_order(ed);
+    long value;
+    
+    switch (ee->format) {
+    case EXIF_FORMAT_SHORT:
+	value = exif_get_short (ee->data, o);
+	break;
+    case EXIF_FORMAT_LONG:
+	value = exif_get_long (ee->data, o);
+	break;
+    case EXIF_FORMAT_SLONG:
+	value = exif_get_slong (ee->data, o);
+	break;
+    default:
+	fprintf(stderr,"get_int oops\n");
+	exit(1);
+    }
+    return value;
+}
+
+static void set_int(ExifData *ed, ExifEntry *ee, long value)
+{
+    ExifByteOrder o = exif_data_get_byte_order(ed);
+
+    switch (ee->format) {
+    case EXIF_FORMAT_SHORT:
+	exif_set_short (ee->data, o, value);
+	break;
+    case EXIF_FORMAT_LONG:
+	exif_set_long (ee->data, o, value);
+	break;
+    case EXIF_FORMAT_SLONG:
+	exif_set_slong (ee->data, o, value);
+	break;
+    default:
+	fprintf(stderr,"set_int oops\n");
+	exit(1);
+    }
+}
+
+static void update_orientation(ExifData *ed, int ifd, int orientation)
+{
+    ExifEntry *ee;
+
+    ee = exif_content_get_entry(ed->ifd[ifd], 0x0112);
+    if (NULL == ee)
+	return;
+    set_int(ed,ee,orientation);
+}
+
+static void update_dimension(ExifData *ed, JXFORM_CODE transform,
+			     int src_x, int src_y)
+{
+    static struct {
+	int idf;
+	int tag;
+	int x;
+    } fields[] = {
+	{
+	    .idf = EXIF_IFD_EXIF,
+	    .tag = EXIF_TAG_PIXEL_X_DIMENSION,
+	    .x   = 1,
+	},{
+	    .idf = EXIF_IFD_EXIF,
+	    .tag = EXIF_TAG_PIXEL_Y_DIMENSION,
+	    .x   = 0,
+	},{
+	    .idf = EXIF_IFD_INTEROPERABILITY,
+	    .tag = EXIF_TAG_RELATED_IMAGE_WIDTH,
+	    .x   = 1,
+	},{
+	    .idf = EXIF_IFD_INTEROPERABILITY,
+	    .tag = EXIF_TAG_RELATED_IMAGE_LENGTH,
+	    .x   = 0,
+	}
+    };
+    ExifEntry *ee;
+    int i;
+
+    for (i = 0; i < sizeof(fields)/sizeof(fields[0]); i++) {
+	ee = exif_content_get_entry(ed->ifd[fields[i].idf], fields[i].tag);
+	if (!ee)
+	    continue;
+	switch (transform) {
+	case JXFORM_ROT_90:
+	case JXFORM_ROT_270:
+	case JXFORM_TRANSPOSE:
+	case JXFORM_TRANSVERSE:
+	    /* x/y reversed */
+	    set_int(ed, ee, fields[i].x ? src_y : src_x);
+	    break;
+	default:
+	    /* normal */
+	    set_int(ed, ee, fields[i].x ? src_x : src_y);
+	    break;
+	}
+    }
+}
+
+static int get_orientation(ExifData *ed)
+{
+    ExifEntry *ee;
+
+    ee = exif_content_get_entry(ed->ifd[EXIF_IFD_0], 0x0112);
+    if (NULL == ee)
+	return 1; /* top - left */
+    return get_int(ed,ee);
+}
+
+/* ---------------------------------------------------------------------- */
+
+struct th {
+    struct jpeg_decompress_struct src;
+    struct jpeg_compress_struct   dst;
+    struct jpeg_error_mgr jsrcerr, jdsterr;
+    unsigned char *in;
+    unsigned char *out;
+    int isize, osize;
+};
+
+static void thumbnail_src_init(struct jpeg_decompress_struct *cinfo)
+{
+    struct th *h  = container_of(cinfo, struct th, src);
+    cinfo->src->next_input_byte = h->in;
+    cinfo->src->bytes_in_buffer = h->isize;
+}
+
+static int thumbnail_src_fill(struct jpeg_decompress_struct *cinfo)
+{
+    fprintf(stderr,"jpeg: panic: no more thumbnail input data\n");
+    exit(1);
+}
+
+static void thumbnail_src_skip(struct jpeg_decompress_struct *cinfo,
+			       long num_bytes)
+{
+    cinfo->src->next_input_byte += num_bytes;
+}
+
+static void thumbnail_src_term(struct jpeg_decompress_struct *cinfo)
+{
+    /* nothing */
+}
+
+static void thumbnail_dest_init(struct jpeg_compress_struct *cinfo)
+{
+    struct th *h  = container_of(cinfo, struct th, dst);
+    h->osize = h->isize * 2;
+    h->out   = malloc(h->osize);
+    cinfo->dest->next_output_byte = h->out;
+    cinfo->dest->free_in_buffer   = h->osize;
+}
+
+static boolean thumbnail_dest_flush(struct jpeg_compress_struct *cinfo)
+{
+    fprintf(stderr,"jpeg: panic: output buffer full\n");
+    exit(1);
+}
+
+static void thumbnail_dest_term(struct jpeg_compress_struct *cinfo)
+{
+    struct th *h  = container_of(cinfo, struct th, dst);
+    h->osize -= cinfo->dest->free_in_buffer;
+}
+
+static struct jpeg_source_mgr thumbnail_src = {
+    .init_source         = thumbnail_src_init,
+    .fill_input_buffer   = thumbnail_src_fill,
+    .skip_input_data     = thumbnail_src_skip,
+    .resync_to_restart   = jpeg_resync_to_restart,
+    .term_source         = thumbnail_src_term,
+};
+
+static struct jpeg_destination_mgr thumbnail_dst = {
+    .init_destination    = thumbnail_dest_init,
+    .empty_output_buffer = thumbnail_dest_flush,
+    .term_destination    = thumbnail_dest_term,
+};
+
+static void do_thumbnail(ExifData *ed, JXFORM_CODE transform)
+{
+    struct th th;
+
+    if (JXFORM_NONE == transform)
+	return;
+    
+    memset(&th,0,sizeof(th));
+    th.in    = ed->data;
+    th.isize = ed->size;
+    
+    /* setup src */
+    th.src.err = jpeg_std_error(&th.jsrcerr);
+    jpeg_create_decompress(&th.src);
+    th.src.src = &thumbnail_src;
+    
+    /* setup dst */
+    th.dst.err = jpeg_std_error(&th.jdsterr);
+    jpeg_create_compress(&th.dst);
+    th.dst.dest = &thumbnail_dst;
+
+    /* transform image */
+    do_transform(&th.src,&th.dst,transform,NULL,NULL,0,JFLAG_TRANSFORM_IMAGE);
+
+    /* cleanup */
+    jpeg_destroy_decompress(&th.src);
+    jpeg_destroy_compress(&th.dst);
+
+    /* replace thumbnail */
+    free(ed->data);
+    ed->data = th.out;
+    ed->size = th.osize;
+}
+
+static void do_exif(struct jpeg_decompress_struct *src,
+		    JXFORM_CODE *transform,
+		    char *thumbnail, int tsize,
+		    unsigned int flags)
+{
+    jpeg_saved_marker_ptr mark;
+    ExifData *ed = NULL;
+    unsigned char *data;
+    unsigned int  size;
+    
+    for (mark = src->marker_list; NULL != mark; mark = mark->next) {
+	if (mark->marker != JPEG_APP0 +1)
+	    continue;
+	ed = exif_data_new_from_data(mark->data,mark->data_length);
+	break;
+    }
+    if (flags & JFLAG_UPDATE_THUMBNAIL) {
+	if (NULL == ed)
+	    ed = exif_data_new();
+	if (NULL == mark) {
+	    mark = src->mem->alloc_large((j_common_ptr)src,JPOOL_IMAGE,sizeof(*mark));
+	    memset(mark,0,sizeof(*mark));
+	    mark->marker = JPEG_APP0 +1;
+	    mark->next   = src->marker_list->next;
+	    src->marker_list->next = mark;
+	}
+	if (ed->data)
+	    free(ed->data);
+	ed->data = thumbnail;
+	ed->size = tsize;
+    }
+    if (NULL == ed)
+	return;
+
+    if (-1 == *transform) {
+	/* automagic image transformation */
+	int orientation = get_orientation(ed);
+	*transform = JXFORM_NONE;
+	if (orientation >= 1 && orientation <= 8)
+	    *transform = transmagic[orientation];
+#if 0
+	if (debug)
+	    fprintf(stderr,"autotrans: %s\n",transname[*transform]);
+#endif
+    }
+
+    /* update exif data */
+    if (flags & JFLAG_UPDATE_ORIENTATION) {
+	update_orientation(ed,EXIF_IFD_0,1);
+	update_orientation(ed,EXIF_IFD_1,1);
+    }
+    if (ed->data && ed->data[0] == 0xff && ed->data[1] == 0xd8 &&
+	(flags & JFLAG_TRANSFORM_THUMBNAIL))
+	do_thumbnail(ed,*transform);
+    update_dimension(ed, (flags & JFLAG_TRANSFORM_IMAGE) ? *transform : JXFORM_NONE,
+		     src->image_width, src->image_height);
+
+    /* build new exif data block */
+    exif_data_save_data(ed,&data,&size);
+    exif_data_unref(ed);
+
+    /* update jpeg APP1 (EXIF) marker */
+    mark->data = src->mem->alloc_large((j_common_ptr)src,JPOOL_IMAGE,size);
+    mark->original_length = size;
+    mark->data_length = size;
+    memcpy(mark->data,data,size);
+    free(data);
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void do_comment(struct jpeg_decompress_struct *src,
+		       unsigned char *comment)
+{
+    jpeg_saved_marker_ptr mark;
+    int size;
+
+    /* find or create comment marker */
+    for (mark = src->marker_list;; mark = mark->next) {
+	if (mark->marker == JPEG_COM)
+	    break;
+	if (NULL == mark->next) {
+	    mark->next = src->mem->alloc_large((j_common_ptr)src,JPOOL_IMAGE,
+					       sizeof(*mark));
+	    mark = mark->next;
+	    memset(mark,0,sizeof(*mark));
+	    mark->marker = JPEG_COM;
+	    break;
+	}
+    }
+
+    /* update comment marker */
+    size = strlen(comment) +1;
+    mark->data = src->mem->alloc_large((j_common_ptr)src,JPOOL_IMAGE,size);
+    mark->original_length = size;
+    mark->data_length = size;
+    memcpy(mark->data,comment,size);
+}
+
+static int do_transform(struct jpeg_decompress_struct *src,
+			struct jpeg_compress_struct *dst,
+			JXFORM_CODE transform,
+			unsigned char *comment,
+			char *thumbnail, int tsize,
+			unsigned int flags)
+{
+    jvirt_barray_ptr * src_coef_arrays;
+    jvirt_barray_ptr * dst_coef_arrays;
+    jpeg_transform_info transformoption;
+
+    jcopy_markers_setup(src, JCOPYOPT_ALL);
+    if (JPEG_HEADER_OK != jpeg_read_header(src, TRUE))
+	return -1;
+
+    do_exif(src,&transform,thumbnail,tsize,flags);
+    if (-1 == transform)
+	transform = JXFORM_NONE;
+    if (!(flags & JFLAG_TRANSFORM_IMAGE))
+	transform = JXFORM_NONE;
+    if ((flags & JFLAG_UPDATE_COMMENT) && NULL != comment)
+	do_comment(src,comment);
+
+    memset(&transformoption,0,sizeof(transformoption));
+    transformoption.transform = transform;
+    transformoption.trim      = FALSE;
+    transformoption.force_grayscale = FALSE;
+
+    /* Any space needed by a transform option must be requested before
+     * jpeg_read_coefficients so that memory allocation will be done right.
+     */
+    jtransform_request_workspace(src, &transformoption);
+    src_coef_arrays = jpeg_read_coefficients(src);
+    jpeg_copy_critical_parameters(src, dst);
+    dst_coef_arrays = jtransform_adjust_parameters
+	(src, dst, src_coef_arrays, &transformoption);
+    
+    /* Start compressor (note no image data is actually written here) */
+    jpeg_write_coefficients(dst, dst_coef_arrays);
+    
+    /* Copy to the output file any extra markers that we want to preserve */
+    jcopy_markers_execute(src, dst, JCOPYOPT_ALL);
+    
+    /* Execute image transformation, if any */
+    jtransform_execute_transformation(src, dst,
+				      src_coef_arrays,
+				      &transformoption);
+    
+    /* Finish compression and release memory */
+    jpeg_finish_compress(dst);
+    jpeg_finish_decompress(src);
+
+    return 0;
+}
+
+/* ---------------------------------------------------------------------- */
+
+int jpeg_transform_fp(FILE *in, FILE *out,
+		      JXFORM_CODE transform,
+		      unsigned char *comment,
+		      char *thumbnail, int tsize,
+		      unsigned int flags)
+{
+    struct jpeg_decompress_struct src;
+    struct jpeg_compress_struct   dst;
+    struct jpeg_error_mgr jdsterr;
+    struct longjmp_error_mgr jsrcerr;
+    
+    /* setup src */
+    src.err = jpeg_std_error(&jsrcerr.jpeg);
+    jsrcerr.jpeg.error_exit = longjmp_error_exit;
+    if (setjmp(jsrcerr.setjmp_buffer))
+	/* something went wrong within the jpeg library ... */
+	goto oops;
+    jpeg_create_decompress(&src);
+    jpeg_stdio_src(&src, in);
+    
+    /* setup dst */
+    dst.err = jpeg_std_error(&jdsterr);
+    jpeg_create_compress(&dst);
+    jpeg_stdio_dest(&dst, out);
+
+    /* transform image */
+    do_transform(&src,&dst,transform,comment,thumbnail,tsize,flags);
+
+    /* cleanup */
+    jpeg_destroy_decompress(&src);
+    jpeg_destroy_compress(&dst);
+    return 0;
+
+ oops:
+    jpeg_destroy_decompress(&src);
+    jpeg_destroy_compress(&dst);
+    return -1;
+}
+
+int jpeg_transform_files(char *infile, char *outfile,
+			 JXFORM_CODE transform,
+			 unsigned char *comment,
+			 char *thumbnail, int tsize,
+			 unsigned int flags)
+{
+    int rc;
+    FILE *in;
+    FILE *out;
+    
+    /* open infile */
+    in = fopen(infile,"r");
+    if (NULL == in) {
+	fprintf(stderr,"open %s: %s\n",infile,strerror(errno));
+	return -1;
+    }
+    
+    /* open outfile */
+    out = fopen(outfile,"w");
+    if (NULL == out) {
+	fprintf(stderr,"open %s: %s\n",outfile,strerror(errno));
+	fclose(in);
+	return -1;
+    }
+
+    /* go! */
+    rc = jpeg_transform_fp(in,out,transform,comment,thumbnail,tsize,flags);
+    fclose(in);
+    fclose(out);
+
+    return rc;
+}
+
+int jpeg_transform_inplace(char *file,
+			   JXFORM_CODE transform,
+			   unsigned char *comment,
+			   char *thumbnail, int tsize,
+			   unsigned int flags)
+{
+    char *tmpfile;
+    char *bakfile;
+    struct stat st;
+    int fd;
+    FILE *in  = NULL;
+    FILE *out = NULL;
+
+    /* are we allowed to write to the file? */
+    if (0 != access(file,W_OK)) {
+	fprintf(stderr,"access %s: %s\n",file,strerror(errno));
+	return -1;
+    }
+
+    /* open infile */
+    in = fopen(file,"r");
+    if (NULL == in) {
+	fprintf(stderr,"open %s: %s\n",file,strerror(errno));
+	return -1;
+    }
+    
+    /* open tmpfile */
+    tmpfile = malloc(strlen(file)+10);
+    sprintf(tmpfile,"%s.XXXXXX",file);
+    fd = mkstemp(tmpfile);
+    if (-1 == fd) {
+	fprintf(stderr,"mkstemp(%s): %s\n",tmpfile,strerror(errno));
+	goto oops;
+    }
+    out = fdopen(fd,"w");
+
+    /* copy owner and permissions */
+    if (-1 == fstat(fileno(in),&st)) {
+	fprintf(stderr,"fstat(%s): %s\n",file,strerror(errno));
+	goto oops;
+    }
+    if (-1 == fchown(fileno(out),st.st_uid,st.st_gid)) {
+	fprintf(stderr,"fchown(%s): %s\n",tmpfile,strerror(errno));
+	goto oops;
+    }
+    if (-1 == fchmod(fileno(out),st.st_mode)) {
+	fprintf(stderr,"fchmod(%s): %s\n",tmpfile,strerror(errno));
+	goto oops;
+    }
+
+    /* transform */
+    if (0 != jpeg_transform_fp(in,out,transform,comment,thumbnail,tsize,flags))
+	goto oops;
+
+    /* worked ok -- commit */
+    fclose(in);
+    fclose(out);
+    if (flags & JFLAG_FILE_BACKUP) {
+	bakfile = malloc(strlen(file)+2);
+	sprintf(bakfile,"%s~",file);
+	rename(file,bakfile);
+	free(bakfile);
+    }
+    rename(tmpfile,file);
+    if (flags & JFLAG_FILE_KEEP_TIME) {
+	struct utimbuf u;
+	u.actime = st.st_atime;
+	u.modtime = st.st_mtime;
+	utime(file,&u);
+    }
+        
+    /* cleanup & return */
+    free(tmpfile);
+    return 0;
+
+ oops:
+    /* something went wrong -- rollback */
+    if (in)
+	fclose(in);
+    if (out) {
+	fclose(out);
+	unlink(tmpfile);
+    }
+    return -1;
+}