jpegcomm.c

来自「是一个手机功能的模拟程序」· C语言 代码 · 共 969 行 · 第 1/3 页

//===========================================================================
//	JPEGCOMM.C
//	This file contains JPEG functons used by the JPEG library but not exposed
//	to the outside world.
//---------------------------------------------------------------------------
//  Copyright (c) 2003 Epson Research and Development, Inc.
//  All Rights Reserved.
//===========================================================================

//------------------------------------------------------------------------------
// Include Files
//------------------------------------------------------------------------------
#include "multiframe.h"
#include "chiplib.h"
#include "Hal.h"
#include "JPEG.h"
#include "JPEGComm.h"

//------------------------------------------------------------------------------
// Local Definitions
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// Local Function Prototypes
//------------------------------------------------------------------------------
static void prvLoadTable( UInt16 index, UInt8* pTable, int size );

//------------------------------------------------------------------------------
// Local Data
//------------------------------------------------------------------------------
static jpegError gJpegComLastError;			// Jdecode last error code

#ifdef JPEGUSEFILESYS
//-----------------------------------------------------------------------------
//	jpegCreateFileName - create appropriate filename
//
//	Input:	pJpegInfo	pointer to JPEGINFO object
//			pszName		pointer to user's string name
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void jpegCreateFileName( JPEGINFO* pJpegInfo, const char* pszName )
{
	char* pszExt = pJpegInfo->m_fMulFrm ? "mf" : "jpg";

	// Write JPEG image to JFIF file
	piCreateFileName( pJpegInfo->m_pszFile, pszName, pszExt ); 
}
#endif

//---------------------------------------------------------------------------
//  jpegGetLastError() - Get last error code.
//---------------------------------------------------------------------------
jpegError jpegGetLastError( void )
{
	return gJpegComLastError;
}

//------------------------------------------------------------------------------
//	jpegHasEndOfImage - Determines if given image has JPEG end-of-image marker
//
//	Input:	pJpegInfo	pointer to JPEGINFO structure
//
//	Return:	TRUE means image has end-of-image marker
//			FALSE means that cannot locate end-of-image marker
//
//------------------------------------------------------------------------------
Boolean jpegHasEndOfImage( JPEGINFO* pJpegInfo )
{
	UInt32 i;

	for ( i=2; i<=5; i++ )
		if ( prvIsEndOfImage(pJpegInfo,i*sizeof(UInt8)) )
			return TRUE;

	jpegSetLastError( JPEG_ERR_NO_ENDOFIMAGE );
	return FALSE;
}

//------------------------------------------------------------------------------
//	jpegHasImageMarkers - Determines if given image has JPEG image markers
//
//	Input:	pJpegInfo	pointer to JPEGINFO structure
//
//	Return:	TRUE means image has image markers
//			FALSE means that cannot locate image markers
//
//------------------------------------------------------------------------------
Boolean jpegHasImageMarkers( JPEGINFO* pJpegInfo )
{
	Boolean fSuccess = jpegHasStartOfImage( pJpegInfo );
	if ( fSuccess )
	{
		fSuccess = jpegHasEndOfImage( pJpegInfo );
	}
	return ( fSuccess );
}

//------------------------------------------------------------------------------
//	jpegHasStartOfImage - determines if given offset into JPEG image has 
//							start-of-image marker
//
//	Input:	pJpegInfo	pointer to JPEGINFO structure
//
//	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
//
//------------------------------------------------------------------------------
Boolean jpegHasStartOfImage( JPEGINFO* pJpegInfo )
{
	// Verify that end-of-image marker is present
	UInt8*	pEOI		= pJpegInfo->m_pBuf;
	UInt16	marker		= *(pEOI + 1) | (*(pEOI + 0) << 8);
	Boolean fSuccess	= (marker == 0xFFD8) ? TRUE : FALSE;
	if ( !fSuccess )
	{
		jpegSetLastError( JPEG_ERR_NO_STARTOFIMAGE );
	}
	return ( fSuccess );
}

