@@ -1,6 +1,6 @@

 CC=gcc

 CFLAGS=-g -Wall

-LDFLAGS=-lm -lpng

+LDFLAGS=-lm -lpng -ljpeg

 all: luttool

@@ -13,18 +13,26 @@

 #include <stdlib.h>

 #include <unistd.h>

 #include <string.h>

+#include <setjmp.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <fcntl.h>

 #include <math.h>

 #include <png.h>

+#include <jpeglib.h>

 #define DEFAULT_IDENTITYSIZE 12 /* Same as RawTherapee's HaldCLUTs, 1728x1728 AKA (12*12)*12x12*(12*12), equivalent to a cube with 144px wide sides*/

 #define DEFAULT_QUALITY 85

-/* #define JPEG_SUPPORTED */

 int luttool_applylut(char *lutfilenamelist,char *infilename, char *outfilename,int quality,int identitysize,int flaginterpolatelut);

+int util_imgload(char *filename, char **bufimg, int *sizebufimg, int *width, int *height);

+int util_imgsave(char *filename, char *bufimg, int width, int height,int quality);

 int util_pnginfo(char *filename, int *width, int *height);

 int util_pngload(char *filename, char **bufimg, int *sizebufimg, int *width, int *height);

 int util_pngsave(char *filename, char *bufimg, int width, int height);

+int util_jpgload(char *filename, char **bufimg, int *sizebufimg, int *width, int *height);

+int util_jpgsave(char *filename, char *bufimg, int width, int height,int quality);

 int util_identitygen(char **bufimg, int *sizebufimg, int identitysize, int *width, int *height);

 int luttool_rgba2lut4096(char *rgba, int width, int height, char **lut4096, int *sizelut4096);

 int luttool_rgba2lut4096_interpolated(char *rgba, int width, int height, char **lut4096, int *sizelut4096);

@@ -44,20 +52,12 @@ main(int argc, char *argv[])

         char bufoutfilename[1024];

         char *currentoutfilename;

         if(argc<2 || strcmp(argv[argc-1],"--help")==0) {

-#ifdef JPEG_SUPPORTED

                 printf("Syntax: %s [-i] [-q jpegquality] [-n identitylevel] {identity | lutfile[,lutfile[,...]]} { identity | infile1 } [infile2 [...]] -o outfile\n",argv[0]);

                 printf("Example: %s haldclut.png sprite.png -o result.png\n",argv[0]);

                 printf("Example: %s -i haldclut.png sprite.png -o result.png\n",argv[0]);

                 printf("Example: %s -n 16 identity identity -o identity.png\n",argv[0]);

                 printf("Example: %s -q 85 haldclut.png infile.png -o outfile.jpg\n",argv[0]);

                 printf("NOTE: -i makes the program interpolate the LUTs.\n");

-#else

-                printf("Syntax: %s [-n identitylevel] {identity | lutfile[,lutfile[,...]]} { identity | infile1 } [infile2 [...]] -o outfile\n",argv[0]);

-                printf("Example: %s haldclut.png sprite.png -o result.png\n",argv[0]);

-                printf("Example: -i %s haldclut.png sprite.png -o result.png\n",argv[0]);

-                printf("Example: %s -n 16 identity identity -o identity.png\n",argv[0]);

-                printf("NOTE: -i makes the program interpolate the LUTs.\n");

-#endif

                 return(1);

         }

         /* parse arguments */

@@ -153,7 +153,7 @@ luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,i

                  if(util_identitygen(&imgbuf,&sizeimgbuf,identitysize,&imgwidth,&imgheight)==-1)

                          in_error=1;

         } else {

-                if(util_pngload(infilename,&imgbuf,&sizeimgbuf,&imgwidth,&imgheight)!=0)

+                if(util_imgload(infilename,&imgbuf,&sizeimgbuf,&imgwidth,&imgheight)!=0)

                         in_error=1;

         }

         /* apply all luts */

@@ -170,7 +170,7 @@ luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,i

                                 break; /* couldn't generate identity lut */

                         }

                 } else {

-                        if(util_pngload(filename,&lutbuf,&sizelutbuf,&lutwidth,&lutheight)==-1) {

+                        if(util_imgload(filename,&lutbuf,&sizelutbuf,&lutwidth,&lutheight)==-1) {

                                 in_error=1;

                                 break; /* couldn't load lut */

                         }

@@ -191,7 +191,7 @@ luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,i

         }

         /* save the result */

         if(in_error==0) {

-                if(util_pngsave(outfilename,imgbuf,imgwidth,imgheight)!=0)

+                if(util_imgsave(outfilename,imgbuf,imgwidth,imgheight,quality)!=0)

                         in_error=1; /* couldn't write */

         }

         /* cleanup and exit */

@@ -204,7 +204,52 @@ luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,i

         return((in_error!=0)?-1:0);

 }

