Jpeg 转bmp

最新推荐文章于 2023-04-26 11:03:10 发布
最新推荐文章于 2023-04-26 11:03:10 发布
阅读量6.3k 收藏 1
点赞数
分类专栏： C、C++ 文章标签： table qt byte buffer file bi 
#include "jpeg.h"
#include "memory.h"
#include "math.h"
#include "stdio.h"
#include "windows.h"

//macro definition
#define WIDTHBYTES(i)    ((i+31)/32*4)
#define PI 3.1415926535
//define return value of function
#define FUNC_OK 0
#define FUNC_MEMORY_ERROR 1
#define FUNC_FILE_ERROR 2
#define FUNC_FORMAT_ERROR 3
//
//Jpeg functions
BOOL LoadJpegFile(char *BmpFileName);
void showerror(int funcret);
int  InitTag();
void InitTable();
int  Decode();
int  DecodeMCUBlock();
int  HufBlock(unsigned char dchufindex,unsigned char achufindex);
int  DecodeElement();
void IQtIZzMCUComponent(short flag);
void IQtIZzBlock(short  *s ,int * d,short flag);
void GetYUV(short flag);
void StoreBuffer();
BYTE ReadByte();
void Initialize_Fast_IDCT();
void Fast_IDCT(int * block);
void idctrow(int * blk);
void idctcol(int * blk);
//
//global variable declaration
BITMAPFILEHEADER   bf;
BITMAPINFOHEADER   bi;
HBITMAP            hBitmap=NULL;
HGLOBAL            hImgData=NULL;
DWORD              NumColors;
DWORD              LineBytes;
DWORD              ImgWidth=0 , ImgHeight=0;
unsigned int       PcxBytesPerLine;
LPSTR              lpPtr;
//
//variables used in jpeg function
short			SampRate_Y_H,SampRate_Y_V;
short			SampRate_U_H,SampRate_U_V;
short			SampRate_V_H,SampRate_V_V;
short			H_YtoU,V_YtoU,H_YtoV,V_YtoV;
short			Y_in_MCU,U_in_MCU,V_in_MCU;
unsigned char   *lpJpegBuf;
unsigned char   *lp;
short			qt_table[3][64];
short			comp_num;
BYTE			comp_index[3];
BYTE		    YDcIndex,YAcIndex,UVDcIndex,UVAcIndex;
BYTE			HufTabIndex;
short		    *YQtTable,*UQtTable,*VQtTable;
BYTE			And[9]={0,1,3,7,0xf,0x1f,0x3f,0x7f,0xff};
short		    code_pos_table[4][16],code_len_table[4][16];
unsigned short	code_value_table[4][256];
unsigned short	huf_max_value[4][16],huf_min_value[4][16];
short			BitPos,CurByte;
short			rrun,vvalue;
short			MCUBuffer[10*64];
int				QtZzMCUBuffer[10*64];
short			BlockBuffer[64];
short			ycoef,ucoef,vcoef;
BOOL			IntervalFlag;
short			interval=0;
int				Y[4*64],U[4*64],V[4*64];
DWORD		    sizei,sizej;
short 			restart;
static  long	iclip[1024];
static  long	*iclp;


