@@ -232,6 +232,7 @@ util_imgsave(char *filename, char *bufimg, int width, int height,int quality)

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

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

         l=strlen(filename);

+        flagjpeg=0;

         if((l>=4

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

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

@@ -53,11 +53,11 @@ main(int argc, char *argv[])

         char *currentoutfilename;

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

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

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

                 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");

                 return(1);

         }

         /* parse arguments */

@@ -492,12 +492,12 @@ util_jpgsave(char *filename, char *bufimg, int width, int height,int quality)

         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) {

+                for(orig=ptr,dest=(unsigned char *)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;

+                rowptrs[0]=(JSAMPROW) rowdata;

                 jpeg_write_scanlines(&cinfo,rowptrs,1);

         }

         jpeg_finish_compress(&cinfo);

@@ -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)

 {

@@ -13,13 +13,14 @@

 #include <stdlib.h>

 #include <unistd.h>

 #include <string.h>

+#include <math.h>

 #include <png.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 luttool_applylut(char *lutfilenamelist,char *infilename, char *outfilename,int quality,int identitysize,int flaginterpolatelut);

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

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

@@ -39,25 +40,36 @@ main(int argc, char *argv[])

         char *lutlist;

         int i;

         int flagseveralinfile;

+        int flaginterpolatelut;

         char bufoutfilename[1024];

         char *currentoutfilename;

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

 #ifdef JPEG_SUPPORTED

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

+                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 */

         identitysize=DEFAULT_IDENTITYSIZE;

         quality=DEFAULT_QUALITY;

-        for(firstarg=1;firstarg<(argc-1) && (strcmp(argv[firstarg],"-n")==0 || (strcmp(argv[firstarg],"-q")==0));) {

+        flaginterpolatelut=0;

+        for(firstarg=1

+          ;firstarg<(argc-1)

+          && (strcmp(argv[firstarg],"-n")==0

+          || strcmp(argv[firstarg],"-q")==0

+          || strcmp(argv[firstarg],"-i")==0)

+          ;) {

                 if(strcmp(argv[firstarg],"-n")==0) {

                         identitysize=atoi(argv[firstarg+1]);

                         if(identitysize<2 || identitysize>16) {

@@ -70,6 +82,9 @@ main(int argc, char *argv[])

                                 fprintf(stderr,"%s: ERROR: the parameter to -q must be between 1 and 100 (default: %i)\n",argv[0],DEFAULT_QUALITY);

                                 return(1);

                         }

+                } else if(strcmp(argv[firstarg],"-i")==0) {

+                        flaginterpolatelut=1;

+                        firstarg--; /* doesn't have param. */

                 }

                 firstarg+=2;

         }

@@ -107,7 +122,7 @@ main(int argc, char *argv[])

                         bufoutfilename[sizeof(bufoutfilename)-1]='\0';

                         currentoutfilename=bufoutfilename;

                 }

-                if(luttool_applylut(lutlist,argv[i],currentoutfilename,quality,identitysize)!=0) {

+                if(luttool_applylut(lutlist,argv[i],currentoutfilename,quality,identitysize,flaginterpolatelut)!=0) {

                         fprintf(stderr,"%s: ERROR: couldn't apply LUTs \"%s\" to \"%s\" or couldn't write \"%s\"\n",argv[0],lutlist,argv[i],currentoutfilename);

                         return(1);

                 }

@@ -116,7 +131,7 @@ main(int argc, char *argv[])

 }

 int

-luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,int identitysize)

+luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,int identitysize,int flaginterpolatelut)

 {

         char *curlut,*next;

         char filename[1024];

@@ -126,6 +141,7 @@ luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,i

         int sizelutbuf,lutwidth,lutheight;

         int sizeimgbuf,imgwidth,imgheight;

         int sizergblutbuf;

+        int res;

         lutbuf=imgbuf=rgblutbuf=NULL;

         sizelutbuf=sizeimgbuf=sizergblutbuf=0;

         lutwidth=lutheight=imgwidth=imgheight=0;

@@ -159,7 +175,12 @@ luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,i

                                 break; /* couldn't load lut */

                         }

                 }

