path: root/EDK/MiniSetup/TseAdvanced/jpeg6.c

//*****************************************************************//
//*****************************************************************//
//*****************************************************************//
//**                                                             **//
//**         (C)Copyright 2010, American Megatrends, Inc.        **//
//**                                                             **//
//**                     All Rights Reserved.                    **//
//**                                                             **//
//**   5555 Oakbrook Pkwy, Building 200,Norcross, Georgia 30093  **//
//**                                                             **//
//**                     Phone (770)-246-8600                    **//
//**                                                             **//
//*****************************************************************//
//*****************************************************************//
//*****************************************************************//
// $Archive: /Alaska/SOURCE/Modules/AMITSE2_0/AMITSE/TseAdvanced/jpeg6.c $
//
// $Author: Premkumara $
//
// $Revision: 11 $
//
// $Date: 5/21/13 1:29a $
//
//*****************************************************************//
//*****************************************************************//
// Revision History
// ----------------
// $Log: /Alaska/SOURCE/Modules/AMITSE2_0/AMITSE/TseAdvanced/jpeg6.c $
// 
// 11    5/21/13 1:29a Premkumara
// [TAG]  		EIP114841 
// [Category]  	Bug Fix
// [Severity]  	Important
// [Symptom]  	When use the broken JPG file as user logo, system hangs up
// CP:0xb4
// [RootCause]  	When corrupted Jpeg image has no proper AC co-efficent
// value in Huffman table then dc_value_length is incremented beyond its
// range value.
// [Solution]  	Checked dc_value_length boundary value.
// [Files]  		Jpeg6.c
// 
// 10    10/18/12 5:53a Arunsb
// Updated for 2.16.1235 QA submission
// 
// 14    10/10/12 12:35p Arunsb
// Synched the source for v2.16.1232, backup with Aptio
// 
// 9     4/26/12 3:25a Arunsb
// [TAG]  		EIP78033
// [Category]  	Bug Fix
// [Severity]  	Normal
// [Symptom]  	YUV122 sampling JPEG image not displayed
// [RootCause]  	No support for  YUV122 sampling
// [Solution]  	Support added for YUV122 sampling
// [Files]  		jpeg6.c
// 
// 8     5/03/11 1:42p Madhans
// [TAG]  		EIP59177 
// [Category]  	Improvement
// [Description]  	Support for JPEG with RSI markers. Fix to support logo
// size that bigger then Screen resolution.
// [Files]  		Logo.c
// Jpeg6.c
// commonHelper.c
// 
// 7     4/29/11 4:44p Madhans
// [TAG]  		EIP59177 
// [Category]  	Improvement
// [Description]  	Support for JPEG with RSI markers. Fix to support logo
// size that bigger then Screen resolution.
// [Files]  		Logo.c
// Jpeg6.c
// commonHelper.c
// 
// 6     9/27/10 7:47a Mallikarjunanv
// EIP 40555 : To avoid Compilation issues with Fareast Windows.
// 
// 5     2/19/10 1:02p Madhans
// Updated for TSE 2.01. Refer Changelog.log for File change history.
// 
// 8     2/19/10 8:11a Mallikarjunanv
// updated year in copyright message
// 
// 7     1/09/10 4:43a Mallikarjunanv
// Updated TSE2.01 Release sources with coding standards
// 
// 6     8/13/09 12:16p Blaines
// Move Image support to binary module
// 
// 5     7/08/09 3:34p Madhans
// Coding Standards.
// 
// 4     6/29/09 12:46p Blaines
// EIP #22305 Fix for improper JPEG Image size calculation logic 
// 
// 3     6/23/09 7:09p Blaines
// Coding standard update, 
// Remove spaces from file header to allow proper chm function list
// creation.
// 
// 2     6/12/09 7:43p Presannar
// Initial implementation of coding standards for AMITSE2.0
// 
// 1     6/04/09 8:05p Madhans
// 
// 1     4/28/09 11:16p Madhans
// Tse 2.0 Code complete Checkin.
// 
// 1     4/28/09 10:27p Madhans
// Tse 2.0 Code complete Checkin.
// 
// 1     9/26/06 4:03p Madhans
// JpegC Implimentation
// 
// 5     9/22/06 3:23a Shirinmd
// Added Support for JPEG Images having 1 Huffman Table and 1 Quantization
// table
// 
// 4     9/15/06 9:54a Shirinmd
// Added the check to find the type of Huffman table
// 
// 3     8/03/06 7:16a Shirinmd
// Removed initialization of global buffers in InitGlobals function to
// reduce code size
// 
// 2     8/02/06 8:55a Shirinmd
// Made changes to reduce the code size
// 
// 1     8/01/06 8:03a Shirinmd
// Files for JPEG decoding (C version)
//
//*****************************************************************//
//*****************************************************************//
//<AMI_FHDR_START>
//
// Name:		jpeg6.c
//
// Description:	Support for JPEG decoding
//
//<AMI_FHDR_END>
//*****************************************************************//

#include "Mydefs.h"
#include "Jpeg6.h"


//Globals_START

UINTN unBitStreamOFFSET;
BYTE bNumBitsRead;
BYTE btempBitStreamByte;

UINTN unSOF0;
WORD wDCLumtable[13*3];
WORD wACLumtable[170*3];
WORD wDCChrtable[13*3];
WORD wACChrtable[170*3];

WORD space_image[256*4];
AMI_TRUECOLOR_PIXEL_JPEG * ScreenBufferJPEG = (AMI_TRUECOLOR_PIXEL_JPEG *)NULL;

