idct.c

JPEG解压软件,包含PC端的测试程序,程序结构比较清晰

#include "idct.h"

#define RemOffset	( 256 << JPEG_QUANTIZE_COE_REM_BITS )

#define COS_2W4		( 362 )	
#define COS_4W2W4	( 669 )
#define COS_4W6W4	( 277 )
#define COS_2W2		( 473 )

#define COS_W4W2	(167)
#define COS_W4W6	(69)

#define COS_W6		(98)
#define COS_W4		(181)
#define COS_W2		(237)

MVoid JPG_IdctIntFast( int *Qtable, register int *inDataBlock, register MByte *LimitTable, MByte *outData, int lineBytes ) {

	register int s0, s1, s2, s3, s4, s5, s6, s7, s8 ;
	int i	= 8 ;

	{
		register int *pQt	= Qtable;
		while ( -- i >= 0 ) {

			if ((inDataBlock[8]==0) && 
				(inDataBlock[16]==0) &&
				(inDataBlock[24]==0) &&
				(inDataBlock[32]==0) &&
				(inDataBlock[40]==0) &&
				(inDataBlock[48]==0) &&
				(inDataBlock[56]==0)) {

				s0				= pQt[0] * inDataBlock[0] ;
				inDataBlock[0]	= 
				inDataBlock[8]	= 
				inDataBlock[16]	= 
				inDataBlock[24]	= 
				inDataBlock[32]	= 
				inDataBlock[40]	= 
				inDataBlock[48]	= 
				inDataBlock[56]	= 
				s0 ;

				pQt		++ ;
				inDataBlock	++ ;
				continue ;
			}

			s7			= pQt[8] * inDataBlock[8] ;
			s8			= pQt[56] * inDataBlock[56] ;
			s5			= s7 - s8 ;										//B17=Y[1]-Y[7]
			s7			+= s8 ;											//A17=Y[1]+Y[7]

			s0			= pQt[16] * inDataBlock[16] ;
			s8			= pQt[48] * inDataBlock[48] ;
			s2			= s0 + s8 ;										//A26=Y[2]+Y[6]
			s3			= (((s0-s8)*COS_2W4)>>8)-s2;	//E26=(Y[2]-Y[6])*2cos(Pi/4)-A26

			s1			= pQt[24] * inDataBlock[24] ;
			s8			= pQt[40] * inDataBlock[40] ;
			s4			= s1 - s8 ;										//B35=Y[3]-Y[5]
			s1			+= s8 ;											//A35=Y[3]+Y[5]

			s6			= ((s4 * COS_4W2W4)>>8) ;		//E35=B35*2[cos(3Pi/8)+cos(Pi/8)]
			s0			= ((s5 * (-COS_4W6W4))>>8) ;		//E17=B17*2[cos(3Pi/8)-cos(Pi/8)]
			s8			= (((s5-s4)*COS_2W2)>>8);		//E1735=(B17-B35)*2cos(Pi/8)

			s4			= (((s1-s7)*COS_2W4)>>8);		//B1735=(A17-A35)*2cos(Pi/4)
			s1			+= s7 ;											//A1735=A17+A35

			s6			+= s8 - s1 ;									//F1735=E1735+E35-A1735
			s4			+= s6 ;											//G1735=F1735-B1735
			s0			+= s4 + s8 ;									//H1735=G1735+E1735+E17

			s5			= pQt[0] * inDataBlock[0] ;
			s7			= pQt[32] * inDataBlock[32] ;
			s8			= s5 - s7 ;										//B04=Y[0]-Y[4]
			s5			+= s7 ;											//A04=Y[0]+Y[4]

			s7			= s5 - s2 ;										//B0426=A04-A26
			s5			+= s2 ;											//A0426=A04+A26
			s2			= s8 - s3 ;										//F0426=B04-E26
			s3			+= s8 ;											//E0426=B04+E26

			inDataBlock[ 0]	= s5 + s1 ;									//Y[0]=A0426+A1735
			inDataBlock[ 8]	= s3 + s6 ;									//Y[1]=E0426+F1735
			inDataBlock[16]	= s2 - s4 ;									//Y[2]=F0426-G1735
			inDataBlock[24]	= s7 + s0 ;									//Y[3]=B0426+H1735
			inDataBlock[32]	= s7 - s0 ;									//Y[4]=B0426-H1735
			inDataBlock[40]	= s2 + s4 ;									//Y[5]=F0426+G1735
			inDataBlock[48]	= s3 - s6 ;									//Y[6]=E0426-F1735
			inDataBlock[56]	= s5 - s1 ;									//Y[7]=A0426-A1735

			pQt ++ ;
			inDataBlock	++ ;

		}
	}

	inDataBlock		-= 8 ;

	i	= 8 ;
	{
		register MByte *pOutData	= outData;

		while ( -- i >= 0 ) {

			if ((inDataBlock[1] == 0) && 
				(inDataBlock[2] == 0) && 
				(inDataBlock[3] == 0) &&
				(inDataBlock[4] == 0) &&
				(inDataBlock[5] == 0) &&
				(inDataBlock[6] == 0) &&
				(inDataBlock[7] == 0)) {

				s0 = LimitTable[(inDataBlock[0] + RemOffset) >> JPEG_QUANTIZE_COE_REM_BITS] ;

				pOutData[0]	= 
				pOutData[1]	= 
				pOutData[2]	= 
				pOutData[3]	=
				pOutData[4]	=
				pOutData[5]	=
				pOutData[6]	=
				pOutData[7]	= 
				s0 ;

				inDataBlock	+= 8 ;
				pOutData		+= lineBytes ;

				continue;
			}

			s1			= inDataBlock[1] - inDataBlock[7] ;							//B17=Y[1]-Y[7]
			s5			= inDataBlock[3] - inDataBlock[5];							//B35=Y[3]-Y[5]
			s7			= ((s1 * (-COS_4W6W4))>>8) ;					//E17=B17*2[cos(3Pi/8)-cos(Pi/8)]
			s6			= ((s5 * COS_4W2W4)>>8) ;					//E35=B35*2[cos(3Pi/8)+cos(Pi/8)]
			s0			= ((( s1 - s5 ) * COS_2W2)>>8) ;			//E1735=(B17-B35)*2cos(Pi/8)

			s5			= inDataBlock[1] + inDataBlock[7] ;							//A17=Y[1]+Y[7]
			s1			= inDataBlock[3] + inDataBlock[5] ;							//A35=Y[3]+Y[5]
			s4			= ((( s1 - s5 ) * COS_2W4)>>8) ;			//B1735=(A17-A35)*2cos(Pi/4)
			s1			+= s5 ;														//A1735=A17+A35
			s6			+= s0 - s1 ;												//F1735=E1735+E35-A1735
			s4			+= s6 ;														//G1735=F1735-B1735
			s0			+= s4 + s7 ;												//H1735=G1735+E1735+E17

			s2			= inDataBlock[2] + inDataBlock[6] ;							//A26=Y[2]+Y[6]
			s8			= inDataBlock[0] + RemOffset ;
			s5			= s8 + inDataBlock[4] ;										//A04=Y[0]+Y[4]
			s7			= s5 - s2 ;													//B0426=A04-A26
			s5			+= s2 ;														//A0426=A04+A26

			s3			= (((inDataBlock[2]-inDataBlock[6])*COS_2W4)>>8)-s2;	//E26=(Y[2]-Y[6])*2cos(Pi/4)-A26
			s8			-= inDataBlock[4] ;											//B04=Y[0]-Y[4]
			s2			= s8 - s3 ;													//F0426=B04-E26
			s3			+= s8 ;														//E0426=B04+E26

			pOutData[0]	= LimitTable[( s5 + s1 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[0]=A0426+A1735
			pOutData[1]	= LimitTable[( s3 + s6 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[1]=E0426+F1735
			pOutData[2]	= LimitTable[( s2 - s4 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[2]=F0426-G1735
			pOutData[3]	= LimitTable[( s7 + s0 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[3]=B0426+H1735
			pOutData[4]	= LimitTable[( s7 - s0 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[4]=B0426-H1735
			pOutData[5]	= LimitTable[( s2 + s4 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[5]=F0426+G1735
			pOutData[6]	= LimitTable[( s3 - s6 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[6]=E0426-F1735
			pOutData[7]	= LimitTable[( s5 - s1 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;	//Z[7]=A0426-A1735

			inDataBlock		+= 8 ;
			pOutData		+= lineBytes ;
		}
	}
}


MVoid JPG_IdctIntFast1x1( int *Qtable, register int *inDataBlock, register MByte *LimitTable, MByte *outData, int lineBytes ) {

	register int s0 ;
	register MByte *pOutData	= outData;
	register int i	= 8 ;

	s0 = LimitTable[(Qtable[0] * inDataBlock[0] + RemOffset) >> JPEG_QUANTIZE_COE_REM_BITS] ;

	while ( -- i >= 0 ) {
		pOutData[0]	= 
		pOutData[1]	= 
		pOutData[2]	= 
		pOutData[3]	=
		pOutData[4]	=
		pOutData[5]	=
		pOutData[6]	=
		pOutData[7]	=
		s0 ;

		pOutData	+= lineBytes ;
	}

}

MVoid JPG_IdctIntFast2x2( int *Qtable, register int *inDataBlock, register MByte *LimitTable, MByte *outData, int lineBytes ) {

	register int s0, s1, s2;
	register int i	= 8 , j;

	{
		register int *pQt	= Qtable;
		while ( -- i >= 0 ) {

			if (i == 5 || i == 3 || i == 1) {
				pQt		++ ;
				inDataBlock	++ ;
				continue;
			}

			if ((inDataBlock[8]==0) && 
				(inDataBlock[24]==0) &&
				(inDataBlock[40]==0) &&
				(inDataBlock[56]==0)) {

				inDataBlock[0]	= 
				inDataBlock[8]	= 
				pQt[0] * inDataBlock[0] ;

				pQt		++ ;
				inDataBlock	++ ;
				continue ;
			}

			s1		= (pQt[8] * inDataBlock[8] - pQt[56] * inDataBlock[56]) * COS_W4W2;
			s0		= (pQt[40] * inDataBlock[40] - pQt[24] * inDataBlock[24]) * COS_W4W6;
			s0		= (s0 + s1) >> 8;
   			s1		= pQt[0] * inDataBlock[0] ;

			inDataBlock[0]	= s1 + s0 ;	
			inDataBlock[8]	= s1 - s0 ;	

			pQt ++ ;
			inDataBlock	++ ;

		}
	}

	inDataBlock		-= 8 ;

	i	= 2 ;
	{
		register MByte *pOutData	= outData;

		while ( -- i >= 0 ) {

			if ((inDataBlock[1] == 0) && 
				(inDataBlock[3] == 0) &&
				(inDataBlock[5] == 0) &&
				(inDataBlock[7] == 0)) {

				s0 = LimitTable[(inDataBlock[0] + RemOffset) >> JPEG_QUANTIZE_COE_REM_BITS] ;

				//pOutData[0]	= 
				//pOutData[4]	= s0 ;
				for (j = 0; j < 4; j ++) {
					pOutData[0]	= 
					pOutData[1]	= 
					pOutData[2]	= 
					pOutData[3]	=
					pOutData[4]	=
					pOutData[5]	=
					pOutData[6]	=
					pOutData[7]	= 
					s0 ;
					pOutData	+= lineBytes ;
				}

				inDataBlock	+= 8 ;
				continue;
			}


			s1		= (inDataBlock[1] - inDataBlock[7]) * COS_W4W2;
			s2		= (inDataBlock[5] - inDataBlock[3]) * COS_W4W6;
			s0		= (s1 + s2) >> 8;

			s1			= inDataBlock[0] + RemOffset ;

			//pOutData[0]	= LimitTable[( s1 + s0 ) >> JPEG_QUANTIZE_COE_REM_BITS];
			//pOutData[4]	= LimitTable[( s1 - s0 ) >> JPEG_QUANTIZE_COE_REM_BITS];

			s2			= LimitTable[( s1 + s0 ) >> JPEG_QUANTIZE_COE_REM_BITS];
			s1			= LimitTable[( s1 - s0 ) >> JPEG_QUANTIZE_COE_REM_BITS];

			for (j = 0; j < 4; j ++) {
				pOutData[0]	= 
				pOutData[1]	= 
				pOutData[2]	= 
				pOutData[3]	= s2;
				pOutData[4]	=
				pOutData[5]	=
				pOutData[6]	=
				pOutData[7]	= s1;
				pOutData	+= lineBytes ;
			}

			inDataBlock		+= 8 ;
		}
	}
}

MVoid JPG_IdctIntFast4x4( int *Qtable, register int *inDataBlock, register MByte *LimitTable, MByte *outData, int lineBytes ) {

	register int s0, s1, s2, s3, s4 ;
	int i	= 8 ,j;

	{
		register int *pQt	= Qtable;
		while ( -- i >= 0 ) {

			if (i == 3) {
				pQt		++ ;
				inDataBlock	++ ;
				continue;
			}

			if ((inDataBlock[8]==0) && 
				(inDataBlock[16]==0) &&
				(inDataBlock[24]==0) &&
				(inDataBlock[40]==0) &&
				(inDataBlock[48]==0) &&
				(inDataBlock[56]==0)) {

				s0				= pQt[0] * inDataBlock[0] ;
				inDataBlock[0]	= 
				inDataBlock[8]	= 
				inDataBlock[16]	= 
				inDataBlock[24]	= 
				s0 ;
				
				pQt		++ ;
				inDataBlock	++ ;
				continue ;
			}

			s0			= pQt[ 8] * inDataBlock[ 8] - pQt[56] * inDataBlock[56];
			s1			= pQt[24] * inDataBlock[24] - pQt[40] * inDataBlock[40];

			s2			= (s0 * COS_W2 + s1 * COS_W6) >> 8;
			s3			= (s0 * COS_W6 - s1 * COS_W2) >> 8;
			
			s0			= pQt[16] * inDataBlock[16] - pQt[48] * inDataBlock[48];
			s1			= (s0 * COS_W4) >> 8;

			s0			= pQt[ 0] * inDataBlock[ 0] ;

			s4			= s0 - s1;
			s0			+= s1;

			inDataBlock[ 0]	= s0 + s2;
			inDataBlock[ 8]	= s4 + s3;
			inDataBlock[16]	= s4 - s3;
			inDataBlock[24]	= s0 - s2;

			pQt ++ ;
			inDataBlock	++ ;

		}
	}

	inDataBlock		-= 8 ;

	i	= 4 ;
	{
		register MByte *pOutData	= outData;

		while ( -- i >= 0 ) {

			if ((inDataBlock[1] == 0) && 
				(inDataBlock[2] == 0) && 
				(inDataBlock[3] == 0) &&
				(inDataBlock[5] == 0) &&
				(inDataBlock[6] == 0) &&
				(inDataBlock[7] == 0)) {

				s0 = LimitTable[(inDataBlock[0] + RemOffset) >> JPEG_QUANTIZE_COE_REM_BITS] ;

				//pOutData[0]	= 
				//pOutData[2]	= 
				//pOutData[4]	=
				//pOutData[6]	= s0 ;
				for (j = 0; j < 2; j ++) {
					pOutData[0]	= 
					pOutData[1]	= 
					pOutData[2]	= 
					pOutData[3]	=
					pOutData[4]	=
					pOutData[5]	=
					pOutData[6]	=
					pOutData[7]	= s0 ;
					pOutData	+= lineBytes ;
				}
				inDataBlock	+= 8 ;

				continue;
			}

			s0			= inDataBlock[1] - inDataBlock[7];
			s1			= inDataBlock[3] - inDataBlock[5];

			s2			= (s0 * COS_W2 + s1 * COS_W6) >> 8;
			s3			= (s0 * COS_W6 - s1 * COS_W2) >> 8;
			
			s0			= inDataBlock[2] - inDataBlock[6];
			s1			= (s0 * COS_W4) >> 8;

			s0			= inDataBlock[0] + RemOffset ;

			s4			= s0 - s1;
			s0			+= s1;

			//pOutData[0]	= LimitTable[( s0 + s2 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;
			//pOutData[2]	= LimitTable[( s4 + s3 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;
			//pOutData[4]	= LimitTable[( s4 - s3 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;
			//pOutData[6]	= LimitTable[( s0 - s2 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;

			s1 	= LimitTable[( s0 + s2 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;
			s0 	= LimitTable[( s0 - s2 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;
			s2 	= LimitTable[( s4 + s3 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;
			s3 	= LimitTable[( s4 - s3 ) >> JPEG_QUANTIZE_COE_REM_BITS] ;

			for (j = 0; j < 2; j ++) {
				pOutData[0]	= 
				pOutData[1]	= s1 ;
				pOutData[2]	= 
				pOutData[3]	= s2 ;
				pOutData[4]	=
				pOutData[5]	= s3 ;
				pOutData[6]	=
				pOutData[7]	= s0 ;
				pOutData	+= lineBytes ;
			}

			inDataBlock		+= 8 ;
		}
	}
}