/*
 * (c) SPDsoft 1993 + ATIC
 * Display a JFIF file using Silicon Graphics gl
 * version 0.4
 * Uses IJG code v6b or ImageMagick 5.x
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include <gl/gl.h>
#include <gl/device.h>
#include <get.h>

#ifdef USE_MAGICK
#include <magick/magick.h>
#else
#include <jpeglib.h>
#include <setjmp.h>
#endif

#ifndef PATH_SEP
# define PATH_SEP	'/'
#endif


#define ALPHA_OPAC	0x00
#define YSTEREO 491
#define YOFFSET_LEFT (1024 - (YSTEREO+1))
#define SCREEN_W	G_prefs.screen_w
#define SCREEN_H	G_prefs.screen_h

#define Boolean	int 
#define Output	if (G_prefs.Verbose) printf

#ifndef MIN
#define MIN(a,b) ((a)>(b)?(b):(a))
#endif

typedef struct { 
			char 	*AppName;
			Boolean Foreground;	
			Boolean FullScreen;	
			Boolean FillScreen;	
			Boolean Stereo;	
			Boolean Crossed;	
			Boolean Anaglyph;	
			Boolean Nosetmon;	
			Boolean Growable;	
			Boolean KeepAspectRatio;	
			Boolean Verbose;	
			int		SlideShow;	
			long	screen_w;
			long	screen_h;
		}  pref;


/*
 * Prototypes
 */
void	init_graphics(void);
int		event_loop(void);
void	redraw(void);
void    usage(char *name);
void    fatalError(char *str);
void	get_options(int argc,char *argv[]);
int		is_stereo(void);

#ifndef USE_MAGICK
/*
 * JPEG Prototypes
 */

static void		my_error_exit (j_common_ptr cinfo);
#endif
int				read_file (char * filename, unsigned char **fb, unsigned char **fb2);


extern char     *optarg;
extern int      optind,opterr;

unsigned		image_H;
unsigned		image_W;
long			monitor;
long			mouse;
long			offset=0;
int				f;
#define framebuffer_r framebuffer
unsigned char	*framebuffer,
				*framebuffer_l,
				*pix, *pix2;

pref			G_prefs;

#ifndef USE_MAGICK
static char __ident[] = "@(#)(c) SPDsoft, (Uses IJG code v6b), 0.4 Sep 2004";
#else
static char __ident[] = "@(#)(c) SPDsoft, (Uses ImageMagick), 0.4 Sep 2004";
#endif
#define VERS_STR    ((char*)&__ident[4])

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

void    usage(char *name)
{
    fprintf(stderr,
    "usage: %s [-b|-F|-g|-G][-s sec][-fvhxa][-3|-4 left right|files...]"
	"\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
	name,
	"-f: Don't fork (run in foreground)",
	"-b: Full screen",
	"-3: Stereo",
	"-4: Stereo w/o setmon",
	"-x: Stereo crossed (r|l)",
	"-a: Stereo anaglyph to grayscale",
	"-F: Fill full screen",
	"-g: Growable, Keep aspect ratio",
	"-G: Growable",
	"-s: Slide Show (seconds)",
	"-v: Version, debug",
	"-h: This text. Note: Press <esc> to go to next image"
	);
    exit(-1);
}

void    fatalError(char *str)
{
    fprintf(stderr, "%s: Fatal Error: %s. bye...\n",G_prefs.AppName,str);
    fprintf(stderr, "%s: %s\n",G_prefs.AppName,strerror(errno));
	if((G_prefs.Stereo||G_prefs.Crossed)&&(!G_prefs.Nosetmon))
	{
		/* restore to original display, cursor range */
/*		setmonitor ((short)monitor);*/
		setmonitor (HZ76);
		setvaluator (MOUSEY, mouse , 0, (short) SCREEN_H);
	}
    exit(-2);
}

#ifndef USE_MAGICK
struct my_error_mgr
{
	struct jpeg_error_mgr pub;	/* "public" fields */
	jmp_buf setjmp_buffer;		/* for return to caller */
};

typedef struct my_error_mgr * my_error_ptr;

