/*
** Copyright (C) 2001 Optek. All rights reserved.
**
** The information and source code contained herein is the exclusive
** property of Mediamatics and may  not be disclosed, examined or
** reproduced in whole or in part without explicit written authorization
** from the company.
*/

/*
** Author:
**
** Date: 1/20/2001
**
** Description: Progarm tools.
** 
*/

//#include <stdio.h>

#include "c_def.h"
#include "debug.h"
#include "oem.h"

#include "tools.h"

#define INVALID_CHAR	('#')


/*about 0.1 us*/
//void delay(WORD num)
//{
//	while (num-- != 0)
//	{
		//NOP;
		//NOP;
		//NOP;
		//NOP;
		//NOP;
		//NOP;
		//NOP;
		//NOP;
		//NOP;
//	};
//}

void dword_endian_convertion (unsigned long *l)
{
	U32 tmp;

	tmp = (*l & 0xFF000000) >> 24;

	tmp |= ( (*l & 0x00FF0000) >> 8);

	tmp |=	( (*l & 0x0000FF00) << 8);

	tmp |=  ( (*l & 0x000000FF) << 24);
	
	*l = tmp;
}

void word_endian_convertion (U16 *w)
{
	U16 tmp;

	tmp = (U16) ( (*w & 0xFF00) >> 8);

	tmp |=	( (*w & 0x00FF) << 8);

	*w = tmp;
}

U32 dword_endian_conv (u8 *p)
{
	return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
}

U16 word_endian_conv (U8 *p)
{
	return p[0] << 8 | p[1];
}


void convert_unicode_to_normal (U16 *buf)
{
} 

//#pragma CODE_SECTION (European2English, ".EXTERNAL_CODE");

U16 European2English ( U16 european )
{
	U16 english;
	
	switch (european )
	{
		// S
	case 138:
		english = 83;
		break;
	
		// A
	case 192:
	case 193:
	case 194:
	case 195:
	case 196:
	case 197:
	case 198:
		english = 65;
		break;

		//E
	case 200:
	case 201:
	case 202:
	case 203:
		english = 69;
		break;

		//I
	case 204:
	case 205:
	case 206:
	case 207:
		english = 73;
		break;

		//C
	case 199:
		english = 67;
		break;

		//D
	case 208:
		english = 68;
		break;

		//N
	case 209:
		english = 78;
		break;

		//O
	case 140:
	case 210:
	case 211:
	case 212:
	case 213:
	case 214:
		english = 79;
		break;

		//U
	case 217:
	case 218:
	case 219:
	case 220:
		english = 85;
		break;

		//Y
	case 221:
		english = 89;
		break;

		//P
	case 222:
		english = 80;
		break;

		//B
	case 223:
		english = 66;
		break;

		//s	
	case 154:
		english = 115;
		break;

		//a
	case 170:
	case 224:
	case 225:
	case 226:
	case 227:
	case 228:
	case 229:
	case 230:
		english = 97;
		break;

		//e
	case 232:
	case 233:
	case 234:
	case 235:
		english = 101;
		break;

		//I
	case 236:
	case 237:
	case 238:
	case 239:
		english = 105;
		break;

		//c
	case 231:
		english = 99;
		break;

		//d
	case 240:
		english = 100;
		break;

		//n
	case 241:
		english = 110;
		break;

		//o
	case 156:
	case 242:
	case 243:
	case 244:
	case 245:
	case 246:
		english = 111;
		break;

		//u 
	case 181:
	case 249:
	case 250:
	case 251:
	case 252:
		english = 117;
		break;

		//y
	case 159:
	case 253:
	case 255:
		english = 121;
		break;

		//p
	case 254:
		english = 112;
		break;

		//0
	case 216:
	case 248:
		english = 48;
		break;

	default:
		english = european;
	}

	return english;
} 

//#pragma CODE_SECTION (convert_European_to_English, ".EXTERNAL_CODE");

void convert_European_to_English(U16 * buf, I16 wlen)
{
#ifdef EUROPEAN_TO_ENGLISH			//support Chinese
	int i;
	U16 tmpH,tmpL;

	for( i = 0; i < wlen; i ++ )
	{
		tmpH = (U16) (buf[i] >> 8);
		if( tmpH >= 0x80 ) {
			tmpH = European2English(tmpH);
		}
		tmpL = (buf[i] & 0xFF);
		if( tmpL >= 0x80 ) {
			tmpL = European2English(tmpL);
		}
		buf[i] = (U16) ( (tmpH << 8) | tmpL );
	}
#endif
}