int LoadJpegFile (char *JpegFileName)
{
	HFILE			   hfjpg;
	DWORD 		       ImgSize;
	DWORD              JpegBufSize;
	HFILE              hfbmp;
	HGLOBAL			   hJpegBuf;
	int				   funcret;
	LPBITMAPINFOHEADER lpImgData;

	if((hfjpg=_lopen(JpegFileName,OF_READ))==HFILE_ERROR)
	{
		showerror(FUNC_FILE_ERROR);
		return 0;
	}
	//get jpg file length
	JpegBufSize=_llseek(hfjpg,0L,SEEK_END);
	//rewind to the beginning of the file
	_llseek(hfjpg,0L,SEEK_SET);

	if((hJpegBuf=GlobalAlloc(GHND,JpegBufSize))==NULL)
	{
		_lclose(hfjpg);
		showerror(FUNC_MEMORY_ERROR);
		return 0;
	}
	lpJpegBuf=(unsigned char  *)GlobalLock(hJpegBuf);
	_hread(hfjpg,(unsigned char  *)lpJpegBuf,JpegBufSize);
	_lclose(hfjpg);


	InitTable();

	if((funcret=InitTag())!=FUNC_OK)
	{
		GlobalUnlock(hJpegBuf);
		GlobalFree(hJpegBuf);
		showerror(funcret);
		return 0;
	}
	//create new bitmapfileheader and bitmapinfoheader
	memset((char *)&bf,0,sizeof(BITMAPFILEHEADER));	
	memset((char *)&bi,0,sizeof(BITMAPINFOHEADER));

	bi.biSize=(DWORD)sizeof(BITMAPINFOHEADER);
	bi.biWidth=(LONG)(ImgWidth);
	bi.biHeight=(LONG)(ImgHeight);
	bi.biPlanes=1;
	bi.biBitCount=24;
	bi.biClrUsed=0;
	bi.biClrImportant=0;
	bi.biCompression=BI_RGB;
	NumColors=0;
	LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
	ImgSize=(DWORD)LineBytes*bi.biHeight;

	bf.bfType=0x4d42;
	bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
	bf.bfOffBits=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
 
	if((hImgData=GlobalAlloc(GHND,ImgSize))==NULL)
	{
		GlobalUnlock(hJpegBuf);
		GlobalFree(hJpegBuf);
		showerror(FUNC_MEMORY_ERROR);
		return FALSE;
	}
	lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
	lpPtr=(char *)lpImgData;

	if((SampRate_Y_H==0)||(SampRate_Y_V==0))
	{
		GlobalUnlock(hJpegBuf);
		GlobalFree(hJpegBuf);
		GlobalUnlock(hImgData);
		GlobalFree(hImgData);
		hImgData=NULL;
		showerror(FUNC_FORMAT_ERROR);
		return FALSE ;
	}

	funcret=Decode();
	
	if(funcret==FUNC_OK)
	{

		hfbmp=_lcreat("test.bmp",0);
		_lwrite(hfbmp,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); //写BMP文件头
		_lwrite(hfbmp,(LPSTR)&bi,sizeof(BITMAPINFOHEADER)); //写BMP文件信息
		_lwrite(hfbmp,(LPSTR)lpImgData,ImgSize);            //写BMP位图数据
		_lclose(hfbmp);
		GlobalUnlock(hJpegBuf);
		GlobalFree(hJpegBuf);
		GlobalUnlock(hImgData);
		return TRUE;
	}
	else
	{
		GlobalUnlock(hJpegBuf);
		GlobalFree(hJpegBuf);
		GlobalUnlock(hImgData);
		GlobalFree(hImgData);
		hImgData=NULL;
		showerror(funcret);
		return FALSE;
	}
}
/
void showerror(int funcret)
{
	switch(funcret)
	{
	case FUNC_MEMORY_ERROR:
		printf("Error alloc memory!\n");   
		exit(1);
		break;
	case FUNC_FILE_ERROR:
		printf("File not found!!\n");   
		exit(1);
		break;
	case FUNC_FORMAT_ERROR:
		printf("File format error!\n");   
		exit(1);
		break;
	}
}

