/*  -*- c -*-  */
/* -------------------------------------------------------------------- *
**  copyright (c) 1995 thomas harrer, ipvr stuttgart.
**  see copyright notices below.
** -------------------------------------------------------------------- *
**
**  libhelp
**
**  a comprehensive hypertext help system for OSF/Motif(tm) applications. 
**  based on libhtmlw from NCSA Mosaic(tm) version 2.4
**
**  written by thomas harrer
**  e-mail: Thomas.Harrer@rus.uni-stuttgart.de
**
** -------------------------------------------------------------------- *
*h  $Id: imageio.c,v 1.10 1995/06/28 12:59:30 thomas Exp $
** -------------------------------------------------------------------- *
**
*h  module:		imageio.c
**
**  contents:		ReadGIF from David Koblas.
**			see Copyright notice below
**
**  interface:		ReadBitmap
**
** -------------------------------------------------------------------- */

/* Copyright for ReadGIF and related stuff:  */
/* +-------------------------------------------------------------------+ */
/* | Copyright 1990 - 1994, David Koblas. (koblas@netcom.com)          | */
/* |   Permission to use, copy, modify, and distribute this software   | */
/* |   and its documentation for any purpose and without fee is hereby | */
/* |   granted, provided that the above copyright notice appear in all | */
/* |   copies and that both that copyright notice and this permission  | */
/* |   notice appear in supporting documentation.  This software is    | */
/* |   provided "as is" without express or implied warranty.           | */
/* +-------------------------------------------------------------------+ */

/* Copyright for ReadBitmap:  */
/****************************************************************************
 * NCSA Mosaic for the X Window System                                      *
 * Software Development Group                                               *
 * National Center for Supercomputing Applications                          *
 * University of Illinois at Urbana-Champaign                               *
 * 605 E. Springfield, Champaign IL 61820                                   *
 * mosaic@ncsa.uiuc.edu                                                     *
 *                                                                          *
 * Copyright (C) 1993, Board of Trustees of the University of Illinois      *
 *                                                                          *
 * NCSA Mosaic software, both binary and source (hereafter, Software) is    *
 * copyrighted by The Board of Trustees of the University of Illinois       *
 * (UI), and ownership remains with the UI.                                 *
 *                                                                          *
 * The UI grants you (hereafter, Licensee) a license to use the Software    *
 * for academic, research and internal business purposes only, without a    *
 * fee.  Licensee may distribute the binary and source code (if released)   *
 * to third parties provided that the copyright notice and this statement   *
 * appears on all copies and that no charge is associated with such         *
 * copies.                                                                  *
 *                                                                          *
 * Licensee may make derivative works.  However, if Licensee distributes    *
 * any derivative work based on or derived from the Software, then          *
 * Licensee will (1) notify NCSA regarding its distribution of the          *
 * derivative work, and (2) clearly notify users that such derivative       *
 * work is a modified version and not the original NCSA Mosaic              *
 * distributed by the UI.                                                   *
 *                                                                          *
 * Any Licensee wishing to make commercial use of the Software should       *
 * contact the UI, c/o NCSA, to negotiate an appropriate license for such   *
 * commercial use.  Commercial use includes (1) integration of all or       *
 * part of the source code into a product for sale or license by or on      *
 * behalf of Licensee to third parties, or (2) distribution of the binary   *
 * code or source code to third parties that need it to utilize a           *
 * commercial product sold or licensed by or on behalf of Licensee.         *
 *                                                                          *
 * UI MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR   *
 * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED          *
 * WARRANTY.  THE UI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY THE    *
 * USERS OF THIS SOFTWARE.                                                  *
 *                                                                          *
 * By using or copying this Software, Licensee agrees to abide by the       *
 * copyright law and all other applicable laws of the U.S. including, but   *
 * not limited to, export control laws, and the terms of this license.      *
 * UI shall have the right to terminate this license immediately by         *
 * written notice upon Licensee's breach of, or non-compliance with, any    *
 * of its terms.  Licensee may be held legally responsible for any          *
 * copyright infringement that is caused or encouraged by Licensee's        *
 * failure to abide by the terms of this license.                           *
 *                                                                          *
 * Comments and questions are welcome and can be sent to                    *
 * mosaic-x@ncsa.uiuc.edu.                                                  *
 ****************************************************************************/
