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

 CC=gcc

 CFLAGS=-g -Wall

-LDFLAGS=-lpng

+LDFLAGS=-lm -lpng

 all: luttool

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

 {