-                if(luttool_rgba2lut4096(lutbuf, lutwidth, lutheight, &rgblutbuf, &sizergblutbuf)!=0) {

+                res=0;

+                if(flaginterpolatelut==0)

+                        res=luttool_rgba2lut4096(lutbuf, lutwidth, lutheight, &rgblutbuf, &sizergblutbuf);

+                else

+                        res=luttool_rgba2lut4096_interpolated(lutbuf, lutwidth, lutheight, &rgblutbuf, &sizergblutbuf);

+                if(res!=0) {

                         in_error=1;

                         break; /* couldn't process lut */

                 }

@@ -387,6 +408,92 @@ luttool_rgba2lut4096(char *rgba, int width, int height, char **lut4096, int *siz

         return(0);

 }

+int

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

+{

+        int n;

+        int reqsize;

+        float fr,fg,fb;

+        int ir,ig,ib;

+        int incr,incg,incb;

+        int posr,posg,posb;

+        int myrgb[3];

+        int x,y;

+        int r,g,b;

+        int i;

+        int isize,isizesq,isizesqminusone;

+        int osize,osizesq,osizesqminusone;

+        unsigned char *orig,*dest;

+        if(rgba==NULL || width!=height || lut4096==NULL || sizelut4096==NULL)

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

+        /* check if size is a supported size */

+        for(n=2;n<=16 && width!=(n*n*n);n++)

+                ;

+        if(n>16)

+                return(-1); /* invalid size */

+        /* expand lut4096 as necessary */

+        reqsize=4096*4096*3;

+        if(*sizelut4096<reqsize) {

+                char *newlut4096;

+                if((newlut4096=realloc(*lut4096,reqsize))==NULL)

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

+                *lut4096=newlut4096;

+                *sizelut4096=reqsize;

+        }

+        /* do the conversion */

+        isize=n;

+        isizesq=n*n;

+        isizesqminusone=isizesq-1;

+        osize=16;

+        osizesq=osize*osize;

+        osizesqminusone=osizesq-1;

+        for(r=0;r<osizesq;r++) {

+                for(g=0;g<osizesq;g++) {

+                        for(b=0;b<osizesq;b++) {

+                                fr=((isizesqminusone*((float)r))/osizesqminusone);

+                                fg=((isizesqminusone*((float)g))/osizesqminusone);

+                                fb=((isizesqminusone*((float)b))/osizesqminusone);

+                                ir=floorf(fr);

+                                ig=floorf(fg);

+                                ib=floorf(fb);

+                                fr=fr-ir;

+                                fg=fg-ig;

+                                fb=fb-ib;

+                                myrgb[0]=myrgb[1]=myrgb[2]=0;

+                                for(i=0;i<2*2*2;i++) {

+                                        incr=(i>>2)&1;

+                                        incg=(i>>1)&1;

+                                        incb=i&1;

+                                        posr=ir+incr;

+                                        posr=(posr<0)?0:(posr>=isizesq)?isizesqminusone:posr;

+                                        posg=ig+incg;

+                                        posg=(posg<0)?0:(posg>=isizesq)?isizesqminusone:posg;

+                                        posb=ib+incb;

+                                        posb=(posb<0)?0:(posb>=isizesq)?isizesqminusone:posb;

+                                        x=posr+(posg%isize)*isizesq;

+                                        y=posb*isize+(posg/isize);

+                                        orig=(unsigned char *) (rgba+((y*width+x)<<2));

+                                        myrgb[0]+=orig[0]*((incr!=0)?fr:(1-fr));

+                                        myrgb[1]+=orig[1]*((incg!=0)?fg:(1-fg));

+                                        myrgb[2]+=orig[2]*((incb!=0)?fb:(1-fb));

+                                }

+                                myrgb[0]/=(i/2);

+                                myrgb[0]=(myrgb[0]<0)?0:(myrgb[0]>255)?255:myrgb[0];

+                                myrgb[1]/=(i/2);

+                                myrgb[1]=(myrgb[1]<0)?0:(myrgb[1]>255)?255:myrgb[1];

+                                myrgb[2]/=(i/2);

+                                myrgb[2]=(myrgb[2]<0)?0:(myrgb[2]>255)?255:myrgb[2];

+                                dest=(unsigned char *) ((*lut4096)+((r<<16)+(g<<8)+b)*3);

+                                dest[0]=myrgb[0];

+                                dest[1]=myrgb[1];

+                                dest[2]=myrgb[2];

+                        }

+                }

+        }

+        return(0);

+}

+

+

 int

 luttool_applylut4096(char *lut4096,char *imgbuf,int imgwidth,int imgheight)

 {

@@ -108,7 +108,7 @@ main(int argc, char *argv[])

                         currentoutfilename=bufoutfilename;

                 }

                 if(luttool_applylut(lutlist,argv[i],currentoutfilename,quality,identitysize)!=0) {

-                        fprintf(stderr,"%s: ERROR: couldn't apply LUTs \"%s\" to \"%s\" or couldn't write \"%s\"cified\n",argv[0],lutlist,argv[i],currentoutfilename);

+                        fprintf(stderr,"%s: ERROR: couldn't apply LUTs \"%s\" to \"%s\" or couldn't write \"%s\"\n",argv[0],lutlist,argv[i],currentoutfilename);

                         return(1);

                 }

         }