#include "helpp.h"

#include <stdio.h>
#include <X11/Intrinsic.h>

#define	MAXCOLORMAPSIZE		256

#define	TRUE			1
#define	FALSE			0

#define CM_RED			0
#define CM_GREEN		1
#define CM_BLUE			2

#define	MAX_LWZ_BITS		12

#define INTERLACE		0x40
#define LOCALCOLORMAP		0x80
#define BitSet(byte, bit)	(((byte) & (bit)) == (bit))

#define	ReadOK(file,buffer,len)	(fread(buffer, len, 1, file) != 0)

#define LM_to_uint(a,b)		(((b)<<8)|(a))

static struct {

    unsigned int	Width;
    unsigned int	Height;
    unsigned char	ColorMap[3][MAXCOLORMAPSIZE];
    unsigned int	BitPixel;
    unsigned int	ColorResolution;
    unsigned int	Background;
    unsigned int	AspectRatio;
    int             	xGrayScale;

} GifScreen;

static struct {

    int	transparent;
    int	delayTime;
    int	inputFlag;
    int	disposal;

} Gif89 = { -1, -1, -1, 0 };

/* global flags  */
static int	verbose = FALSE;
static int	showComment = FALSE;

/* prototypes  */
static int ReadColorMap (FILE*, int, unsigned char [3][MAXCOLORMAPSIZE], int*);
static int DoExtension (FILE*, int);
static int GetDataBlock (FILE*, unsigned char *);
static unsigned char* ReadImage (FILE*, int, int, XColor*, int,
				 unsigned char[3][MAXCOLORMAPSIZE], 
				 int, int, int);

