/******************************************************************************
/
/	File:			CC.cpp
/
/	Description:	Closed caption module.
/
/	Copyright 2001, Carlos Hasan
/
*******************************************************************************/

#include <stdio.h>
#include <Debug.h>
#include "CC.h"

CCaption::CCaption(CCapture & capture)
	:	fCapture(capture),
		fChannel(C_RADEON_CC1),
		fRow(0),
		fColumn(0),
		fColor(0),
		fLastControlCode(0)
{
	for (int row = 0; row < C_RADEON_CC_ROWS; row++) {
		for (int column = 0; column < C_RADEON_CC_COLUMNS; column++) {
			fText[row][column] = fDisplayText[row][column] = 0x0000;
		}
	}
}

CCaption::~CCaption()
{
}

status_t CCaption::InitCheck() const
{
	return fCapture.InitCheck();
}

void CCaption::SetMode(cc_mode mode)
{
	fChannel = mode;
	fLastControlCode = 0;
}

bool CCaption::DecodeBits(const unsigned char * buffer, int & data)
{
	// assume the buffer is long enough (at least VBI line width bytes)
	if (buffer == NULL)
		return false;

	// compute low/high levels
	int low = 0xff, high = 0x00;
	for (int offset = C_RADEON_CC_BLANK_START; offset < C_RADEON_CC_BLANK_START + 4 * C_RADEON_CC_BIT_DURATION; offset++) {
		if (low > buffer[offset])
			low = buffer[offset];
		if (high < buffer[offset])
			high = buffer[offset];
	}
	if (low + C_RADEON_CC_LEVEL_THRESHOLD >= high)
		return false;

	const int middle = (low + high) >> 1;
	
	// find position of the first pulse
	int start = C_RADEON_CC_BLANK_START + C_RADEON_CC_BIT_DURATION;
	while (start <= C_RADEON_CC_BLANK_START + 4 * C_RADEON_CC_BIT_DURATION) {
		if (buffer[start + 0] < middle && buffer[start + 1] < middle &&
			buffer[start + 3] > middle && buffer[start + 4] > middle)
			break;
		start++;
	}
	if (start >= C_RADEON_CC_BLANK_START + 4 * C_RADEON_CC_BIT_DURATION)
		return false;

	// compute position of the last pulse
	int end = start + 17 * C_RADEON_CC_BIT_DURATION;

	// start in middle of first pulse
	int bit = 0;
	bool one = true;
	for (int offset = start + C_RADEON_CC_BIT_DURATION / 2; offset < end; offset++) {
		int width = 1;
		
		// search the next pulse front
		while (offset < end) {
			if (one) {
				if (buffer[offset + 0] > middle && buffer[offset + 1] > middle &&
					buffer[offset + 3] < middle && buffer[offset + 4] < middle)
					break;
			}
			else {
				if (buffer[offset + 0] < middle && buffer[offset + 1] < middle &&
					buffer[offset + 3] > middle && buffer[offset + 4] > middle)
					break;
			}
			offset++;
			width++;
		}

		// compute pulse width in bits
		const int nbits = (width + (bit == 0 ? 0 : bit == 15 ? C_RADEON_CC_BIT_DURATION :
			C_RADEON_CC_BIT_DURATION / 2)) / C_RADEON_CC_BIT_DURATION;
		data >>= nbits;
		if (one)
			data |= (0xffff << (16 - nbits)) & 0xffff;
		
		if ((bit += nbits) >= C_RADEON_CC_BITS_PER_FIELD)
			break;
		
		one = !one;
	}
	
	if (bit != C_RADEON_CC_BITS_PER_FIELD)
		return false;

	return true;
}

