/****************************************************************************

giftool.c - GIF transformation tool.

****************************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <stdbool.h>

#include "getopt.h"

#include "getarg.h"

#include "gif_lib.h"

#define PROGRAM_NAME	"giftool"

#define MAX_OPERATIONS	256

#define MAX_IMAGES	2048

enum boolmode {numeric, onoff, tf, yesno};

char *putbool(bool flag, enum boolmode mode)

{

    if (flag)

	switch (mode) {

	case numeric: return "1"; break;

	case onoff:   return "on"; break;

	case tf:      return "true"; break;

	case yesno:   return "yes"; break;

	}

    else

	switch (mode) {

	case numeric: return "0"; break;

	case onoff:   return "off"; break;

	case tf:      return "false"; break;

	case yesno:   return "no"; break;

	}

    return "FAIL";	/* should never happen */

}

bool getbool(char *from)

{

    struct valmap {char *name; bool val;} 

    boolnames[] = {

	{"yes", true},

	{"on",  true},

	{"1",   true},

	{"t",   true},

	{"no",  false},

	{"off", false},

	{"0",   false},

	{"f",   false},

	{NULL,  false},

    }, *sp;

    for (sp = boolnames; sp->name; sp++)

	if (strcmp(sp->name, from) == 0)

	    return sp->val;

    (void)fprintf(stderr, 

		  "giftool: %s is not a valid boolean argument.\n",

		  sp->name);

    exit(EXIT_FAILURE);

}

struct operation {

    enum {

	aspect,

	delaytime,

	background,

	info,

	interlace,

	position,

	screensize,

	transparent,

	userinput,

	disposal,

    } mode;    

    union {

	GifByteType numerator;

	int delay;

	int color;

	int dispose;

	char *format;

	bool flag;

	struct {

	    int x, y;

	} p;

    };

};

int main(int argc, char **argv)