/* -------------------------------------------------------------------- *
*P  procedure-name:	ReadGIF
**
**			Read a GIF file (from opened stream fd).
**			Code from David Koblas.
**			cited after Mosaic 2.4's gifread.c.
** -------------------------------------------------------------------- */
unsigned char *
ReadGIF (/* i  */ FILE*		fd, 
	 /*  o */ int*		w, 
	 /*  o */ int*		h, 
	 /*  o */ XColor*	colrs, 
	 /*  o */ int*		bg)
{
    unsigned char	buf[16];
    unsigned char	c;
    unsigned char	localColorMap[3][MAXCOLORMAPSIZE];
    int			grayScale;
    int			useGlobalColormap;
    int			bitPixel;
    int			imageCount = 0;
    char		version[4];
    int			imageNumber = 1;
    unsigned char	*image = NULL;
    int i;

    verbose = FALSE;
    showComment = FALSE;

    /*
     * Initialize GIF89 extensions
     */
    Gif89.transparent = -1;
    Gif89.delayTime = -1;
    Gif89.inputFlag = -1;
    Gif89.disposal = 0;

    if (! ReadOK(fd,buf,6)) {
	return (NULL);
    }

    if (c_strncmp((char *)buf,"GIF",3) != 0) {
	return (NULL);
    }

    c_strncpy(version, (char *)buf + 3, 3);
    version[3] = '\0';

    if ((c_strcmp(version, "87a") != 0) && (c_strcmp(version, "89a") != 0)) {
	return (NULL);
    }

    if (! ReadOK (fd, buf, 7)) {
	return (NULL);
    }

    GifScreen.Width           = LM_to_uint(buf[0],buf[1]);
    GifScreen.Height          = LM_to_uint(buf[2],buf[3]);
    GifScreen.BitPixel        = 2<<(buf[4]&0x07);
    GifScreen.ColorResolution = (((buf[4]&0x70)>>3)+1);
    GifScreen.Background      = buf[5];
    GifScreen.AspectRatio     = buf[6];

    if (BitSet(buf[4], LOCALCOLORMAP)) { /* Global Colormap */
	int scale = 65536/MAXCOLORMAPSIZE;

	if (ReadColorMap(fd,GifScreen.BitPixel,GifScreen.ColorMap,
			 &GifScreen.xGrayScale)) {
	    return (NULL);
	}
	for (i=0; i < GifScreen.BitPixel; i++) {

	    colrs[i].red = GifScreen.ColorMap[0][i] * scale;
	    colrs[i].green = GifScreen.ColorMap[1][i] * scale;
	    colrs[i].blue = GifScreen.ColorMap[2][i] * scale;
	    colrs[i].pixel = i;
	    colrs[i].flags = DoRed|DoGreen|DoBlue;
	}
	
	for (i = GifScreen.BitPixel; i<MAXCOLORMAPSIZE; i++) {
	    colrs[i].red = 0;
	    colrs[i].green = 0;
	    colrs[i].blue = 0;
	    colrs[i].pixel = i;
	    colrs[i].flags = DoRed|DoGreen|DoBlue;
	}
    }

    if (GifScreen.AspectRatio != 0 && GifScreen.AspectRatio != 49) {
	float	r;
	r = ( (float) GifScreen.AspectRatio + 15.0 ) / 64.0;
    }

    while (image == NULL) {
	if (! ReadOK(fd,&c,1)) {
	    return (NULL);
	}

	if (c == ';') {		/* GIF terminator */
	    if (imageCount < imageNumber) {
		return (NULL);
	    }
	    break;
	}

	if (c == '!') { 	/* Extension */
	    if (! ReadOK(fd,&c,1)) {
		return (NULL);
	    }
	    DoExtension(fd, c);
	    continue;
	}

	if (c != ',') {		/* Not a valid start character */
	    continue;
	}

	++imageCount;

	if (! ReadOK(fd,buf,9)) {
	    return(NULL);
	}

	useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP);

	bitPixel = 1<<((buf[8]&0x07)+1);

	/*
	 * We only want to set width and height for the imageNumber
	 * we are requesting.
	 */
	if (imageCount == imageNumber)
	{
	    *w = LM_to_uint(buf[4],buf[5]);
	    *h = LM_to_uint(buf[6],buf[7]);
	}
	if (! useGlobalColormap) {
	    if (ReadColorMap(fd,bitPixel,localColorMap,&grayScale)) {
		return(NULL);
	    }

	    /*
	     * We only want to set the data for the
	     * imageNumber we are requesting.
	     */
	    if (imageCount == imageNumber) {
		image = ReadImage(fd, LM_to_uint(buf[4],buf[5]),
				  LM_to_uint(buf[6],buf[7]), colrs,
				  bitPixel, localColorMap, grayScale,
				  BitSet(buf[8], INTERLACE),
				  imageCount != imageNumber);
	    } else {
		unsigned char *tdata;

		tdata = ReadImage(fd, LM_to_uint(buf[4],buf[5]),
				  LM_to_uint(buf[6],buf[7]), colrs,
				  bitPixel, localColorMap, grayScale,
				  BitSet(buf[8], INTERLACE),
				  imageCount != imageNumber);
	    }
	} else {
	    /*
	     * We only want to set the data for the
	     * imageNumber we are requesting.
	     */
	    if (imageCount == imageNumber)
	    {
		image = ReadImage(fd, LM_to_uint(buf[4],buf[5]),
				  LM_to_uint(buf[6],buf[7]), colrs,
				  GifScreen.BitPixel, GifScreen.ColorMap,
				  GifScreen.xGrayScale,
				  BitSet(buf[8], INTERLACE),
				  imageCount != imageNumber);
	    } else {
		unsigned char *tdata;

		tdata = ReadImage(fd, LM_to_uint(buf[4],buf[5]),
				  LM_to_uint(buf[6],buf[7]), colrs,
				  GifScreen.BitPixel, GifScreen.ColorMap,
				  GifScreen.xGrayScale,
				  BitSet(buf[8], INTERLACE),
				  imageCount != imageNumber);
	    }
	}
    }
    *bg = Gif89.transparent;

    return(image);
}