+int

+util_imgload(char *filename, char **bufimg, int *sizebufimg, int *width, int *height)

+{

+        int fd;

+        char buf[8];

+        if((fd=open(filename,O_RDONLY))==-1

+          || read(fd,buf,sizeof(buf))<sizeof(buf)) {

+                if(fd!=-1)

+                        close(fd),fd=-1;

+                return(-1); /* couldn't open file for reading */

+        }

+        close(fd),fd=-1;

+        if(memcmp(buf,"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a",8)==0) { /* PNG magic */

+                return(util_pngload(filename,bufimg,sizebufimg,width,height));

+        } else if(memcmp(buf,"\xff\xd8",2)==0) { /* EXIF magic */

+                return(util_jpgload(filename,bufimg,sizebufimg,width,height));

+        }

+        return(-1); /* file type not recognized */

+}

+int

+util_imgsave(char *filename, char *bufimg, int width, int height,int quality)

+{

+        int l;

+        int flagjpeg;

+        if(filename==NULL || bufimg==NULL || width<=0 || height<=0)

+                return(-1); /* sanity check error */

+        l=strlen(filename);

+        if((l>=4

+          && filename[l-4]=='.'

+          && (filename[l-3]=='J' || filename[l-3]=='j')

+          && (filename[l-2]=='P' || filename[l-2]=='p')

+          && (filename[l-1]=='G' || filename[l-1]=='g'))

+          || (l>=5

+          && filename[l-5]=='.'

+          && (filename[l-4]=='J' || filename[l-4]=='j')

+          && (filename[l-3]=='P' || filename[l-3]=='p')

+          && (filename[l-2]=='e' || filename[l-2]=='e')

+          && (filename[l-1]=='G' || filename[l-1]=='g'))) {

+                flagjpeg=1;

+        }

+        /* use png as default format; only use jpg if file extension says so */

+        if(flagjpeg)

+                return(util_jpgsave(filename,bufimg,width,height,quality));

+        return(util_pngsave(filename,bufimg,width,height));

+}

 int

 util_pnginfo(char *filename, int *width, int *height)

@@ -322,6 +367,147 @@ util_pngsave(char *filename, char *bufimg, int width, int height)

         return(0);

 }

+typedef struct jpegerrmgr_t {

+        struct jpeg_error_mgr pub;

+        jmp_buf setjmpbuf;

+} jpegerrmgr_t;

+

+static void

+util_jpgerrhandler(j_common_ptr cinfo)

+{

+        jpegerrmgr_t *errmgr;

+        errmgr=(jpegerrmgr_t *)cinfo->err;

+        longjmp(errmgr->setjmpbuf,1);

+}

+

+int

+util_jpgload(char *filename, char **bufimg, int *sizebufimg, int *width, int *height)

