jcamencode.c

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

	//|+----------------Soft nReset for sensor
	//+-----------------Soft nReset

	if ( fSuccess )
	{
		if ( (pJpegInfo->m_QTable >= 0) && (pJpegInfo->m_QTable <= 63) )
		{
			// Using Fixed Q-Tables Page 57 of Agilent ADCM-1650 CIF Reslution CMOS Camera Module
			// Disable Auto Q Adjust
			mainCfg2 &= ~0x0040;
			fSuccess = AgilentProcessorWrite( apr04_CFG_MAIN2, mainCfg2 );
			if ( fSuccess )
			{
				// Select QTable
				fSuccess = AgilentProcessorWrite( apr62_QTABLE_SELECT, pJpegInfo->m_QTable );
				if ( fSuccess )
				{
					// Set ALQ to load JPEG quantization table RAM
					mainCfg2 |= 0x0020;
					fSuccess = AgilentProcessorWrite( apr04_CFG_MAIN2, mainCfg2 );
				}
			}
		}
		else
		{
			// Enable Auto Q Adjust
			mainCfg2 |= 0x0040;
			fSuccess = AgilentProcessorWrite( apr04_CFG_MAIN2, mainCfg2 );
		}
	}	

	if ( !fSuccess )
	{
		jpegSetLastError( JPEG_ERR_AGILENT_ERROR );
	}
	return ( fSuccess );
}

//---------------------------------------------------------------------------
//	prvInitAnyCapture - prepares data structures for next capture
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			pCamEncState	pointer to prvCamEncodeState object
//
//	Return:	TRUE successful, FALSE if error.
//---------------------------------------------------------------------------
Boolean prvInitAnyCapture( JPEGINFO* pJpegInfo, prvCamEncodeState* pCamEncState )
{
	Boolean fSuccess = prvValidateParam( pJpegInfo );
	if ( fSuccess )
	{
		UInt32 loop = 0;

		pCamEncState->m_fNoTimeOut	= TRUE;
		pCamEncState->m_fCamClk		= prvGetCamClk();

		// Stop Camera Capture
		pCamEncState->m_CamControl = prvStopCapture();

		// Start Camera Clock if not already started
		if ( !pCamEncState->m_fCamClk )
		{
			prvSetCamClk( TRUE );
			halDelayUS( 200 * 1000 );
		}

		fSuccess = prvAccessAgilent( pJpegInfo, pCamEncState );
		if ( fSuccess )
		{
			pCamEncState->m_AutoFrameXfer = (Boolean)halReadReg8( REG003C_LCDXFER );

			// Turn off auto frame transfer if enabled
			if ( pCamEncState->m_AutoFrameXfer & 1 )
			{
				halWriteReg8( REG003C_LCDXFER, 0 );
			}
		}

	}
	return ( fSuccess );
}

//-----------------------------------------------------------------------------
//	prvRestoreReg - Restore list of previously saved registers
//
//	Input:	pSaveReg	pointer to array of register values to restore
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvRestoreReg( UInt8* pSaveReg )
{
	UInt8 i;

	for ( i = 0; i < CAMENC_REG_SIZE; ++i, ++pSaveReg )
	{
		halWriteReg8( gCamEncodeRegIndex[ i ], *pSaveReg );
	}
}

//-----------------------------------------------------------------------------
//	prvRestoreState - restore saved world state
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			pCamEncState	pointer to prvCamEncodeState object
//			fSuccess		status of encoding
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvRestoreState( JPEGINFO* pJpegInfo, prvCamEncodeState* pCamEncState, Boolean fSuccess )
{
	// Restore pointers to starting state
	pJpegInfo->m_pBuf		= pCamEncState->m_pStart;
	pJpegInfo->m_BufSize	= pCamEncState->m_BufSize;
	pJpegInfo->m_EncSize	= pCamEncState->m_TotalSize;

	if ( fSuccess  )
	{
		// Restore previous address
		halWriteReg8( REG0102_CMSIGNAL, pCamEncState->m_CamSignal );
		//76543210b
		//|||||||+--Valid Input Clock Edge
		//||||||+---CMVREF Active Select 1=Active Hi 0=Active Lo
		//|||||+----CMHREF Active Select 1=Active Hi 0=Active Lo
		//|||++-----YUV Data Format Select
		//||+-------Clock Mode Select
		//|+--------Reserved
		//+---------n/a

		// Force Capture Frame to start capture (this bit is write only so having
		// saved the original state does not help
		halWriteReg8( REG0108_CMCONTROL, (UInt8)((pCamEncState->m_CamControl & ~0x08) | 0x02));
		//76543210b
		//|||||||+--CMCLK Output Hold Reset
		//||||||+---Capture Frame
		//|||||+----Repeat Capture Frame
		//||||+-----Camera Capture Stop
		//|||+------Camera Data Type 1=YUV 0=JPEG
		//+++-------n/a

		prvSetStartAddrImg( pCamEncState->m_StartAddr.m_Prev );
	}

	if ( pCamEncState->m_fUnWind )
	{
		prvUnWind( pJpegInfo, pCamEncState );
    }

	prvRestoreReg( pCamEncState->m_aSaveReg );
}

//-----------------------------------------------------------------------------
//	prvSaveReg - Saves hardware to array of register values
//
//	Input:	pSaveReg	pointer to array of register values to save
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvSaveReg( UInt8* pSaveReg )
{
	UInt8 i;

	for ( i = 0; i < CAMENC_REG_SIZE; ++i, ++pSaveReg )
	{
		*pSaveReg = halReadReg8( gCamEncodeRegIndex[ i ] );
	}
}