/* -------------------------------------------------------------------- *
*P  procedure-name:	ReadColorMap
** -------------------------------------------------------------------- */
static int
ReadColorMap (/* i  */ FILE* 	fd, 
	      /* i  */ int 	number, 
	      /*  o */ unsigned char buffer[3][MAXCOLORMAPSIZE],
	      /*  o */ int*	gray)
{
    int		i;
    unsigned char	rgb[3];
    int		flag;

    flag = TRUE;

    for (i = 0; i < number; ++i) {
	if (! ReadOK(fd, rgb, sizeof(rgb))) {
	    return(TRUE);
	}

	buffer[CM_RED][i] = rgb[0] ;
	buffer[CM_GREEN][i] = rgb[1] ;
	buffer[CM_BLUE][i] = rgb[2] ;

	flag &= (rgb[0] == rgb[1] && rgb[1] == rgb[2]);
    }

    *gray = flag;

    return FALSE;
}

static int
DoExtension (FILE* 	fd, 
	     int 	label)
{
    static char	buf[256];
    char	*str;

    switch (label) {
      case 0x01:		/* Plain Text Extension */
	str = "Plain Text Extension";
	break;
      case 0xff:		/* Application Extension */
	str = "Application Extension";
	break;
      case 0xfe:		/* Comment Extension */
	str = "Comment Extension";
	while (GetDataBlock(fd, (unsigned char*) buf) > 0) {
	    if (showComment) {
		;
	    }
	}
	return FALSE;
      case 0xf9:		/* Graphic Control Extension */
	str = "Graphic Control Extension";
	(void) GetDataBlock(fd, (unsigned char*) buf);
	Gif89.disposal    = (buf[0] >> 2) & 0x7;
	Gif89.inputFlag   = (buf[0] >> 1) & 0x1;
	Gif89.delayTime   = LM_to_uint(buf[1],buf[2]);
	if ((buf[0] & 0x1) != 0)
	    Gif89.transparent = (int)((unsigned char)buf[3]);

	while (GetDataBlock(fd, (unsigned char*) buf) > 0)
	    ;
	return FALSE;
      default:
	str = buf;
	sprintf (buf, "UNKNOWN (0x%02x)", label);
	break;
    }

    /* fprintf(stderr, "got a '%s' extension\n", str); */

    while (GetDataBlock(fd, (unsigned char*) buf) > 0)
	;

    return FALSE;
}

static int	ZeroDataBlock = FALSE;

static int
GetDataBlock (FILE 		*fd, 
	      unsigned char 	*buf)
{
    unsigned char	count;

    count = 0;
    if (! ReadOK(fd, &count, 1)) {
	return -1;
    }

    ZeroDataBlock = count == 0;

    if ((count != 0) && (! ReadOK(fd, buf, count))) {
	return -1;
    }

    return((int)count);
}

/*
**  Pulled out of nextCode
*/
static  int             curbit, lastbit, get_done, last_byte;
static  int             return_clear;
/*
**  Out of nextLWZ
*/
static int      stack[(1<<(MAX_LWZ_BITS))*2], *sp;
static int      code_size, set_code_size;
static int      max_code, max_code_size;
static int      clear_code, end_code;

/* -------------------------------------------------------------------- *
*P  procedure-name:	initLWZ
** -------------------------------------------------------------------- */
static void 
initLWZ (/* i  */ int input_code_size)
{
/*    static int      inited = FALSE;*/

    set_code_size = input_code_size;
    code_size     = set_code_size + 1;
    clear_code    = 1 << set_code_size ;
    end_code      = clear_code + 1;
    max_code_size = 2 * clear_code;
    max_code      = clear_code + 2;

    curbit = lastbit = 0;
    last_byte = 2;
    get_done = FALSE;

    return_clear = TRUE;

    sp = stack;
}

