jpegfile.cpp

医学图象处理系统

void JpegFile1::StoreBuffer()
{
	short		   i, j, k, l;
	unsigned char *lpbmp;
	int y, u, v, rr, gg, bb;

	int Endi = SampRate_Y_V << 3;
	int Endj = SampRate_Y_H << 3;
	int OffX = sizej * comp_num;
	int x1 = sizej, x2 = min(sizej+ Endj+ 1, ImgWidth);
	int y1 = sizei, y2 = min(sizei+ Endi+ 1, ImgHeight);
	int *ttt = new int[Endi+1];
	for(ttt[0]= 0, i= 1; i<= Endi; i++)
		ttt[i] = ttt[i-1] + Endj;

	if(comp_num == 3)
	{
		for(i=0, k= y1; k< y2; k++, i++)
		{
			lpbmp = lpImgData[k] + OffX;
			for(j= 0, l= x1; l< x2; l++, j++)
			{
				y  = Y[ttt[i] + j];
				u  = U[ttt[i/ V_YtoU] + j/ H_YtoU];
				v  = V[ttt[i/ V_YtoV] + j/ H_YtoV];

				rr = ((y<<8) + 18* u + 367*v) >>8;
				gg = ((y<<8) - 159*u - 220*v) >>8;
				bb = ((y<<8) + 411*u - 29 *v) >>8;//*/

				*lpbmp++ = *(blpClip + bb);
				*lpbmp++ = *(blpClip + gg);
				*lpbmp++ = *(blpClip + rr);
			}
		}
	}
	else
	{
		for(i=0, k= y1; k< y2; k++, i++)
		{
			lpbmp = lpImgData[k] + OffX;
			for(j= 0, l= x1; l< x2; l++, j++)
			{
				y  = Y[i*Endj + j];
				u  = U[(i/ V_YtoU)* Endj + j/ H_YtoU];
				v  = V[(i/ V_YtoV)* Endj + j/ H_YtoV];
				rr = ((y<<8) + 18* u + 367*v) >>8;
				//gg = ((y<<8) - 159*u - 220*v) >>8;
				//bb = ((y<<8) + 411*u - 29*v)  >>8;
				*lpbmp++ = *(blpClip + rr);
			}
		}
	}
	if(ttt != NULL) delete []ttt;
}
///////////////////////////////////////////////////////////////////////////////
int JpegFile1::DecodeMCUBlock()
{
	short *lpMCUBuffer;
	short i,j;
	int funcret;

	if(IntervalFlag)
	{
		lp     += 2;
		ycoef   = ucoef = vcoef = 0;
		BitPos  = 0;
		CurByte = 0;
	}
	switch(comp_num)
	{
	case 3:
		lpMCUBuffer = MCUBuffer;
		for (i= 0; i< Y_in_MCU; i++)  //Y
		{
			funcret = HufBlock(YDcIndex, YAcIndex);
			if(funcret!=0) return funcret;
			BlockBuffer[0] = BlockBuffer[0] + ycoef;
			ycoef = BlockBuffer[0];
			for(j= 0; j<64; j++)
				*lpMCUBuffer++ = BlockBuffer[j];
		}
		for (i=0; i< U_in_MCU; i++)  //U
		{
			funcret = HufBlock(UVDcIndex, UVAcIndex);
			if(funcret!=0)	return funcret;
			BlockBuffer[0] = BlockBuffer[0] + ucoef;
			ucoef = BlockBuffer[0];
			for(j= 0; j< 64; j++)
				*lpMCUBuffer++ = BlockBuffer[j];
		}
		for (i= 0; i< V_in_MCU; i++)  //V
		{
			funcret = HufBlock(UVDcIndex, UVAcIndex);
			if(funcret!=0) return funcret;
			BlockBuffer[0] = BlockBuffer[0]+vcoef;
			vcoef = BlockBuffer[0];
			for(j= 0; j< 64; j++)
				*lpMCUBuffer++ = BlockBuffer[j];
		}
		break;
	case 1:
		lpMCUBuffer = MCUBuffer;
		funcret = HufBlock(YDcIndex, YAcIndex);
		if(funcret!=0)	return funcret;
		BlockBuffer[0] = BlockBuffer[0] + ycoef;
		ycoef = BlockBuffer[0];
		for(j= 0; j< 64; j++)
			*lpMCUBuffer++ = BlockBuffer[j];
		memset(lpMCUBuffer, 0, 128*sizeof(short));
		//for(i= 0; i< 128; i++)	*lpMCUBuffer++=0;
		break;
	default:
		return 1;
	}
	return 0;
}
//////////////////////////////////////////////////////////////////
int JpegFile1::HufBlock(BYTE dchufindex,BYTE achufindex)
{
	short count= 0, i;
	int funcret;

	//dc
	HufTabIndex = dchufindex;
	funcret		= DecodeElement();
	if(funcret!=0) 	return funcret;

	BlockBuffer[count++] = vvalue;
	//ac
	HufTabIndex = achufindex;
	while (count<64)
	{
		funcret = DecodeElement();
		if(funcret!=0) return funcret;
		if ((rrun==0)&&(vvalue==0))
		{
			for (i= count; i<64; i++)
				BlockBuffer[i]=0;
			count = 64;
		}
		else
		{
			for (i= 0; i< rrun; i++)
				BlockBuffer[count++] =0 ;
			BlockBuffer[count++] = vvalue;
		}
	}
	return 0;
}
//////////////////////////////////////////////////////////////////////////////
int JpegFile1::DecodeElement()
{
	int   thiscode, tempcode;
	BYTE  temp, valueex;
	short codelen;
	BYTE  hufexbyte, runsize, tempsize, sign;
	BYTE  newbyte, lastbyte;

	if(BitPos>=1)
	{
		BitPos--;
		thiscode = (BYTE)CurByte>>BitPos;
		CurByte  = CurByte & And[BitPos];
	}
	else
	{
		lastbyte = ReadByte();
		BitPos--;
		newbyte  = CurByte&And[BitPos];
		thiscode = lastbyte >> 7;
		CurByte  = newbyte;
	}
	codelen = 1;
	while ((thiscode<huf_min_value[HufTabIndex][codelen-1])||
		  (code_len_table[HufTabIndex][codelen-1]==0)||
		  (thiscode>huf_max_value[HufTabIndex][codelen-1]))
	{
		if(BitPos>=1)
		{
			BitPos--;
			tempcode = (BYTE)CurByte>>BitPos;
			CurByte  = CurByte & And[BitPos];
		}
		else
		{
			lastbyte = ReadByte();
			BitPos--;
			newbyte  = CurByte&And[BitPos];
			tempcode = (BYTE)lastbyte>>7;
			CurByte  = newbyte;
		}
		thiscode = (thiscode<<1) + tempcode;
		codelen++;
		if(codelen>16) return 1;
	}//while
	temp = thiscode - huf_min_value[HufTabIndex][codelen-1] + 
		              code_pos_table[HufTabIndex][codelen-1];
	hufexbyte = (BYTE)code_value_table[HufTabIndex][temp];
	rrun      = (short)(hufexbyte>>4);
	runsize	  = hufexbyte & 0x0f;
	if(runsize==0)
	{
		vvalue = 0;
		return 0;
	}
	tempsize = runsize;
	if(BitPos>=runsize)
	{
		BitPos -= runsize;
		valueex = (BYTE)CurByte>>BitPos;
		CurByte = CurByte&And[BitPos];
	}
	else
	{
		valueex   = BYTE( CurByte );
		tempsize -= BitPos;
		while(tempsize>8)
		{
			lastbyte = ReadByte();
			valueex  = (valueex<<8) + (BYTE)lastbyte;
			tempsize-= 8;
		}  //while
		lastbyte = ReadByte();
		BitPos  -= tempsize;
		valueex  = (valueex<<tempsize) + (lastbyte>>BitPos);
		CurByte  = lastbyte & And[BitPos];
	}  //else
	sign = valueex >> (runsize-1);
	if(sign)
		vvalue = valueex;
	else
	{
		valueex = valueex ^ 0xffff;
		temp    = 0xffff << runsize;
		vvalue  =-(short)(valueex^temp);
	}
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
void JpegFile1::IQtIZzMCUComponent(short flag)
{
	short H, VV, i, j, *pMCUBuffer;
	int *pQtZzMCUBuffer;

	switch(flag)
	{
	case 0:
		H  = SampRate_Y_H;
		VV = SampRate_Y_V;
		pMCUBuffer	   = MCUBuffer;
		pQtZzMCUBuffer = QtZzMCUBuffer;
		break;
	case 1:
		H  = SampRate_U_H;
		VV = SampRate_U_V;
		pMCUBuffer	   = MCUBuffer + (Y_in_MCU << 6);
		pQtZzMCUBuffer = QtZzMCUBuffer + (Y_in_MCU << 6);
		break;
	case 2:
		H  = SampRate_V_H;
		VV = SampRate_V_V;
		pMCUBuffer	   = MCUBuffer + ( (Y_in_MCU+ U_in_MCU) << 6);
		pQtZzMCUBuffer = QtZzMCUBuffer + ((Y_in_MCU+ U_in_MCU) << 6);
		break;
	}
	int add = 0;
	for(i= 0; i<VV; i++)
		for (j= 0; j<H; j++, add += 64)
			IQtIZzBlock(pMCUBuffer+ add, pQtZzMCUBuffer+ add, flag);
}
//////////////////////////////////////////////////////////////////////////////////////////
void JpegFile1::IQtIZzBlock(short  *s ,int * d,short flag)
{
	short i, j, tag, offset, *pQt;
	int buffer2[8][8], *buffer1;

	switch(flag)
	{
	case 0:
		pQt	   = YQtTable;
		offset = 128;
		break;
	case 1:
		pQt	   = UQtTable;
		offset = 0;
		break;
	case 2:
		pQt	   = VQtTable;
		offset = 0;
		break;
	}

	for(i= 0; i< 8; i++)
		for(j= 0;j< 8; j++)
		{
			tag = Zig_Zag[i][j];
			buffer2[i][j] = (int)s[tag]* (int)pQt[tag];
		}
	buffer1 = (int *)buffer2;
	Fast_IDCT(buffer1);
	if( flag )
		memcpy(d, buffer1, 64* sizeof(int));
	else
	{
		int * it = d;
		for(i= 0; i< 64; i++)			
				*it++ = *buffer1++ + offset;
	}
}
///////////////////////////////////////////////////////////////////////////////
void JpegFile1::Fast_IDCT(int * block)
{
	for(short i= 0; i< 64; i+=8)
		idctrow(block + i);

	for (i= 0; i< 8; i++)
		idctcol(block + i);
}
///////////////////////////////////////////////////////////////////////////////
inline BYTE JpegFile1::ReadByte()
{
	BYTE  i = *(lp++);
	if(i==0xff)	lp++;
	BitPos  = 8;
	CurByte = i;
	return i;
}
////////////////////////////////////////////////////////////////////////
void JpegFile1::idctrow(int * blk)
{
	int x0, x1, x2, x3, x4, x5, x6, x7, x8;
	//intcut
	if (!((x1 = blk[4]<<11) | (x2 = blk[6]) | (x3 = blk[2]) |
		(x4 = blk[1]) | (x5 = blk[7]) | (x6 = blk[5]) | (x7 = blk[3])))
	{
		blk[0]=blk[1]=blk[2]=blk[3]=blk[4]=blk[5]=blk[6]=blk[7]= blk[0]<<3;
		return;
	}
	x0 = (blk[0]<<11) + 128; // for proper rounding in the fourth stage 
	//first stage
	x8 = W7 * (x4+ x5);
	x4 = x8 + (W1- W7)* x4;
	x5 = x8 - (W1+ W7)* x5;
	x8 = W3 * (x6+ x7);
	x6 = x8 - (W3- W5)* x6;
	x7 = x8 - (W3+ W5)* x7;
	//second stage
	x8 = x0 + x1;
	x0-= x1;
	x1 = W6* (x3+ x2);
	x2 = x1 - (W2+ W6)* x2;
	x3 = x1 + (W2- W6)* x3;
	x1 = x4 + x6;
	x4-= x6;
	x6 = x5 + x7;
	x5-= x7;
	//third stage
	x7 = x8 + x3;
	x8-= x3;
	x3 = x0 + x2;
	x0-= x2;
	x2 = (181* (x4+x5)+ 128) >> 8;
	x4 = (181* (x4-x5)+ 128) >> 8;
	//fourth stage
	*blk = (x7+ x1) >> 8;
	*(blk+ 1) = (x3+ x2) >> 8;
	*(blk+ 2) = (x0+ x4) >> 8;
	*(blk+ 3) = (x8+ x6) >> 8;
	*(blk+ 4) = (x8- x6) >> 8;
	*(blk+ 5) = (x0- x4) >> 8;
	*(blk+ 6) = (x3- x2) >> 8;
	*(blk+ 7) = (x7- x1) >> 8;
}
//////////////////////////////////////////////////////////////////////////////
void JpegFile1::idctcol(int * blk)
{
	int x0, x1, x2, x3, x4, x5, x6, x7, x8;
	//intcut
	if (!((x1 = (blk[32]<<8)) | (x2 = blk[48]) | (x3 = blk[16]) |
		  (x4 = blk[8]) | (x5 = blk[56]) | (x6 = blk[40]) | (x7 = blk[24])))
	{
		blk[0]=blk[8]=blk[16]=blk[24]=blk[32]=blk[40]=blk[48]=blk[56] = (blk[0] + 32)>>6;
		return;
	}

	x0 = (blk[0]<<8) + 8192;
	//first stage
	x8 = W7* (x4+ x5) + 4;
	x4 =(x8+ (W1- W7)* x4) >> 3;
	x5 =(x8- (W1+ W7)* x5) >> 3;
	x8 = W3* (x6+ x7) + 4;
	x6 =(x8- (W3- W5)* x6) >> 3;
	x7 =(x8- (W3+ W5)* x7) >> 3;
	//second stage
	x8 = x0 + x1;
	x0-= x1;
	x1 = W6* (x3+ x2) + 4;
	x2 =(x1- (W2+ W6)* x2) >> 3;
	x3 =(x1+ (W2- W6)* x3) >> 3;
	x1 = x4 + x6;
	x4-= x6;
	x6 = x5 + x7;
	x5-= x7;
	//third stage
	x7 = x8 + x3;
	x8-= x3;
	x3 = x0 + x2;
	x0-= x2;
	x2 = (181* (x4+ x5) + 128) >> 8;
	x4 = (181* (x4- x5) + 128) >> 8;
	//fourth stage
	*blk	   = iclp[ (x7+ x1) >> 14 ];
	*(blk+ 8 ) = iclp[ (x3+ x2) >> 14 ];
	*(blk+ 16) = iclp[ (x0+ x4) >> 14 ];
	*(blk+ 24) = iclp[ (x8+ x6) >> 14 ];
	*(blk+ 32) = iclp[ (x8- x6) >> 14 ];
	*(blk+ 40) = iclp[ (x0- x4) >> 14 ];
	*(blk+ 48) = iclp[ (x3- x2) >> 14 ];
	*(blk+ 56) = iclp[ (x7- x1) >> 14 ];
}