简单的JPEG解码程序

最新推荐文章于 2024-04-24 22:03:20 发布

lpt19832003

最新推荐文章于 2024-04-24 22:03:20 发布

阅读量1.2w

点赞数

分类专栏： windows编程文章标签： table byte qt file buffer null

windows编程专栏收录该内容

14 篇文章 0 订阅

订阅专栏

// simplejpeg.cpp : Defines the entry point for the console application.
//
//header file
//#include "bmp.h"

//*************************************************************************************
//#include "jpeg.h"
#pragma pack(1)
#define M_SOF0 0xc0
#define M_DHT   0xc4
#define M_EOI   0xd9
#define M_SOS   0xda
#define M_DQT   0xdb
#define M_DRI   0xdd
#define M_APP0 0xe0

static int Zig_Zag[8][8]={{0,1,5,6,14,15,27,28},
        {2,4,7,13,16,26,29,42},
        {3,8,12,17,25,30,41,43},
        {9,11,18,24,37,40,44,53},
        {10,19,23,32,39,45,52,54},
        {20,22,33,38,46,51,55,60},
        {21,34,37,47,50,56,59,61},
        {35,36,48,49,57,58,62,63}
       };

#define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */
#define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */
#define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */
#define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */
#define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */
#define W7 565 /* 2048*sqrt(2)*cos(7*pi/16) */

//*************************************************************************************
typedef char CHAR;
typedef short SHORT;
typedef long LONG;

typedef unsigned long       DWORD;
typedef int                 BOOL;
typedef unsigned char       BYTE;
typedef unsigned short      WORD;

typedef int HFILE;
typedef CHAR *LPSTR, *PSTR;

#define FALSE 0
#define TRUE 1

typedef struct tagBITMAPINFOHEADER{
        DWORD      biSize;
        LONG       biWidth;
        LONG       biHeight;
        WORD       biPlanes;
        WORD       biBitCount;
        DWORD      biCompression;
        DWORD      biSizeImage;
        LONG       biXPelsPerMeter;
        LONG       biYPelsPerMeter;
        DWORD      biClrUsed;
        DWORD      biClrImportant;
} BITMAPINFOHEADER, * LPBITMAPINFOHEADER,*PBITMAPINFOHEADER;

typedef struct tagBITMAPFILEHEADER {
        WORD    bfType;
        DWORD   bfSize;
        WORD    bfReserved1;
        WORD    bfReserved2;
        DWORD   bfOffBits;
} BITMAPFILEHEADER, * LPBITMAPFILEHEADER,*PBITMAPFILEHEADER;

/* constants for the biCompression field */
#define BI_RGB        0L
#define BI_RLE8       1L
#define BI_RLE4       2L
#define BI_BITFIELDS 3L

typedef struct tagRGBQUAD {
        BYTE    rgbBlue;
        BYTE    rgbGreen;
        BYTE    rgbRed;
        BYTE    rgbReserved;
} RGBQUAD;
typedef RGBQUAD * LPRGBQUAD;

#define MAKEWORD(a, b)      ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8))
#define MAKELONG(a, b)      ((LONG)(((WORD)(a)) | ((DWORD)((WORD)(b))) << 16))
#define LOWORD(l)           ((WORD)(l))
#define HIWORD(l)           ((WORD)(((DWORD)(l) >> 16) & 0xFFFF))
#define LOBYTE(w)           ((BYTE)(w))
#define HIBYTE(w)           ((BYTE)(((WORD)(w) >> 8) & 0xFF))

//---yk--- add

#include "memory.h"
#include "math.h"
#include "stdio.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(BYTE dchufindex,BYTE 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;
//HPALETTE           hPalette=NULL;
//HBITMAP            hBitmap=NULL;
char *            hImgData=NULL;
DWORD              NumColors;
DWORD              LineBytes;
DWORD              ImgWidth=0 , ImgHeight=0;
char*             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;

