/***************************************************************************
 *   Copyright (C) 2007 by Nicholas Thomas                                 *
 *   nick@lupine.me.uk                                                     *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define OUTPUT_FPS		25	// We output at 25fps, non-interlaced. TODO: make this CLI configurable (implies switch to getopts)
#define OUTPUT_MS_PER_FRAME	1000 / OUTPUT_FPS
 
#define ERR_NONE		0
#define ERR_CMD_ARGS		1
#define ERR_IO			2
 
typedef struct 
{
	u_int32_t x;
	u_int32_t y;
	u_int32_t width;
	u_int32_t height;
	u_int8_t ***data;
} InputRect;
 
typedef struct 
{
	u_int32_t delta_t;
	u_int32_t num_rects;
	InputRect *rects;
} InputFrame;
 
 
void bail(const char *error_message, int retval)
{
	fprintf(stderr, error_message);
	fcloseall();
	exit(retval);
}
 
inline int read8(FILE *data, u_int8_t *buf)
{
	if (fread(buf, sizeof(u_int8_t), 1, data) != 1) 
		return ERR_IO;
	else return ERR_NONE;
}
 
inline int read32(FILE *data, u_int32_t *buf)
{
	if (fread(buf, sizeof(u_int32_t), 1, data) != 1) 
		return ERR_IO;
	else return ERR_NONE;
}
 
// Reads header information from the file.
int getHeader(FILE *data, u_int32_t *height, u_int32_t *width)
{
	read32(data, width);
	read32(data, height);
}
 
// This function writes the frame to output as YUV data.
int writeOutputFrame(FILE *output, u_int8_t ***data, u_int32_t width, u_int32_t height)
{
	// TODO: Error checking
	// 	YUV values apparently need clamping to the 0-255 range
	// In this function, we need to convert from RGBA, upside-down left to right pixel data to
	// YUV format
	u_int8_t *Ys;
	u_int8_t *Us;
	u_int8_t *Vs;
	unsigned long x, y;
	long temp;
 
	Ys = malloc(sizeof(u_int8_t) * width * height);
 
//	Us = malloc((sizeof(u_int8_t) * width * height) / 4);
//	Vs = malloc((sizeof(u_int8_t) * width * height) / 4);
	for (x = 0; x < width; x++)	// Don't forget, our data are bottom-to-top
		for(y = 0; y < height; y++) // Magic conversion factors
		{
			Ys[(y*width)+x] = (0.257 * data[x][y][0]) +     		// R
				  (0.504 * data[x][y][1]) +     		// G
				  (0.098 * data[x][y][2]) + 16;  		// B
/*
			Ys[(y*width)+x] = (0.257 * data[(y*width*4) + (x*4) + 0]) +     		// R
				  (0.504 * data[(y*width*4) + (x*4) + 1]) +     		// G
				  (0.098 * data[(y*width*4) + (x*4) + 2]) + 16;  		// B
*/
/*
			// Only execute the below  code for 1/4 of the pixels. Even only.
			if (y% 2 ==0 && x % 2 == 0 && y +1 != height)
			{
				Us[((y/2)*(width/2))+(x/2)] = ((-(0.148 * data[(y*width*4) + (x*4) + 0]) - 		// R
	                                             (0.291 * data[(y*width*4) + (x*4) + 1]) + 			// G
	                                             (0.439 * data[(y*width*4) + (x*4) + 2]) + 128) +		// B 
 
						   (-(0.148 * data[(y*width*4) + ((x+1)*4) + 0]) - 		// R
						     (0.291 * data[(y*width*4) + ((x+1)*4) + 1]) + 		// G
						     (0.439 * data[(y*width*4) + ((x+1)*4) + 2]) + 128) +	// B 
 
						   (-(0.148 * data[((y+1)*width*4) + (x*4) + 0]) - 	// R
						     (0.291 * data[((y+1)*width*4) + (x*4) + 1]) + 	// G
						     (0.439 * data[((y+1)*width*4) + (x*4) + 2]) + 128) +	// B 
 
						   (-(0.148 * data[((y+1)*width*4) + ((x+1)*4) + 0]) - 	// R
						     (0.291 * data[((y+1)*width*4) + ((x+1)*4) + 1]) + 	// G
						     (0.439 * data[((y+1)*width*4) + ((x+1)*4) + 2]))) / 4;	// B 
 
				Vs[((y/2)*(width/2))+(x/2)] =  (((0.439 * data[(y*width*4) + (x*4) + 0]) - 			// R
						     (0.368 * data[(y*width*4) + (x*4) + 1]) - 			// G 
						     (0.071 * data[(y*width*4) + (x*4) + 2]) + 128) +		// B
 
						    ((0.439 * data[(y*width*4) + ((x+1)*4) + 0]) - 		// R
						     (0.368 * data[(y*width*4) + ((x+1)*4) + 1]) - 		// G 
						     (0.071 * data[(y*width*4) + ((x+1)*4) + 2]) + 128) +	// B
 
						    ((0.439 * data[((y+1)*width*4) + (x*4) + 0]) - 		// R
						     (0.368 * data[((y+1)*width*4) + (x*4) + 1]) - 		// G 
						     (0.071 * data[((y+1)*width*4) + (x*4) + 2]) + 128) +	// B
 
						    ((0.439 * data[((y+1)*width*4) + ((x+1)*4) + 0]) - 		// R
						     (0.368 * data[((y+1)*width*4) + ((x+1)*4) + 1]) - 		// G 
						     (0.071 * data[((y+1)*width*4) + ((x+1)*4) + 2]) + 128))/4; // B 
			}*/
		} 
 
	fwrite(Ys, sizeof(u_int8_t), height * width, output);