/* 
* convert a number into a string, and return the length of string.
* NOTICE: user must add a end flag to the string.
*/
U8 convert_int2str(U32 number, U8 *buf)
{
	U8 i;
	U8 temp = 0;
	U32 number_bak = number;
	
	while (number_bak/10)
	{
		temp++;
		number_bak /= 10;
	}
	
	temp++;
	number_bak = number;
	
	for (i = temp; i > 0; i--)
	{
		buf[i-1] = number_bak%10 + '0';
		number_bak /= 10;
	}
	
	return temp;
}


U8 aString [6];
#define Itoa_Max		6

void itoa( U16 val, U8 *string )
{
    unsigned char *p;
    char *str1;
    str1 = "0123456789ABCDEF";
    
    p = aString+Itoa_Max-1;
    *p = 0;
    
    do
    { 
		*--p = str1[val % 10];
		val = val/10;
    } while( val );

	while (*p != 0) {
		*string++ = *p++;
	}
	
//	*string = 0;
}

/************************************************************/
/*					RANDOM									*/
/************************************************************/

U16 random_seed;
U16 random_base;

/*(10,3,0)*/
void random_set_seed (U16 seed)
{
	if (seed == 0) {
		seed = 0xAA;
	}

	random_seed = seed & 0x3FF;
}

void random_set_base (U16 base)
{
	if (base == 0) {
		base = 0x55;
	}

	random_base = base & 0x3FF;
}

U16 random (void)
{
	BOOL LFSR_bit;
	
	if (random_base > 0x3FF) {
		
		U16 tmp;
	    
	    tmp = (random_base >> 10);
	    
		random_base &= 0x3FF;     
		
		random_base |= tmp;
	}
	
	if (random_seed == 0) {
		random_seed = 0x45;
	}

	LFSR_bit = random_seed & 0x01;	/*bit 10*/
	LFSR_bit ^= (random_seed & 0x80) >> 7;	/*bit 3*/

	random_seed >>= 1;

	if (LFSR_bit == 1) {
		random_seed |= 0x200;
	}

	return ((random_seed ^ random_base) & 0x3FF);
}

U16 random_track (U16 max_track)
{
	U16 random_track;
	
	while (1)
	{
		random_track = random ();
		if (random_track <= max_track && random_track != 0) {
			return (random_track-1);
		}
	}
}

void random_start (U16 s)
{
	random_base = random_seed ^ s;
}

void unicode_to_oem (U16 *buf)
{
#if 0
	U8 *d;
	U16 len = 0;

	d = (U8 *) buf;

	while ( *buf != 0x0 )
	{
		if ( (*buf & 0xFF00) != 0x0 ) {
			*d++ = (U8) (*buf >> 8);
			len++;
		}

		if ( (*buf & 0x00FF) != 0x0 ) {
			*d++ = (U8) (*buf & 0x00FF);
			len++;
		}

		buf++;
	}

	/*Please note, it will be need that unicode null*/
	*d++ = 0x0;
	*d++ = 0x0;

	if (len & 0x01) {
		*d++ = 0;
	}
#endif

#ifdef UNICODE_TO_RUSSIAN
	while ( *buf != 0x0 )
	{
		if ( (*buf >= 0x0401) && (*buf <= 0x0451) )
		{
			*buf = Russian_Uni_2_OEM_table[*buf - 0x0401][2];
		}
		buf++;
	}
#endif
}

void unicode_to_oem_used_cd (U16 *buf)
{
#if 0
	U8 *d;
	U16 len = 0;

	d = (U8 *) buf;

	while ( *buf != 0x0 )
	{
		if ( (*buf & 0xFF00) != 0x0 )
		{
			*d++ = (U8) (*buf >> 8);
			len++;
		}

		if ( (*buf & 0x00FF) != 0x0 )
		{
			*d++ = (U8) (*buf & 0x00FF);
			len++;
		}

		buf++;
	}

	/*Please note, it will be need that unicode null*/
	*d++ = 0x0;
	*d++ = 0x0;

	if (len & 0x01)
	{
		*d++ = 0;
	}
#endif

#ifdef UNICODE_TO_RUSSIAN
	while ( *buf != 0x0 )
	{
		if ( (*buf >= 0x0401) && (*buf <= 0x0451) )
		{
			*buf = Russian_Uni_2_OEM_table[*buf - 0x0401][2];
		}
		buf++;
	}
#endif
}

