jdecode.c

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

C
911 行
字号
12
			if ( pJpegInfo->m_fAFAP )
			{
				for ( ; HeaderSize; --HeaderSize, ++pHeader )
					halWriteReg8( REG081A_JPEGFIFOWRITE, *pHeader );
			}
			else
			{
				for ( ; fifoSize && HeaderSize; --fifoSize, --HeaderSize, ++pHeader )
					halWriteReg8( REG081A_JPEGFIFOWRITE, *pHeader );
				fifoSize = 32 - (halReadReg8(REG0808_JPEGRAWSTATUS1)&0x3F);
			}
		}
		else
		{
			Boolean fFifoFull;

			do
			{
				fFifoFull = prvIsFifoFull();
			}
			while ( fSuccess && (!fFifoFull) );

			if ( fSuccess )
			{
				for ( ; (!fFifoFull) && HeaderSize; ++pHeader, --HeaderSize )
				{
					halWriteReg8( REG081A_JPEGFIFOWRITE, *pHeader );
					fFifoFull = prvIsFifoFull();
				}
			}
		}
	}

	++pData;
	++pData;
	jpegDataSize--;
	jpegDataSize--;	
*/

	while ( fSuccess && jpegDataSize )
	{
		if ( pJpegInfo->m_fFastCpu )
		{
			if ( pJpegInfo->m_fAFAP )
			{
				for ( ; HeaderSize; --HeaderSize, ++pHeader )
				{
					halWriteReg8( REG081A_JPEGFIFOWRITE, *pHeader );
					//*ptmpjpg=*pHeader;
					//ptmpjpg++;
				}
				++pData;
				++pData;
				jpegDataSize--;
				jpegDataSize--;					
				for ( ; jpegDataSize; --jpegDataSize, ++pData )
					halWriteReg8( REG081A_JPEGFIFOWRITE, *pData );
			}
			else
			{
				if(!fLoadHeader)
				{
					for ( ; fifoSize && HeaderSize; --fifoSize, --HeaderSize, ++pHeader )
					{
						halWriteReg8( REG081A_JPEGFIFOWRITE, *pHeader );
						//*ptmpjpg=*pHeader;
						//ptmpjpg++;
					}
					fifoSize = 32 - (halReadReg8(REG0808_JPEGRAWSTATUS1)&0x3F);	
					if(HeaderSize<=0)
					{
						++pData;
						++pData;
						jpegDataSize--;
						jpegDataSize--;					
						fLoadHeader=TRUE;
					}
				}
				else
				{
					for ( ; fifoSize && jpegDataSize; --fifoSize, --jpegDataSize, ++pData )
						{
							halWriteReg8( REG081A_JPEGFIFOWRITE, *pData );
							//*ptmpjpg=*pData;
							//ptmpjpg++;
						}						
						
					fifoSize = 32 - (halReadReg8(REG0808_JPEGRAWSTATUS1)&0x3F);
				}
			}
		}
		else
		{
			Boolean fFifoFull;

			do
			{
				fFifoFull = prvIsFifoFull();
#ifndef MV850E
				if ( !fFifoFull )
				{
					//fSuccess = jpegNoTimeOut( pJpegInfo );
				}
#endif
			}
			while ( fSuccess && (!fFifoFull) );

			if ( fSuccess )
			{
				for ( ; (!fFifoFull) && jpegDataSize; ++pData, --jpegDataSize )
				{
					halWriteReg8( REG081A_JPEGFIFOWRITE, *pData );
					fFifoFull = prvIsFifoFull();
				}
			}
		}

		if ( fSuccess )
		{
			prvJpegFlag jpegStatus = prvGetJpegStatus();

			/*if ( pJpegInfo->m_fVerbose )
			{
				if ( jpegStatus != prevStatus )
				{
					if ( jpegStatus & JpegCodec )
						//printf( "JpegCodec " );
					if ( jpegStatus & LnBufOverflow )
						//printf( "LnBufOverflow " );
					if ( jpegStatus & JpegDecMarkerRd )
						//printf( "DecodeMarkerRead " );
					if ( jpegStatus & JpegDecComplete )
						//printf( "JpegComplete" );
					//printf( "\n" );

					prevStatus = jpegStatus;
				}
			}*/

			// Decode Marker Read
			if ( jpegStatus & JpegDecMarkerRd )
			{
				fSuccess = prvReadMarker( pJpegInfo, jpegStatus );
			}
#ifndef MV850E
			else
			{
				//fSuccess = jpegNoTimeOut( pJpegInfo );
			}
#endif
		}
	}

	if ( pJpegInfo->m_fPause )
	{
		//printf( "Pause right after JPEG decode is complete.  Press any key to continue..." );
		//getch();
		//printf( "\n" );
	}

	if ( !pJpegInfo->m_fFastCpu )
	{
		halWriteReg8( REG0302_IRQENABLE0, irqEnable );
	}

	return ( fSuccess );
}


