jpegcomm.c

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

	//||||||||++--------n/a
	//|||||||+----------JPEG Encode Overflow Interrupt Enable
	//|||||++-----------n/a
	//||||+-------------Encode Size Limit Over Interrupt Enable
	//++++--------------n/a
}

//-----------------------------------------------------------------------------
//	prvLoadHuffmanTables - loads Huffman table registers with default values
//
//	Input:	n/a
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvLoadHuffmanTables( void )
{
	static UInt8 aDCHuffmanTable0[] = 
	{
		0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
		0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b
	};
	static UInt8 aACHuffmanTable0[] = 
	{
		0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,0x00,0x00,0x01,0x7d,
		0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,
		0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,
		0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
		0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
		0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,
		0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
		0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,
		0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,
		0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
		0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
		0xf9,0xfa
	};
	static UInt8 aDCHuffmanTable1[] = 
	{
		0x00,0x03,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
		0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b
	};
	static UInt8 aACHuffmanTable1[] = 
	{
		0x00,0x02,0x01,0x02,0x04,0x04,0x03,0x04,0x07,0x05,0x04,0x04,0x00,0x01,0x02,0x77,
		0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,
		0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,
		0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
		0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,
		0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,
		0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
		0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,
		0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,
		0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
		0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
		0xf9,0xfa
	};

	prvLoadTable( REG1400_JDCHUFF0REG0, aDCHuffmanTable0, sizeof( aDCHuffmanTable0 ) / sizeof( UInt8 ) );
	prvLoadTable( REG1440_JACHUFF0REG0, aACHuffmanTable0, sizeof( aACHuffmanTable0 ) / sizeof( UInt8 ) );
	prvLoadTable( REG1600_JDCHUFF1REG0, aDCHuffmanTable1, sizeof( aDCHuffmanTable1 ) / sizeof( UInt8 ) );
	prvLoadTable( REG1640_JACHUFF1REG0, aACHuffmanTable1, sizeof( aACHuffmanTable1 ) / sizeof( UInt8 ) );
}

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

//-----------------------------------------------------------------------------
//	prvLoadQuantizationTables - loads quantization tables with default values
//
//	Input:	n/a
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvLoadQuantizationTables( void )
{
	static UInt8 aQuantizationTable0[] = 
	{
		0x0c,0x08,0x07,0x0c,0x12,0x1e,0x26,0x2d,0x09,0x09,0x0a,0x0e,0x13,0x2b,0x2d,0x29,
		0x0a,0x09,0x0c,0x12,0x1e,0x2a,0x33,0x2a,0x0a,0x0c,0x10,0x15,0x26,0x41,0x3c,0x2e,
		0x0d,0x10,0x1b,0x2a,0x33,0x51,0x4d,0x39,0x12,0x1a,0x29,0x30,0x3c,0x4e,0x54,0x45,
		0x24,0x30,0x3a,0x41,0x4d,0x5a,0x5a,0x4b,0x36,0x45,0x47,0x49,0x54,0x4b,0x4d,0x4a
	};
	static UInt8 aQuantizationTable1[] = 
	{
		0x0c,0x0d,0x12,0x23,0x4a,0x4a,0x4a,0x4a,0x0d,0x0f,0x13,0x31,0x4a,0x4a,0x4a,0x4a,
		0x12,0x13,0x2a,0x4a,0x4a,0x4a,0x4a,0x4a,0x23,0x31,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,
		0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,
		0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a
	};

	prvLoadTable( REG1200_JQUANT0, aQuantizationTable0, sizeof( aQuantizationTable0 ) / sizeof( UInt8 ) );
	prvLoadTable( REG1280_JQUANT1, aQuantizationTable1, sizeof( aQuantizationTable1 ) / sizeof( UInt8 ) );
}

//-----------------------------------------------------------------------------
//	prvLoadTable - loads a given table with a list of values
//
//	Input:	index		starting index for table load (assumed every 2nd registers)
//			pTable		pointer to table values to program in registers
//			size		number of entries in given table
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvLoadTable( UInt16 index, UInt8* pTable, int size )
{
	for ( ; size; index += sizeof( UInt16), --size, ++pTable )
	{
		halWriteReg8( index, *pTable );
	}
}

//-----------------------------------------------------------------------------
//	prvGetJpeg - get status of JPEG module
//
//	Input:	n/a
//
//	Output:	on	true means clock supplies to Jpeg module
//				false means clock does not supply to Jpeg module
//
//-----------------------------------------------------------------------------
Boolean prvGetJpeg( void )
{
	UInt8 control = halReadReg8( REG0800_JPEGCONTROL );
	//76543210b
	//|||||||+--Jpeg Module On/Off
	//|++++++---n/a
	//+---------SW Reset (WO)
	Boolean fEnable = (control & 1) ? TRUE : FALSE;
	return ( fEnable );
}

//-----------------------------------------------------------------------------
//	prvSetJpeg - sets state of JPEG module
//
//	Input:	fEnable		true means clock supplies to Jpeg module
//						false means clock does not supply to Jpeg module
//			fReset
//
//	Output:	n/a
//
//-----------------------------------------------------------------------------
void prvSetJpeg( Boolean fEnable, Boolean fReset )
{
	UInt8 control = halReadReg8( REG0800_JPEGCONTROL );
	//76543210b
	//|||||||+--Jpeg Module On/Off
	//|++++++---n/a
	//+---------SW Reset (WO)
	control &= (~1);
	control |= fEnable ? 1 : 0;
	control |= fReset ? 0x80 : 0;
	halWriteReg8( REG0800_JPEGCONTROL, control );
}