void _unicode_to_oem (U16 *buf, U8 *d)
{
#ifdef UNICODE_TO_OEM

	U16 len = 0;

	while ( *buf != 0x0 )
	{
#if 0
		if ( (*buf & 0xFF00) != 0x0 )
		{
			*d++ = (U8) (*buf >> 8);
			len++;
		}

		if ( (*buf & 0x00FF) != 0x0 )
		{
			*d++ = (U8) (*buf & 0x00FF);
			len++;
		}

		buf++;
#endif

		if (*buf >= 0x100)
		{
#if defined JP_SR80I
			*d++ = (U8) '*';
#elif defined BLUESEA_SDK
			*d++ = (U8) '#';
#else
			*d++ = (U8) '*';
#endif
			buf++;
		}
		else
		{
			*d++ = (U8) *buf++;
		}
	}

	/*Please note, it will be need that unicode null*/
	*d++ = 0x0;
	*d++ = 0x0;

	if (len & 0x01)
	{
		*d++ = 0;
	}
#endif
}

//#define JAPAN_KATAKATA
U16 unicode_to_oem_n (U16 *l_name, U8 *s_name, U16 n)
{
	U16 i, num;

	num = 0;

	s_name[0] =0x0;

	for (i=0;i<n;i++)
	{
		if (*l_name == 0)
		{
			break;
		}

		if (*l_name >= 0xFF) {
			
			*s_name = (U8) INVALID_CHAR;

#ifdef KATAKATA
			for (i=0;i<KATAKAHA_NUM;i++)
			{
				if (*l_name == JPLCD_OEM_UNICODE[i][1])
				{
					*s_name = JPLCD_OEM_UNICODE[i][0];					
				}
			}
#endif
	
			s_name++;
			l_name++;
		}
		else {
			*s_name++ = (U8) *l_name++;
		}	
	}

	*s_name++ = 0x0;
}

void oem_to_unicode (U8 *oem_buf, U16 *unicode_buf)
{
	U16 tmp;

	while (1)
	{
		if (*oem_buf == 0x0)
		{
			break;
		}
		else if (*oem_buf < 0x80)
		{
			*unicode_buf++ = (U16) *oem_buf++;
		}
		else
		{
			if ( *(oem_buf+1) >= 0x80)
			{
				tmp = ((*oem_buf++) << 8);
				tmp |= *oem_buf++;
				*unicode_buf++ = tmp;
			}
			else
			{
				*unicode_buf++ = (U16) *oem_buf++;
			}
		}
	}

	*unicode_buf = 0;
}


void unicode_to_English_oem( U16 *lfn_name, U16 n, U8 *oem_name)
{
	U16 i;

	for (i=0; i<n; i++)
	{	
		if (*lfn_name == 0)
		{
			break;
		}

#ifdef LCD_DISP_SUPPOERT_GERMANY
		if (*lfn_name >= 0xFF)
		{
#if 0
			*oem_name++ = (U8) *lfn_name++;
#else
			
#if defined JP_SR80I
			*oem_name++ = (U8) '*';
#elif defined SHARP_HF108P
			*oem_name++ = (U8) '#';
#else
			*oem_name++ = (U8) '*';
#endif
			lfn_name++;
#endif
		}
		else
		{
			*oem_name++ = (U8) *lfn_name++;
		}

#else
		if (*lfn_name >= 0x80)
		{
#if 0
			*oem_name++ = (U8) *lfn_name++;
#else

#if defined JP_SR80I
			*oem_name++ = (U8) '*';
#elif defined BLUESEA_SDK
			*oem_name++ = (U8) '#';
#else
			*oem_name++ = (U8) '*';
#endif
			lfn_name++;
#endif
		}
		else
		{
			*oem_name++ = (U8) *lfn_name++;
		}
#endif //LCD_DISP_SUPPOERT_GERMANY
	}

	//unicode null
	*oem_name++ = 0x0;
}



void unicode_to_English_oem_n( U16 *lfn_name, U8 *oem_name, U16 n)
{
	U16 i, num;

	num = 0;

	while (1)
	{
		if (*lfn_name == 0)
		{
			break;
		}

#ifdef LCD_DISP_SUPPOERT_GERMANY
		if (*lfn_name >= 0xFF)
		{
#if 0
			*oem_name++ = (U8) *lfn_name++;
#else
			
#if defined JP_SR80I
			*oem_name++ = (U8) '*';
#elif defined SHARP_HF108P
			*oem_name++ = (U8) '#';
#else
			*oem_name++ = (U8) '*';
#endif
			
			lfn_name++;
#endif
		}
		else
		{
			*oem_name++ = (U8) *lfn_name++;
		}
		
		num++;
		
		if (num >= n)
		{
			break;
		}
	}

#else
		if (*lfn_name >= 0x80)
		{
#if 0
			*oem_name++ = (U8) *lfn_name++;
#else

#if defined JP_SR80I
			*oem_name++ = (U8) '*';
#elif defined BLUESEA_SDK
			*oem_name++ = (U8) '#';
#else
			*oem_name++ = (U8) '*';
#endif

			lfn_name++;
#endif
		}
		else
		{
			*oem_name++ = (U8) *lfn_name++;
		}
		
		num++;

		if (num >= n)
		{
			break;
		}
	}