//	fwrite(Us, sizeof(u_int8_t), (height * width)/4, output);
//	fwrite(Vs, sizeof(u_int8_t), (height * width)/4, output);
 
	free(Ys);
//	free(Us);
//	free(Vs);
	return ERR_NONE;
}
 
int readInputRect(FILE *input, InputRect *rect)
{
	unsigned long n, x, y;
	// TODO: Error checking
	// These read correctly
	read32(input, &rect->x);
	read32(input, &rect->y);
	read32(input, &rect->width);
	read32(input, &rect->height);
	fprintf(stderr, "New rect. delta x: %i; y: %i; width: %i; height: %i\n", rect->x, rect->y, rect->width, rect->height);
 
	rect->data = malloc(rect->width * sizeof(u_int8_t **)); // NOTE: 4 due to RGBA
 
	for (x = 0; x < rect->width; x++) 
	{
		rect->data[x] = malloc(rect->height * sizeof(u_int8_t *));
		for (y = 0; y < rect->height; y++) 
			rect->data[x][y] = malloc(4 * sizeof(u_int8_t));
	}
 
	for (x = 0; y < rect->width; x++)
		for (y = 0; y < rect->height; y++)
		{
			fread(&rect->data[x][y][0], sizeof(u_int8_t), 1, input);
			fread(&rect->data[x][y][1], sizeof(u_int8_t), 1, input);
			fread(&rect->data[x][y][2], sizeof(u_int8_t), 1, input);
			fread(&rect->data[x][y][3], sizeof(u_int8_t), 1, input);
		}
	return ERR_NONE;
}
 
int readInputFrame(FILE *input, InputFrame *buf)
{
	unsigned long n;
	// TODO: Error checking
	read32(input, &buf->delta_t);
	read32(input, &buf->num_rects);
	fprintf(stderr, "New frame. delta t: %i; number of rects: %i\n", buf->delta_t, buf->num_rects);
	buf->rects = (InputRect *) malloc(sizeof(InputRect) * buf->num_rects);
 
	for (n = 0; n < buf->num_rects; n++)
		readInputRect(input, &buf->rects[n]);
 
	return ERR_NONE;
}
 
int applyInputFrame(u_int8_t ***raw_frame, InputFrame *data, u_int32_t frame_height, u_int32_t frame_width)
{
	// TODO: Error-checking
	unsigned long i, j, x, y;
 
	for (i = 0; i < data->num_rects; i++)
	{
		InputRect *rect = &data->rects[i];
 
		for (x = 0; y < rect->width; x++)
			for (y = 0; y < rect->height; y++)
			{
				raw_frame[x+rect->x][y+rect->y][0] = rect->data[x][y][0];
				raw_frame[x+rect->x][y+rect->y][1] = rect->data[x][y][1];
				raw_frame[x+rect->x][y+rect->y][2] = rect->data[x][y][2];
				raw_frame[x+rect->x][y+rect->y][3] = rect->data[x][y][3];
			}
/*
		for (y = 0; y < rect->height; y++)
			memcpy(&raw_frame[((rect->y + y) * frame_width * 4) + (rect->x * 4)], &rect->data[y * rect->width * 4], sizeof(u_int8_t) * rect->width * 4);
*/
// 		memcpy(raw_frame, rect->data, sizeof(u_int8_t) * rect->height * rect->width * 4);
/*
		for (j = 0; j < rect->height; j++)
		{
			int rect_line = rect->y + j;
			int frame_line = (frame_height -1) - rect_line;
 
			u_int8_t *raw_frame_line = raw_frame + 4 * frame_width * frame_line;	// go to the correct line of the frame.
			u_int8_t *rect_data_line = rect->data + 4 * rect->width * j;		// go to the correct line of the rect data.
 
			memcpy(raw_frame_line + 4 * rect->x, rect_data_line, sizeof(u_int8_t) * rect->width * 4);
		}*/
	}
}
 