int InitTag()
{
	BOOL finish=FALSE;
	BYTE id;
	short  llength;
	short  i,j,k;
	short  huftab1,huftab2;
	short  huftabindex;
	BYTE hf_table_index;
	BYTE qt_table_index;
	BYTE comnum;

	unsigned char  *lptemp;
	short  ccount;

	lp=lpJpegBuf+2;

	while (!finish)
	{
		id=*(lp+1);
		lp+=2;
		switch (id)
		{
		case M_APP0:
			llength=MAKEWORD(*(lp+1),*lp);
			lp+=llength;
			break;
		case M_DQT:
			llength=MAKEWORD(*(lp+1),*lp);
			qt_table_index=(*(lp+2))&0x0f;
			lptemp=lp+3;
			if(llength<80)
			{
				for(i=0;i<64;i++)
					qt_table[qt_table_index][i]=(short)*(lptemp++);
			}
			else
			{
				for(i=0;i<64;i++)
					qt_table[qt_table_index][i]=(short)*(lptemp++);
                qt_table_index=(*(lptemp++))&0x0f;
  				for(i=0;i<64;i++)
					qt_table[qt_table_index][i]=(short)*(lptemp++);
  			}
  			lp+=llength;		
			break;
		case M_SOF0:
	 		llength=MAKEWORD(*(lp+1),*lp);
	 		ImgHeight=MAKEWORD(*(lp+4),*(lp+3));
	 		ImgWidth=MAKEWORD(*(lp+6),*(lp+5));
            comp_num=*(lp+7);
		    if((comp_num!=1)&&(comp_num!=3))
	  			return FUNC_FORMAT_ERROR;
			if(comp_num==3)
			{
				comp_index[0]=*(lp+8);
	  			SampRate_Y_H=(*(lp+9))>>4;
	  			SampRate_Y_V=(*(lp+9))&0x0f;
	  			YQtTable=(short *)qt_table[*(lp+10)];

				comp_index[1]=*(lp+11);
				SampRate_U_H=(*(lp+12))>>4;
	  			SampRate_U_V=(*(lp+12))&0x0f;
	  			UQtTable=(short *)qt_table[*(lp+13)];

	  			comp_index[2]=*(lp+14);
	  			SampRate_V_H=(*(lp+15))>>4;
	  			SampRate_V_V=(*(lp+15))&0x0f;
				VQtTable=(short *)qt_table[*(lp+16)];
	  		}
			else
			{
	  			comp_index[0]=*(lp+8);
				SampRate_Y_H=(*(lp+9))>>4;
	  			SampRate_Y_V=(*(lp+9))&0x0f;
	  			YQtTable=(short *)qt_table[*(lp+10)];

				comp_index[1]=*(lp+8);
	  			SampRate_U_H=1;
	  			SampRate_U_V=1;
	  			UQtTable=(short *)qt_table[*(lp+10)];

				comp_index[2]=*(lp+8);
				SampRate_V_H=1;
	  			SampRate_V_V=1;
	  			VQtTable=(short *)qt_table[*(lp+10)];
			}
  			lp+=llength;						    
			break;
		case M_DHT:             
			llength=MAKEWORD(*(lp+1),*lp);
			if (llength<0xd0)
			{
				huftab1=(short)(*(lp+2))>>4;     //huftab1=0,1
		 		huftab2=(short)(*(lp+2))&0x0f;   //huftab2=0,1
				huftabindex=huftab1*2+huftab2;
		 		lptemp=lp+3;
				for (i=0; i<16; i++)
					code_len_table[huftabindex][i]=(short)(*(lptemp++));
				j=0;
				for (i=0; i<16; i++)
					if(code_len_table[huftabindex][i]!=0)
					{
						k=0;
						while(k<code_len_table[huftabindex][i])
						{
							code_value_table[huftabindex][k+j]=(short)(*(lptemp++));
							k++;
						}
						j+=k;	
					}
				i=0;
				while (code_len_table[huftabindex][i]==0)
		 			i++;
				for (j=0;j<i;j++)
				{
					huf_min_value[huftabindex][j]=0;
					huf_max_value[huftabindex][j]=0;
				}
				huf_min_value[huftabindex][i]=0;
				huf_max_value[huftabindex][i]=code_len_table[huftabindex][i]-1;
				for (j=i+1;j<16;j++)
				{
					huf_min_value[huftabindex][j]=(huf_max_value[huftabindex][j-1]+1)<<1;
					huf_max_value[huftabindex][j]=huf_min_value[huftabindex][j]+code_len_table[huftabindex][j]-1;
				}
				code_pos_table[huftabindex][0]=0;
				for (j=1;j<16;j++)
		  			code_pos_table[huftabindex][j]=code_len_table[huftabindex][j-1]+code_pos_table[huftabindex][j-1];
		  		lp+=llength;
			}  //if
			else
			{
	 			hf_table_index=*(lp+2);
				lp+=2;
				while (hf_table_index!=0xff)
				{
					huftab1=(short)hf_table_index>>4;     //huftab1=0,1
			 		huftab2=(short)hf_table_index&0x0f;   //huftab2=0,1
					huftabindex=huftab1*2+huftab2;
					lptemp=lp+1;
					ccount=0;
					for (i=0; i<16; i++)
					{
						code_len_table[huftabindex][i]=(short)(*(lptemp++));
						ccount+=code_len_table[huftabindex][i];
					}
					ccount+=17;	
					j=0;
					for (i=0; i<16; i++)
						if(code_len_table[huftabindex][i]!=0)
						{
							k=0;
							while(k<code_len_table[huftabindex][i])
							{
								code_value_table[huftabindex][k+j]=(short)(*(lptemp++));
								k++;
							}
							j+=k;
						}
					i=0;
					while (code_len_table[huftabindex][i]==0)
						i++;
					for (j=0;j<i;j++)
					{
						huf_min_value[huftabindex][j]=0;
						huf_max_value[huftabindex][j]=0;
					}
					huf_min_value[huftabindex][i]=0;
					huf_max_value[huftabindex][i]=code_len_table[huftabindex][i]-1;
					for (j=i+1;j<16;j++)
					{
						huf_min_value[huftabindex][j]=(huf_max_value[huftabindex][j-1]+1)<<1;
						huf_max_value[huftabindex][j]=huf_min_value[huftabindex][j]+code_len_table[huftabindex][j]-1;
					}
					code_pos_table[huftabindex][0]=0;
					for (j=1;j<16;j++)
						code_pos_table[huftabindex][j]=code_len_table[huftabindex][j-1]+code_pos_table[huftabindex][j-1];
					lp+=ccount;
					hf_table_index=*lp;
				}  //while
			}  //else
			break;
		case M_DRI:
			llength=MAKEWORD(*(lp+1),*lp);
			restart=MAKEWORD(*(lp+3),*(lp+2));
			lp+=llength;
			break;
		case M_SOS:
			llength=MAKEWORD(*(lp+1),*lp);
			comnum=*(lp+2);
			if(comnum!=comp_num)
				return FUNC_FORMAT_ERROR;
			lptemp=lp+3;
			for (i=0;i<comp_num;i++)
			{
				if(*lptemp==comp_index[0])
				{
					YDcIndex=(*(lptemp+1))>>4;   //Y
					YAcIndex=((*(lptemp+1))&0x0f)+2;
				}
				else{
					UVDcIndex=(*(lptemp+1))>>4;   //U,V
					UVAcIndex=((*(lptemp+1))&0x0f)+2;
				}
				lptemp+=2;
			}
			lp+=llength;
			finish=TRUE;
			break;
		case M_EOI:    
			return FUNC_FORMAT_ERROR;
			break;
		default:
 			if ((id&0xf0)!=0xd0)
			{
				llength=MAKEWORD(*(lp+1),*lp);
	 			lp+=llength;
			}
			else lp+=2;
			break;
  		}  //switch
	} //while
	return FUNC_OK;
}
/
void InitTable()
{
	short i,j;
	sizei=sizej=0;
	ImgWidth=ImgHeight=0;
	rrun=vvalue=0;
	BitPos=0;
	CurByte=0;
	IntervalFlag=FALSE;
	restart=0;
	for(i=0;i<3;i++)
		for(j=0;j<64;j++)
			qt_table[i][j]=0;
	comp_num=0;
	HufTabIndex=0;
	for(i=0;i<3;i++)
		comp_index[i]=0;
	for(i=0;i<4;i++)
		for(j=0;j<16;j++)
		{
			code_len_table[i][j]=0;
			code_pos_table[i][j]=0;
			huf_max_value[i][j]=0;
			huf_min_value[i][j]=0;
		}
	for(i=0;i<4;i++)
		for(j=0;j<256;j++)
			code_value_table[i][j]=0;
	
	for(i=0;i<10*64;i++)
	{
		MCUBuffer[i]=0;
		QtZzMCUBuffer[i]=0;
	}
	for(i=0;i<4*64;i++)
	{
		Y[i]=0;
		U[i]=0;
		V[i]=0;		
	}
	for(i=0;i<64;i++)
		BlockBuffer[i]=0;
	ycoef=ucoef=vcoef=0;
}
/
int Decode()
{
	int funcret;

	Y_in_MCU=SampRate_Y_H*SampRate_Y_V;
	U_in_MCU=SampRate_U_H*SampRate_U_V;
	V_in_MCU=SampRate_V_H*SampRate_V_V;
	H_YtoU=SampRate_Y_H/SampRate_U_H;
	V_YtoU=SampRate_Y_V/SampRate_U_V;
	H_YtoV=SampRate_Y_H/SampRate_V_H;
	V_YtoV=SampRate_Y_V/SampRate_V_V;
	Initialize_Fast_IDCT();
	while((funcret=DecodeMCUBlock())==FUNC_OK)
	{
		interval++;
		if((restart)&&(interval % restart==0))
			 IntervalFlag=TRUE;
		else
			IntervalFlag=FALSE;
		IQtIZzMCUComponent(0);
		IQtIZzMCUComponent(1);
		IQtIZzMCUComponent(2);
		GetYUV(0);
		GetYUV(1);
		GetYUV(2);
		StoreBuffer();
		sizej+=SampRate_Y_H*8;
		if(sizej>=ImgWidth)
		{
			sizej=0;
			sizei+=SampRate_Y_V*8;
		}
		if ((sizej==0)&&(sizei>=ImgHeight))
			break;
	}
	return funcret;
}
/
void  GetYUV(short flag)
{
	short	H,VV;
	short	i,j,k,h;
	int		*buf;
	int		*pQtZzMCU;

	switch(flag)
	{
	case 0:
		H=SampRate_Y_H;
		VV=SampRate_Y_V;
		buf=Y;
		pQtZzMCU=QtZzMCUBuffer;
		break;
	case 1:
		H=SampRate_U_H;
		VV=SampRate_U_V;
		buf=U;
		pQtZzMCU=QtZzMCUBuffer+Y_in_MCU*64;
		break;
	case 2:
		H=SampRate_V_H;
		VV=SampRate_V_V;
		buf=V;
		pQtZzMCU=QtZzMCUBuffer+(Y_in_MCU+U_in_MCU)*64;
		break;
	}
	for (i=0;i<VV;i++)
		for(j=0;j<H;j++)
			for(k=0;k<8;k++)
				for(h=0;h<8;h++)
					buf[(i*8+k)*SampRate_Y_H*8+j*8+h]=*pQtZzMCU++;
}
///
void StoreBuffer()
{
	short i,j;
	unsigned char  *lpbmp;
	unsigned char R,G,B;
	int y,u,v,rr,gg,bb;

	for(i=0;i<SampRate_Y_V*8;i++)
	{
		if((sizei+i)<ImgHeight)
		{
			lpbmp=((unsigned char *)lpPtr+(DWORD)(ImgHeight-sizei-i-1)*LineBytes+sizej*3);
			for(j=0;j<SampRate_Y_H*8;j++)
			{
				if((sizej+j)<ImgWidth)
				{
					y=Y[i*8*SampRate_Y_H+j];
					u=U[(i/V_YtoU)*8*SampRate_Y_H+j/H_YtoU];
					v=V[(i/V_YtoV)*8*SampRate_Y_H+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;
					R=(unsigned char)rr;
					G=(unsigned char)gg;
					B=(unsigned char)bb;
					if (rr&0xffffff00) if (rr>255) R=255; else if (rr<0) R=0;
					if (gg&0xffffff00) if (gg>255) G=255; else if (gg<0) G=0;
					if (bb&0xffffff00) if (bb>255) B=255; else if (bb<0) B=0;
					*lpbmp++=B;
					*lpbmp++=G;
					*lpbmp++=R;
				}
				else  break;
			}
		}
		else break;
	}
}
///
int 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<SampRate_Y_H*SampRate_Y_V;i++)  //Y
		{
			funcret=HufBlock(YDcIndex,YAcIndex);
			if (funcret!=FUNC_OK)
				return funcret;
			BlockBuffer[0]=BlockBuffer[0]+ycoef;
			ycoef=BlockBuffer[0];
			for (j=0;j<64;j++)
				*lpMCUBuffer++=BlockBuffer[j];
		}
		for (i=0;i<SampRate_U_H*SampRate_U_V;i++)  //U
		{
			funcret=HufBlock(UVDcIndex,UVAcIndex);
			if (funcret!=FUNC_OK)
				return funcret;
			BlockBuffer[0]=BlockBuffer[0]+ucoef;
			ucoef=BlockBuffer[0];
			for (j=0;j<64;j++)
				*lpMCUBuffer++=BlockBuffer[j];
		}
		for (i=0;i<SampRate_V_H*SampRate_V_V;i++)  //V
		{
			funcret=HufBlock(UVDcIndex,UVAcIndex);
			if (funcret!=FUNC_OK)
				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!=FUNC_OK)
			return funcret;
		BlockBuffer[0]=BlockBuffer[0]+ycoef;
		ycoef=BlockBuffer[0];
		for (j=0;j<64;j++)
			*lpMCUBuffer++=BlockBuffer[j];
		for (i=0;i<128;i++)
			*lpMCUBuffer++=0;
		break;
	default:
		return FUNC_FORMAT_ERROR;
	}
	return FUNC_OK;
}
//
int HufBlock(BYTE dchufindex,BYTE achufindex)
{
	short count=0;
	short i;
	int funcret;

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

	BlockBuffer[count++]=vvalue;
	//ac
	HufTabIndex=achufindex;
	while (count<64)
	{
		funcret=DecodeElement();
		if(funcret!=FUNC_OK)
			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 FUNC_OK;
}
//
int DecodeElement()
{
	int thiscode,tempcode;
	unsigned short 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 FUNC_FORMAT_ERROR;
	}  //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 FUNC_OK;
	}
	tempsize=runsize;
	if(BitPos>=runsize)
	{
		BitPos-=runsize;
		valueex=(BYTE)CurByte>>BitPos;
		CurByte=CurByte&And[BitPos];
	}
	else
	{
		valueex=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 FUNC_OK;
}
/
void IQtIZzMCUComponent(short flag)
{
	short H,VV;
	short i,j;
	int *pQtZzMCUBuffer;
	short  *pMCUBuffer;

	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*64;
		pQtZzMCUBuffer=QtZzMCUBuffer+Y_in_MCU*64;
		break;
	case 2:
		H=SampRate_V_H;
		VV=SampRate_V_V;
		pMCUBuffer=MCUBuffer+(Y_in_MCU+U_in_MCU)*64;
		pQtZzMCUBuffer=QtZzMCUBuffer+(Y_in_MCU+U_in_MCU)*64;
		break;
	}
	for(i=0;i<VV;i++)
		for (j=0;j<H;j++)
			IQtIZzBlock(pMCUBuffer+(i*H+j)*64,pQtZzMCUBuffer+(i*H+j)*64,flag);
}
//
void IQtIZzBlock(short  *s ,int * d,short flag)
{
	short i,j;
	short tag;
	short *pQt;
	int buffer2[8][8];
	int *buffer1;
	short offset;

	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);
	for(i=0;i<8;i++)
		for(j=0;j<8;j++)
			d[i*8+j]=buffer2[i][j]+offset;
}
///
void Fast_IDCT(int * block)
{
	short i;

	for (i=0; i<8; i++)
		idctrow(block+8*i);

	for (i=0; i<8; i++)
		idctcol(block+i);
}
///
BYTE  ReadByte()
{
	BYTE  i;

	i=*(lp++);
	if(i==0xff)
		lp++;
	BitPos=8;
	CurByte=i;
	return i;
}
///
void Initialize_Fast_IDCT()
{
	short i;

	iclp = iclip+512;
	for (i= -512; i<512; i++)
		iclp[i] = (i<-256) ? -256 : ((i>255) ? 255 : i);
}