new file mode 100644

@@ -0,0 +1,408 @@

+/*

+ * luttool.c

+ *

+ * Utility to apply LUTs to images

+ *

+ * Author: Dario Rodriguez antartica@whereismybit.com

+ * This program is licensed under the terms of the MIT license,

+ * with an exception: the license text may be substituted for a

+ * link to it. MIT license text: https://spdx.org/licenses/MIT.html

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <unistd.h>

+#include <string.h>

+#include <png.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 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_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);

+int luttool_applylut4096(char *lut4096,char *imgbuf,int imgwidth,int imgheight);

+

+int

+main(int argc, char *argv[])

+{

+        int firstarg,outfilenamearg;

+        int identitysize;

+        int quality;

+        char *outfilename;

+        char *lutlist;

+        int i;

+        int flagseveralinfile;

+        char bufoutfilename[1024];

+        char *currentoutfilename;

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

+#ifdef JPEG_SUPPORTED

+                printf("Syntax: %s [-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 -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]);

+#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: %s -n 16 identity identity -o identity.png\n",argv[0]);

+#endif

+                return(1);

+        }

+        /* parse arguments */

+        identitysize=DEFAULT_IDENTITYSIZE;

+        quality=DEFAULT_QUALITY;

+        for(firstarg=1;firstarg<(argc-1) && (strcmp(argv[firstarg],"-n")==0 || (strcmp(argv[firstarg],"-q")==0));) {

+                if(strcmp(argv[firstarg],"-n")==0) {

+                        identitysize=atoi(argv[firstarg+1]);

+                        if(identitysize<2 || identitysize>16) {

+                                fprintf(stderr,"%s: ERROR: the parameter to -n must be between 2 and 16 (default: %i)\n",argv[0],DEFAULT_IDENTITYSIZE);

+                                return(1);

+                        }

+                } else if(strcmp(argv[firstarg],"-q")==0) {

+                        quality=atoi(argv[firstarg+1]);

+                        if(quality<1 || quality>100) {

+                                fprintf(stderr,"%s: ERROR: the parameter to -q must be between 1 and 100 (default: %i)\n",argv[0],DEFAULT_QUALITY);

+                                return(1);

+                        }

+                }

+                firstarg+=2;

+        }

+        for(outfilenamearg=-1,outfilename=NULL,i=1;i<(argc-1);i++) {

+                if(strcmp(argv[i],"-o")==0) {

+                        outfilename=argv[i+1];

+                        outfilenamearg=i;

+                        break;

+                }

+        }

+        if(outfilename==NULL) {

+                fprintf(stderr,"%s: ERROR: no output file specified\n",argv[0]);

+                return(1);

+        }

+        firstarg+=((firstarg==outfilenamearg)?2:0);

+        lutlist=argv[firstarg];

+        firstarg++;

+        flagseveralinfile=((argc-firstarg-((outfilenamearg>=firstarg)?2:0))>1)?1:0;

+        /* process files sequentially, skipping the "-o outputfilename" */

+        for(i=firstarg;i<argc;i++) {

+                if(i==outfilenamearg) {

+                        i++;

+                        continue;

+                }

+                currentoutfilename=outfilename;

+                if(flagseveralinfile) {

+                        char *ext;

+                        int l;

+                        strncpy(bufoutfilename,argv[i],sizeof(bufoutfilename));

+                        bufoutfilename[sizeof(bufoutfilename)-1]='\0';

+                        if((ext=strrchr(bufoutfilename,'.'))!=NULL)

+                                *ext='\0';

+                        l=strlen(bufoutfilename);

+                        snprintf(bufoutfilename+l,sizeof(bufoutfilename)-l,"_%s",outfilename);

+                        bufoutfilename[sizeof(bufoutfilename)-1]='\0';

+                        currentoutfilename=bufoutfilename;

+                }

+                if(luttool_applylut(lutlist,argv[i],currentoutfilename,quality,identitysize)!=0) {

+                        fprintf(stderr,"%s: ERROR: couldn't apply LUTs \"%s\" to \"%s\" or couldn't write \"%s\"cified\n",argv[0],lutlist,argv[i],currentoutfilename);

+                        return(1);

+                }

+        }