+{

+        FILE *f;

+        struct jpeg_decompress_struct cinfo;

+        jpegerrmgr_t errmgr;

+        int reqsize;

+        JSAMPROW rowptrs[1];

+        unsigned char *ptr,*orig,*dest;

+        if(filename==NULL || (bufimg==NULL && sizebufimg!=NULL) || (bufimg!=NULL && sizebufimg==NULL) || width==NULL || height==NULL)

+                return(-1); /* sanity check failed */

+        if((f=fopen(filename,"rb"))==NULL)

+                return(-1); /* couldn't open file */

+        memset(&cinfo,0,sizeof(cinfo));

+        cinfo.err=jpeg_std_error(&errmgr.pub);

+        errmgr.pub.error_exit=util_jpgerrhandler;

+        if(setjmp(errmgr.setjmpbuf)) {

+                jpeg_destroy_decompress(&cinfo);

+                if(f!=NULL)

+                        fclose(f),f=NULL;

+                return(-1); /* libjpeg couldn't decompress stream */

+        }

+        jpeg_create_decompress(&cinfo);

+        jpeg_stdio_src(&cinfo,f);

+        jpeg_read_header(&cinfo,TRUE);

+        jpeg_start_decompress(&cinfo);

+        *width=cinfo.output_width;

+        *height=cinfo.output_height;

+        /* special case: if bufimg==NULL, we only want the width/height */

+        if(bufimg==NULL) {

+                jpeg_destroy_decompress(&cinfo);

+                return(0); /* all done */

+        }

+        /* make sure is in a supported format */

+        if(cinfo.output_components!=3 && cinfo.output_components!=4) {

+                jpeg_destroy_decompress(&cinfo);

+                return(-1); /* we only support 8-bit RGB jpeg */

+        }

+        /* make sure we have enough space for the new image in 8-bit RGBA */

+        reqsize=(*width)*(*height)*4;

+        if(*sizebufimg<reqsize) {

+                char *newbufimg;

+                if((newbufimg=realloc(*bufimg,reqsize))==NULL) {

+                      jpeg_destroy_decompress(&cinfo);

+                      fclose(f),f=NULL;

+                      return(-1); /* insuf. mem. for resulting image */

+                }

+                *bufimg=newbufimg;

+                *sizebufimg=reqsize;

+        }

+        while(cinfo.output_scanline<cinfo.output_height) {

+                ptr=(unsigned char *)((*bufimg)+cinfo.output_scanline*((*width)*4));

+                rowptrs[0]=ptr;

+                jpeg_read_scanlines(&cinfo,rowptrs,1);

+                if(cinfo.output_components==3) {

+                        orig=ptr+((*width)-1)*3;

+                        dest=ptr+((*width)-1)*4;

+                        for(;orig>=ptr;orig-=3,dest-=4) {

+                                dest[0]=orig[0];

+                                dest[1]=orig[1];

+                                dest[2]=orig[2];

+                                dest[3]=0xff;

+                        }

+                }

+        }

+        jpeg_finish_decompress(&cinfo);

+        jpeg_destroy_decompress(&cinfo);

+        fclose(f),f=NULL;

+        return(0);

+}

+

+int

+util_jpgsave(char *filename, char *bufimg, int width, int height,int quality)

+{

+        FILE *f;

+        struct jpeg_compress_struct cinfo;

+        jpegerrmgr_t errmgr;

+        char *rowdata;

+        JSAMPROW rowptrs[1];

+        int i;

+        unsigned char *ptr,*orig,*dest;

+        if(filename==NULL || bufimg==NULL || width<=0 || height<=0 || quality<1 || quality>100)

+                return(-1); /* sanity check failed */

+        if((rowdata=malloc(width*3))==NULL)

+                return(-1);

+        if((f=fopen(filename,"wb"))==NULL) {

+                if(rowdata!=NULL)

+                        free(rowdata),rowdata=NULL;

+                return(-1); /* couldn't open file for writing */

+        }

+        memset(&cinfo,0,sizeof(cinfo));

+        cinfo.err=jpeg_std_error(&errmgr.pub);

+        errmgr.pub.error_exit=util_jpgerrhandler;

+        if(setjmp(errmgr.setjmpbuf)) {

+                if(f!=NULL)

+                        fclose(f),f=NULL;

+                if(rowdata!=NULL)

+                        free(rowdata),rowdata=NULL;

+                jpeg_destroy_compress(&cinfo);

+                return(-1); /* libjpeg couldn't compress stream */

+        }

+        jpeg_create_compress(&cinfo);

+        jpeg_stdio_dest(&cinfo,f);

+        cinfo.image_width=width;

+        cinfo.image_height=height;

+        cinfo.input_components=3;

+        cinfo.in_color_space=JCS_RGB;

+        jpeg_set_defaults(&cinfo);

+        jpeg_set_quality(&cinfo,quality,TRUE);

+        jpeg_start_compress(&cinfo,TRUE);

+        while(cinfo.next_scanline<cinfo.image_height) {

+                ptr=(unsigned char *)(bufimg+cinfo.next_scanline*(width*4));

+                for(orig=ptr,dest=rowdata,i=0;i<width;i++,orig+=4,dest+=3) {

+                        dest[0]=orig[0];

+                        dest[1]=orig[1];

+                        dest[2]=orig[2];

+                }

+                rowptrs[0]=rowdata;

+                jpeg_write_scanlines(&cinfo,rowptrs,1);

+        }

+        jpeg_finish_compress(&cinfo);

+        jpeg_destroy_compress(&cinfo);

+        fclose(f),f=NULL;

+        free(rowdata),rowdata=NULL;

+        return(0);

+}

+

+

 int

 util_identitygen(char **bufimg, int *sizebufimg, int identitysize, int *width, int *height)

 {