static void my_error_exit (j_common_ptr cinfo)
{
	my_error_ptr myerr = (my_error_ptr) cinfo->err;

	(*cinfo->err->output_message) (cinfo);
	longjmp(myerr->setjmp_buffer, 1);
}
#endif

#ifdef USE_MAGICK
int read_file (char * filename, unsigned char **fb, unsigned char **fb2)
{
	Image *image;
	ImageInfo *image_info;
	ExceptionInfo exception;
	PixelPacket	q;
	int i,j;

	image_info=CloneImageInfo((ImageInfo *) NULL);
	if (filename != NULL)
	{
		(void) strcpy(image_info->filename,filename);
	}
	else
	{
		(void) strcpy(image_info->filename,"-");
	}
	image=ReadImage(image_info,&exception);


	image_H=image->rows;
	image_W=image->columns;

	if (( NULL != fb2 )&&(!G_prefs.Anaglyph))
		image_W /=2 ;


/*
 * Framebuffer
 */
	Output("%03d %s\t%u\t%u\t",f,filename,image_H,image_W );
	if (G_prefs.Verbose) fflush(stdout);

	if((( image_W > SCREEN_W ) || ( image_H > SCREEN_H))&&(G_prefs.FullScreen))
			G_prefs.FillScreen=1;
			
	*fb =
		(unsigned char *)calloc( (size_t)image_H * (size_t)image_W , (size_t)4);
	
	if (*fb==NULL) fatalError("Out of memory");
	pix = *fb + (size_t)4*image_W*(image_H-1);


	if ( NULL != fb2 )
	{
	*fb2 =
		(unsigned char *)calloc( (size_t)image_H * (size_t)image_W , (size_t)4);
	
	if (*fb2==NULL) fatalError("Out of memory");
	pix2 = *fb2 + (size_t)4*image_W*(image_H-1);
	}

/*
 * Draw to framebuffer
 */


	for(i=0; i<image_H; i++)
	{
		for(j=0; j<image_W; j++)
		{
			q=GetOnePixel(image, j, i); 

			if (G_prefs.Anaglyph)
			{
				*pix++ = q.opacity;
				*pix++ = q.blue;
				*pix++ = q.blue;
				*pix++ = q.blue;
				*pix2++ = q.opacity;
				*pix2++ = q.red;
				*pix2++ = q.red;
				*pix2++ = q.red;
			}
			else
			{
				*pix++ = q.opacity;
				*pix++ = q.blue;
				*pix++ = q.green;
				*pix++ = q.red;
			}
		}
		if (( NULL != fb2 )&&(!G_prefs.Anaglyph))
		{
			for (j=image_W; j<2*image_W; j++)
			{
				q=GetOnePixel(image, j, i); 
				*pix2++ = q.opacity;
				*pix2++ = q.blue;
				*pix2++ = q.green;
				*pix2++ = q.red;
			}
		}
		pix -= 8* image_W;
		pix2 -= 8* image_W;
	}


	DestroyImage(image);


	return 0;
}
#else
int read_file (char * filename, unsigned char **fb, unsigned char **fb2)
{
	struct jpeg_decompress_struct cinfo;
	struct my_error_mgr jerr;

	FILE		*infile;			/* source file */
	JSAMPARRAY	buffer;				/* Output row buffer */
	int			row_stride;         /* physical row width in output buffer */
	register JSAMPROW inptr;

	int j,w;

	
	if (filename != NULL)
	{
		if ((infile = fopen(filename, "rb")) == NULL)
		{
			fatalError(filename);
		}
	}
	else
		infile = stdin;

	cinfo.err = jpeg_std_error(&jerr.pub);
	jerr.pub.error_exit = my_error_exit;
	if (setjmp(jerr.setjmp_buffer))
	{
	/* If we get here, the JPEG code has signaled an error.
	 * We need to clean up the JPEG object, close the input file, and return.
	 */
		jpeg_destroy_decompress(&cinfo);
		fclose(infile);
		return NULL;
	}


	jpeg_create_decompress(&cinfo);
	jpeg_stdio_src(&cinfo, infile);
	(void) jpeg_read_header(&cinfo, TRUE);

	jpeg_start_decompress(&cinfo);

	image_H = cinfo.output_height;
	image_W = cinfo.output_width;

	row_stride = cinfo.output_width * cinfo.output_components;
	buffer = (*cinfo.mem->alloc_sarray)
		((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);


	if (( NULL != fb2 )&&(!G_prefs.Anaglyph))
		image_W /=2 ;
/*
 * Framebuffer
 */
	Output("%03d %s\t%u\t%u\t",f,filename,image_H,image_W );
	if((( image_W > SCREEN_W ) || ( image_H > SCREEN_H))&&(G_prefs.FullScreen))
			G_prefs.FillScreen=1;
			
	*fb =
		(unsigned char *)calloc( (size_t)image_H * (size_t)image_W , (size_t)4);
	
	if ((*fb==NULL)||(buffer==NULL)) fatalError("Out of memory");
	pix = *fb + (size_t)4*image_W*(image_H-1);
	w=cinfo.output_width;

	if ( NULL != fb2 )
	{
	*fb2 =
		(unsigned char *)calloc( (size_t)image_H * (size_t)image_W , (size_t)4);
	
	if (*fb2==NULL) fatalError("Out of memory");
	pix2 = *fb2 + (size_t)4*image_W*(image_H-1);
	if (!G_prefs.Anaglyph)
		w=cinfo.output_width/2;
	}

/*
 * Draw to framebuffer
 */
	if ( cinfo.output_components != 1 )
	{
		Output("RGB image\n");
		while (cinfo.output_scanline < cinfo.output_height)
		{
			(void) jpeg_read_scanlines(&cinfo, buffer, 1);
			for (j=0, inptr=*buffer; j<w; j++)
			{
				if (G_prefs.Anaglyph)
				{
					/*
					 * Red Channel: Left Eye (Red lens)
					 * Green+Blue Channel: Rigth Eye (Cyan lens)
					 * lrectwrite(3G) -> 0xAABBGGRR
					 */
					*pix++ = ALPHA_OPAC;
/*					*pix++ = (char)inptr[2];*/
/*					*pix++ = (char)inptr[1];*/
/*					*pix++ = 0x00;*/
					*pix++ = (char)inptr[1];
					*pix++ = (char)inptr[1];
					*pix++ = (char)inptr[1];
					*pix2++ = ALPHA_OPAC;
/*					*pix2++ = 0x00;*/
/*					*pix2++ = 0x00;*/
/*					*pix2++ = (char)inptr[0];*/
					*pix2++ = (char)inptr[0];
					*pix2++ = (char)inptr[0];
					*pix2++ = (char)inptr[0];
				}
				else
				{
					*pix++ = ALPHA_OPAC;
					*pix++ = (char)inptr[2];
					*pix++ = (char)inptr[1];
					*pix++ = (char)inptr[0];
				}
				inptr += 3;
			}
			pix -= 8* image_W;
			if (( NULL != fb2 )&&(!G_prefs.Anaglyph))
			{
				for (j=0; j<w ; j++)
				{
					*pix2++ = ALPHA_OPAC;
					*pix2++ = (char)inptr[2];
					*pix2++ = (char)inptr[1];
					*pix2++ = (char)inptr[0];
					inptr += 3;
				}
			}
			pix2 -= 8* image_W;
		}
	}
	else
	{
		Output("Grayscale image\n");
		while (cinfo.output_scanline < cinfo.output_height)
		{
			(void) jpeg_read_scanlines(&cinfo, buffer, 1);
            for (j=0, inptr=*buffer; j<w; j++)
            {
				*pix++ = ALPHA_OPAC;
				*pix++ = (char)inptr[0];
				*pix++ = (char)inptr[0];
				*pix++ = (char)inptr[0];
				inptr += 1;
            }
			pix -= 8* image_W;
			if (( NULL != fb2 )&&(!G_prefs.Anaglyph))
			{
				for (j=0; j<w ; j++)
				{
					*pix2++ = ALPHA_OPAC;
					*pix2++ = (char)inptr[0];
					*pix2++ = (char)inptr[0];
					*pix2++ = (char)inptr[0];
					inptr += 1;
				}
				pix2 -= 8* image_W;
			}
        }

	}

/*
 * Finish
 */
	(void) jpeg_finish_decompress(&cinfo);
	jpeg_destroy_decompress(&cinfo);
	fclose(infile);

	return 0;
}
#endif


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

void	get_options(int argc,char *argv[])
{
	int opcion;
	int theError=0;

	if ((G_prefs.AppName = strrchr(argv[0], PATH_SEP))  != NULL)
			G_prefs.AppName = G_prefs.AppName+1;
	else
			G_prefs.AppName = argv[0];

	G_prefs.Foreground	= 0;
	G_prefs.FullScreen	= 0;
	G_prefs.FillScreen	= 0;
	G_prefs.SlideShow	= -1;
	G_prefs.Growable	= 0;
	G_prefs.Stereo		= 0;
	G_prefs.Crossed		= 0;
	G_prefs.Anaglyph	= 0;
	G_prefs.Nosetmon	= 0;
	G_prefs.KeepAspectRatio	= 1;
	G_prefs.Verbose=0;

	while ( (opcion=getopt(argc,argv,"s:43fbFgGvxXah")) != EOF )
	{
		switch(opcion)
		{
				case '4':
						G_prefs.Stereo = 1;
						G_prefs.Nosetmon = 1;
						G_prefs.FullScreen = 1;
						break;
				case '3':
						G_prefs.Stereo = 1;
						G_prefs.FullScreen = 1;
						break;
				case 'a':
						G_prefs.Anaglyph = 1;
						G_prefs.FullScreen = 1;
						break;
				case 'x':
						G_prefs.Crossed = 1;
						G_prefs.FullScreen = 1;
						break;
				case 'X':
						G_prefs.Crossed = 1;
						G_prefs.Nosetmon = 1;
						G_prefs.FullScreen = 1;
						break;
				case 'f':
						G_prefs.Foreground = 1;
						break;
				case 'b':
						G_prefs.FullScreen = 1;
						break;
				case 'F':
						G_prefs.FullScreen = 1;
						G_prefs.FillScreen = 1;
						break;
				case 'g':
						G_prefs.Growable = 1;
						break;
				case 's':
						G_prefs.SlideShow = atoi(optarg);
						break;
				case 'G':
						G_prefs.Growable = 1;
						G_prefs.KeepAspectRatio = 0;
						break;
				case 'v':
						printf("%s:%s\n",G_prefs.AppName,VERS_STR);
						G_prefs.Verbose=1;
						break;
				default:
						usage(G_prefs.AppName);
		}
		if ( theError!=0)  usage(G_prefs.AppName);
	}
}


main(int argc,char *argv[])
{
	Boolean	Fill;

	long gwid;
	long gw_x, gw_y;

	char tmpStr[64];

#ifdef USE_MAGICK
	InitializeMagick(*argv);
#endif

	get_options(argc,argv);
	init_graphics();

	if (G_prefs.Stereo||G_prefs.Crossed||G_prefs.Anaglyph)
	{
		if (is_stereo())
		{
			/* save original display mode and switch to stereo */
			monitor = getmonitor ();
			mouse = getvaluator(MOUSEY);
			if (!G_prefs.Nosetmon)
			{
			setmonitor (STR_RECT);
			/* limit cursor range to one eye's subfield */
			setvaluator (MOUSEY, (short) SCREEN_H / 2, 0, (short) SCREEN_H/2);
			}
		}
		else
		{
			fprintf(stderr,"Sorry, can't do stereo\n");
			G_prefs.Stereo = 0;
		}
	}

	if(G_prefs.FullScreen|G_prefs.Stereo) 
	{
			prefposition( 0, SCREEN_W, 0, SCREEN_H );
			gwid=winopen("");
			RGBmode();
			gconfig();
	}

	if (optind==argc)
	{
		argc ++;
	}

	if (G_prefs.Stereo)
	{
		read_file(argv[optind],&framebuffer_l,NULL);
		read_file(argv[optind+1],&framebuffer_r,NULL);
		redraw();
		event_loop();

		if(!G_prefs.FullScreen) winclose(gwid);
		if(framebuffer_l) free(framebuffer_l);
		if(framebuffer_r) free(framebuffer_r);
	}
	else if (G_prefs.Crossed||G_prefs.Anaglyph)
	{
		for(f=optind; f<argc; f++)
		{
			read_file(argv[f],&framebuffer_r,&framebuffer_l);
			redraw();
			if (event_loop())
				f=argc;
		}

		if(!G_prefs.FullScreen) winclose(gwid);
		if(framebuffer_l) free(framebuffer_l);
		if(framebuffer_r) free(framebuffer_r);
	}
	else
	{
	Fill = G_prefs.FillScreen;

	for(f=optind; f<argc; f++)
	{
		G_prefs.FillScreen = Fill;

		read_file(argv[f],&framebuffer,NULL);

		if(G_prefs.FullScreen) 
		{
			if(G_prefs.FillScreen)
			{
			float scale=1.0;
					getsize(&gw_x, &gw_y);

					scale= MIN(	(float)gw_x/(float)image_W,
								(float)gw_y/(float)image_H);

					rectzoom(scale,scale);
			}
			redraw();
		}
		else
		{
				sprintf(tmpStr,"%s: %s", G_prefs.AppName, 
									(argv[f]==NULL?"stdin":argv[f]));
				prefsize((long)image_W,(long)image_H);
				gwid=winopen(tmpStr);
				clear();
				RGBmode();
				gconfig();
				if(G_prefs.Growable)
				{
					if(G_prefs.KeepAspectRatio)
						keepaspect((long)image_W,(long)image_H);
					winconstraints();
				}
		}
		if (event_loop())
			f=argc;

		if(!G_prefs.FullScreen) winclose(gwid);
		if(framebuffer) free(framebuffer);
	}
	}
	if(G_prefs.FullScreen) winclose(gwid);

	if((G_prefs.Stereo||G_prefs.Crossed||G_prefs.Anaglyph)&&(!G_prefs.Nosetmon))
	{
		/* restore to original display, cursor range */
/*		setmonitor ((short)monitor);*/
		setmonitor (HZ76);
		setvaluator (MOUSEY, mouse , 0, (short) SCREEN_H);
	}
#ifdef USE_MAGICK
	DestroyMagick();
#endif
	return(0);
}

int event_loop(void)
{
	Boolean	quitting=0;
	Boolean	end=0;
	short val;
	long MyEvent;
	static Boolean	NeedRedraw=1;
/*
 * just for IRIX 5.3 (and later, I guess)
 *
 * IRIX 5.2 sends REDRAW properly
 */
        redraw();
/*
 */

		for (quitting=0;!quitting;)
		{
			if ( 0 <= G_prefs.SlideShow )
			{
				redraw();

				if ( 0 < G_prefs.SlideShow )
				{
					sleep(G_prefs.SlideShow);
				}

				quitting=1;
			}
			else
			{
				while (qtest() || (!NeedRedraw ))
				{
				/* Event Loop */

				switch(MyEvent=qread(&val))
				{
					case ESCKEY:
						quitting=!val;
						break;

					case LEFTARROWKEY:
						if (val)
						{
							offset--;
							redraw();
						}
						break;

					case RIGHTARROWKEY:
						if (val)
						{
							offset++;
							redraw();
						}
						break;

					case REDRAW:
						NeedRedraw=1;
						redraw();
						break;

					case WINQUIT:
						quitting=1;
						end=1;
						break;

					case INPUTCHANGE:
						break;

					default:
						if(G_prefs.Verbose)
						{
							printf("Event: %ld\n", MyEvent);
							fflush(stdout);
						}
						break;

				}

					if (quitting) break;

				} /* while */
				redraw();
				NeedRedraw=0;
			}
		}
	return end;
}


void init_graphics(void)
{
		long savescrn;

#ifdef _CAN_LRECTWRITE_OVER_SOCKET_

		char *display;

		if (NULL!=(display=getenv("DISPLAY")))
		{
			if ( 0 > dglopen(display,DGLTSOCKET))
			{
				fatalError("Can't open dgl socket");
			}
		}
#endif

		qdevice(ESCKEY);
		qdevice(REDRAW);
		qdevice(WINSHUT);
		qdevice(WINQUIT);
	
		if (G_prefs.Stereo||G_prefs.Crossed||G_prefs.Anaglyph)
		{
			qdevice(LEFTARROWKEY);
			qdevice(RIGHTARROWKEY);
		}

		savescrn = scrnselect(getwscrn());

			G_prefs.screen_w = getgdesc(GD_XPMAX);
			G_prefs.screen_h = getgdesc(GD_YPMAX);

		scrnselect(savescrn);

		if (( G_prefs.screen_w == -1 ) || ( G_prefs.screen_h == -1 ))
			fatalError("getgdesc failed");

		if(G_prefs.Foreground) foreground();
}

void	redraw(void)
{
	long gw_x, gw_y;

	if(G_prefs.FullScreen) 
	{
		if(G_prefs.Stereo||G_prefs.Crossed||G_prefs.Anaglyph)
		{
			float sx=2.0,sy=1.0;
			Screencoord mx, my;

			if ( image_H > (YSTEREO+1) )
			{
				sy= (float)(YSTEREO+1)/(float)image_H;
				sx= 2.0 * sy;
				my = 0;
				mx = ((Screencoord) SCREEN_W - 
					(Screencoord) ((float)image_W * sx )) / 2.0;
			}
			else if ( image_W > (SCREEN_W/2) )
			{
				sx= (float) SCREEN_W / (float)image_W;
				sy= sx/2.0;
				mx= 0;
				my = ((Screencoord) (YSTEREO+1) - 
					(Screencoord) ((float)image_H * sy )) / 2.0;
			}
			else
			{
				my = (Screencoord)(YSTEREO+1 - image_H)/2;
				mx = (Screencoord)(SCREEN_W - image_W * 2)/2;
			}
			rectzoom( sx, sy );
/*			viewport (0, SCREEN_W, YOFFSET_LEFT, SCREEN_H);*/
			clear();
			lrectwrite(
					mx - (Screencoord)offset,
					my + YOFFSET_LEFT,
					mx + image_W-1 - (Screencoord)offset,
					my + image_H-1 + YOFFSET_LEFT,
					(unsigned long *)framebuffer_l);

/*			viewport (0, SCREEN_W, 0, YSTEREO);*/
				lrectwrite(
					mx + (Screencoord)offset,
					my,
					mx + image_W-1 + (Screencoord)offset,
					my + image_H-1,
				(unsigned long *)framebuffer_r);
		}
		else
		{
			clear();
			if(G_prefs.FillScreen) 
			{
				lrectwrite(	0,(image_H-1),(image_W-1),0,
					(unsigned long *)framebuffer);
			}
			else
			{
				lrectwrite(
					(Screencoord)(SCREEN_W-image_W+1)/2,
					(Screencoord)(SCREEN_H+image_H-1)/2,
					(Screencoord)(SCREEN_W+image_W-1)/2,
					(Screencoord)(SCREEN_H-image_H+1)/2,
					(unsigned long *)framebuffer);
			}
		}
	}
	else
	{
		if(G_prefs.Growable)
		{
			getsize(&gw_x, &gw_y);
			viewport(0,(Screencoord)gw_x-1,0,(Screencoord)gw_y-1);
			rectzoom(	(float)gw_x/(float)image_W,
						(float)gw_y/(float)image_H);
		}
		lrectwrite(	0,(image_H-1),(image_W-1),0, (unsigned long *)framebuffer);
	}
}


/* --------------------------------------------------------------------- */
int is_stereo(void)
{
/* This routine returns 1 if Hardware is STEREO READY, 0 IF NOT*/

#ifdef PRE_IRIX33
	/* for: pre-IRIX 3.3 systems, */
	/* is read/write or read-onl:*/
	long rw1, rw2;
	rw1 = getvideo(DE_R1);
	rw2 = rw1 ^= DER1_STEREO;
	setvideo(DE_R1, rw2);
	rw2 = getvideo(DE_R1);
	if (! (rw1 == rw2))
		return(1);
	rw1 = rw2 ^= DER1_STEREO;
	setvideo(DE_R1, rw2);
	rw2 = getvideo(DE_R1);
	return ( ! (rw1 == rw2 ) ) ;
#else
	return(getgdesc(GD_STEREO));
#endif
}