/************************************************************************\
 *                                                                        *
 *               Copyright (C) 1994, Silicon Graphics, Inc.               *
 *                                                                        *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *                                                                        *
 \************************************************************************/

/* Software monitor, takes output of video interface module and simulates */
/* a simple television.                                                   */
/*
/* NOTE: This won't work if the first input vector has a vertical sync    */

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

#include <PRimage.h>

int StartLine  =  21;
int EndLine    = 483;
int FirstPixel = 100;
int LastPixel  = 420;
int CurrentRow;

unsigned short **RedRows, **GreenRows, **BlueRows;
unsigned short *OutputRed, *OutputGreen, *OutputBlue;
int ImageWidth, ImageHeight;

char *InputFileName, *OutputFileName;
IMAGE *image;
FILE *InFile;
char InData[80] = "foo";
char *ReadOk = "foo";
int CurrentLine = 0;

unsigned int vbus_data, vbus_sync;

void usage(void)
{
    fprintf(stderr, "!!!ERROR, try again \n");
    exit(1);
}

void GetData(void)
{

    ReadOk = fgets(InData, 80, InFile);
    CurrentLine++;

    while (InData[0] == '#')
	{
	    ReadOk = fgets(InData, 80, InFile);
	    CurrentLine++;
	}
    
    sscanf(InData, "%x %d", &vbus_data, &vbus_sync);    
}