WORD image_Y[64];
WORD image_Y1[64];
WORD image_Y2[64];
WORD image_Y3[64];
WORD image_Cr[64];
WORD image_Cb[64];
UINTN QT[2];
UINTN HT[4];
BYTE bQTLumTable[64];
BYTE bQTChrTable[64];
WORD jpeg_zigzag_order[] = {								\
							0,  1,  5,  6, 14, 15, 27, 28,	\
							2,  4,  7, 13, 16, 26, 29, 42,	\
							3,  8, 12, 17, 25, 30, 41, 43,	\
							9, 11, 18, 24, 31, 40, 44, 53,	\
							10, 19, 23, 32, 39, 45, 52, 54,	\
							20, 22, 33, 38, 46, 51, 55, 60,	\
							21, 34, 37, 47, 50, 56, 59, 61,	\
							35, 36, 48, 49, 57, 58, 62, 63	\
							};

WORD jpeg_zigzag_order_temp[64];


WORD diff_Y	;
WORD diff_Cr;
WORD diff_Cb;
WORD gRsi = 0;
UINT32 g_un32BufferWidth ;
UINT32 g_un32BufferHeight;

//Globals_End


//Function Declarations
void BuildHuffmanCodeTable(WORD * pwHuffCodeTable ,BYTE * pbySrcHT);
void HuffmanDecoding(WORD * pwDCCoeffTable, WORD * pwACCoeffTable, WORD * pwImage);
void GetDCValue(WORD * pwHuffmanTable, WORD * pwValue, WORD * pwLengthDC_RunSizeAC);
BOOL SearchHuffmanCode(WORD * pwSearchTablePos, WORD * pwHuffmanCodeValue, WORD wDc_value_length);
BOOL GetEncodedBit();
void ReadJPEGImage(WORD * pwDCCoeffTable, WORD * pwACCoeffTable, WORD * pwImage, WORD * diff, BYTE * pbySrcQT, int nLumFlag);
void ReadJPEGImage_YUV(DWORD * pdwBuffer, WORD wSampling);
void OutputJPEGImage_YUV(WORD wXPos, WORD wYPos, WORD wXLength, WORD wYLength, WORD	wSampling);
void Output8x8Image(WORD wLeft, WORD wTop, BYTE * pspace_image);
BOOL InitJpegParams(BYTE * pbyImage);
DWORD ConvertYCbCrToRGB(short Y, short Cb, short Cr);
void InvertDCT(WORD * pwSource);
void InvertDCT_xy(WORD * pwSource, WORD wVal);
void GetTables(BYTE bNumQT, BYTE bNumHT);


//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	InitGlobals
//
// Description:	Initializes required global variables
//
// Input:		None
//
// Output:		None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void InitGlobals(){
	diff_Y		= 0;
	diff_Cr	= 0;
	diff_Cb	= 0;
	bNumBitsRead = 8;
	btempBitStreamByte = 0;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	DecodeJPEG
