encode.c

一款SmartPhone的驱动代码

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
// 2002/12/17
// Konagayoshi Susumu 
// The Addition of New Function 
//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>

#include "sysLCDC.h"



/////////////////////////////////////////////////////////////////////////////////////////////////
// GLOBALS
/////////////////////////////////////////////////////////////////////////////////////////////////

unsigned char *				pBuffer;
unsigned long				BufferSize;
unsigned long				EncodedSize;
char*						pszFileName; 


/*********************************************************
Descriptions: encode initialize
Returns: 
Notes: 
**********************************************************/
void CaptureInit( void )	
{
	unsigned short		Xb,Yb,Xe,Ye,Rate;
	ResizeScalingMode	Mode;

	// For each count capture the camera image
	// Set the Capture resize image size
	Xb=ViewStartXPosGet( );
	Yb=ViewStartYPosGet( );
	Xe=ViewEndXPosGet( );
	Ye=ViewEndYPosGet( );
	Rate=ViewScalingRateGet( );
	Mode=ViewScalingModeGet();
	halWriteReg16(0x112, 0x1C);
	CapEnSet(0);					// capture resizer disable
	CapStartXPosSet(Xb);
	CapStartYPosSet(Yb);
	CapEndXPosSet(Xe);
	CapEndYPosSet(Ye);
	CapScalingRateSet(Rate);
	CapScalingModeSet(Mode);
	CapSWReset();
	CapEnSet(1);					// capture resizer enable
	halWriteReg16(0x112, 0x0);
	
	return;
}

unsigned long Encode(unsigned char Quality, 
					unsigned short ActiveSequence,
					unsigned char *Buffer,
					unsigned long bufSize )
{
	EncodedSize = 0;
	pBuffer = Buffer;
	BufferSize = bufSize; 

	// Get buffer for saving JPEG image
	if ( pBuffer != NULL )
	{
		// Get JPEG data from FIFO
		if(!JpegEncode(Quality, ActiveSequence))
			return 0;
	}
	else
		return 0;
	
	return EncodedSize;
}




BOOL JpegEncode(unsigned char Quality, unsigned short ActiveSequence)
{
	BOOL encode;

	JpegEncodeInit(Quality, ActiveSequence);		// Initialize JPEG hardware
	
	encode = JpegProcessFifo();					// Drain FIFO data

	halWriteReg16(0x098A, 0x0000);				// Stop JPEG Codec

	if ( encode )									
		if ( !JpegHasEndOfImage() )				// Error! No End Marker
			encode = FALSE;
		
	JpegEncodeTerminate();						// Clear any pending settings

	return ( encode );
}