{

    extern char	*optarg;	/* set by getopt */

    extern int	optind;		/* set by getopt */

    struct operation operations[MAX_OPERATIONS];

    struct operation *top = operations;

    int selected[MAX_IMAGES], nselected = 0;

    bool have_selection = false;

    char *cp;

    int	i, status, ErrorCode;

    GifFileType *GifFileIn, *GifFileOut = (GifFileType *)NULL;

    struct operation *op;

    /*

     * Gather operations from the command line.  We use regular

     * getopt(3) here rather than Gershom's argument getter because

     * preserving the order of operations is important.

     */

    while ((status = getopt(argc, argv, "a:b:d:f:i:n:p:s:u:x:")) != EOF)

    {

	if (top >= operations + MAX_OPERATIONS) {

	    (void)fprintf(stderr, "giftool: too many operations.");

	    exit(EXIT_FAILURE);

	}

	switch (status)

	{

	case 'a':

	    top->mode = aspect;

	    top->numerator = (GifByteType)atoi(optarg);

	    break;

	case 'b':

	    top->mode = background;

	    top->color = atoi(optarg);

	    break;

	case 'd':

	    top->mode = delaytime;

	    top->delay = atoi(optarg);

	    break;

	case 'f':

	    top->mode = info;

	    top->format = optarg;

	    break;

	case 'i':

	    top->mode = interlace;

	    top->flag = getbool(optarg);

	    break;

	case 'n':

	    have_selection = true;

	    nselected = 0;

	    cp = optarg;

	    for (;;)

	    {

		size_t span = strspn(cp, "0123456789");

		if (span > 0)

		{

		    selected[nselected++] = atoi(cp)-1;

		    cp += span;

		    if (*cp == '\0')

			break;

		    else if (*cp == ',')

			continue;

		}

		(void) fprintf(stderr, "giftool: bad selection.\n");

		exit(EXIT_FAILURE);

	    }

	    break;

	case 'p':

	case 's':

	    if (status == 'p')

		top->mode = position;

	    else

		top->mode = screensize;

	    cp = strchr(optarg, ',');

	    if (cp == NULL)

	    {

		(void) fprintf(stderr, "giftool: missing comma in coordinate pair.\n");

		exit(EXIT_FAILURE);

	    }

	    top->p.x = atoi(optarg);

	    top->p.y = atoi(cp+1);

	    if (top->p.x < 0 || top->p.y < 0)

	    {

		(void) fprintf(stderr, "giftool: negative coordinate.\n");

		exit(EXIT_FAILURE);

	    }

	    break;

	case 'u':

	    top->mode = userinput;

	    top->flag = getbool(optarg);

	    break;

	case 'x':

	    top->mode = disposal;

	    top->dispose = atoi(optarg);

	    break;

	default:

	    fprintf(stderr, "usage: giftool [-b color] [-d delay] [-iI] [-t color] -[uU] [-x disposal]\n");

	    break;

	}

	++top;

    }	

    /* read in a GIF */

    if ((GifFileIn = DGifOpenFileHandle(0, &ErrorCode)) == NULL) {

	PrintGifError(ErrorCode);

	exit(EXIT_FAILURE);

    }

    if (DGifSlurp(GifFileIn) == GIF_ERROR) {

	PrintGifError(GifFileIn->Error);

	exit(EXIT_FAILURE);

    }

    if ((GifFileOut = EGifOpenFileHandle(1, &ErrorCode)) == NULL) {

	PrintGifError(ErrorCode);

	exit(EXIT_FAILURE);

    }

    /* if the selection is defaulted, compute it; otherwise bounds-check it */

    if (!have_selection)

	for (i = nselected = 0; i < GifFileIn->ImageCount; i++)

	    selected[nselected++] = i;

    else

	for (i = 0; i < nselected; i++)

	    if (selected[i] >= GifFileIn->ImageCount || selected[i] < 0)

	    {

		(void) fprintf(stderr,

			       "giftool: selection index out of bounds.\n");

		exit(EXIT_FAILURE);

	    }

    /* perform the operations we've gathered */

    for (op = operations; op < top; op++)

	switch (op->mode)

	{

	case background:

	    GifFileIn->SBackGroundColor = op->color; 

	    break;

	case delaytime:

	    for (i = 0; i < nselected; i++)

	    {

		GraphicsControlBlock gcb;

		DGifSavedExtensionToGCB(GifFileIn, selected[i], &gcb;;

		gcb.DelayTime = op->delay;

		EGifGCBToSavedExtension(&gcb, GifFileIn, selected[i]);

	    }

	    break;

	case info:

	    for (i = 0; i < nselected; i++) {

		SavedImage *ip = &GifFileIn->SavedImages[selected[i]];

		GraphicsControlBlock gcb;

		for (cp = op->format; *cp; cp++) {

		    if (*cp == '\\') 

		    {

			char c;

			switch (*++cp) 

			{

			case 'b':

			    (void)putchar('\b');

			    break;

			case 'e':

			    (void)putchar(0x1b);

			    break;

			case 'f':

			    (void)putchar('\f');

			    break;

			case 'n':

			    (void)putchar('\n');

			    break;

			case 'r':

			    (void)putchar('\r');

			    break;

			case 't':

			    (void)putchar('\t');

			    break;

			case 'v':

			    (void)putchar('\v');

			    break;

			case 'x':

			    switch (*++cp) {

			    case '0':

				c = (char)0x00;

				break;

			    case '1':

				c = (char)0x10;

				break;

			    case '2':

				c = (char)0x20;

				break;

			    case '3':

				c = (char)0x30;

				break;

			    case '4':

				c = (char)0x40;

				break;

			    case '5':

				c = (char)0x50;

				break;

			    case '6':

				c = (char)0x60;

				break;

			    case '7':

				c = (char)0x70;

				break;

			    case '8':

				c = (char)0x80;

				break;

			    case '9':

				c = (char)0x90;

				break;

			    case 'A':

			    case 'a':

				c = (char)0xa0;

				break;

			    case 'B':

			    case 'b':

				c = (char)0xb0;

				break;

			    case 'C':

			    case 'c':

				c = (char)0xc0;

				break;

			    case 'D':

			    case 'd':

				c = (char)0xd0;

				break;

			    case 'E':

			    case 'e':

				c = (char)0xe0;

				break;

			    case 'F':

			    case 'f':

				c = (char)0xf0;

				break;

			    default:

				return -1;

			    }

			    switch (*++cp) {

			    case '0':

				c += 0x00;

				break;

			    case '1':

				c += 0x01;

				break;

			    case '2':

				c += 0x02;

				break;

			    case '3':

				c += 0x03;

				break;

			    case '4':

				c += 0x04;

				break;

			    case '5':

				c += 0x05;

				break;

			    case '6':

				c += 0x06;

				break;

			    case '7':

				c += 0x07;

				break;

			    case '8':

				c += 0x08;

				break;

			    case '9':

				c += 0x09;

				break;

			    case 'A':

			    case 'a':

				c += 0x0a;

				break;

			    case 'B':

			    case 'b':

				c += 0x0b;

				break;

			    case 'C':

			    case 'c':

				c += 0x0c;

				break;

			    case 'D':

			    case 'd':

				c += 0x0d;

				break;

			    case 'E':

			    case 'e':

				c += 0x0e;

				break;

			    case 'F':

			    case 'f':

				c += 0x0f;

				break;

			    default:

				return -2;

			    }

			    putchar(c);

			    break;

			default:

			    putchar(*cp);

			    break;

			}

		    }

	    	    else if (*cp == '%')

		    {

			enum boolmode  boolfmt;

			SavedImage *sp = &GifFileIn->SavedImages[i];

			if (cp[1] == 't') {

			    boolfmt = tf;

			    ++cp;

			} else if (cp[1] == 'o') {

			    boolfmt = onoff;

			    ++cp;

			} else if (cp[1] == 'y') {

			    boolfmt = yesno;

			    ++cp;

			} else if (cp[1] == '1') {

			    boolfmt = numeric;

			    ++cp;

			} else

			    boolfmt = numeric;

			switch (*++cp) 

			{

			case '%':

			    putchar('%');

			    break;

			case 'a':

			    (void)printf("%d", GifFileIn->AspectByte);

			    break;

			case 'b':

			    (void)printf("%d", GifFileIn->SBackGroundColor);

			    break;

			case 'd':

			    DGifSavedExtensionToGCB(GifFileIn, 

						    selected[i], 

						    &gcb;;

			    (void)printf("%d", gcb.DelayTime);

			    break;

			case 'h':

			    (void)printf("%d", ip->ImageDesc.Height);

			    break;

			case 'n':

			    (void)printf("%d", selected[i]+1);

			    break;

			case 'p':

			    (void)printf("%d,%d", 

					 ip->ImageDesc.Left, ip->ImageDesc.Top);

			    break;

			case 's':

			    (void)printf("%d,%d", 

					 GifFileIn->SWidth, 

					 GifFileIn->SHeight);

			    break;

			case 'w':

			    (void)printf("%d", ip->ImageDesc.Width);

			    break;

			case 't':

			    DGifSavedExtensionToGCB(GifFileIn, 

						    selected[i], 

						    &gcb;;

			    (void)printf("%d", gcb.TransparentColor);

			    break;

			case 'u':

			    DGifSavedExtensionToGCB(GifFileIn, 

						    selected[i], 

						    &gcb;;

			    (void)printf("%s", putbool(gcb.UserInputFlag, boolfmt));

			    break;

			case 'v':

			    fputs(EGifGetGifVersion(GifFileIn), stdout);

			    break;

			case 'x':

			    DGifSavedExtensionToGCB(GifFileIn, 

						    selected[i], 

						    &gcb;;

			    (void)printf("%d", gcb.DisposalMode);

			    break;

			case 'z':

			    (void) printf("%s", putbool(sp->ImageDesc.ColorMap && sp->ImageDesc.ColorMap->SortFlag, boolfmt));

			    break;

			default:

			    (void)fprintf(stderr, 

					  "giftool: bad format %%%c\n", *cp);

			}

		    }

	    	    else

			(void)putchar(*cp);

		}

	    }

	    exit(EXIT_SUCCESS);

	    break;

	case interlace:

	    for (i = 0; i < nselected; i++)

		GifFileIn->SavedImages[selected[i]].ImageDesc.Interlace = op->flag;

	    break;

	case position:

	    for (i = 0; i < nselected; i++) {

		GifFileIn->SavedImages[selected[i]].ImageDesc.Left = op->p.x;

		GifFileIn->SavedImages[selected[i]].ImageDesc.Top  = op->p.y;

	    }

	    break;

	case screensize:

	    GifFileIn->SWidth = op->p.x;

	    GifFileIn->SHeight = op->p.y;

	    break;

	case transparent:

	    for (i = 0; i < nselected; i++)

	    {

		GraphicsControlBlock gcb;

		DGifSavedExtensionToGCB(GifFileIn, selected[i], &gcb;;

		gcb.TransparentColor = op->color;

		EGifGCBToSavedExtension(&gcb, GifFileIn, selected[i]);

	    }

	    break;

	case userinput:

	    for (i = 0; i < nselected; i++)

	    {

		GraphicsControlBlock gcb;

		DGifSavedExtensionToGCB(GifFileIn, selected[i], &gcb;;

		gcb.UserInputFlag = op->flag;

		EGifGCBToSavedExtension(&gcb, GifFileIn, selected[i]);

	    }

	    break;

	case disposal:

	    for (i = 0; i < nselected; i++)

	    {

		GraphicsControlBlock gcb;

		DGifSavedExtensionToGCB(GifFileIn, selected[i], &gcb;;

		gcb.DisposalMode = op->dispose;

		EGifGCBToSavedExtension(&gcb, GifFileIn, selected[i]);

	    }

	    break;

	default:

	    (void)fprintf(stderr, "giftool: unknown operation mode\n");

	    exit(EXIT_FAILURE);

	}

    /* write out the results */

    GifFileOut->SWidth = GifFileIn->SWidth;

    GifFileOut->SHeight = GifFileIn->SHeight;

    GifFileOut->SColorResolution = GifFileIn->SColorResolution;

    GifFileOut->SBackGroundColor = GifFileIn->SBackGroundColor;

    GifFileOut->SColorMap = GifMakeMapObject(

				 GifFileIn->SColorMap->ColorCount,

				 GifFileIn->SColorMap->Colors);

    for (i = 0; i < GifFileIn->ImageCount; i++)

	(void) GifMakeSavedImage(GifFileOut, &GifFileIn->SavedImages[i]);

    EGifSpew(GifFileOut);

    if (DGifCloseFile(GifFileIn, &ErrorCode) == GIF_ERROR)

	PrintGifError(ErrorCode);

    return 0;

}

/* end */