/* > hrptx.c
 * (C) 1996 Andrew Brooks arb@sat.dundee.ac.uk
 * 1.04 arb Thu Feb 18 10:18:01 GMT 1999 - remove need for format parameter.
 * 1.03 arb Wed Nov 19 15:44:51 GMT 1997 - add support for writing PGM images.
 * 1.02 arb Tue Jun 24 13:50:50 BST 1997 - added default to switch statement
 *      to keep someone's compiler happy.
 * 1.01 arb Tue Nov 26 11:38:41 GMT 1996 - added packed Dundee format, check
 *      for correct input format, check for number of lines written.
 * 1.00 arb Thu Nov  7 12:04:00 GMT 1996
 * Usage: hrptx fmt filename
 *   where fmt is "raw", "22k", "24k" or "dundee".
 * Extracts image data plus TIP and CALIB from an HRPT file.
 * Writes to filename.ch[1-5] plus ch6 (TIP) and ch7 (CALIB).
 */

static char SCCSid[] = "@(#)hrptx.c       1.04 (C) 1996 arb HRPT extract";

/*
 * Notes:
 * Extracts line-by-line, does not rotate for Northbound passes.
 */

/*
 * Configuration:
 * Define OUTPUT_PGM for 10-bit ASCII PGM output instead of raw binary.
 * Define strcasecmp if needed by your compiler
 */
#define OUTPUT_PGM
/*#define strcasecmp stricmp*/


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


typedef enum { HRPT_Bad, HRPT_Raw, HRPT_22k, HRPT_24k, HRPT_Dundee } hrpt_type_t;
#define NUM_PIX           2048
#define NUM_CH_IM         5
#define NUM_CH            (NUM_CH_IM+2)
#define OFFSET_WORD_IM    750
#define OFFSET_WORD_TIP   103
#define OFFSET_WORD_CALIB 0
#define LEN_WORD_TIP      (104*5)
#define LEN_WORD_CALIB    103
#define TAPE_BLOCK        3700           /* for unpacking Dundee format */
#define SEEK_END          2


char *prog;
char *usage = "usage: %s filename\nFormats understood are raw, 22k, 24k or dundee.\nWrites image channels, then TIP then CALIB.\n";

long
hrpt_linesize(hrpt_type_t hrpt_type)
{
	switch (hrpt_type)
	{
		case HRPT_Raw: return(22180);
		case HRPT_22k: return(22528);
		case HRPT_24k: return(24576);
		case HRPT_Dundee: return(14800);
	}
	return(-1);
}

hrpt_type_t
decode_hrpt_type(long filesize)
{
	if ((filesize % hrpt_linesize(HRPT_Raw)) == 0) return(HRPT_Raw);
	else if ((filesize % hrpt_linesize(HRPT_22k)) == 0) return(HRPT_22k);
	else if ((filesize % hrpt_linesize(HRPT_24k)) == 0) return(HRPT_24k);
	else if ((filesize % hrpt_linesize(HRPT_Dundee)) == 0) return(HRPT_Dundee);
	else return(HRPT_Bad);
}

int
hrpt_unpack_dundee(unsigned char *inbuf, unsigned short *outbuf)
{
	int i, j;
	unsigned short s[4];

	for (i = 3*(TAPE_BLOCK-1), j = 4*(TAPE_BLOCK-1); i >= 0; i -= 3, j -= 4)
	{
		s[0] = (unsigned short)inbuf[j];
		s[1] = (unsigned short)inbuf[j+1];
		s[2] = (unsigned short)inbuf[j+2];
		s[3] = (unsigned short)inbuf[j+3];
		outbuf[i]   = ((s[0] << 2) + (s[1] >> 6));
		outbuf[i+1] = ((s[1] << 4) + (s[2] >> 4)) & 0x3FF;
		outbuf[i+2] = ((s[2] << 6) + (s[3] >> 2)) & 0x3FF;
	}
	return(0);
}