//-----------------------------------------------------------------------------
//	JpegEncodeInit 
//
//	Input:	
//			
//			
//	Output:	n/a
//
//-----------------------------------------------------------------------------
BOOL JpegEncodeInit(unsigned char Quality, unsigned short ActiveSequence)
{
	unsigned short	tmp;

	halWriteReg16(0x0980, 0x0001);	// Jpeg Module ON

	halWriteReg16(0x1002, 0x0080);	// Jpeg Codec Software Reset

	halWriteReg16(0x0980, 0x0081);	// Jpeg Module Software Reset

	halWriteReg16(0x0930, ActiveSequence);	// Active Sequence Select

	// Enable & Reset Capture Resizer
	halWriteReg16(0x0960, 0x0001);
	halWriteReg16(0x0960, 0x0081);
 
	// Jpeg Operation Mode
	halWriteReg16(0x1000, 0x0001);

	// Quantization Table Select
	//  V = QTable1, U = QTable1, Y = QTable0
	halWriteReg16(0x1006, 0x0006);

	// Huffman Table Select
	//  V = AC1,DC1, U = AC1, DC1, Y = AC0, DC0
	halWriteReg16(0x1008, 0x003C);

	// DRI Marker
	halWriteReg16(0x100A, 0x0000);
	halWriteReg16(0x100C, 0x0000);

	
	// Get Jpeg Image Size
	{
	unsigned short  Width = halReadReg16(0x0968) - halReadReg16(0x0964) + 1;
	unsigned short  Height = halReadReg16(0x096A) - halReadReg16(0x0966) + 1;
	unsigned char   Rate = (unsigned char)(halReadReg16(0x096C));

	if ( Rate > 1 )
		{
			Width /= Rate;
			Height /= Rate;
		}

	// JPEG Image Height
	halWriteReg16(0x100E, (unsigned char)((Height & 0xFF00) >> 8));
	halWriteReg16(0x1010, (unsigned char)(Height & 0x00FF));

	// JPEG Image Width
	halWriteReg16(0x1012, (unsigned char)((Width & 0xFF00) >> 8));
	halWriteReg16(0x1014, (unsigned char)(Width & 0x00FF));
	}

	// Set Quantize Table
	JPEGQuantQualitySet( Quality );

	// Set Huffman Table
	JpegLoadHuffmanTables();

	// Set Fifo Size
       halWriteReg16(0x9A4, 0x7);

	// JPEG Encode Limit
	halWriteReg16(0x09B0, 0x0000);
	halWriteReg16(0x09B2, 0x0002);

	// Set Fifo Threshold
	halWriteReg16(0x9A0, 0x30);
	
	// Clear Fifo
	{
	tmp = halReadReg16(0x09A0); 
	halWriteReg16( 0x09A0, (unsigned short)(tmp | 0x0004));
	// Dummy Read FIFO RW Register
	halReadReg16(0x09A6); 
	halReadReg16(0x09A6);
	}


	// Disable Interrupt Flag
	halWriteReg16(0x0986, 0x0000);
	
	// Clear Interrupt Flag
	halWriteReg16(0x0982, 0xFFFF);

	// Enable Interrupt
	halWriteReg16(0x0986, 0x0E06);

	// Disable JPEG Module

	// Enable IRQ

	// Enable JPEG Codec Operation
	halWriteReg16(0x1002, 0x0001);

	// Start JPEG Encode
	halWriteReg16(0x098A, 0x0001);

	return(0);
}


BOOL JpegProcessFifo()
{

	BOOL work = TRUE;
	BOOL success = TRUE;
	unsigned short status;

	unsigned short* pCurrent = (unsigned short*)pBuffer;
	unsigned long encSizeResult;
	long remainder;
	long i = 0;

	// Assume no error encountered for encoding
	EncodedSize = 0;
	do
	{
		status = halReadReg16(0x0984);		// Get current status of encoding flags

		if ( status & 0x0800 )					// Error if surpassed size limit
		{
			success = FALSE;
			return(FALSE);
		}
		
		else if ( status & 0x0400 )				// Retrieve data if FIFO threshold trigger asserted
		{
			halWriteReg16(0x0982, 0x0400);	// Clear Fifo Threshold Flag
			success = JpegReadFifo( &pCurrent );
		}
		
		else if ( status & 0x004C )				// Error if line buffer overflow
		{
			success = FALSE;
			return(FALSE);
		}
		
		else if ( status & 0x0200 )				// Retrieve data if FIFO buffer is full
		{
			halWriteReg16(0x0982, 0x0200);	// Clear Fofo Buffer Full Flag
			success = JpegReadFifo( &pCurrent );
		}
		
		else if ( status & 0x0002 )				// Check if data is ready to retrieve if CODEC but not trigger or error
		{
			for(i=0;i<1000;i++);

			if ( status & 0x3000 )
				success = JpegReadFifo( &pCurrent );

			work = FALSE;
		}

		// Error Time Out 
		i++;
		if ( i == 1000000 )
			return(FALSE);
	}
	while( work && success );

	if ( success )
	{
		// Check to see if any data pending in FIFO even though JPEG is complete
		remainder = halReadReg16( 0x09A8 );
		
		if ( remainder )
			JpegReadFifo( &pCurrent );
		
		// Check to see if encode size result is greater than what we have processed so far if so then read remainder from FIFO
		encSizeResult =  (unsigned long)(halReadReg16(0x09B4) | (halReadReg16(0x09B6) << 16));

		if ( encSizeResult > BufferSize )			// Encode Size Limit Error!!
			success = FALSE;
		else
		{
			remainder = encSizeResult - EncodedSize;
			if ( remainder > 0  )
			{
				unsigned long i;

				++remainder;
				remainder >>= 1;
	
				for ( i = 0; i < remainder; i++, ++pCurrent )			// Read each entry in FIFO
					*pCurrent = halReadReg16( 0x09A6 );
	
				EncodedSize = encSizeResult;
			}

			if ( EncodedSize == 0 )				// Error! No Fifo Data
				success = FALSE;
			else if ( EncodedSize > BufferSize )	// Error! Encode Size Limit Over
				success = FALSE;
		}
	}

	return ( success );
}