//------------------------------------------------------------------------------
//	prvLoadYUV - loads YUV data into Line Buffer
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//
//	Output:	TRUE means success
//			FALSE means NOT success
//
//------------------------------------------------------------------------------
static Boolean prvLoadYUV( JPEGINFO* pJpegInfo )
{
	Boolean fSuccess		= TRUE;
	UInt32	jpegDataSize	= pJpegInfo->m_EncSize;
	UInt8*	pData			= pJpegInfo->m_pBuf;

	halWriteReg8( REG082A_JPEGLINEIRQ,    0x00 );	// Disable all line buffer interrupts
	halWriteReg8( REG0825_JPEGLINESTATUS, 0xFF );	// Reset all line buffer status flags

	if ( pJpegInfo->m_fAFAP )
	{
		for ( ; jpegDataSize; --jpegDataSize, ++pData )
			halWriteReg8( REG0900_JPEGLINEWRITE, *pData );
	}
	else
	{
		halWriteReg8( REG082A_JPEGLINEIRQ,    0x04 );	// Enable the line buffer half full interrupt
		for ( ; jpegDataSize; --jpegDataSize, ++pData )
		{
			// If the Line buffer is full, wait until it's not full.
			while ( halReadReg8(REG0825_JPEGLINESTATUS) & 0x04 )
				halWriteReg8( REG0825_JPEGLINESTATUS, 0x04 );	// Clear flag.
			halWriteReg8( REG0900_JPEGLINEWRITE, *pData );
		}

		halWriteReg8( REG0825_JPEGLINESTATUS, 0xFF );	// Reset all line buffer status flags
		halWriteReg8( REG082A_JPEGLINEIRQ,    0x00 );	// Disable all line buffer interrupts
	}

	return ( fSuccess );
}

//------------------------------------------------------------------------------
//	prvReadMarker - process prvode marker
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			jpegStatus		current JPEG status 
//
//	Output:	TRUE means success
//			FALSE means NOT success
//
//------------------------------------------------------------------------------
Boolean prvReadMarker( JPEGINFO* pJpegInfo, prvJpegFlag jpegStatus )
{
	UInt8	scalev,scaleh;
	UInt16	width		= prvHalReadReg16( REG1014_HORZPIXELSIZE1, REG1012_HORZPIXELSIZE0 );
	UInt16	height		= prvHalReadReg16( REG1010_VERTPIXELSIZE1, REG100E_VERTPIXELSIZE0 );
	UInt16	XEnd		= pJpegInfo->m_XStart + width - 1;
	UInt16	YEnd		= pJpegInfo->m_YStart + height - 1;
	Boolean fSuccess	= TRUE; // ROC REMOVED: prvSetResizeRect( pJpegInfo->m_XStart, pJpegInfo->m_YStart, XEnd, YEnd, pJpegInfo );
	
	if(pJpegInfo->m_fScale)
	{
		pJpegInfo->m_Width=width;
		pJpegInfo->m_Height=height;

		if(width<	pJpegInfo->m_DesiredWidth)
			scaleh=1;
		else
			scaleh = (width)/pJpegInfo->m_DesiredWidth;
			
		if(height<pJpegInfo->m_DesiredHeight)
			scalev=1;
		else
			scalev = (height)/pJpegInfo->m_DesiredHeight;

		if(!pJpegInfo->m_fIndScale)
			{
			if(scaleh < scalev)
				scalev=scaleh;
			else
				scaleh=scalev;
			}

		pJpegInfo->m_HScaleRate=scaleh;
		pJpegInfo->m_VScaleRate=scalev;
		pJpegInfo->m_XStart=(width-scaleh*pJpegInfo->m_DesiredWidth)/2;
		pJpegInfo->m_YStart=(height-scalev*pJpegInfo->m_DesiredHeight)/2;
		pJpegInfo->m_XEnd=pJpegInfo->m_XStart+scaleh*pJpegInfo->m_DesiredWidth-1;
		pJpegInfo->m_YEnd=pJpegInfo->m_YStart+scalev*pJpegInfo->m_DesiredHeight-1;
		
		// Set Resizer Dimensions
		prvSetResizeRect( pJpegInfo->m_XStart, pJpegInfo->m_YStart, pJpegInfo->m_XEnd, pJpegInfo->m_YEnd);
		prvSetResizeScaleMode( pJpegInfo->m_ScaleMode, pJpegInfo );
		prvSetResizeIndScaleRate( pJpegInfo->m_fIndScale, pJpegInfo );
		prvSetResizeHScaleRate(scaleh, pJpegInfo );
		prvSetResizeVScaleRate( scalev, pJpegInfo );
	}
	else
	{
		fSuccess	=  prvSetResizeRect( pJpegInfo->m_XStart, pJpegInfo->m_YStart, XEnd, YEnd);
	}
	
	if ( fSuccess )
	{
		// JPEG h/w requires DecodeMarkerRead Interrupt to be disabled, 
		// before clearing the interrupt status bit!!
		// otherwise, it may cause noise in JPEG Decode.
		prvJpegFlag irqControl	= prvGetIrqControl();
		irqControl				&= (~JpegDecMarkerRd);
		prvSetIrqControl( irqControl );
			
		jpegStatus |= JpegDecMarkerRd;
		prvSetJpegStatus( jpegStatus );
	}


	// Enable and Reset Resizer
	prvSetResize( TRUE, pJpegInfo );
	prvResetResize( TRUE, pJpegInfo );
	prvResetResize( FALSE, pJpegInfo );	
	return ( fSuccess );
}