/* -------------------------------------------------------------------- *
*P  procedure-name:	nextCode
** -------------------------------------------------------------------- */
static int 
nextCode (FILE 	*fd, 
	  int  	code_size)
{
    static unsigned char    buf[280];
    static int maskTbl[16] = {
	0x0000, 0x0001, 0x0003, 0x0007,
	0x000f, 0x001f, 0x003f, 0x007f,
	0x00ff, 0x01ff, 0x03ff, 0x07ff,
	0x0fff, 0x1fff, 0x3fff, 0x7fff,
    };
    int                     i, j, ret, end;

    if (return_clear) {
	return_clear = FALSE;
	return clear_code;
    }

    end = curbit + code_size;

    if (end >= lastbit) {
	int     count;

	if (get_done) {
	    if (curbit >= lastbit) {
		;
	    }
	    return -1;
	}
	buf[0] = buf[last_byte-2];
	buf[1] = buf[last_byte-1];

	if ((count = GetDataBlock(fd, &buf[2])) == 0)
	    get_done = TRUE;

	last_byte = 2 + count;
	curbit = (curbit - lastbit) + 16;
	lastbit = (2+count)*8 ;

	end = curbit + code_size;
    }

    j = end / 8;
    i = curbit / 8;

    if (i == j)
	ret = (int)buf[i];
    else if (i + 1 == j)
	ret = (int)buf[i] | ((int)buf[i+1] << 8);
    else
	ret = (int)buf[i] | ((int)buf[i+1] << 8) | ((int)buf[i+2] << 16);

    ret = (ret >> (curbit % 8)) & maskTbl[code_size];

    curbit += code_size;

    return ret;
}

#define readLWZ(fd) ((sp > stack) ? *--sp : nextLWZ(fd))

/* -------------------------------------------------------------------- *
*P  procedure-name:	nextLWZ
** -------------------------------------------------------------------- */
static int 
nextLWZ (/* i  */ FILE *fd)
{
    static int       table[2][(1<< MAX_LWZ_BITS)];
    static int       firstcode, oldcode;
    int              code, incode;
    register int     i;

    while ((code = nextCode(fd, code_size)) >= 0) {
	if (code == clear_code) {

	    /* corrupt GIFs can make this happen */
	    if (clear_code >= (1<<MAX_LWZ_BITS)) {
		return -2;
	    }

	    for (i = 0; i < clear_code; ++i) {
		table[0][i] = 0;
		table[1][i] = i;
	    }
	    for (; i < (1<<MAX_LWZ_BITS); ++i)
		table[0][i] = table[1][i] = 0;
	    code_size = set_code_size+1;
	    max_code_size = 2*clear_code;
	    max_code = clear_code+2;
	    sp = stack;
	    do {
		firstcode = oldcode = nextCode(fd, code_size);
	    } while (firstcode == clear_code);

	    return firstcode;
	}
	if (code == end_code) {
	    int             count;
	    unsigned char   buf[260];

	    if (ZeroDataBlock)
		return -2;

	    while ((count = GetDataBlock(fd, buf)) > 0)
		;

	    if (count != 0)  {
		;
	    }
	    return -2;
	}

	incode = code;

	if (code >= max_code) {
	    *sp++ = firstcode;
	    code = oldcode;
	}

	while (code >= clear_code) {
	    *sp++ = table[1][code];
	    if (code == table[0][code]) {
		return(code);
	    }
	    if ((int)sp >= ((int)stack + sizeof(stack))) {
		return(code);
	    }
	    code = table[0][code];
	}

	*sp++ = firstcode = table[1][code];

	if ((code = max_code) <(1<<MAX_LWZ_BITS)) {
	    table[0][code] = oldcode;
	    table[1][code] = firstcode;
	    ++max_code;
	    if ((max_code >= max_code_size) &&
		(max_code_size < (1<<MAX_LWZ_BITS))) {
		max_code_size *= 2;
		++code_size;
	    }
	}

	oldcode = incode;

	if (sp > stack)
	    return *--sp;
    }
    return code;
}