void JpegEncodeTerminate()
{
	unsigned short	tmp;
	// Read REG[1004h] due to clear JPEG Codec Core longerrupt.
	halReadReg16(0x1004);

	halWriteReg16(0x0986, 0x0000);

	//  clear all Codec Status flags
	halWriteReg16(0x0982, 0xFFFF);

	// Clear JPEG registers

	// Clear Fifo
	{
	tmp = halReadReg16(0x09A0); 
	halWriteReg16( 0x09A0, (unsigned short)(tmp | 0x0004));
	// Dummy Read FIFO RW Register
	halReadReg16(0x09A6);
	halReadReg16(0x09A6);
	}
	
	// JPEG Codec Software Reset & Disable
	halWriteReg16(0x1002, 0x0080);
	halWriteReg16(0x1002, 0x0000);


	halWriteReg16(0x0980, 0x0080);

}



BOOL JpegReadFifo( unsigned short** ppCurrent )
{
	unsigned short jpegFifoValidDataSize = halReadReg16( 0x09A8 );
	unsigned long dataSize = jpegFifoValidDataSize * 4;
	unsigned long startSize = EncodedSize;
	unsigned short* pCurrent = *ppCurrent;
	EncodedSize += dataSize;

	// Only process if there is FIFO data to get
	if ( jpegFifoValidDataSize > 0 )
	{
		unsigned short i;

		// Read each entry in FIFO
		for ( i = 0; i < jpegFifoValidDataSize; i++ )
		{
			*pCurrent = halReadReg16( 0x09A6 );
			++pCurrent;
			*pCurrent = halReadReg16( 0x09A6 );
			++pCurrent;
		}
	}

	*ppCurrent = pCurrent;
	return ( TRUE );
}

//------------------------------------------------------------------------------
//	jpegHasEndOfImage
//
//	Input:	JENCODEINFO *pJEncodeInfo
//
//	Return:	TRUE means image has end-of-image marker
//			FALSE means that cannot locate end-of-image marker
//
//------------------------------------------------------------------------------
BOOL JpegHasEndOfImage()
{
	BOOL hasEndOfImage = JpegIsEndOfImage( sizeof( unsigned short ) );

	if ( !hasEndOfImage )
	{
		// Marker may have been skewed by Valid Data Size is always multiple of 4-bytes and therefore we may have read 2 too many bytes so check for EOI marker at -4 from end of size
		hasEndOfImage = JpegIsEndOfImage( 2 * sizeof( unsigned short ) );
		if ( !hasEndOfImage )
			hasEndOfImage = JpegIsEndOfImage( 3 * sizeof( unsigned char ) );
	}

	return ( hasEndOfImage );
}

//------------------------------------------------------------------------------
//	prvJpegIsEndOfImage
// 
//	Input:	JENCODEINFO *pJEncodeInfo
//			offset
//
//	Return:	TRUE means image has end-of-image marker at given offset
//			FALSE means that image does not have end-of-image marker at given offset
//
//------------------------------------------------------------------------------
BOOL JpegIsEndOfImage( unsigned long offset )
{
	BOOL hasEndOfImage = TRUE;

	// Verify that end-of-image marker is present
	unsigned char* pEOI = pBuffer + EncodedSize - offset;
	unsigned short marker = *pEOI;
	++pEOI;
	marker = marker | (*pEOI << 8);
	if ( marker != 0xD9FF )
		hasEndOfImage = FALSE;
	
	return ( hasEndOfImage );
}