//------------------------------------------------------------------------------
//	prvInitNextDecode - after decoding single image then setup hardware for next decode
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//			prvode			current status
//
//	Output:	TRUE means success
//			FALSE means NOT success
//
//------------------------------------------------------------------------------
Boolean prvInitNextDecode( JPEGINFO* pJpegInfo, Boolean fSuccess )
{
	// Disable Marker Interrupt
	prvHalReadReg16( REG0806_JPEGRAWSTATUS0, REG0808_JPEGRAWSTATUS1 );
	//FEDBCA9876543210b
	//|||||||||||||||+--Reserved JPEG Line Buffer Interrupt Raw Flag
	//||||||||||||||+---Raw JPEG Code Interrupt Flag
	//|||||||||||||+----Raw Line Buffer Overflow Flag
	//||||||||||||+-----Raw Reserved Size Mismatch Flag
	//|||||||||||+------Raw Decode Marker Read Flag
	//||||||||||+-------Raw JPEG Decode Complete Flag
	//|||||||||+--------n/a
	//||||||||+---------Reserved
	//||++++++----------FIFO Level Status
	//|+----------------Raw JPEG Codec File Out Status
	//+-----------------Raw Encode Size Limit Violation Flag
				
	// Check Codec Status to reset Codec Interrupt
	prvGetOpWork();

	// Reset all status flags
	prvSetJpegStatus( AllStatusClear );
				
	// Reset JPEG
	prvSetJpeg( FALSE, FALSE );
	prvSetJpeg( FALSE, TRUE );

	if ( fSuccess )
	{
		fSuccess = jpegWaitLCDNotBusy( pJpegInfo );
		if ( fSuccess )
			if ( !pJpegInfo->m_MemEnc )
				halWriteReg8( REG003A_LCDFRAMEXFER, 0x01 );
	}

	// If decoding from memory, disable Memory Decode Display
	if ( pJpegInfo->m_MemEnc )
		halWriteReg8( REG004C_DISPSETTING, (UInt8)(halReadReg8(REG004C_DISPSETTING)&0x7F) );

	return ( fSuccess );
}