void 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[0] = (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 idctcol(int * blk)
{
	int x0, x1, x2, x3, x4, x5, x6, x7, x8;
	//intcut
	if (!((x1 = (blk[8*4]<<8)) | (x2 = blk[8*6]) | (x3 = blk[8*2]) |
		(x4 = blk[8*1]) | (x5 = blk[8*7]) | (x6 = blk[8*5]) | (x7 = blk[8*3])))
	{
		blk[8*0]=blk[8*1]=blk[8*2]=blk[8*3]=blk[8*4]=blk[8*5]
			=blk[8*6]=blk[8*7]=iclp[(blk[8*0]+32)>>6];
		return;
	}
	x0 = (blk[8*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[8*0] = iclp[(x7+x1)>>14];
	blk[8*1] = iclp[(x3+x2)>>14];
	blk[8*2] = iclp[(x0+x4)>>14];
	blk[8*3] = iclp[(x8+x6)>>14];
	blk[8*4] = iclp[(x8-x6)>>14];
	blk[8*5] = iclp[(x0-x4)>>14];
	blk[8*6] = iclp[(x3-x2)>>14];
	blk[8*7] = iclp[(x7-x1)>>14];
}

main(   )   
{  
        LoadJpegFile("test.jpg");    
}


xiaolomg
关注
专栏目录
将JPEG格式转化为BMP格式
03-16
此资源将JPEG格式的图片转化为BMP格式，首先进行解码，然后对其进行Bmp格式编码
libjpeg库的示例工程，实现Jpeg转Bmp
01-19
“libjpeg库的示例工程，实现Jpeg转Bmp”这个标题表明，这是一个关于图像处理的项目，具体来说是利用libjpeg库将JPEG格式的图像转换成BMP格式的图像。libjpeg是一个开源的、用于读取、修改和写入JPEG图像的库，而...
jpeg转为bmp
zimu2702的专栏
12-08 1147
#include #include #include #include #include "bmp.h" #include "jpeg-8b/jpeglib.h" #include #pragma comment( lib , "jpeg-8b/libjpeg.lib" ) char * jpgFileName = "input.jpg"; char * bmp
使用jpeglib库实现bmp转jpg
Welcom to zougangx's blog
10-11 989
一、vc编译jpeglib库 1、下载源代码 下载地址：http://www.ijg.org/。注意：一定要下载win32 版本 2、编译源代码.     A、解压源代码，修改源代码中jconfig.vc为jconfig.h；     B、添加环境变量PATH，C:/Program Files/Microsoft Visual Studio/VC98/
jpg转bmp（使用libjpeg）
tanqiuwei的专栏
08-14 4974
jpg转bmp（使用libjpeg） 　　还是关于图像格式上的东西。使用了libjpeg库将jpeg图像转换到bmp格式。解压原理还是相对复杂的，将来有机会说不定会详细介绍。这里只是库的使用而已。 　　首先需要下载libjpeg库，网址在这里：http://www.ijg.org/ 　　然后需要配置环境，我是在windows下用vs2010搞的，编译库可以参考这篇文章。编译出jpeg
BMP图像处理（jpeg转bmp，以及bmp图片缩放，附代码）
最新发布
bigger_belief的博客
04-26 2764
BMP图像处理（jpeg转bmp，以及bmp图片缩放，附代码）
jpeg-src.rar_JPEG 转 BMP_jpeg_jpeg bmp_jpeg2bmp_jpg
09-24
本文将深入探讨JPEG转BMP的过程，以及相关的编程知识。 JPEG（Joint Photographic Experts Group）是一种有损压缩的图像文件格式，广泛应用于网络和数字摄影。它通过去除图像中的冗余信息来实现压缩，但可能会导致...
jpeg转bmp位图源码
01-31
本文将深入探讨如何使用C语言和libjpeg库在Linux系统上实现JPEG图像转换为BMP图像的过程，即“jpeg转bmp”。 首先，让我们了解JPEG和BMP这两种图像格式的基本知识。JPEG（Joint Photographic Experts Group）是一种...
jpeg转bmp格式
11-24
本文将深入探讨如何使用C语言实现从JPEG格式转换为BMP格式的过程，这在嵌入式系统和网络传输中尤其重要。 首先，我们要理解JPEG和BMP这两种图片格式。JPEG（Joint Photographic Experts Group）是一种广泛使用的...
Jpeg_Decompress.rar_JPEG 转 BMP_bmp转jpg的c代码_jpeg decompress_site:
09-14
标题中的“Jpeg_Decompress.rar”是一个压缩文件，其中包含了一个名为“Jpeg_Decompress.c”的C源代码文件，这个源代码是用于处理JPEG图像格式与BMP图像格式转换的。JPEG（Joint Photographic Experts Group）是一种...
jpeg内存转bmp文件
04-28
Linux下将usb摄像头（mjpg格式）内存中解压为灰度rgb格式，同时保存为bmp格式文件，以查看输出图像是否正确。C语言源码，仅供参考。
jpeg2000格式转换成bmp格式_c语言源码
05-05
jpeg2000格式转换成bmp格式_c语言源码
图像压缩算法JPEG源代码实现（C语言）
06-16
用C/C++语言实现了JPEG图像压缩算法
对于JPEG图片的数字水印提取程序
04-18
能够对嵌入水印信息的JPEG图片进行水印的提取 有没有用处 大家可以一起来鉴定一下 呵呵 //函数声明 void InitTable(); int InitTag(); int DecodeMCUBlock(); void IQtIZzBlock(LONG *s); void IZzBlock(LONG *s); int HufBlock(BYTE dchufindex,BYTE achufindex); int DecodeElement(); BYTE ReadByte(); int WaterMarkExtractDecode(); void IQtIZzMCUComponent(short flag); void IZzMCUComponent(short flag); void RubostWaterMarkExtractMCUComponent(short flag); void FragileWaterMarkExtractMCUComponent(short flag); void RubostWaterMarkExtractBlock(LONG * d); void FragileWaterMarkExtractBlock(LONG * d);
BMP与JPG互换函数
RENYUAN
07-14 1120
function Bmp2Jpg(Bmp: TBitmap; Quality: Integer = 100): TJpegImage;begin  Result := nil;  if Assigned(Bmp)  then begin    Result := TJpegImage.Create;    Result.Assign(Bmp); {Its all folks...}    Resu
windows 批量 jpg 转 bmp 方法
perthblank
01-29 1515
前段时间遇到一个需求是把一堆 jpg 转化为 bmp 想来这种问题从来都是秒做结果找了半天竟然找不到一个好用的工具（一定是打开的方法不对）。 队友大喝我要手撸！ 最后找到了这个工具 Easy2Convert/ 虽然本身也是单次转化，但可以直接用 cmd 传参数 jpg2bmp.exe -i -o 这就可以批量转了啊。先把程序目录加到环境变量里面，然后写
jpg 转bmp
qq_33760835的博客
11-08 398
jpg 转bmp //jenc.cpp /* 这是一个简单的jpeg编码程序，支持1：1：1采样的baseline彩色jpeg，输入只能是24bit的BMP文件 代码结构只求能说明各步骤过程，并不做特别的优化，效率较为一般。jpeg的色彩是采用YCrCb模式 的，所以从BMP到jpeg要经过YUV的转换。 */ #include "jenc.h" // 存放VLI表 BYTE VLI_TA...
Jpeg文件格式转换成bmp文件格式
一个码农的足迹
09-24 1310
Jpeg文件格式转换成bmp文件格式 为了简单，我将jpg图片原文件和转换后的bmp文件都直接存到内存的数组，这样不会涉及文件操作。 将jpg文件转换成数组，并将数组存到文件中方便编译调用，我用的是C库文件操作接口，也可以用其他文件系统。 //读文件 int FILE_Read(FILE*fd, const void*buf, int len) { #defi
CImage实现jpeg到bmp内存图像转换
Augusdi的专栏
03-16 3666
不需要CxImage这样的第三方扩展库微软的GDI+也可以转换的CImage mmage; HWND hWnd = ::GetDesktopWindow();//获得屏幕的HWND. HDC hScreenDC = ::GetDC(hWnd); //获得屏幕的HDC. HDC MemDC = ::CreateCompatible
C语言实现JPEG到24位BMP转换
"JPEG解压缩成BMP" 在计算机图形处理领域，JPEG（Joint Photographic Experts Group）是一种广泛使用的有损图像压缩标准，而BMP（Bitmap）则是Windows操作系统中的位图文件格式。本资源主要讲解如何利用C语言实现...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值