//------------------------------------------------------------------------------
//	prvAdvanceStartAddr - Advances start address to next location allowing for
//							image wrap
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			pStartAddr		pointer to start address object
//
//	Return:	n/a
//
//------------------------------------------------------------------------------
void prvAdvanceStartAddr( JPEGINFO* pJpegInfo, prvStartAddr* pStartAddr )
{
	if ( pJpegInfo->m_fMultiLoc )
	{
		// Advance to next memory location
		pStartAddr->m_Cur += pJpegInfo->m_EncSize + 15;
		pStartAddr->m_Cur &= 0xFFFFFFF0;

		// Check for memory wrap
		if ( pStartAddr->m_Cur > 0x27000L )
		{
			// If wrap reset to "starting" address
			pStartAddr->m_Cur = pStartAddr->m_First;
		}
		prvSetStartAddrImg( pStartAddr->m_Cur );
	}
}

//------------------------------------------------------------------------------
//	prvSetStartAddrImg - writes start address hardware
//
//	Input:	image write start address
//
//	Return:	n/a
//
//------------------------------------------------------------------------------
void prvSetStartAddrImg( UInt32 address )
{
	prvHalWriteReg24( REG0224_YUVWRSTART0, address );
}

//------------------------------------------------------------------------------
//	prvInitStartAddr - initializes start address object & hardware
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			pStartAddr		pointer to start address object
//
//	Return:	n/a
//
//------------------------------------------------------------------------------
void prvInitStartAddr( JPEGINFO* pJpegInfo, prvStartAddr* pStartAddr )
{
	UInt32 height	= GetDisplayHeight( cl_MAIN_WINDOW );
	UInt32 stride	= GetStride( cl_MAIN_WINDOW );
	UInt32 start	= GetStartAddress( cl_MAIN_WINDOW );
	UInt32 end		= start + (stride * height);

	pStartAddr->m_Cur = pStartAddr->m_Prev = prvHalReadReg24( REG0224_YUVWRSTART0 );

	if ( pJpegInfo->m_fMultiLoc )
	{
		pStartAddr->m_First = pStartAddr->m_Cur;
	}
	else
	{
		pStartAddr->m_Cur = end;
	}

	prvSetStartAddrImg( pStartAddr->m_Cur );
	pJpegInfo->m_CapAddr = pStartAddr->m_Cur;
}

//-----------------------------------------------------------------------------
//	prvUnWind - Restore previous hardware states
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			pCamEncState	pointer to prvCamEncodeState object
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvUnWind( JPEGINFO* pJpegInfo, prvCamEncodeState* pCamEncState )
{
    if ( pCamEncState->m_fYUV )
	{
		AgilentYUVCIF();
	}

	if ( !pCamEncState->m_fCamClk )
	{
		prvSetCamClk( FALSE );
	}

    // Restore previous auto frame transfer if enabled
	if ( pCamEncState->m_AutoFrameXfer & 0x01 )
	{	
		halWriteReg8( REG003C_LCDXFER, 1 );
    }
}

//-----------------------------------------------------------------------------
//	prvValidateParam - validate JPEGINFO object
//
//	Input:	pJpegInfo	pointer to JPEGINFO object
//
//	Output:	TRUE if valid parameters
//			FALSE if NOT valid paramaters
//
//-----------------------------------------------------------------------------
Boolean prvValidateParam( JPEGINFO* pJpegInfo )
{
	Boolean fSuccess = jpegValidateBuf( pJpegInfo );
	if ( pJpegInfo->m_fFixBug )
	{
		fSuccess = (pJpegInfo->m_XStart & 0x03) ? FALSE : TRUE;
		if ( fSuccess )
		{
			fSuccess = (pJpegInfo->m_YStart & 0x03) ? FALSE : TRUE;
			if ( fSuccess )
			{
				fSuccess = (pJpegInfo->m_Height & 0x03) ? FALSE : TRUE;
				if ( fSuccess )
				{
					fSuccess = (pJpegInfo->m_Width & 0x03) ? FALSE : TRUE;
				}
			}
		}
		if ( !fSuccess )
		{
			jpegSetLastError( JPEG_ERR_DIM_RESTRICT );
		}
	}

	return ( fSuccess );
}

//------------------------------------------------------------------------------
//	prvWaitForCapture - captures image despite truncation
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			pCamEncState	pointer to prvCamEncodeState object
//
//	Return:	TRUE means valid image
//			FALSE means NOT valid image
//
//------------------------------------------------------------------------------
Boolean prvWaitForCapture( JPEGINFO* pJpegInfo, prvCamEncodeState* pCamEncState )
{
	Boolean fSuccess;
	Boolean fCompleteImage;
	UInt32	retry = 0;

	do
	{
		fSuccess = prvStartCapture( pJpegInfo, pCamEncState, &fCompleteImage );
		if ( fSuccess )
		{
			if ( !fCompleteImage )
			{
				++retry;
				if ( pJpegInfo->m_fVerbose )
				{
					UInt8 qTable = halReadDisplay8( pCamEncState->m_StartAddr.m_Cur + 3 );
					//printf( "Image %d truncated for QTable %u.  Retry %u\n", pCamEncState->m_Count, qTable, retry );
				}
				fCompleteImage = (pJpegInfo->m_fUseTrunc && pJpegInfo->m_fWrAlways) ? TRUE : FALSE;
				if ( fCompleteImage )
				{
					if ( pJpegInfo->m_fVerbose )
					{
						//printf( "Using truncated image %d\n", pCamEncState->m_Count );
					}
				}

				fSuccess = (retry < pJpegInfo->m_TruncAt) ? TRUE : FALSE;
				if ( !fSuccess )
				{
					jpegSetLastError( JPEG_ERR_TRUNCATED_JPEG_DATA );
				}
			}
		}
	}
	while ( (!fCompleteImage) && fSuccess );

	return ( fSuccess );
}