//
// Description:	Decode the JPEG image into the given buffer at given position, 
//					subject to the limit of the Buffer Width and Height
//
// Input:		WORD wXPos - X Start Postion with in the Buffer 
//									where the image need to be decoded
//					WORD wYPos - Y Start Postion with in the Buffer 
//									where the image need to be decoded
//					BYTE * pbyJPEGInputData - Pointer that gives the memory location 
//											  where the Input data is available
//					BYTE * pbyJPEGOutputData - Pointer that gives the pointer 
//											   for the output buffer
//					UINT32 un32BufferWidth - Width of the output Buffer
//					UINT32 un32BufferHeight	- Height of the output Buffer
//
// Output:		BOOL - TRUE/FALSE Indicate whether the Decoding was successful
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOL DecodeJPEG(WORD wXPos, WORD wYPos, BYTE * pbyJPEGInputData, BYTE * pbyJPEGOutputData, UINT32 un32BufferWidth, UINT32 un32BufferHeight){
	WORD wX_Length=0, wY_Length=0; 
	ScreenBufferJPEG = (AMI_TRUECOLOR_PIXEL_JPEG *)pbyJPEGOutputData;
	g_un32BufferWidth	= un32BufferWidth ; 
	g_un32BufferHeight	= un32BufferHeight;

    gRsi = 0;
	InitGlobals();

	if(InitJpegParams(pbyJPEGInputData)){
		wX_Length = (*(WORD*)((BYTE *)unSOF0+5)<<8)|*((BYTE *)unSOF0+6);
		wY_Length = (*(WORD*)((BYTE *)unSOF0+3)<<8)|*((BYTE *)unSOF0+4);
		 
if((0x11==(*(BYTE *)(unSOF0+3+4+1+1+3)))&&(0x11==((*(BYTE *)(unSOF0+3+4+1+1+3+3)))))
		{
#if MKF_JPEG_YUV111_SUPPORT
			if(0x11==(*(BYTE *)(unSOF0+3+4+1+1)))
				OutputJPEGImage_YUV(wXPos, wYPos, wX_Length, wY_Length, 0x111);
			else
#endif
				if(0x22==(*(BYTE *)(unSOF0+3+4+1+1)))
					OutputJPEGImage_YUV(wXPos, wYPos, wX_Length, wY_Length, 0x122);
		}
		return TRUE;
	}
	else
		return FALSE;
	
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	GetJPEGDimensions
//
// Description:	Get the dimensions (Width and Height) for the JPEG image
//
// Input:	BYTE * pbyJPEGInputData - Pointer that gives the memory 
//									location where the Input data is available
//					UINT32 * pun32Width - Pointer to the UINT32 variable that 
//									will recieve the Width of the Image
//					UINT32 * pun32Height - Pointer to the UINT32 variable that 
//									will recieve the Height of the Image
//
// Output:	BOOL - TRUE/FALSE.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOL GetJPEGDimensions(BYTE * pbyJPEGInputData, UINT32 * pun32Width, UINT32 * pun32Height){
	if(InitJpegParams(pbyJPEGInputData)){
		*pun32Width =  (WORD)((*(WORD*)((BYTE *)unSOF0+5)<<8)|*((BYTE *)unSOF0+6));
		*pun32Height=  (WORD)((*(WORD*)((BYTE *)unSOF0+3)<<8)|*((BYTE *)unSOF0+4));
		return TRUE;
	}
	else return FALSE;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	BuildHuffmanCodeTable
//
// Description:	Builds the Huffman codes for the particular JPEG Huffman table.
//					By incrementing the offset of the Huffman table by 3, 
//					the offset of the actual data is obtained. The first 
//					16 bytes represent the no: of code words for a paricular 
//					bit-size. Having the bit-size and the no: of code words 
//					for each bit-size, the Huffman code table is built.
//
// Input:	WORD * pwHuffCodeTable - Pointer to the memory location 
//							that contains the Huffman codes for the particular JPEG Huffman table.
//					BYTE * pbySrcHT - Pointer to the memory location that contains 
//							the offset of the JPEG Huffman Table.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void BuildHuffmanCodeTable(WORD * pwHuffCodeTable ,BYTE * pbySrcHT){

	BYTE * pbySrcHTCopy = NULL;
	int nCounter=0;
	int nOffSet=0;			
	BYTE wCodeSize = 1;		
	WORD wCodeWord = 0;		

	pbySrcHT			+= 1;	
	pbySrcHTCopy = pbySrcHT;
	do{
		for(nCounter=*pbySrcHT;nCounter>0; nCounter--){
			pwHuffCodeTable[nOffSet++]	= wCodeSize;
			pwHuffCodeTable[nOffSet++]	= wCodeWord++;
			pwHuffCodeTable[nOffSet++] = *(pbySrcHTCopy+16);
			pbySrcHTCopy++;
		}
		wCodeWord<<=1;
		pbySrcHT++; 
		wCodeSize++;
	}while(wCodeSize<=16);
	pwHuffCodeTable[nOffSet]	= 17;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	ReadJPEGImage
//
// Description:	Reads the 8x8 matrix data for each of Y_0,Y_1,Y_2,Y_3,Cb and Cr. 
//					The final output will be image data after inverse DCT is applied.
//
// Input:	WORD * pwDCCoeffTable - DC Luminance/ Chrominance Huffman Table.
//					WORD * pwACCoeffTable - AC Luminance/ Chrominance Huffman Table.
//					WORD * pwImage - Pointer to the 8x8 matrix data for each of Y_0,Y_1,Y_2,Y_3,Cb and Cr.
//					WORD * pwDiff  - Pointer to the variable that hold the differences of the DC coefficients. 
//						Adds the difference to the Prev Dc coefficient value to get the present DC coefficient value.
//					BYTE * pbySrcQT - Pointer to the Quantization table.
//					int nLumFlag - Flag if it is set, indicates that the image component is luminance.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void ReadJPEGImage(WORD * pwDCCoeffTable, WORD * pwACCoeffTable, WORD * pwImage, WORD * diff, BYTE * pbySrcQT, int nLumFlag)
{
	int nCounter;
	HuffmanDecoding(pwDCCoeffTable, pwACCoeffTable, pwImage);
	*diff = *diff + pwImage[0]; 
	pwImage[0] = *diff;
	
	//DeQuantization
	for(nCounter=0; nCounter<64; nCounter++)
	{
		pwImage[nCounter] = pwImage[nCounter] * (WORD)pbySrcQT[nCounter]; 
	}
	
	//InvertZigZagOrder
	for(nCounter=0; nCounter<64; nCounter++)
	{
		jpeg_zigzag_order_temp[nCounter] = *((WORD *)((BYTE *)pwImage+(jpeg_zigzag_order[nCounter]<<1)));
	}
	memcpy(pwImage,jpeg_zigzag_order_temp, 128);
	InvertDCT(pwImage);

	if(nLumFlag)
	{
	//Add128
	for(nCounter=0; nCounter<64; nCounter++)
		pwImage[nCounter] +=128; 
	}
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	ReadJPEGImage_YUV
//
// Description:	Reads the 8x8 matrix data for each of Y_0,Y_1,Y_2,Y_3,Cb and Cr. 
//					The final output will be RGB pixel data.
//
// Input:	DWORD * pdwBuffer - RGB format of image data.
//					WORD wSampling - Value tells whether image is YUV111(luminance 
//						as well as chrominance is taken for every pixel) or 
//						YUV122(luminance is taken for every pixel while chrominance 
//						is taken as medium value for 2x2 block of pixels).
//						Since the sampling factor for Luminance is 2, all the pixel 
//						values are stored, where as for Cb and Cr, only the average 
//						of 2x2 pixels is stored.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void ReadJPEGImage_YUV(DWORD * pdwBuffer, WORD wSampling){
	int nCounter = 0;
	int nCbCrCounter = 0;					
	ReadJPEGImage(wDCLumtable, wACLumtable, image_Y, &diff_Y, bQTLumTable, 1);
	
	if(0x122 ==wSampling)
	{
		ReadJPEGImage(wDCLumtable, wACLumtable, image_Y1,&diff_Y, bQTLumTable, 1);
		ReadJPEGImage(wDCLumtable, wACLumtable, image_Y2,&diff_Y, bQTLumTable, 1);
		ReadJPEGImage(wDCLumtable, wACLumtable, image_Y3,&diff_Y, bQTLumTable, 1);
	}

	ReadJPEGImage(wDCChrtable, wACChrtable, image_Cr,&diff_Cr, bQTChrTable, 0);
	ReadJPEGImage(wDCChrtable, wACChrtable, image_Cb,&diff_Cb, bQTChrTable, 0);

	for(nCounter=0; nCounter< 64; nCounter++){
#if MKF_JPEG_YUV111_SUPPORT
		if(0x111 ==wSampling)
		pdwBuffer[nCounter] = ConvertYCbCrToRGB(image_Y[nCounter], image_Cr[nCounter], image_Cb[nCounter]);
		else
#endif
		if(0x122 ==wSampling)
		{
			nCbCrCounter = (nCounter&0xfff7)/2;
			pdwBuffer[nCounter]		= ConvertYCbCrToRGB(image_Y[nCounter], image_Cr[nCbCrCounter], image_Cb[nCbCrCounter]);
			pdwBuffer[64+nCounter]	= ConvertYCbCrToRGB(image_Y1[nCounter], image_Cr[nCbCrCounter + 4], image_Cb[nCbCrCounter + 4]);
			pdwBuffer[128+nCounter] = ConvertYCbCrToRGB(image_Y2[nCounter], image_Cr[nCbCrCounter + 32], image_Cb[nCbCrCounter + 32]);
			pdwBuffer[192+nCounter] = ConvertYCbCrToRGB(image_Y3[nCounter], image_Cr[nCbCrCounter + 32 + 4], image_Cb[nCbCrCounter + 32 + 4]);
		}
	}

}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	HuffmanDecoding
//
// Description:	This routine decodes the AC and DC coefficients using the 
//					Huffman tables stored in the JPEG image.
//
// Input:	WORD * pwDCCoeffTable - DC Luminance/ Chrominance Huffman Table.
//					WORD * pwACCoeffTable - AC Luminance/ Chrominance Huffman Table.
//					WORD * pwImage -Pointer to the memory location that contains the decoded data.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void HuffmanDecoding(WORD * pwDCCoeffTable, WORD * pwACCoeffTable, WORD * pwImage)
{
	int nBlockCount=0;

	WORD wLengthDC_RunSizeAC	= 0;
	WORD wCoeffVal		= 0;

	memset(pwImage,(64*sizeof(WORD)),0);

	GetDCValue(pwDCCoeffTable, &wCoeffVal, &wLengthDC_RunSizeAC);
	pwImage[nBlockCount++] = wCoeffVal;	// DC coefficient Value
	
	for(;nBlockCount<64;nBlockCount++)
	{
			GetDCValue(pwACCoeffTable, &wCoeffVal, &wLengthDC_RunSizeAC);
			if(0==wLengthDC_RunSizeAC){
				break;
			}
		wLengthDC_RunSizeAC&=0x0F0;
		wLengthDC_RunSizeAC>>=4;

		for(;wLengthDC_RunSizeAC>0;wLengthDC_RunSizeAC--){
			pwImage[nBlockCount++] = 0;
		}

		pwImage[nBlockCount] = wCoeffVal;	// AC coefficient Value
	}

	return;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	GetDCValue
//
// Description:	This routine returns the differences(DCCoefficientpresent - 
//					DCCoefficientprev) for the DC coefficient. For AC coefficients, 
//					it returns the actual AC coefficient value and Run/Size.
//
// Input:	WORD * pwHuffmanTable - Pointer to the huffman table ?DC Luminance, 
//						DC Chrominance, AC Luminance, AC Chrominance.
//					WORD * pwValue - Code Word (Actual Bit representation).
//					WORD * pwLengthDC_RunSizeAC - Indicates the no: of zeroes.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void GetDCValue(WORD * pwHuffmanTable, WORD * pwValue, WORD * pwLengthDC_RunSizeAC)
{
	WORD dc_value_length=0;
	WORD wCoeffLen=0; 
	DWORD dwCoeffVal=0;
	int i=0;

	while(1)
	{
		wCoeffLen<<=1;
		if(GetEncodedBit())
			wCoeffLen|=0x1;

		dc_value_length++;
		
		if( 0xffff == dc_value_length ) //EIP-114841 Corrupted Jpeg
			return;

		if(SearchHuffmanCode(pwHuffmanTable, (WORD*)&wCoeffLen,dc_value_length)){
			break;
		}
	};


	*pwLengthDC_RunSizeAC	= wCoeffLen;
		
	wCoeffLen&=0x0f;
	
	for(i=0;i<wCoeffLen;i++)
	{
		dwCoeffVal<<=1;
		if(GetEncodedBit())
			dwCoeffVal|=0x1;
	}


	if(0!=wCoeffLen--)
	{
		if(!( dwCoeffVal & (0x1<<(wCoeffLen%16)) )   )
		{
			wCoeffLen = (14+16) - wCoeffLen;
	
			dwCoeffVal=(dwCoeffVal<<(wCoeffLen&0xff)) | 0x80000000;
			
			*((signed int *)(&dwCoeffVal))	>>= (wCoeffLen&0xff);
			dwCoeffVal++;
		}
	}
		
	*pwValue				= (WORD)dwCoeffVal;
	return;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	SearchHuffmanCode
//
// Description:	Searches the Huffman code of the DC/AC Luminance/Chrominace 
//					values in Huffman code tables and find the appropriate HuffmanCodeValue.
//
// Input:	WORD * pwSearchTablePos - Pointer to the huffman table ?DC Luminance, 
//						DC Chrominance, AC Luminance, AC Chrominance.
//					WORD * pwHuffmanCodeValue - Pointer to the variable that contains 
//						the Huffman code value.
//					WORD wDc_value_length - No: of bits in the Huffman code.
//
// Output:	BOOL - TRUE/FALSE.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOL SearchHuffmanCode(WORD * pwSearchTablePos, WORD * pwHuffmanCodeValue, WORD wDc_value_length)
{
	BOOL bReturn = FALSE;

	while(wDc_value_length>=(*pwSearchTablePos))
	{
		if(wDc_value_length==(*pwSearchTablePos))
		{
			if(*pwHuffmanCodeValue==*(pwSearchTablePos+1))
			{ 
				*pwHuffmanCodeValue=*(pwSearchTablePos+2);
				bReturn = TRUE;
				break;
			}
		}
		pwSearchTablePos+=3;
	}
	return bReturn;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	GetEncodedBit
//
// Description:	Reads bits from the stream and returns whether the carry 
//					flag is set or not.
//
// Input:	None
//
// Output:	BOOL - TRUE/FALSE depending on whether the Carry flag is set or not.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOL GetEncodedBit()
{	
	
	UINTN unBitStreamOFFSETCopy;
	BYTE bStreamData;

	unBitStreamOFFSETCopy = unBitStreamOFFSET;
	if(8==bNumBitsRead){
		bStreamData=*(BYTE *)(unBitStreamOFFSETCopy++);
		if(0xff==bStreamData){
			if(0!=(*(BYTE *)(unBitStreamOFFSETCopy++))){
					bStreamData=*(BYTE *)(unBitStreamOFFSETCopy++);
				}
		}
		unBitStreamOFFSET = unBitStreamOFFSETCopy;
		btempBitStreamByte = bStreamData;
		bNumBitsRead=0;
	}
	bNumBitsRead++;
	bStreamData					= btempBitStreamByte;

	if( (bStreamData&(0x1<<(8-bNumBitsRead))) ){
		return TRUE;
	}
	else{
		return FALSE;
	}
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	OutputJPEGImage_YUV
//
// Description:	This functions writes to the Global Screen Buffer by calling 
//					Output8x8Image function.
//
// Input:	WORD wX_position - X Start Position within the output buffer 
//						from where the image needs to be decoded.
//					WORD wY_position - Y Start Position within the output buffer 
//						from where the image needs to be decoded.
//					WORD wX_length - Width of the image.
//					WORD wY_length - Height of the image.
//					WORD wSampling - Value tells whether image is YUV111(luminance 
//						as well as chrominance is taken for every pixel) or YUV122
//						(luminance is taken for every pixel while chrominance is 
//						taken as medium value for 2x2 block of pixels).
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void OutputJPEGImage_YUV(WORD wX_position, WORD wY_position, WORD wX_length, WORD wY_length, WORD	wSampling)
{
	WORD Temp_X_Pos= wX_position;
	WORD Temp_X_Len= wX_length;
	UINTN BlkCount=0;

	if(wSampling==0x122)
	{
		wY_length+= 0x0f;
		wY_length >>=4;
	}
#if MKF_JPEG_YUV111_SUPPORT
	else if(wSampling==0x111)
	{
		wY_length+= 0x07;
		wY_length >>=3;
	}
#endif	
		for(;wY_length>0;wY_length--)
		{
			wX_position			= Temp_X_Pos;
			wX_length			= Temp_X_Len; 

			if(wSampling==0x122)
			{
				wX_length+= 0x0f;
				wX_length >>=4;
			
			for(;wX_length>0;wX_length--)
			{
//				memset(space_image,sizeof(space_image),0);
				{
					ReadJPEGImage_YUV((DWORD *)space_image,wSampling);
					Output8x8Image(wX_position, wY_position, (BYTE *)space_image);
					Output8x8Image(wX_position+8, wY_position, (BYTE *)space_image+256);
					Output8x8Image(wX_position, wY_position+8, (BYTE *)space_image+(256*2));
					Output8x8Image(wX_position+8, wY_position+8, (BYTE *)space_image+(256*3));
					wX_position+=16;
					BlkCount++;
                    // if Restart Interval valid Support for YUV122
					if(gRsi && ((BlkCount%gRsi) == 0))
					{   
                        UINT8 *jpgScan = (UINT8*)unBitStreamOFFSET;
                        // It is going to be 0xFFD0 .. 0xFFD7
                        if((jpgScan[0] == 0xFF) && ((jpgScan[1]& 0xF8 ) == 0xD0))
                        {
                            // Restart the scan params
 							InitGlobals();
                            // Skip the Rsi maraker
							unBitStreamOFFSET+=2;
                        }
					}
				}
			}
			wY_position+=16;
			}
#if MKF_JPEG_YUV111_SUPPORT
			else if(wSampling==0x111)
			{
				wX_length+= 0x07;
				wX_length >>=3;
				for(;wX_length>0;wX_length--)
				{
						//memset(space_image,sizeof(space_image),wSampling);
						ReadJPEGImage_YUV((DWORD *)space_image,wSampling);
						Output8x8Image(wX_position, wY_position, (BYTE *)space_image);
						wX_position+=8;
						BlkCount++;
                        // if Restart Interval valid
						if(gRsi && ((BlkCount%gRsi) == 0))
						{   
                            UINT8 *jpgScan = (UINT8*)unBitStreamOFFSET;
                            // It is going to be 0xFFD0 .. 0xFFD7
                            if((jpgScan[0] == 0xFF) && ((jpgScan[1]& 0xF8 ) == 0xD0))
                            {
                                // Restart the scan params
 							    InitGlobals();
                                // Skip the Rsi maraker
							    unBitStreamOFFSET+=2;
                            }
						}
				}
				wY_position+=8;
			}
#endif
		}
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	Output8x8Image
//
// Description:	This functions writes to the Global Screen Buffer.
//
// Input:	WORD wLeft - Left coordinate from where the Screen buffer 
//						is to be filled.
//					WORD wTop - Top coordinate from where the Screen buffer is to be filled.
//					BYTE * pspace_image - Pointer to 8x8 block of image.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>  
void Output8x8Image(WORD wLeft, WORD wTop, BYTE * pspace_image){
	int nCounterY=0;
	int nCounterX=0;
	AMI_TRUECOLOR_PIXEL_JPEG * pStartofLineInScreenBuffer = (AMI_TRUECOLOR_PIXEL_JPEG *)ScreenBufferJPEG + wTop * g_un32BufferWidth + wLeft;

	for(;nCounterY<8;nCounterY++){
		if((UINT32)(wTop + nCounterY) >= g_un32BufferHeight){
			break;
		}
		for(nCounterX=0;nCounterX<8; nCounterX++){
			if( (UINT32)(wLeft + nCounterX) < g_un32BufferWidth){
				(pStartofLineInScreenBuffer + nCounterX)->Red	= *pspace_image;
				(pStartofLineInScreenBuffer + nCounterX)->Green	= *(pspace_image+1);
				(pStartofLineInScreenBuffer + nCounterX)->Blue	= *(pspace_image+2);
				}
			pspace_image+=4;
		}
		pStartofLineInScreenBuffer+=g_un32BufferWidth;
	}
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	GetTables
//
// Description:	Gets the 2 Quantization Tables and 4 Huffman Tables.
//					Checks the type of table and then builds the corresponding table.
//
// Input:	BYTE bNumQT - Number of Quantization Tables.
//					BYTE bNumHT - Number of Huffman Tables.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void GetTables(BYTE bNumQT, BYTE bNumHT)
{
	int i,j;
	
	for(j=0;j<bNumQT;j++)
	{

		switch(*((BYTE*)QT[j]))
		{
		case 0x00:
				for(i=0;i<64;i++)
				{
					bQTLumTable[i] = *((BYTE*)QT[j]+i+1);
				}
			break;
		case 0x01:
				for(i=0;i<64;i++)
				{
					bQTChrTable[i] = *((BYTE*)QT[j]+i+1);
				}
			break;
		}
	}
	for(i=0;i<bNumHT;i++)
	{
		switch((*(BYTE*)(HT[i])))
		{
			case 0x00:
				BuildHuffmanCodeTable(wDCLumtable,(BYTE *)(HT[i]));
				break;
			case 0x10:
				BuildHuffmanCodeTable(wACLumtable,(BYTE *)(HT[i]));
				break;
			case 0x01:
				BuildHuffmanCodeTable(wDCChrtable,(BYTE *)(HT[i]));
				break;
			case 0x11:
				BuildHuffmanCodeTable(wACChrtable,(BYTE *)(HT[i]));
				break;
		}
	}

}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	InitJpegParams
//
// Description:	Reads the image parameters and checks whether the image 
//				is supported or not.
//              TSE Jpeg Algorithm Supports following Markers
//              ==================================================
//              0C0h - Start Of Frame (Baseline DCT) (REQUIRED)
//              0C4h - Define Huffman Table (REQUIRED)
//              0D0h - RSI0 Marker (OPTIONAL)
//              0D1h - RSI1 Marker (OPTIONAL)
//              0D2h - RSI2 Marker (OPTIONAL)
//              0D3h - RSI3 Marker (OPTIONAL)
//              0D4h - RSI4 Marker (OPTIONAL)
//              0D5h - RSI5 Marker (OPTIONAL)
//              0D6h - RSI6 Marker (OPTIONAL)
//              0D7h - RSI7 Marker (OPTIONAL)
//              0D8h - Start of Image (REQUIRED)
//              0D9h - End of Image (REQUIRED)
//              0DAh - Start Of Scan (REQUIRED)
//              0DBh - Define Quantization Table (REQUIRED)
//              0DDh - Define Restart Interval (OPTIONAL)
//              0E0h - 0xEF - APPx Markers (Does Depend on and just Skips marker) (DON'T CARE)
//              0F0h - 0xFD - Reserved for JPEG extensions (Does Depend on and just Skips marker) (DON'T CARE)
//              0FEh - Jpeg Comment (Does Depend on and just Skips marker) (DON'T CARE)
//
//              TSE Jpeg Algorithom Does not Support following Markers
//              ======================================================
//              000h-0BFh - RESERVED
//              0C1h - Start Of Frame (Extended sequential DCT)
//              0C2h - Start Of Frame (Progressive DCT)
//              0C3h - Start Of Frame (Lossless (sequential))
//              0C5h - Start Of Frame (Differential sequential DCT)
//              0C6h - Start Of Frame (Differential progressive DCT)
//              0C7h - Start Of Frame (Differential lossless (sequential))
//              0C8h - Start Of Frame (Reserved for JPEG extensions)
//              0C9h - Start Of Frame (Extended sequential DCT)
//              0CAh - Start Of Frame (Progressive DCT)
//              0CBh - Start Of Frame (Lossless (sequential))
//              0CDh - Start Of Frame (Differential sequential DCT)
//              0CEh - Start Of Frame (Differential progressive DCT)
//              0CFh - Start Of Frame (Differential lossless (sequential))
//              0CCh - Arithmetic coding conditioning
//              0DCh - Define number of lines
//              0DEh - Define hierarchical progression
//              0DFh - Expand reference component(s)
//              0FFh - RESERVED
//
// Input:	BYTE * pbyImage - Pointer to the JPEG image.
//
// Output:	BOOL TRUE/FALSE.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOL InitJpegParams(BYTE * pbyImage)
{
	
	BYTE bJpegImageFlag	 = 0;
	BYTE bCount = 0;
	int i = 0;
	BYTE bNumHT=0;
	BYTE bNumQT=0;
	WORD wLen = 0;

	if ( ( *pbyImage != 0xFF ) || ( *(pbyImage+1) != 0xD8 ) )	// if marker is not Start Of Image
		return FALSE;
	do{
		if(0x0FF== *pbyImage){
			pbyImage++;
			//; start of image
			if ( 0xD8 == *pbyImage )
			{
				pbyImage++;
				continue;
			}
			//; end of image
			if(0x0D9== *pbyImage){
				break;
			}
			if(*pbyImage){
                // APPx Marks No information needed for us
                if((0x0F0 & *pbyImage) == 0x0E0){
				}
				//	; if maker is Start Of Frame
				else if(0x0C0== *pbyImage){
					bJpegImageFlag|=2;
					unSOF0 = (UINTN)(pbyImage+1);
				}
				//; if maker is Define Huffman Table
				else if(0x0C4== *pbyImage){
					HT[bNumHT] = (UINTN)(pbyImage+3);
					bNumHT++;
				}
				else if((0x0F0 & *pbyImage) == 0xC0){
				//	; if Frame markers
                    switch(*pbyImage) 
                    {
                    //Unsupported Frame Markers
                    case 0x0C1: //Start Of Frame (Extended sequential DCT)
                    case 0x0C2: //Start Of Frame (Progressive DCT)
                    case 0x0C3: //Start Of Frame (Lossless (sequential))
                    case 0x0C5: //Start Of Frame (Differential sequential DCT)
                    case 0x0C6: //Start Of Frame (Differential progressive DCT)
                    case 0x0C7: //Start Of Frame (Differential lossless (sequential))
                    case 0x0C8: //Start Of Frame (Reserved for JPEG extensions)
                    case 0x0C9: //Start Of Frame (Extended sequential DCT)
                    case 0x0CA: //Start Of Frame (Progressive DCT)
                    case 0x0CB: //Start Of Frame (Lossless (sequential))
                    case 0x0CD: //Start Of Frame (Differential sequential DCT)
                    case 0x0CE: //Start Of Frame (Differential progressive DCT)
                    case 0x0CF: //Start Of Frame (Differential lossless (sequential))
                    //Arithmetic coding conditioning
                    case 0x0CC:
    					return FALSE;
                    default:
                        // Never comes here as C4 and C0 is handled above
                        break;
                    }
				}
				//; if maker is Start Of Scan
				else if(0x0DA== *pbyImage){
					//SOS = (UINTN)(pbyImage+1);
					unBitStreamOFFSET = (UINTN)(pbyImage+13);
					break;
				}
				//; if maker is Define Quantization Table
				else if(0x0DB== *pbyImage){
						QT[bNumQT] = (UINTN)(pbyImage+3);
						bNumQT++;
				}
				//; if marker is Define Restart Interval Start
				else if(0x0DD== *pbyImage){
					*((BYTE *)&gRsi) = *(pbyImage+4);
					*((BYTE *)&gRsi+1) = *(pbyImage+3);
				}
                // if Restart RSIx Marker
				else if((*pbyImage & 0xF8 ) == 0xD0){
                }
				//; if marker is Define number of lines
				else if(0x0DC== *pbyImage){
   					return FALSE;
				}
				//; if marker is Define hierarchical progression
				else if(0x0DE== *pbyImage){
   					return FALSE;
				}

				//; if marker is Expand reference component(s)
				else if(0x0DF== *pbyImage){
   					return FALSE;
				}
                // Reserved for JPEG extensions and Comment. Skip it
                else if((*pbyImage >= 0xF0) && (*pbyImage <= 0xFE)){
                }
                // if the Marker is Less then 0xC0 Or 0xFF then they are reserved marker. No Valid
                // JPEG file may use it. We don't handle such files
                // that is ((*pbyImage < 0xC0) || (*pbyImage == 0xFF))
                else 
                {
   					return FALSE;
                }
    			pbyImage++;
				*((BYTE *)&wLen) = *(pbyImage+1);
				*((BYTE *)&wLen+1) = *pbyImage;
				pbyImage += wLen;
			}
			else
			{
				return FALSE;
			}
		}
		else
		{
			return FALSE;
		}
	}while(1);
	
	//Support for 1 QT
	if(1 == bNumQT)
	{
			QT[bNumQT++] = (UINTN)(QT[0]+65);
	}

	//Support for 1 HT
	if(1 == bNumHT)
	{
		while(bNumHT<4)
		{
			bCount = 0;
		for(i=0;i<16;i++)
		{
			bCount = bCount + *(BYTE*)(HT[bNumHT-1]+i+1);
		}
		HT[bNumHT++] = (UINTN)(HT[bNumHT-1]+bCount+17);
		}
	}
// Check for 4 HT and 2 QT and SOF0
	if((4==bNumHT)&&(2==bNumQT)&&(0x02 & bJpegImageFlag)) 
	{
		GetTables(bNumQT, bNumHT);
		return TRUE;
	}
else
return FALSE;

}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	Check
//
// Description:	Internal function for doing a check for each color component
//
// Input:	INT32 n32ColorComp - Color Component (R, G or B).
//
// Output:	The color component value after the check.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
INT32 Check(INT32 n32ColorComp)
{
	n32ColorComp>>=14;
	if(0x8000==(n32ColorComp&0x8000))
		n32ColorComp=0;

	if((n32ColorComp&0xffff)>255)
		n32ColorComp=0x00ff;//mov CX,255

	return n32ColorComp;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	ConvertYCbCrToRGB
//
// Description:	Converts the luminance(Y) and chrominance(Cb and Cr) values
//					of the image to R, G, B values.	The R,G, B values are stored 
//					in a DWORD variable.
//
// Input:	short Y - Y is the luminance value.
//					short Cb - Cb is the chrominance Hue value.
//					short Cr - Cr is the chrominance Saturation value.
//
// Output:	Variable having the RGB value, which is a DWORD.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
DWORD ConvertYCbCrToRGB(short Y, short Cb, short Cr)
{
	DWORD dwRGB    =0;
	INT32 n32ColorComp	=0;
	INT32 YComp = (((INT32)(Y))<<14);
	INT32 CrComp = (((INT32)(Cr))*c_g_cr);
	INT32 CbComp =	((INT32)(Cb) * c_g_cb);
	//;;;cal r
	n32ColorComp = Check((YComp + (CrComp<<1)));
	dwRGB = ((n32ColorComp<<16)|((unsigned int)n32ColorComp>>16));

	//;;;cal g
	n32ColorComp = Check((YComp-CrComp-CbComp));
	*(((char *)(&dwRGB))+1) = *(char *)(&n32ColorComp);

	//;;;cal b
	n32ColorComp = Check((YComp + CbComp + (CbComp<<2) + (CbComp>>3)));
	*(char *)(&dwRGB) = *(char *)(&n32ColorComp);

	return dwRGB;

}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	InvertDCT
//
// Description:	Performs inverse discrete cosine transform on dequantized data.
//
// Input:	WORD * pwSource - Input is dequantized array of 8x8 pixels and 
//						output is data after  applying inverse discrete cosine transform.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void InvertDCT(WORD * pwSource){
	WORD * pwSourceCopy=pwSource;
	int nCounter=0;

	for(nCounter=0; nCounter<8; nCounter++){
		InvertDCT_xy(pwSource,1);
		pwSource+=8;		
	}
	pwSource = pwSourceCopy;
	for(nCounter=0; nCounter<8; nCounter++){
		InvertDCT_xy(pwSource,8);
		pwSource++;		
	}
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// Procedure:	InvertDCT_xy
//
// Description:	Performs inverse discrete cosine transform on dequantized 
//					data in x and y direction.
//
// Input:	WORD * pwSource - Input is dequantized array of 8x8 pixels 
//						and output is data after applying inverse discrete cosine transform.
//					WORD wVal - 
//						wVal = 1, then the routine performs inverse discrete 
//							cosine transform on dequantized data in x direction.
//						wVal = 8, then the routine performs inverse discrete cosine 
//							transform on dequantized data in y direction.
//
// Output:	None
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>
void InvertDCT_xy(WORD * pwSource, WORD wVal)
{
INT32 buf1[8];
INT32 buf2[8];
int Index[8];
int i=0;
for(;i<8;i++)
Index[i] = i*wVal;

//;;;stage 1, 2 ,3

//	;;o0=x0 and normalize
	buf2[0] = (((INT32)(INT16)(pwSource[0])*c1_sqrt2))>>14;


//	;;o1=x4*c1_4
	buf2[1] = (((INT32)(INT16)(pwSource[Index[4]]))*c1_4)>>14;

//	;;o2=x2

	buf2[2]	= ((INT32)(INT16)(pwSource[Index[2]]));
//	;;;o3=(x2+x6)*c1_4

	buf2[3] = ((((buf2[2] + (INT32)(INT16)(pwSource[Index[6]]))*c1_4))>>14);

//	;;o4=x1

	buf2[4]	= (INT32)(INT16)(pwSource[Index[1]]);

//	;;;o6=x1+x3

	buf2[6]	= buf2[4]	+ (INT32)(INT16)(pwSource[Index[3]]);

//	;;;o7=(x1+x3+x5+x7)*c1_4

	buf2[7] = (((buf2[6]+((INT32)(INT16)(pwSource[Index[5]]))+((INT32)(INT16)(pwSource[Index[7]])))*c1_4)>>14);

//	;;;o5=(x3+x5)*c1_4

	buf2[5] = (((((INT32)(INT16)(pwSource[Index[3]]))+((INT32)(INT16)(pwSource[Index[5]])))*c1_4)>>14);

//;;;stage 4, 5

//	;;b0=o0+o1
	buf1[0] = buf2[0]+buf2[1];

//	;;b1=o0-o1
	buf1[1] = buf2[0]-buf2[1];

//	;;b2=(o2+o3)*c1_8

	buf1[2]=(((buf2[2]+buf2[3])*c1_8)>>14);

//	;;b3=(o2-o3)*c3_8

	buf1[3]=(((buf2[2]-buf2[3])*c3_8)>>14);

//	;;b4=o4+o5
	buf1[4] = buf2[4]+buf2[5];

//	;;b5=o4-o5
	buf1[5] = buf2[4]-buf2[5];

//	;;b6=(o6+o7)*c1_8

	buf1[6]=(((buf2[6]+buf2[7])*c1_8)>>14);

//	;;b7=(o6-o7)*c3_8

	buf1[7]=(((buf2[6]-buf2[7])*c3_8)>>14);

//;;;stage 6, 7

//	;;o0=b0+b2
	buf2[0] = buf1[0]+buf1[2];

//	;;o2=b0-b2
	buf2[2] = buf1[0]-buf1[2];

//	;;o1=b1+b3
	buf2[1] = buf1[1]+buf1[3];

//	;;o3=b1-b3
	buf2[3] = buf1[1]-buf1[3];

//	;;o4=(b4+b6)*c1_16

	buf2[4] = (((buf1[4]+buf1[6])*c1_16)>>14);

//	;;o6=(b4-b6)*c7_16

	buf2[6] = (((buf1[4]-buf1[6])*c7_16)>>14);

//	;;o5=(b5+b7)*c3_16

	buf2[5] = (((buf1[5]+buf1[7])*c3_16)>>14);

//	;;o7=(b5-b7)*c5_16

	buf2[7] = (((buf1[5]-buf1[7])*c5_16)>>14);

//;;;stage 8

//	;;b0=o0+o4

	pwSource[0] = (WORD)((buf2[0]+buf2[4])>>1); 

//	;;b7=o0-o4

	pwSource[Index[7]] = (WORD)((buf2[0]-buf2[4])>>1);

//	;;b1=o1+o5

	pwSource[Index[1]] = (WORD)((buf2[1]+buf2[5])>>1);

//	;;b6=o1-o5

	pwSource[Index[6]] = (WORD)((buf2[1]-buf2[5])>>1);

//	;;b2=o3+o7

	pwSource[Index[2]] = (WORD)((buf2[3]+buf2[7])>>1);

//	;;b5=o3-o7

	pwSource[Index[5]] = (WORD)((buf2[3]-buf2[7])>>1);

//	;;b3=o2+o6

	pwSource[Index[3]] = (WORD)((buf2[2]+buf2[6])>>1);

//	;;b4=o2-o6

	pwSource[Index[4]] = (WORD)((buf2[2]-buf2[6])>>1);
	}
//**********************************************************************
//**********************************************************************
//**                                                                  **
//**        (C)Copyright 1985-2010, American Megatrends, Inc.         **
//**                                                                  **
//**                       All Rights Reserved.                       **
//**                                                                  **
//**     5555 Oakbrook Pkwy, Building 200,Norcross, Georgia 30093     **
//**                                                                  **
//**                       Phone: (770)-246-8600                      **
//**                                                                  **
//**********************************************************************
//**********************************************************************