void monitor()
{
    int FieldBegin = 0;
    unsigned short *(BufferArray[3]);
    int BufferArrayPtr = 0;
    int ScanLine = -1;
    int CurrentScanLine;
    int PixelNumber;
    int i;

    BufferArray[0] = OutputRed;
    BufferArray[1] = OutputGreen;
    BufferArray[2] = OutputBlue;

    /* printf("Using width %d height %d \n", ImageWidth, ImageHeight); */

    /* Loop until vbus_data == 0x0f since the bus is
       basically garbage until then */

    while (vbus_data != 0x0f)
	{
	    GetData();
	}

    /* printf("Got 0x0f on line %d \n", CurrentLine); */

    while (!feof(InFile))
	{
	    /* printf("!!!!!!!!!!Entering FieldBegin loop on line %d \n", CurrentLine); */
	    
	    /* Loop until get vertical sync */
	    while (!FieldBegin && !feof(InFile))
		{
		    GetData();
		    if ((!vbus_sync) && !(vbus_data & (1 << 3)))
			FieldBegin = 1;	    
		}

	    /* if (!feof(InFile)) printf("Got vertical sync on line %d \n", CurrentLine); */

	    /* Loop until hit first horizontal line visible on screen */
	    while ((ScanLine < StartLine) && !feof(InFile))
		{
		    /* This if statement is to catch when we get a vertical
		       and horizontal sync on the same clock */
		    if ((!vbus_sync) && !(vbus_data & (1 << 1)))
			{
			    int HitEndOfSync = 0;
		    
			    /* printf("Entering hsync on line %d \n", CurrentLine); */
		    
			    while (!HitEndOfSync && !feof(InFile))
				{
				    GetData();
				    if (!vbus_sync)
					{
					    if ((vbus_data & (1 << 1)))
						HitEndOfSync = 1;
					}				    
				}
			    /* printf("Leaving hsync on line %d \n", CurrentLine); */

			    ScanLine++;	    	    
			}

		    GetData();

		    if ((!vbus_sync) && !(vbus_data & (1 << 1)))
			{
			    int HitEndOfSync = 0;

			    /* printf("Entering hsync on line %d \n", CurrentLine); */
		    
			    while (!HitEndOfSync && !feof(InFile))
				{
				    GetData();
				    if (!vbus_sync)
					{
					    if ((vbus_data & (1 << 1)))
						HitEndOfSync = 1;
					}				    
				}

			    /* printf("Leaving hsync on line %d \n", CurrentLine); */

			    ScanLine++;	    	    
			}

		}

	    /* if (!feof(InFile)) printf("Starting visible lines on line %d \n", CurrentLine); */

	    /* Now loop through all the visible horizontal lines */
	    while ((ScanLine <= EndLine) && !feof(InFile))
		{
		    PixelNumber = 0;

		    /* printf("->Current Row  %d <- \n", CurrentRow); */

		    if (CurrentRow == 2*ImageHeight)
			{
			    printf("ERROR: input data has too many rows, exiting \n");
			    exit(1);
			}

		    OutputRed   = RedRows[CurrentRow];
		    OutputGreen = GreenRows[CurrentRow];
		    OutputBlue  = BlueRows[CurrentRow];

		    BufferArray[0] = OutputRed;
		    BufferArray[1] = OutputGreen;
		    BufferArray[2] = OutputBlue;

		    /* init output arrays so that if we get a truncated line later we don't
		       have crap showing through */
		    for (i=0; i< ImageWidth ; i++)
			{
			    OutputRed[i]   = 0;
			    OutputGreen[i] = 0;
			    OutputBlue[i]  = 0;
			}


		    /* Loop along pixels until hit first visible pixel in line */
		    while ((PixelNumber < FirstPixel) && !feof(InFile))
			{
			    GetData();
			    if (!vbus_sync) PixelNumber++;
			}

		    /* printf("Starting visible pixel data on line %d \n", CurrentLine); */

		    /* Now loop through the visible pixels in this line */
		    /* Note that the pixel numbers are starting inclusive and
		       ending exclusive */
		    while ((PixelNumber < LastPixel) && !feof(InFile))
			{
			    /* Read in srgb values */

			    GetData();
			    if (!vbus_sync)
				{
				    PixelNumber++;
				    BufferArrayPtr = 0;
				}
			    else
				{
				    if (BufferArrayPtr > 2)
					{
					    fprintf(stderr, "!!!ERROR bad rgb data, line %d \n", CurrentLine);
					    exit(1);
					}

				    *(BufferArray[BufferArrayPtr++])++ = (short) vbus_data;
				/* printf("Valid rgb data -> 0x%.2x \n", vbus_data); */
				}		    
			}

		    /* printf("Finished visible pixel data on line %d CurrentRow-> %d \n",  
			   CurrentLine, CurrentRow); */

		    CurrentRow++;

		    /* Now loop through the pixels on the current line that are off the visible edge */
		    /* Stop when we have passed the horizontal sync for the next line */

		    CurrentScanLine = ScanLine;
		    while ((CurrentScanLine == ScanLine) && !feof(InFile))
			{
			    if ((!vbus_sync) && !(vbus_data & (1 << 1)))
				{
				    int HitEndOfSync = 0;
			    
				/* printf("Entering hsync on line %d \n", CurrentLine); */
			    
				    while (!HitEndOfSync && !feof(InFile))
					{
					    GetData();
					    if (!vbus_sync)
						{
						    if ((vbus_data & (1 << 1)))
							HitEndOfSync = 1;
						}				    
					}
				/* printf("Leaving hsync on line %d \n", CurrentLine); */
			    
				    ScanLine++;	    	    
				}
			    GetData();
			}
		}

	    FieldBegin = 0;
	    ScanLine   = -1;
	}

    /* Stop reading after last visible line, don't care what else is happening in file */
    /* All that we require is that there is a final horizontal sync after the end of   */
    /* the last visible line */
}

void OpenRGBFile(int Height)
{
    if ((image = iopen(OutputFileName, "w", RLE(1), 3, ImageWidth, Height, 3)) == NULL)
	{
	    fprintf(stderr, "!!!ERROR, could not open output file %s \n", OutputFileName);
	    exit(1);
	}
}

int Foo(int i)
{
    return(ImageHeight*2 - 1 - (2 * (i % (CurrentRow / 2)) + 2 * i / CurrentRow));
}

void WriteRGBFile(void)
{
    int i;

    /* printf("Current Row %d, ImageHeight %d \n", CurrentRow, ImageHeight); */

    OpenRGBFile(CurrentRow); 

    if (CurrentRow <= ImageHeight)
	{
	    for (i=0; i<CurrentRow; i++)
		{
		    putrow(image, RedRows[i],   CurrentRow - i - 1, 0);
		    putrow(image, GreenRows[i], CurrentRow - i - 1, 1);
		    putrow(image, BlueRows[i],  CurrentRow - i - 1, 2); 
		}
	}
    else
	{
	    /* Do interlacing crap-o-la here */

	    for (i=0; i<CurrentRow; i++)
		{
		    /* printf("(%d) Putting row %d \n", i, Foo(i)); */
		    
		    putrow(image, RedRows[i],   Foo(i), 0);
		    putrow(image, GreenRows[i], Foo(i), 1);
		    putrow(image, BlueRows[i],  Foo(i), 2);
		}
	}

    iclose(image);
}