//------------------------------------------------------------------------------
//	prvInitDecodeCodec - before prvoding single image setup hardware
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//
//	Output:	TRUE means success
//			FALSE means NOT success
//
//------------------------------------------------------------------------------
Boolean prvInitDecodeCodec( JPEGINFO* pJpegInfo )
{
	// If decoding from memory, enable Memory Decode Display
	if ( pJpegInfo->m_MemEnc )
		halWriteReg8( REG004C_DISPSETTING, (UInt8)(halReadReg8(REG004C_DISPSETTING)|0x80) );

	// Enable JPEG Codec
	prvSetJpeg( TRUE, FALSE );

	prvResetJpegCodec();

	if ( pJpegInfo->m_IsYUVfile )
	{
		// Set YUV Output Data Range.
		UInt8 Value = halReadReg8(REG0800_JPEGCONTROL) | 0x10;

		// Set JPEG Operation to YUV-to-Line-Buffer (and select its YUV format).
		switch ( pJpegInfo->m_YUVFmt )
		{
			case YUVFmt422:	Value = (Value&0xF1) | 0x1;	break;
			case YUVFmt420:	Value = (Value&0xF1) | 0xA;	break;
			default:	return FALSE;	//printf("ERROR: That YUV format isn't supported by the Line Buffer (REG[0800h-b3:1])\n" );
				
		}
		halWriteReg8( REG0800_JPEGCONTROL, (UInt8)(Value|0x12) );

		// Set image dimensions.
		prvHalWriteReg16( REG1010_VERTPIXELSIZE1, REG100E_VERTPIXELSIZE0, pJpegInfo->m_Height );
		prvHalWriteReg16( REG1014_HORZPIXELSIZE1, REG1012_HORZPIXELSIZE0, pJpegInfo->m_Width );
	}
	else
	{
		// Set JPEG Codec Operation to Decode
		halWriteReg8( REG1000_OPMODE, 0x04 );
	}
	
	// Set RST Marker operation
	halWriteReg8( REG101C_RSTOPSETTING, 0x1 );

	// Set Resizer Dimensions
	prvInitDecodeResizer( pJpegInfo );

	// Enable and Reset Resizer
	prvSetResize( TRUE, pJpegInfo );
	prvResetResize( TRUE, pJpegInfo );
	prvResetResize( FALSE, pJpegInfo );

	// Reset JPEG Module
	prvSetJpeg( TRUE, TRUE );

	// Set JPEG File Size
	prvHalWriteReg24( REG0822_JPEGFILESIZE0, pJpegInfo->m_EncSize );

	// Reset all status flags
	prvSetIrqControl( IrqDisable );
	prvSetJpegStatus( AllStatusClear );

	// Enable the appropriate interrupts
	if ( pJpegInfo->m_IsYUVfile )
		prvSetIrqControl( JpegLineBuffer );
	else if ( pJpegInfo->m_MemEnc )
		prvSetIrqControl( JpegCodec|LnBufOverflow|JpegDecComplete );
	else
		prvSetIrqControl( JpegCodec|LnBufOverflow|JpegDecMarkerRd|JpegDecComplete );

	if ( pJpegInfo->m_fPause )
	{
		//printf( "Pause right before JPEG decode is started.  Press any key to continue..." );
		//getch();
		//printf( "\n" );
	}

	if ( !pJpegInfo->m_IsYUVfile )
		prvStartJpeg();

	return TRUE;
}

//------------------------------------------------------------------------------
//	prvInitDecodeResizer - Programs resizer options
//
//	Input:	pJpegInfo		pointer to JPEGINFO object
//
//	Output:	TRUE means success
//			FALSE means NOT success
//
//------------------------------------------------------------------------------
Boolean prvInitDecodeResizer( JPEGINFO* pJpegInfo )
{
	if ( pJpegInfo->m_RWidth > 0 )
		pJpegInfo->m_XEnd = pJpegInfo->m_XStart + pJpegInfo->m_RWidth - 1;
	if ( pJpegInfo->m_RHeight > 0 )
		pJpegInfo->m_YEnd = pJpegInfo->m_YStart + pJpegInfo->m_RHeight - 1;
	prvSetResizeRect( pJpegInfo->m_XStart, pJpegInfo->m_YStart, pJpegInfo->m_XEnd, pJpegInfo->m_YEnd);
	prvSetResizeScaleMode( pJpegInfo->m_ScaleMode, pJpegInfo  );
	prvSetResizeIndScaleRate( pJpegInfo->m_fIndScale, pJpegInfo );
	prvSetResizeHScaleRate( pJpegInfo->m_HScaleRate, pJpegInfo );
	prvSetResizeVScaleRate( pJpegInfo->m_VScaleRate, pJpegInfo );
	return TRUE;
}
12

jdecode.c - 源码说明

本页面展示了「是一个手机功能的模拟程序」中的 jdecode.c 源码文件，采用 C语言 编程语言编写，共 911 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫下载站收录了大量与手机功能相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?