bool CCaption::Decode(const unsigned char * buffer0,
							const unsigned char * buffer1)
{
	enum caption_code {
		/* channel */
		C_CC1		= 0x0000,
		C_CC2		= 0x0800,
		
		/* address */
		C_ROW_1		= 0x0100,
		C_ROW_2		= 0x0120,
		C_ROW_3		= 0x0200,
		C_ROW_4		= 0x0220,
		C_ROW_5		= 0x0500,
		C_ROW_6		= 0x0520,
		C_ROW_7		= 0x0600,
		C_ROW_8		= 0x0620,
		C_ROW_9		= 0x0700,
		C_ROW_10	= 0x0720,
		C_ROW_11	= 0x0000,
		C_ROW_12	= 0x0300,
		C_ROW_13	= 0x0320,
		C_ROW_14	= 0x0400,
		C_ROW_15	= 0x0420,
				
		/* color */
		C_WHITE		= 0x0000,
		C_GREEN		= 0x0002,
		C_BLUE		= 0x0004,
		C_CYAN		= 0x0006,
		C_RED		= 0x0008,
		C_YELLOW	= 0x000a,
		C_MAGENTA	= 0x000c,
		C_ITALICS	= 0x000e,
		
		/* underline */
		C_NORMAL	= 0x0000,
		C_UNDERLINE	= 0x0001,
		
		/* control */
		C_RCL		= 0x0000,	// resume caption loading
		C_BS		= 0x0001,	// backspace
		C_AOF		= 0x0002,	// alarm off
		C_AON		= 0x0003,	// alarm on
		C_DER		= 0x0004,	// delete to end of row
		C_RU2		= 0x0005,	// roll-up captions (2 rows)
		C_RU3		= 0x0006,	// roll-up captions (3 rows)
		C_RU4		= 0x0007,	// roll-up captions (4 rows)
		C_FON		= 0x0008,	// flash on
		C_RDC		= 0x0009,	// resume direct captioning
		C_TR		= 0x000a,	// text restart
		C_RTD		= 0x000b,	// resume text display
		C_EDM		= 0x000c,	// erase displayed memory
		C_CR		= 0x000d,	// carriage return
		C_ENM		= 0x000e,	// erase non-displayed memory
		C_EOC		= 0x000f,	// end of caption
		
		/* special character */
		C_reg		= 0x0000,	// registered
		C_deg		= 0x0001,	// degree
		C_frac12	= 0x0002,	// fraction 1/2
		C_iquest	= 0x0003,	// invert question
		C_trademark	= 0x0004,	// trademark
		C_cent		= 0x0005,	// cent
		C_pound		= 0x0006,	// pound
		C_music		= 0x0007,	// music note
		C_agrave	= 0x0008,	// agrave
		C_tspace	= 0x0009,	// transparent space
		C_egrave	= 0x000a,	// egrave
		C_acirc		= 0x000b,	// a circ
		C_ecirc		= 0x000c,	// e circ
		C_icirc		= 0x000d,	// i circ
		C_ocirc		= 0x000e,	// o circ
		C_ucirc		= 0x000f,	// u circ
		
		/* standard character (ASCII) */
		C_aacute	= 0x002a,	// a acute accent
		C_eacute	= 0x005c,	// e acute accent
		C_iacute	= 0x005e,	// i acute accent
		C_oacute	= 0x005f,	// o acute accent
		C_uacute	= 0x0060,	// u acute accent
		C_ccedil	= 0x007b,	// c cedilla
		C_division	= 0x007c,	// division sign
		C_Ntilde	= 0x007d,	// N tilde
		C_ntilde	= 0x007e,	// n tilde
		C_block		= 0x007f	// solid block
	};
	
	int code, channel, character;
	
	/* decode next pair of bytes from the odd or even field buffer */
	if (!DecodeBits(fChannel == C_RADEON_CC1 || fChannel == C_RADEON_CC2 ? buffer0 : buffer1, code))
		return false;
	
	/* swap decoded bytes */
	code = ((code << 8) & 0xff00) | ((code >> 8) & 0x00ff);

	/* check parity */
	for (int bit = 0; bit < 7; bit++) {
		if ((code & (0x0001 << bit)) != 0)
			code ^= 0x0080;
		if ((code & (0x0100 << bit)) != 0)
			code ^= 0x8000;
	}
	if ((code & 0x8080) != 0x8080) {
		PRINT(("CCaption::Decode() - parity error (%04X)\n", code));
		return false;
	}
		
	/* check channel number */
	channel = (code & 0x0800) >> 12;
	if (channel == 0) {
		if (fChannel != C_RADEON_CC1 && fChannel != C_RADEON_CC3) {
			PRINT(("CCaption::Decode() - ignore channel (%02X)\n", code & 0x7f7f));
			return false;
		}
	}
	else {
		if (fChannel != C_RADEON_CC2 && fChannel != C_RADEON_CC4) {
			PRINT(("CCaption::Decode() - ignore channel (%02X)\n", code & 0x7f7f));
			return false;
		}
	}

	if ((code & 0x7000) == 0x0000) {
		/* one-byte standard character (0?XX) */
		character = code & 0x007f;
		
		if (character >= 0x20) {
		
			PRINT(("%c", character));
			
			fText[fRow][fColumn] = (fColor << 8) + character;
			if (fColumn < C_RADEON_CC_COLUMNS - 1)
				fColumn++;
		}
		else if (character != 0x00) {
			PRINT(("<%04X>", code & 0x7f7f));
		}
	}
	else if ((code & 0x7770) == 0x1120) {
		/* middle row code (112X) */
		fColor = code & 0x000f;
		
		fText[fRow][fColumn] = (fColor << 8) + ' ';
		if (fColumn < C_RADEON_CC_COLUMNS - 1)
			fColumn++;
		
		switch (fColor & 0x000e) {
		case C_WHITE:
			PRINT(("<white"));
			break;
		case C_GREEN:
			PRINT(("<green"));
			break;
		case C_BLUE:
			PRINT(("<blue"));
			break;
		case C_CYAN:
			PRINT(("<cyan"));
			break;
		case C_RED:
			PRINT(("<red"));
			break;
		case C_YELLOW:
			PRINT(("<yellow"));
			break;
		case C_MAGENTA:
			PRINT(("<magenta"));
			break;
		case C_ITALICS:
			PRINT(("<italics"));
			break;
		}
		if ((fColor & 0x0001) != 0)
			PRINT((",underline>"));
		else
			PRINT((">"));
	}
	else if ((code & 0x7770) == 0x1130) {
		/* two-byte special character (113X) */
		character = (code & 0x000f);

		fText[fRow][fColumn] = (fColor << 8) + character + 0x0080;
		if (fColumn < C_RADEON_CC_COLUMNS - 1)
			fColumn++;
		
		switch (character) {
		case C_reg:
			PRINT(("&reg;"));
			break;
		case C_deg:
			PRINT(("&deg;"));
			break;
		case C_frac12:
			PRINT(("&frac12;"));
			break;
		case C_iquest:
			PRINT(("&iquest;"));
			break;
		case C_trademark:
			PRINT(("&trademark;"));
			break;
		case C_cent:
			PRINT(("&cent;"));
			break;
		case C_pound:
			PRINT(("&pound;"));
			break;
		case C_music:
			PRINT(("&music;"));
			break;
		case C_agrave:
			PRINT(("&agrave;"));
			break;
		case C_tspace:
			PRINT(("&tspace;"));
			break;
		case C_egrave:
			PRINT(("&egrave;"));
			break;
		case C_acirc:
			PRINT(("&acirc;"));
			break;
		case C_ecirc:
			PRINT(("&ecirc;"));
			break;
		case C_icirc:
			PRINT(("&icirc;"));
			break;
		case C_ocirc:
			PRINT(("&ocirc;"));
			break;
		case C_ucirc:
			PRINT(("&ucirc;"));
			break;
		default:
			PRINT(("<special=%04X>", code & 0x7f7f));
			break;
		}
	}
	else if ((code & 0x7770) == 0x1420) {
	
		if (code == fLastControlCode)
			return false;
		fLastControlCode = code;
		
		/* miscellaneous control code (142X) */
		switch (code & 0x000f) {
		case C_RCL:
			// resume caption loading
			PRINT(("<rcl>"));
			break;
			
		case C_BS:
			// backspace
			PRINT(("<bs>"));
			if (fColumn > 0)
				fText[fRow][--fColumn] = 0x0000;
			break;
			
		case C_AOF:
			// alarm off
			PRINT(("<aof>"));
			break;
			
		case C_AON:
			// alarm on
			PRINT(("<aon>"));
			break;
			
		case C_DER:
			// delete to end of row
			PRINT(("<der>"));
			for (int column = fColumn; column < C_RADEON_CC_COLUMNS; column++)
				fText[fRow][column] = 0x0000;
			break;
			
		case C_RU2:
			// rollup captions (2 rows)
			PRINT(("<ru2>"));
			for (int row = 0; row < C_RADEON_CC_ROWS - 2; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = fText[row + 2][column];
			}
			for (int row = C_RADEON_CC_ROWS - 2; row < C_RADEON_CC_ROWS; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = 0x0000;
			}
			break;

		case C_RU3:
			// rollup captions (3 rows)
			PRINT(("<ru3>"));
			for (int row = 0; row < C_RADEON_CC_ROWS - 3; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = fText[row + 2][column];
			}
			for (int row = C_RADEON_CC_ROWS - 3; row < C_RADEON_CC_ROWS; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = 0x0000;
			}
			break;
			
		case C_RU4:
			// rollup captions (4 rows)
			PRINT(("<ru4>"));
			for (int row = 0; row < C_RADEON_CC_ROWS - 4; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = fText[row + 2][column];
			}
			for (int row = C_RADEON_CC_ROWS - 4; row < C_RADEON_CC_ROWS; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = 0x0000;
			}
			break;

		case C_FON:
			// flash on
			PRINT(("<fon>"));
			break;
			
		case C_RDC:
			// resume direct captioning
			PRINT(("<rdc>"));
			break;
			
		case C_TR:
			// text restart
			PRINT(("<tr>"));
			
			fRow = fColumn = 0;
			break;
		
		case C_RTD:
			// resume text display
			PRINT(("<rtd>"));

			fRow = fColumn = 0;
			break;
			
		case C_EDM:
			// erase displayed memory
			PRINT(("<edm>\n"));
			for (int row = 0; row < C_RADEON_CC_ROWS; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fDisplayText[row][column] = 0x0000;
			}
			DisplayCaptions();
			break;
			
		case C_CR:
			// carriage return
			PRINT(("<cr>"));
			
			/* has no effect in caption loading mode */
			break;
		
		case C_ENM:
			// erase non-displayed memory
			PRINT(("<enm>"));
			for (int row = 0; row < C_RADEON_CC_ROWS; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++)
					fText[row][column] = 0x0000;
			}
			break;
			
		case C_EOC:
			// end of caption
			PRINT(("<eoc>\n"));
			for (int row = 0; row < C_RADEON_CC_ROWS; row++) {
				for (int column = 0; column < C_RADEON_CC_COLUMNS; column++) {
					const int code = fText[row][column];
					fText[row][column] = fDisplayText[row][column];
					fDisplayText[row][column] = code;
				}
			}
			
			DisplayCaptions();
			break;		
		}
	}
	else if ((code & 0x7770) == 0x1720) {
		/* tab offset (172X) */
		const int offset = code & 0x000f;

		if (offset >= 1 && offset <= 3) {
			PRINT(("<tab%d>", offset));
			
			if ((fColumn += offset) >= C_RADEON_CC_COLUMNS - 1)
				fColumn = C_RADEON_CC_COLUMNS - 1;
		}
		else {
			PRINT(("<tab=%04X>", code & 0x7f7f));
		}
	}
	else if ((code & 0x7040) == 0x1040) {
		/* preamble address code (1Y4X, 1Y6X) */
	
		switch (code & 0x0720) {
		case C_ROW_1:
			PRINT(("\n<row1"));
			fRow = 0;
			break;
		case C_ROW_2:
			PRINT(("\n<row2"));
			fRow = 1;
			break;
		case C_ROW_3:
			PRINT(("\n<row3"));
			fRow = 2;
			break;
		case C_ROW_4:
			PRINT(("\n<row4"));
			fRow = 3;
			break;
		case C_ROW_5:
			PRINT(("\n<row5"));
			fRow = 4;
			break;
		case C_ROW_6:
			PRINT(("\n<row6"));
			fRow = 5;
			break;
		case C_ROW_7:
			PRINT(("\n<row7"));
			fRow = 6;
			break;
		case C_ROW_8:
			PRINT(("\n<row8"));
			fRow = 7;
			break;
		case C_ROW_9:
			PRINT(("\n<row9"));
			fRow = 8;
			break;
		case C_ROW_10:
			PRINT(("\n<row10"));
			fRow = 9;
			break;
		case C_ROW_11:
			PRINT(("\n<row11"));
			fRow = 10;
			break;
		case C_ROW_12:
			PRINT(("\n<row12"));
			fRow = 11;
			break;
		case C_ROW_13:
			PRINT(("\n<row13"));
			fRow = 12;
			break;
		case C_ROW_14:
			PRINT(("\n<row14"));
			fRow = 13;
			break;
		case C_ROW_15:
			PRINT(("\n<row15"));
			fRow = 14;
			break;
		default:
			PRINT(("\n<pac=%04X>", code & 0x7f7f));
			return false;
		}
		
		if ((code & 0x0010) == 0x0000) {
			/* change color */
			fColor = (code & 0x000f);
			fColumn = 0;
			
			switch (fColor & 0x000e) {
			case C_WHITE:
				PRINT((",white"));
				break;
			case C_GREEN:
				PRINT((",green"));
				break;
			case C_BLUE:
				PRINT((",blue"));
				break;
			case C_CYAN:
				PRINT((",cyan"));
				break;
			case C_RED:
				PRINT((",red"));
				break;
			case C_YELLOW:
				PRINT((",yellow"));
				break;
			case C_MAGENTA:
				PRINT((",magenta"));
				break;
			case C_ITALICS:
				PRINT((",italics"));
				break;
			}
			if ((fColor & 0x0001) != 0)
				PRINT((",underline>"));
			else
				PRINT((">"));
			
		}
		else {
			/* indent, white */
			fColor = C_WHITE | (code & 0x0001);
			fColumn = (code & 0x000e) << 1;
			PRINT((",col%d>", fColumn));
		}
	}
	else {
		/* two one-byte standard characters */
		character = (code >> 8) & 0x7f;
		if (character >= 0x20) {
		
			PRINT(("%c", character));
			
			fText[fRow][fColumn] = (fColor << 8) + character;
			if (fColumn < C_RADEON_CC_COLUMNS - 1)
				fColumn++;
		}
		else if (character != 0x00) {
			PRINT(("<%02X>", character));
		}
		
		character = (code >> 0) & 0x7f;
		if (character >= 0x20) {

			PRINT(("%c", character));

			fText[fRow][fColumn] = (fColor << 8) + character;
			if (fColumn < C_RADEON_CC_COLUMNS - 1)
				fColumn++;
		}
		else if (character != 0x00) {
			PRINT(("<%02X>", character));
		}
	}
	
	return true;
}