void ParseOptions(int argc, char **argv)
{
    int c;
    extern char *optarg;
    extern int optind;
    char *ofile = NULL;

    while ((c = getopt(argc, argv, "i:o:b:e:f:l:h:v:")) != EOF)
	switch (c)
	    {
	    case 'i':
		InputFileName = strdup(optarg);
		break;
	    case 'o':
		OutputFileName = strdup(optarg);
		break;
	    case 'b':
		StartLine = atoi(optarg);
		break;
	    case 'e':
		EndLine = atoi(optarg);
		break;
	    case 'f':
		FirstPixel = atoi(optarg);
		break;
	    case 'l':
		LastPixel = atoi(optarg);
		break;
	    case 'h':
		LastPixel  = strtoul(optarg, (char **) NULL, 16) & ((1 << 10) - 1);
		FirstPixel = (strtoul(optarg, (char **) NULL, 16) & (((1 << 10) - 1) << 16)) >> 16;
		/* printf("First 0x%.2x Last 0x%.2x \n", FirstPixel, LastPixel); */
		break;
	    case 'v':
		EndLine   = ((strtoul(optarg, (char **) NULL, 16)  & ((1 << 10) - 1)) - 1) >> 1;
		StartLine = (((strtoul(optarg, (char **) NULL, 16)  & (((1 << 10) - 1) << 16)) >> 16) + 1) >> 1;
		/* printf("Start 0x%.2x End 0x%.2x \n", StartLine, EndLine); */
		break;
	    case '?':
		usage();
		break;		
	    }    
}

void CheckOptions(void)
{
    if ((InputFileName == NULL) || (OutputFileName == NULL))
	usage();

    ImageWidth  = LastPixel - FirstPixel;
    ImageHeight = EndLine - StartLine + 1;

    if ((ImageWidth < 0) || (ImageHeight < 0))
	{
	    fprintf(stderr, "!!!ERROR Image size incorrect, %d %d \n",
		    ImageWidth, ImageHeight);
	}
}

void InitializeVariables(void)
{
    int i;

    RedRows =   (unsigned short **) malloc(ImageHeight * 2 * sizeof(unsigned short *));
    GreenRows = (unsigned short **) malloc(ImageHeight * 2 * sizeof(unsigned short *));
    BlueRows =  (unsigned short **) malloc(ImageHeight * 2 * sizeof(unsigned short *));

    for (i=0; i< ImageHeight * 2; i++)
	{
	    RedRows[i]   = (unsigned short *) malloc(ImageWidth * sizeof(unsigned short));
	    GreenRows[i] = (unsigned short *) malloc(ImageWidth * sizeof(unsigned short));
	    BlueRows[i]  = (unsigned short *) malloc(ImageWidth * sizeof(unsigned short));
	}

    CurrentRow = 0;
    OutputRed   = RedRows[CurrentRow];
    OutputGreen = GreenRows[CurrentRow];
    OutputBlue  = BlueRows[CurrentRow];
}

void OpenInFile(void)
{
    if ((InFile = fopen(InputFileName, "r")) == NULL)
	{
	    fprintf(stderr, "!!!ERROR, could not open input file %s \n", InputFileName);
	    exit(1);
	}    
}

main(int argc, char *argv[])
{
    char InData[80] = "foo";

    unsigned int vbus_data, vbus_sync, vbus_clock_enable_l, vi_int, 
	refresh_strobe, cbus_data;

    int ValidLines = 0;

    ParseOptions(argc, argv);
    CheckOptions();
    InitializeVariables();
    OpenInFile();

    while((InData[0] != '0') && (InData[1] != 'x'))
	{
	    fgets(InData, 80, InFile);
	    CurrentLine++;
	}

    monitor();
    WriteRGBFile();

    fclose(InFile);
    return 0;
}