+        return(0);

+}

+

+int

+luttool_applylut(char *lutlist,char *infilename, char *outfilename,int quality,int identitysize)

+{

+        char *curlut,*next;

+        char filename[1024];

+        int l;

+        int in_error;

+        char *lutbuf,*imgbuf,*rgblutbuf;

+        int sizelutbuf,lutwidth,lutheight;

+        int sizeimgbuf,imgwidth,imgheight;

+        int sizergblutbuf;

+        lutbuf=imgbuf=rgblutbuf=NULL;

+        sizelutbuf=sizeimgbuf=sizergblutbuf=0;

+        lutwidth=lutheight=imgwidth=imgheight=0;

+        if(lutlist==NULL || infilename==NULL || outfilename==NULL)

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

+        in_error=0;

+        /* load the image to process */

+        if(strcmp(infilename,"identity")==0) {

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

+                         in_error=1;

+        } else {

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

+                        in_error=1;

+        }

+        /* apply all luts */

+        for(curlut=lutlist,next=strchr(curlut,','),next=((next==NULL)?(curlut+strlen(curlut)):next)

+          ;in_error==0 && *curlut!='\0'

+          ;curlut=next+((*next==',')?1:0),next=strchr(curlut,','),next=((next==NULL)?(curlut+strlen(curlut)):next)) {

+                l=next-curlut;

+                l=(l>(sizeof(filename)-1))?(sizeof(filename)-1):l;

+                memcpy(filename,curlut,l);

+                filename[l]='\0';

+                if(strcmp(filename,"identity")==0) {

+                        if(util_identitygen(&lutbuf,&sizelutbuf,identitysize,&lutwidth,&lutheight)==-1) {

+                                in_error=1;

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

+                        }

+                } else {

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

+                                in_error=1;

+                                break; /* couldn't load lut */

+                        }

+                }

+                if(luttool_rgba2lut4096(lutbuf, lutwidth, lutheight, &rgblutbuf, &sizergblutbuf)!=0) {

+                        in_error=1;

+                        break; /* couldn't process lut */

+                }

+                if(luttool_applylut4096(rgblutbuf,imgbuf,imgwidth,imgheight)!=0) {

+                        in_error=1;

+                        break; /* couldn't apply lut */

+                }

+        }

+        /* save the result */

+        if(in_error==0) {

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

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

+        }

+        /* cleanup and exit */

+        if(lutbuf!=NULL)

+                free(lutbuf),lutbuf=NULL;

+        if(imgbuf!=NULL)

+                free(imgbuf),imgbuf=NULL;

+        if(rgblutbuf!=NULL)

+                free(rgblutbuf),rgblutbuf=NULL;

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

+}

+

+

+

+int

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

+{

+        return(util_pngload(filename,NULL,NULL,width,height));

+}

+

+int

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

+{

+        FILE *f;

+        png_structp png;

+        png_infop info;

+        png_byte color_type,bit_depth;

+        png_bytep *rowpointers;

+        int reqsize;

+        int i,pitch;

+        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 */

+        if((png=png_create_read_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL))==NULL

+          || (info=png_create_info_struct(png))==NULL

+          || setjmp(png_jmpbuf(png))) {

+                if(png!=NULL)

+                        png_destroy_read_struct(&png,&info,NULL),png=NULL,info=NULL;

+                fclose(f),f=NULL;

+                return(-1); /* couldn't init png library */

+        }

+        png_init_io(png,f);

+        png_read_info(png,info);

+        *width=png_get_image_width(png,info);

+        *height=png_get_image_height(png,info);

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

+        if(bufimg==NULL) {

+                png_destroy_read_struct(&png,&info,NULL),png=NULL,info=NULL;

+                fclose(f),f=NULL;

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

+        }

+        /* 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) {

+                      png_destroy_read_struct(&png,&info,NULL),png=NULL,info=NULL;

+                      fclose(f),f=NULL;

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

+                }

+                *bufimg=newbufimg;

+                *sizebufimg=reqsize;

+        }

+        /* make sure we get 8-bit RGBA data, regardless of the file's bit_depth and color_type */

+        if((bit_depth=png_get_bit_depth(png,info))==16)

+                png_set_strip_16(png);

+        color_type=png_get_color_type(png,info);