//---------------------------------------------------------------------------
// jpegInit() - initialize JPEG encode library
//
//	Input:	pJpegInfo	pointer to JPEGINFO structure
//
// Function: Prepare for encode.
// Return:	TRUE successful, FALSE if error.
//---------------------------------------------------------------------------
Boolean	jpegInit( JPEGINFO* pJpegInfo )
{
	InitChipLib();

	// Initialize JEncodeInfo structure with default values
	prvGetResizeRect( &pJpegInfo->m_XStart, &pJpegInfo->m_YStart, &pJpegInfo->m_XEnd, &pJpegInfo->m_YEnd );
	pJpegInfo->m_RWidth			= 0;
	pJpegInfo->m_RHeight		= 0;
	pJpegInfo->m_Width			= pJpegInfo->m_XEnd - pJpegInfo->m_XStart + 1;
	pJpegInfo->m_Height			= pJpegInfo->m_YEnd - pJpegInfo->m_YStart + 1;

	pJpegInfo->m_BufSize		= 0;
	//pJpegInfo->m_CapAddr		= 0;
	pJpegInfo->m_Delay			= 30000;
	//pJpegInfo->m_fDumpOnly		= FALSE;
	pJpegInfo->m_EncSize		= 0;
	//pJpegInfo->m_fFixBug		= FALSE;
	pJpegInfo->m_pszFile		= NULL; 
	pJpegInfo->m_fFastCpu		= FALSE;
	pJpegInfo->m_FrameCount		= 1;
	pJpegInfo->m_HScaleRate		= prvGetResizeHScaleRate();
	pJpegInfo->m_fIndScale		= prvGetResizeIndScaleRate();
	pJpegInfo->m_fInfLoop		= FALSE;
	//pJpegInfo->m_fInit			= TRUE;
	//pJpegInfo->m_fInterpret		= FALSE;
	//pJpegInfo->m_LoopCount		= 1;
	//pJpegInfo->m_MinDelay		= 1000;
	pJpegInfo->m_fMulFrm		= FALSE;
	//pJpegInfo->m_fMultiLoc		= FALSE;
	pJpegInfo->m_fPause			= FALSE;
	pJpegInfo->m_pBuf			= NULL;
	//pJpegInfo->m_QTable			= -1; // Which means use auto selection
	pJpegInfo->m_ScaleMode		= prvGetResizeScaleMode();
	pJpegInfo->m_fSOE			= FALSE;
	pJpegInfo->m_TimeOutMS		= 0; // Default is no time out
	//pJpegInfo->m_TruncAt		= 20;
	//pJpegInfo->m_fVerbose		= FALSE;
	//pJpegInfo->m_fVideoOnly		= FALSE;
	//pJpegInfo->m_fViewImage		= FALSE;
	pJpegInfo->m_VScaleRate		= prvGetResizeVScaleRate();
	pJpegInfo->m_fWrAlways		= FALSE;
	pJpegInfo->m_YUVFmt			= YUVFmt422;
	pJpegInfo->m_fAFAP			= FALSE;
	pJpegInfo->m_IsYUVfile		= FALSE;
	pJpegInfo->m_MemEnc			= FALSE;
	//pJpegInfo->m_MemSize		= 0;
	jpegSetLastError( JPEG_ERR_NONE );
	return ( TRUE );
}

//-----------------------------------------------------------------------------
//	jpegInitVideo - performs minimal steps to enable viewing of camera
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//
//	Output:	TRUE means camera enabled
//			FALSE means camera not enabled
//
//-----------------------------------------------------------------------------
Boolean jpegInitVideo( JPEGINFO* pJpegInfo )
{
	// Enable camera clock
	halWriteReg8( REG0108_CMCONTROL, 0x01 );
	halWriteReg8( REG0108_CMCONTROL, 0x00 );
	
	halWriteReg8( REG0104_CMMODE0, (UInt8)(halReadReg8(REG0104_CMMODE0)|0x01) );

	// Delay 750 milliseconds to stablize camera output.
	halDelayUS( 750 * 1000 );

	// Start capture
	halWriteReg8( REG0108_CMCONTROL, 0x16 );

	// Enable View Encode (simultaneous display)
	halWriteReg8( REG0202_RESIZE, (UInt8)(halReadReg8(REG0202_RESIZE)|0x08));

	// Enable and reset resizer [norman delete]
	//prvSetResize( TRUE, pJpegInfo );
	// Enable and Reset Resizer [norman add]
	prvSetResize( TRUE, pJpegInfo );
	prvResetResize( TRUE, pJpegInfo );
	prvResetResize( FALSE, pJpegInfo );
	
	// LCD Interface Auto Transfer Enable
	halWriteReg8( REG003C_LCDXFER, 0x01 );

// The following test is invalid, because REG[010Ah-b0] keeps changing from 1 to 0 over time. Jiliang knows why, but I have no clue. [Roc 2003-AUG-4]
//	value	= halReadReg8( REG010A_CMSTATUS );
//	fCamera = (Boolean)(value & 0x01) ? TRUE : FALSE;
//	return ( fCamera );
	return TRUE;
}