/* -------------------------------------------------------------------- *
*P  procedure-name:	ReadImage
** -------------------------------------------------------------------- */
static unsigned char *
ReadImage (/* i  */ FILE 	*fd, 
	   /* i  */ int 	len, 
	   /* i  */ int 	height, 
	   /* i  */ XColor* 	colrs, 
	   /* i  */ int 	cmapSize,
	   /* i  */ unsigned char cmap[3][MAXCOLORMAPSIZE],
	   /* i  */ int 	gray,
	   /* i  */ int 	interlace, 
	   /* i  */ int 	ignore)
{
    unsigned char	*dp, c;	
    int			v;
    int			xpos = 0, ypos = 0;
    /*int 		pass = 0;*/
    unsigned char 	*image;

    /*
     **  Initialize the Compression routines
     */
    if (! ReadOK(fd,&c,1)) {
	return(NULL);
    }

    initLWZ(c);

    /*
     **  If this is an "uninteresting picture" ignore it.
     */
    if (ignore) {
	while (readLWZ(fd) >= 0)
	    ;
	return(NULL);
    }

    checked_calloc (image, len * height, unsigned char);
    if (image == NULL) {
	return(NULL);
    }

    for (v = 0; v < MAXCOLORMAPSIZE; v++) {
	colrs[v].red = colrs[v].green = colrs[v].blue = 0;
	colrs[v].pixel = v;
	colrs[v].flags = DoRed|DoGreen|DoBlue;
    }
    for (v = 0; v < cmapSize; v++) {
	colrs[v].red   = cmap[CM_RED][v]   * 0x101;
	colrs[v].green = cmap[CM_GREEN][v] * 0x101;
	colrs[v].blue  = cmap[CM_BLUE][v]  * 0x101;
    }

    if (interlace) {
	int     i;
	int     pass = 0, step = 8;

	for (i = 0; i < height; i++) {
	    if (ypos < height)
	    {
		dp = &image[len * ypos];
		for (xpos = 0; xpos < len; xpos++) {
		    if ((v = readLWZ(fd)) < 0)
			goto fini;

		    *dp++ = v;
		}
	    }
	    if ((ypos += step) >= height) {
		if (pass++ > 0)
		    step /= 2;
		ypos = step / 2;
	    }
	}
    } else {
	dp = image;
	for (ypos = 0; ypos < height; ypos++) {
	    for (xpos = 0; xpos < len; xpos++) {
		if ((v = readLWZ(fd)) < 0)
		    goto fini;

		*dp++ = v;
	    }
	}
    }

  fini:
    if (readLWZ (fd)>=0) {
    }

    return(image);
}

/* -------------------------------------------------------------------- *
*P  procedure-name:	ReadBitmap
**  
**			from Mosaic 2.4.
**			currently only GIF's are supported.
**			Could be easily extended to x-bitmaps and 
**			xpm3 pixmaps.
** -------------------------------------------------------------------- */
unsigned char*
ReadBitmap (/* i  */ char* 	datafile, 
	    /*  o */ int* 	w, 
	    /*  o */ int* 	h, 
	    /*  o */ XColor* 	colrs, 
	    /*  o */ int* 	bg)
{
    unsigned char *bit_data;
    FILE *fp;

    *bg = -1;

    /* Obviously this isn't going to work. */
    if ((datafile == NULL) || (datafile[0] == '\0')) {
	fp = NULL;
    } else {
	fp = fopen (datafile, "r");
    }

    if (fp != NULL) {
	bit_data = ReadGIF (fp, w, h, colrs, bg);
	if (bit_data != NULL) {
	    if (fp != stdin) fclose(fp);
	    return (bit_data);
	}
    }
    
    if (fp != stdin) fclose(fp);
    return ((unsigned char*) NULL);
}
/* -------------------------------------------------------------------- *
*L  Emacs:
**  Local Variables:
**  mode:		c
**  outline-regexp:	"\*[HGPLT]"
**  gh-language:	"english"
**  comment-column:	32
**  eval:		(outline-minor-mode t)
**  End:
** -------------------------------------------------------------------- */