#endif //LCD_DISP_SUPPOERT_GERMANY

	//unicode null
	*oem_name++ = 0x0;
}


void oem_to_n_unicode (U8 *oem_buf, U16 *unicode_buf, U16 n)
{
	U16 tmp;
	U16 num = 0;

	while (1)
	{
		if (*oem_buf == 0x0)
		{
			break;
		}

		if (num >= n)
		{
			break;
		}

		if (*oem_buf < 0x80)
		{
			*unicode_buf++ = (U16) *oem_buf++;
		}
		else
		{
			if ( *(oem_buf+1) >= 0x80)
			{
				tmp = ((*oem_buf++) << 8);
				tmp |= *oem_buf++;
				*unicode_buf++ = tmp;
			}
			else
			{
				*unicode_buf++ = (U16) *oem_buf++;
			}
		}
		num++;
	}

	*unicode_buf = 0;
}

//#define UNICODE_TO_OEM

U16 unicode_char_to_oem_char (U16 uchar)
{
	return uchar;
}

WORD w_Little_Big_Endian (void * p)
{
	WORD tmp;
	BYTE *pByte = p;

	tmp =  (*pByte)  & 0xff;
	tmp |= ( *(pByte + 1) << 8 ) & 0xff00;
	return tmp;
}

DWORD dw_Little_Big_Endian (void *p)
{
	DWORD tmp;
	BYTE *pByte = p;

	tmp =  (*pByte) & 0x000000ff;
	tmp |= ( ( *(pByte + 1) ) << 8 ) & 0x0000ff00;
	tmp |= ( ( *(pByte + 2) ) << 16 ) & 0x00ff0000;
	tmp |= ( *(pByte + 3) << 24 ) & 0xff000000;
	return tmp;
}

U32 U32_endian_buf(U8 *buf)
{
#ifdef LITTLE_ENDIAN
	return (U32)((U32)(buf[0]<<24)|(U32)(buf[1]<<16)|(U32)(buf[2]<<8)|(U32)(buf[3]<<0));
#else
	return (U32)((U32)(buf[3]<<24)|(U32)(buf[2]<<16)|(U32)(buf[1]<<8)|(U32)(buf[0]<<0));
#endif
}

U16 U16_endian_buf(U8 *buf)
{
#ifdef LITTLE_ENDIAN
	return (U16)( (U16)(buf[0 ] << 8) | (U16)(buf[1] << 0) );
#else
	return (U16)( (U16)(buf[1] << 8) | (U16)(buf[0] << 0) );
#endif
}

void endian_convert_u16_from_big_to_little(U16 *buf, U16 len)
{
	U16 i;
	U16 *pBuf = buf;

	for (i=0; i<len; i++)
	{
		*pBuf = ( (*pBuf >> 8) | (*pBuf << 8) );
		pBuf++;
	}
}

#ifdef DOLBY_ENABLE
U32 u32_endian_swap(U8 *buf)
{
	U32 tmp;

//	tmp = ((buf[3] >> 24) | ((buf[2] >> 8) & 0x0000FF00) | ((buf[1] << 8) & 0x00FF0000) | (buf[0] << 24));
	tmp = ((buf[0] << 24) | ((buf[1] >> 16) & 0x00FF0000) | ((buf[2] << 8) & 0x0000FF00) | buf[3]);

	return tmp;
}

#endif

U32 _2power(U32 exp)// output = 2^exp;
{
	U32 ret=1;
		
	while(exp--)
		ret *= 2;

	return ret;
}


U8 *p_dump;
U32 dump_size;
void dump_init(U8 *p)
{
	p_dump = p;
	dump_size = 0;
}

void dump_write(U8 *buf,U32 len)
{
	memcpy(p_dump,buf,len);
	p_dump += len;
	dump_size += len; 
}

U32 get_dump_size(void)
{
	return dump_size;
}