BOOL LoadJpegFile (char *JpegFileName)
{
FILE*      hfjpg;
DWORD          ImgSize;
DWORD              BufSize,JpegBufSize;
FILE*              hfbmp;
FILE*              IMGdata;
void *      hJpegBuf;
int       funcret;
DWORD i;
LPBITMAPINFOHEADER lpImgData;

char * hImgData256;

if((hfjpg=fopen(JpegFileName,"rb"))==NULL)
{
showerror(FUNC_FILE_ERROR);
return FALSE;
}
/*SEEK_CUR
Current position of file pointer.
SEEK_END
End of file.
SEEK_SET
Beginning of file.*/

//get jpg file length
fseek(hfjpg,0L,SEEK_END);
JpegBufSize=ftell(hfjpg);
//rewind to the beginning of the file
fseek(hfjpg,0L,SEEK_SET);

if((hJpegBuf=malloc(JpegBufSize))==NULL)
{
  fclose(hfjpg);
  showerror(FUNC_MEMORY_ERROR);

  return FALSE;
}
lpJpegBuf=(unsigned char *)hJpegBuf;
fread((unsigned char *)hJpegBuf,sizeof( char ),JpegBufSize,hfjpg);
fclose(hfjpg);

InitTable();

if((funcret=InitTag())!=FUNC_OK)
{
// GlobalUnlock(hJpegBuf);
  free(hJpegBuf);
  showerror(funcret);
  return FALSE;
}
//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;
printf("bi.biWidth is %ld/n",bi.biWidth);
printf("bi.biBitCount is %ld/n",bi.biBitCount);
LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
printf("LineBytes is %ld/n",LineBytes);
ImgSize=(DWORD)LineBytes*bi.biHeight;//???????
printf("size is %ld/n",ImgSize);
bf.bfType=0x4d42;
int a= sizeof(BITMAPFILEHEADER);
int b= sizeof(BITMAPINFOHEADER);
//注意字节对齐问题!!!!!!!!!!!!!!!!!!!!!!!!1
//如果没有#pragma pack(1)，a是16~~~~~~~
int c=NumColors*sizeof(RGBQUAD);

bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
bf.bfOffBits=54;//(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
// printf("size is %ld/n",BufSize);
if((hImgData=(char*)malloc(BufSize))==NULL)
{
  //GlobalUnlock(hJpegBuf);
  free(hJpegBuf);
  showerror(FUNC_MEMORY_ERROR);
  showerror(FUNC_MEMORY_ERROR);
  return FALSE;
}
// lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
lpImgData=(LPBITMAPINFOHEADER)hImgData;
memcpy(lpImgData,(char *)&bi,sizeof(BITMAPINFOHEADER));
lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);

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

funcret=Decode();
if(funcret==FUNC_OK)
{
  //hDc=GetDC(hWnd);
/*  hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
      (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
         (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
*/
// hfbmp=fopen("c://jpeg2-bmp.bmp","Wb");

  if((hfbmp=fopen("jpeg2-bmp.bmp","wb"))==NULL)
  {
   showerror(FUNC_FILE_ERROR);
   return FALSE;
  }

// hfbmp=fopen("c://jpeg2-bmp.bmp","Wb");

fwrite((LPSTR)&bf,sizeof(BITMAPFILEHEADER),1,hfbmp);
fwrite((LPSTR)lpImgData,sizeof(char),BufSize,hfbmp);

  if((IMGdata=fopen("111.txt","wb"))==NULL)
  {
   showerror(FUNC_FILE_ERROR);
   return FALSE;
  }
  DWORD xx = ImgWidth*ImgHeight;
  if(( hImgData256=(char *)malloc(xx))==NULL)
  {
   //GlobalUnlock(hJpegBuf);
   free(hImgData256);
   showerror(FUNC_MEMORY_ERROR);
   showerror(FUNC_MEMORY_ERROR);
   showerror(FUNC_MEMORY_ERROR);
   return FALSE;
  }

  char * temp=hImgData256;
  for(i=0; i < xx; i++)
  {
   i;
   char t3=*lpPtr;
   t3 &= 0xE0;
   char t1=*(lpPtr+1);
   t1 = t1>>3;
   t1 &= 0x1c;
   char t2=*(lpPtr+2);
   t2=t2>>6;
   t2 &= 0x03;
   char t4 = t3 + t1 + t2 ;
   *temp++=t4;
   lpPtr=lpPtr+ 3;
   //不能使用temp+=3;
  }
  int count=fwrite(hImgData256,sizeof(char),xx,IMGdata);
  //free((void*)hImgData256);
  fclose(IMGdata);

  fclose(hfbmp);

//  ReleaseDC(hWnd,hDc);
//  GlobalUnlock(hJpegBuf);
  free(hJpegBuf);
  //GlobalUnlock(hImgData);
  return TRUE;
}
else
{
  //GlobalUnlock(hJpegBuf);
  free(hJpegBuf);
// GlobalUnlock(hImgData);
  free(hImgData);
  hImgData=NULL;
  showerror(funcret);
  return FALSE;
}
}
/
void showerror(int funcret)
{
switch(funcret)
{
case FUNC_MEMORY_ERROR:
    printf("Error alloc memory/n!");
  break;
case FUNC_FILE_ERROR:
    printf("File not found!/n");
  break;
case FUNC_FORMAT_ERROR:
  printf("File format error!/n");
  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<64;i++){
  Y[i]=0;
  U[i]=0;
  V[i]=0;
  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];
}

int main()
{
LoadJpegFile("test.jpg");
return 0;
}

lpt19832003

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
3
评论
简单的JPEG解码程序

// simplejpeg.cpp : Defines the entry point for the console application.////header file//#include "bmp.h"//*************************************************************************************//#inc
复制链接

扫一扫