//-----------------------------------------------------------------------------
//	prvGetOpWork - get JPEG Operation Status
//
//	Input:	n/a
//
//	Out:	FALSE means idle
//			TRUE means work
//
//-----------------------------------------------------------------------------
Boolean prvGetOpWork( void )
{
	Boolean fWork = halReadReg8( REG1004_JPEGOP ) ? TRUE : FALSE;
	return ( fWork );
}

//------------------------------------------------------------------------------
//	prvRestoreWorld - Restore previously saved values
//
//	Input:	pJpegWorld		pointer to prvWorld object
//
//	Return:	TRUE means success
//			FALSE means NOT success
//
//------------------------------------------------------------------------------
Boolean prvRestoreWorld( JPEGINFO* pJpegInfo, prvWorld* pJpegWorld )
{
	Boolean fSuccess;

	// Restore Previous State
	halWriteReg8( REG1000_OPMODE, pJpegWorld->m_OpMode );
	prvSetJpeg( pJpegWorld->m_fJpeg, FALSE );

	fSuccess = prvSetResizeRect
	( 
		pJpegWorld->m_XStart, 
		pJpegWorld->m_YStart, 
		pJpegWorld->m_XEnd, 
		pJpegWorld->m_YEnd 
	);
	if ( fSuccess )
	{
		fSuccess = prvSetResizeScaleMode( pJpegWorld->m_ScaleMode, pJpegInfo );
		if ( fSuccess )
		{
			fSuccess = prvSetResizeHScaleRate( pJpegWorld->m_HScaleRate, pJpegInfo );
			if ( fSuccess )
			{
				fSuccess = prvSetResizeVScaleRate( pJpegWorld->m_VScaleRate, pJpegInfo );
				if ( fSuccess )
				{
					fSuccess = prvSetResize( pJpegWorld->m_fResize, pJpegInfo );
					if ( fSuccess )
					{
						if ( pJpegWorld->m_fCamClk != prvGetCamClk() )
						{
							prvSetCamClk( pJpegWorld->m_fCamClk );
						}
					}
				}
			}
		}
	}
	return ( fSuccess );
}

//------------------------------------------------------------------------------
//	prvSaveWorld - Save values
//
//	Input:	pJpegWorld		pointer to prvWorld object
//
//	Return:	n/a
//
//------------------------------------------------------------------------------
void prvSaveWorld( prvWorld* pJpegWorld )
{
	// Save registers that don't "belong" to JPEG
	pJpegWorld->m_fCamClk = prvGetCamClk();

	prvGetResizeRect
	( 
		&pJpegWorld->m_XStart, 
		&pJpegWorld->m_YStart,
		&pJpegWorld->m_XEnd,
		&pJpegWorld->m_YEnd
	);
	pJpegWorld->m_ScaleMode		= prvGetResizeScaleMode();
	pJpegWorld->m_HScaleRate	= prvGetResizeHScaleRate();
	pJpegWorld->m_VScaleRate	= prvGetResizeVScaleRate();
	pJpegWorld->m_fResize		= prvGetResize();
	pJpegWorld->m_fJpeg			= prvGetJpeg();
	pJpegWorld->m_OpMode		= halReadReg8( REG1000_OPMODE );
}

prvJpegFlag prvGetJpegStatus( void )
{
	return ( prvHalReadReg16( REG0802_JPEGSTATUS0, REG0804_JPEGSTATUS1 ) );
}

//------------------------------------------------------------------------------
//	prvSetJpegStatus
//
//	Input:	flag		flag to set
//
//	Return:	n/a
//
//------------------------------------------------------------------------------
void prvSetJpegStatus( prvJpegFlag flag )
{
	prvHalWriteReg16( REG0802_JPEGSTATUS0, REG0804_JPEGSTATUS1, (UInt16)flag );
	//FEDBCA9876543210b
	//|||||||||||||||+--Reserved JPEG Line Buffer Interrupt Flag
	//||||||||||||||+---JPEG Code Interrupt Flag
	//|||||||||||||+----Line Buffer Overflow Flag
	//||||||||||||+-----Reserved Size Mismatch Flag
	//|||||||||||+------Decode Marker Read Flag
	//||||||||||+-------JPEG Decode Complete Flag
	//|||||||||+--------n/a
	//||||||||+---------Reserved
	//|||||||+----------JPEG Encode Overflow Flag
	//|||||++-----------n/a
	//||||+-------------Encode Size Limit Violation Flag
	//||++--------------n/a
	//|+----------------JPEG Codec File Out Status
	//+-----------------Reserved
}

UInt32 jpegGetEncSizeResult( void )
{
	return ( prvHalReadReg24( REG081C_ENCODERESULT0 ) );
}

void prvStartJpeg( void )
{
	halWriteReg8( REG1002_COMMAND, 0x01 );
	//76543210b
	//|||||||+--JPEG Operation Enable
	//|++++++---n/a
	//+---------SW Reset
}

void prvResetJpegCodec( void )
{
	halWriteReg8( REG1002_COMMAND, 0x80 );
	//76543210b
	//|||||||+--JPEG Operation Enable
	//|++++++---n/a
	//+---------SW Reset
}