void CCaption::DisplayCaptions() const
{
	printf("\x1b[H\x1b[J");
	
	for (int row = 0; row < C_RADEON_CC_ROWS; row++) {
		for (int column = 0; column < C_RADEON_CC_COLUMNS; column++) {
			if (fDisplayText[row][column] == 0x0000) {
				printf("\x1b[0;47;37m ");
				continue;
			}
				
			const int code = (fDisplayText[row][column] >> 0) & 0xff;
			const int color = (fDisplayText[row][column] >> 8) & 0xff;

			switch (color & 0x000e) {
			case 0x0000: // WHITE
				printf("\x1b[0;%d;40;37m", (color & 1) << 2);
				break;
			case 0x0002: // GREEN
				printf("\x1b[0;%d;40;32m", (color & 1) << 2);
				break;
			case 0x0004: // BLUE
				printf("\x1b[0;%d;40;34m", (color & 1) << 2);
				break;
			case 0x0006: // CYAN
				printf("\x1b[0;%d;40;35m", (color & 1) << 2);
				break;
			case 0x0008: // RED
				printf("\x1b[0;%d;40;31m", (color & 1) << 2);
				break;
			case 0x000a: // YELLOW
				printf("\x1b[0;%d;40;33m", (color & 1) << 2);
				break;
			case 0x000c: // MAGENTA
				printf("\x1b[0;%d;40;36m", (color & 1) << 2);
				break;
			case 0x000e: // WHITE ITALICS
				if ((color & 1) == 0)
					printf("\x1b[1;40;37m");
				else
					printf("\x1b[1;4;40;37m");
				break;
			}
			
			if (code >= 0x20 && code <= 0x7f) {
				switch (code) {
				case 0x002a:
					// aacute
					printf("\xc3\xa1");
					break;
				case 0x005c:
					// eacute
					printf("\xc3\xa9");
					break;
				case 0x005e:
					// iacute
					printf("\xc3\xad");
					break;
				case 0x005f:
					// oacute
					printf("\xc3\xb3");
					break;
				case 0x0060:
					// uacute
					printf("\xc3\xba");
					break;
				case 0x007b:
					// ccedil
					printf("\xc3\xa7");
					break;
				case 0x007c:
					// division
					printf("\xc3\xb7");
					break;
				case 0x007d:
					// Ntilde
					printf("\xc3\x91");
					break;
				case 0x007e:
					// ntilde
					printf("\xc3\xb1");
					break;
				case 0x007f:
					// block
					printf("\xc1\xbf");
					break;
				default:
					// ASCII character
					printf("%c", code);
					break;
				}
			}
			else {
				switch (code) {
				case 0x0080:
					// reg
					printf("\xc2\xae");
					break;
				case 0x0081:
					// deg
					printf("\xc2\xb0");
					break;
				case 0x0082:
					// frac12
					printf("\xc2\xbd");
					break;
				case 0x0083:
					// iquest
					printf("\xc2\xbf");
					break;
				case 0x0084:
					// trademark
					printf("\xe2\x84");
					break;
				case 0x0085:
					// cent
					printf("\xc2\xa2");
					break;
				case 0x0086:
					// pound
					printf("\xc2\xa3");
					break;
				case 0x0087:
					// music
					printf("\xc2\xa7");
					break;
				case 0x0088:
					// agrave
					printf("\xc3\xa0");
					break;
				case 0x0089:
					// tspace
					printf("\x1b[0;47;37m ");
					break;
				case 0x008a:
					// egrave
					printf("\xc3\xa8");
					break;
				case 0x008b:
					// acirc
					printf("\xc3\xa2");
					break;
				case 0x008c:
					// ecirc
					printf("\xc3\xaa");
					break;
				case 0x008d:
					// icirc
					printf("\xc3\xae");
					break;
				case 0x008e:
					// ocirc
					printf("\xc3\xb4");
					break;
				case 0x008f:
					// ucirc
					printf("\xc3\xbb");
					break;
				default:
					// buggy code
					printf("<%02X>", code);
					break;
				}
			}
		}
		printf("\n");
	}
	printf("\x1b[0;30;47m");
}