+        if(color_type==PNG_COLOR_TYPE_PALETTE)

+                png_set_palette_to_rgb(png);

+        if(color_type==PNG_COLOR_TYPE_GRAY && bit_depth<8)

+                png_set_expand_gray_1_2_4_to_8(png);

+        if(png_get_valid(png,info,PNG_INFO_tRNS))

+                png_set_tRNS_to_alpha(png);

+        if(color_type==PNG_COLOR_TYPE_RGB

+          || color_type==PNG_COLOR_TYPE_GRAY

+          || color_type==PNG_COLOR_TYPE_PALETTE) {

+                png_set_filler(png,0xff,PNG_FILLER_AFTER);

+        }

+        if(color_type==PNG_COLOR_TYPE_GRAY

+          || color_type==PNG_COLOR_TYPE_GRAY_ALPHA) {

+                png_set_gray_to_rgb(png);

+        }

+        /* read the image */

+        png_read_update_info(png,info);         

+        if((rowpointers=(png_bytep *)malloc(sizeof(png_bytep)*(*height)))==NULL) {

+                png_destroy_read_struct(&png,&info,NULL),png=NULL,info=NULL;

+                fclose(f),f=NULL;

+                return(-1); /* insuf. mem. for temporary data */

+        }

+        for(i=0,pitch=(*width)*4;i<(*height);i++)

+                rowpointers[i]=(png_byte *)((*bufimg)+i*pitch);

+        png_read_image(png,rowpointers);

+        /* cleanup */

+        free(rowpointers),rowpointers=NULL;

+        fclose(f),f=NULL;

+        png_destroy_read_struct(&png,&info,NULL),png=NULL,info=NULL;

+        return(0);

+}

+

+int

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

+{

+        FILE *f;

+        png_structp png;

+        png_infop info;

+        int i,pitch;

+        char *ptr;

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

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

+        if((png=png_create_write_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL))==NULL

+          || (info=png_create_info_struct(png))==NULL

+          || setjmp(png_jmpbuf(png))) {

+                if(png!=NULL)

+                        png_destroy_write_struct(&png,&info),png=NULL,info=NULL;

+                fclose(f),f=NULL;

+                return(-1); /* couldn't init png library */

+        }

+        png_init_io(png,f);

+        png_set_IHDR(png,info,width,height,8,PNG_COLOR_TYPE_RGBA,

+          PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_BASE,PNG_FILTER_TYPE_BASE);

+        png_write_info(png,info);

+        for(i=0,ptr=bufimg,pitch=width*4;i<height;i++,ptr+=pitch)

+                png_write_row(png,(png_const_bytep)ptr);

+        png_write_end(png,NULL);

+        fclose(f),f=NULL;

+        png_destroy_write_struct(&png,&info),png=NULL,info=NULL;

+        return(0);

+}

+

+int

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

+{

+        int x,y,r,g,b;

+        int isizesq,isizesqminusone;

+        int osizesqminusone;

+        int reqsize;

+        int l;

+        unsigned char *ptr;

+        if(bufimg==NULL || sizebufimg==NULL || identitysize<=1 || identitysize>16 || width==NULL || height==NULL)

+                return(-1);

+        l=*width=*height=identitysize*identitysize*identitysize;

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

+        if(*sizebufimg<reqsize) {

+                char *newbufimg;

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

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

+                *bufimg=newbufimg;

+                *sizebufimg=reqsize;

+        }

+        isizesq=identitysize*identitysize;

+        isizesqminusone=isizesq-1;

+        osizesqminusone=256-1;

+        for(y=0,ptr=(unsigned char *)(*bufimg);y<l;y++) {

+                for(x=0;x<l;x++,ptr+=4) {

+                        r=x%isizesq;

+                        g=(y%identitysize)*identitysize+(x/isizesq);

+                        b=y/identitysize;

+                        ptr[0]=r*osizesqminusone/isizesqminusone;

+                        ptr[1]=g*osizesqminusone/isizesqminusone;

+                        ptr[2]=b*osizesqminusone/isizesqminusone;

+                        ptr[3]=0xff;

+                }

+        }

+        return(0);

+}

+

+int

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

+{

+        int n;

+        int reqsize;

+        int x,y;

+        int r,g,b;

+        int isize,isizesq,isizesqminusone;

+        int osize,osizesq,osizesqminusone;

+        unsigned char *orig,*dest;

+        if(rgba==NULL || width!=height || lut4096==NULL || sizelut4096==NULL)