int
hrpt_extract_line(FILE *fp[NUM_CH], unsigned short *line)
{
	int ch, x;
	unsigned short *ptr;
	unsigned char tipval;

	ptr = line + OFFSET_WORD_IM;
	for (x=0; x<NUM_PIX; x++)
	{
		for (ch=0; ch<NUM_CH_IM; ch++)
		{
#ifdef OUTPUT_PGM
			if (fprintf(fp[ch], "%d%c", *ptr, (x%16)==15?'\n':' ') == EOF)
#else
			if (fwrite(ptr, sizeof(unsigned short), 1, fp[ch]) != 1)
#endif
			{
				fprintf(stderr, "%s: error writing word %d to channel %d\n", prog, x, ch+1);
				return(-1);
			}
			ptr++;
		}
	}

#ifdef OUTPUT_PGM
	for (ch=0; ch<NUM_CH_IM; ch++)
		fprintf(fp[ch], "\n");
#endif

	/* TIP channel, 520 8-bit words */
	ptr = line + OFFSET_WORD_TIP;
	for (x=0; x<LEN_WORD_TIP; x++)
	{
		tipval = *ptr++;
		if (fwrite(&tipval, sizeof(tipval), 1, fp[ch]) != 1)
		{
			fprintf(stderr, "%s: error writing to TIP file\n", prog);
			return(-1);
		}
	}

	/* CALIB channel, 103 words */
	ch++;
	ptr = line + OFFSET_WORD_CALIB;
	if (fwrite(ptr, LEN_WORD_CALIB*sizeof(unsigned short), 1, fp[ch]) != 1)
	{
		fprintf(stderr, "%s: error writing to CALIB file\n", prog);
		return(-1);
	}

	return(0);
}

int
main(int argc, char *argv[])
{
	hrpt_type_t intype;
	FILE *infp, *outfp[NUM_CH];
	char *filestr;
	char *buf, *inbuf, *name;
	int linesize;
	int i;
	int numlines = 0, linenum = 0;
	long filesize = 0L;

	/* Check command line parameters */
	prog = argv[0];
	if (argc != 2)
	{
		fprintf(stderr, usage, prog);
		exit(1);
	}
	filestr = argv[1];

	/* Open input file and determine size and thus format */
	infp = fopen(filestr, "rb");
	if (infp == NULL)
	{
		fprintf(stderr, "%s: cannot open file %s\n", prog, filestr);
		exit(1);
	}
	if (fseek(infp, 0, SEEK_END) == 0)
	{
		filesize = ftell(infp);
		rewind(infp);
	}
	else
		fprintf(stderr, "%s: warning: cannot determine number of lines in input file\n", prog);
	intype = decode_hrpt_type(filesize);
	linesize = hrpt_linesize(intype);
	if (intype == HRPT_Bad)
	{
		fprintf(stderr, usage, prog);
		exit(1);
	}
	numlines = filesize / linesize;

	/* Allocate buffer for one line */
	inbuf = buf = (char*)malloc(linesize);
	if (intype == HRPT_Dundee)
		buf = (char*)malloc(hrpt_linesize(HRPT_24k));
	if (buf == NULL || inbuf == NULL)
	{
		fprintf(stderr, "%s: out of memory\n", prog);
		exit(1);
	}

	name = (char*)malloc(strlen(filestr)+10);
	if (name == NULL)
	{
		fprintf(stderr, "%s: out of memory\n", prog);
		exit(1);
	}
	for (i=0; i<NUM_CH; i++)
	{
		sprintf(name, "%s.ch%d", filestr, i+1);
		outfp[i] = fopen(name, "wb");
		if (outfp[i] == NULL)
		{
			fprintf(stderr, "%s: cannot open file %s\n", prog, name);
			exit(1);
		}
#ifdef OUTPUT_PGM
		if (i<5)
			fprintf(outfp[i], "P2 2048 %d 1023\n", numlines);
#endif
	}
	free(name);
	while (fread(inbuf, linesize, 1, infp) == 1)
	{
		linenum++;
		if (intype == HRPT_Dundee)
			hrpt_unpack_dundee((unsigned char*) inbuf, (unsigned short*) buf);
		if (hrpt_extract_line(outfp, (unsigned short*) buf) == -1)
		{
			fprintf(stderr, "%s: error writing line %d\n", prog, linenum);
			break;
		}
	}
	fclose(infp);
	free(buf);
	if (inbuf != buf)
		free(inbuf);
	for (i=0; i<NUM_CH; i++)
		fclose(outfp[i]);
	fprintf(stderr, "%s: extracted %d lines\n", prog, linenum);
	if (numlines && (numlines != linenum))
		fprintf(stderr, "%s: warning: only wrote %d out of %d lines\n", prog, linenum, numlines);
	return(0);
}