//---------------------------------------------------------------------------
//  jpegSetLastError() - Set last error code.
//---------------------------------------------------------------------------
void jpegSetLastError( jpegError error )
{
	gJpegComLastError = error;
}

//-----------------------------------------------------------------------------
//	jpegValidateBuf - validates input parameters
//
//	Input:	pJpegInfo	pointer to JPEGINFO object
//
//	Output:	TRUE means success
//			FALSE means NOT success
//
//-----------------------------------------------------------------------------
Boolean jpegValidateBuf( JPEGINFO* pJpegInfo )
{
	Boolean fSuccess = (pJpegInfo->m_pBuf != NULL) ? TRUE : FALSE;
	if ( !fSuccess )
	{
		jpegSetLastError( JPEG_ERR_NULL_BUFFER );
	}
	else
	{
		fSuccess = ( pJpegInfo->m_BufSize != 0) ? TRUE : FALSE;
		if ( !fSuccess )
		{
			jpegSetLastError( JPEG_ERR_ZERO_BUFFER_SIZE );
		}
	}
	return ( fSuccess );
}

//-----------------------------------------------------------------------------
//	jpegWaitTillLCDNotBusy - waits till LCD is not busy or time out
//
//	Input:	pJpegInfo	pointer to JPEG decode info object
//
//	Output:	TRUE means LCD not busy (and no time out)
//			FALSE means time out
//
//-----------------------------------------------------------------------------
Boolean jpegWaitLCDNotBusy( JPEGINFO* pJpegInfo )
{
	Boolean fSuccess = TRUE;
	Boolean fBusy;

	do
	{
		fBusy = (halReadReg8( REG0038_LCDSTATUS ) & 0x01 ) ? TRUE : FALSE;
#ifndef MV850E
		if ( fBusy )
		{
			//fSuccess = jpegNoTimeOut( pJpegInfo );
		}
#endif
	}
	while ( fBusy && fSuccess );
	return ( fSuccess );
}

#ifdef JPEGUSEFILESYS
//-----------------------------------------------------------------------------
//	jpegWriteImage - writes memory image as single or multiple files
//
//	Input:	pszName			pointer to name prefix for file
//			pJpegInfo	pointer to JPEG Encode Info object
//
//	Output:	write output file result
//
//-----------------------------------------------------------------------------
Boolean jpegWriteImage( const char* pszName, JPEGINFO* pJpegInfo )
{
	Boolean fSuccess = TRUE;

	if ( pJpegInfo->m_fMulFrm || (pJpegInfo->m_FrameCount == 1) )
	{
		jpegCreateFileName( pJpegInfo, pszName );
		fSuccess = jpegWriteFile( pJpegInfo );
	}
	else
	{
		// Save original settings
		UInt32 count;
		UInt8* pBuf		= pJpegInfo->m_pBuf;
		UInt32 encSize	= pJpegInfo->m_EncSize;

		for ( count = 1; (count <= pJpegInfo->m_FrameCount) && fSuccess; ++count )
		{
			char szFile[ 256 ];
			JPEGMULTIFRAME* pJpegMultiFrame = (JPEGMULTIFRAME*)pJpegInfo->m_pBuf;
			pJpegInfo->m_pBuf				+= sizeof( JPEGMULTIFRAME );
			pJpegInfo->m_EncSize = pJpegMultiFrame->ResultSize;
			//sprintf( szFile, "%s%04d", pszName, count ); 
			jpegCreateFileName( pJpegInfo, szFile );
			fSuccess			= jpegWriteFile( pJpegInfo );
			pJpegInfo->m_pBuf	+= pJpegMultiFrame->PaddedSize;
		}