jpegtools.c

/*
 * 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 Hoffmann <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;
	    src->marker_list = 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;
}