int freeInputFrame(InputFrame *frame)
{
	//TODO: Error-checking
	unsigned long n, x, y;
	for (n = 0; n < frame->num_rects; n++)
		for (x = 0; x < frame->rects[n].width; x++) 
		{
			for (y = 0; y < frame->rects[n].height; y++) 
				free(frame->rects[n].data[x][y]);
			free(frame->rects[n].data[x]);
		}
//		free(frame->rects[n].data);
 
	free(frame->rects);
}
 
int main(int argc, char *argv[])
{
	FILE *input;
	FILE *output;
	int err, x, y;
	unsigned long n;
	char *s;
 
	unsigned long current_input_video_time = 0;
	unsigned long outputted_frames = 0;
 
	InputFrame input_buf;
 
	u_int8_t ***raw_frame;  // The full frame at current_input_video_time
	u_int32_t video_height = 0;
	u_int32_t video_width = 0;
 
 
 
	switch (argc)
	{
		case 1: // Where no command-line arguments are given, assume input from stdin and output from stdout
		{
			input = stdin; 
			output = stdout;
		} 
		break;
		case 3: // If input is specified, output must also be specified as rsc2raw input_file output_file
		{
			input = fopen(argv[1], "r");
			output = fopen(argv[2], "w");
		}
		break;
		default: // Bail out with an error.
		{
			fprintf(stderr, "Failure parsing command-line arguments.\n");
			fprintf(stderr, "Format: rsc2raw [<inputfile> <outputfile>]\n");
			fprintf(stderr, "Running \"rsc2raw\" with no arguments results in processing from stdin to stdout\n");
			fcloseall();
			exit(ERR_CMD_ARGS);
		};
		break;
	}
 
	// Check assignment worked properly 
	if (input == NULL || output == NULL) 
		exit(ERR_IO);
 
	err = getHeader(input, &video_width, &video_height);
	if (err != ERR_NONE) 
		bail("Failure reading header - probably an invalid input file.\n", err);
 
	raw_frame = malloc(video_width * sizeof(u_int8_t **));
	for (x = 0; x < video_width; x++) 
	{
		raw_frame[x] = malloc(video_height * sizeof(u_int8_t *));
		for (y = 0; y < video_height; y++) 
			raw_frame[x][y] = malloc(4 * sizeof(u_int8_t)); // NOTE: 4 due to RGBA
	}
 
	// Now keep going until we either run out of input or hit an error.
	while(feof(input) == 0)
	{
		int i_err = ferror(input);
		int o_err = ferror(output);
		if (i_err != 0 || o_err != 0)
			fprintf(stderr, "Error occured reading/writing last frame! i: %i; o: %i\n", i_err, o_err);
 
		// We want to output a new frame every (1000/OUTPUT_FPS) 40 ms. Our input frames have variable delta time
		while (current_input_video_time < outputted_frames * OUTPUT_MS_PER_FRAME)
		{
			// TODO: Error-checking
			readInputFrame(input, &input_buf);
			applyInputFrame(raw_frame, &input_buf, video_height, video_width);
			current_input_video_time += input_buf.delta_t;
			freeInputFrame(&input_buf);
		}
		writeOutputFrame(output, raw_frame, video_width, video_height);
		outputted_frames++;
	}
 
	// TODO: Full memory deallocation
	for (x = 0; x < video_width; x++) 
	{
		for (y = 0; y < video_height; y++) 
			free(raw_frame[x][y]);
		free(raw_frame[x]);
	}
	free(raw_frame);
 
	fcloseall();
	return ERR_NONE;
}