开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
compress.c
资源名称：VC++_image_Code.zip　[点击查看]
上传用户：s6549606
上传日期：2015-11-11
资源大小：12002k
文件大小：31k
源码类别：

图形图像处理

开发平台：

Visual C++

compress.c：源码内容
  1. //////////////////////////////////////////////////////////////
  2. //Name:compress.c
  3. //Purpose: Run length algorithm and Jpeg decoding
  4. //Author: phoenix, CS, TshingHua, Beijing, P.R.C.
  5. //Email: bjlufengjun@www.163.net or lufengjun@hotmail.com
  6. //Date:April 3, 1998
  8. //header file
  9. #include "bmp.h"
  10. #include "jpeg.h"
  11. #include "memory.h"
  12. #include "math.h"
  13. #include "stdio.h"
  14. //macro definition
  15. #define WIDTHBYTES(i)    ((i+31)/32*4)
  16. #define PI 3.1415926535
  17. //define return value of function
  18. #define FUNC_OK 0
  19. #define FUNC_MEMORY_ERROR 1
  20. #define FUNC_FILE_ERROR 2
  21. #define FUNC_FORMAT_ERROR 3
  23. //function declaration
  24. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  25. LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM);
  26. BOOL LoadPcxFile(HWND hWnd,char *BmpFileName);
  27. void ReadPcxLine(unsigned char *p,FILE *fp);
  28. //////////////////////////////////////////////////
  29. //Jpeg functions
  30. BOOL LoadJpegFile(HWND hWnd,char *BmpFileName);
  31. void showerror(int funcret);
  32. int  InitTag();
  33. void InitTable();
  34. int  Decode();
  35. int  DecodeMCUBlock();
  36. int  HufBlock(BYTE dchufindex,BYTE achufindex);
  37. int  DecodeElement();
  38. void IQtIZzMCUComponent(short flag);
  39. void IQtIZzBlock(short  *s ,int * d,short flag);
  40. void GetYUV(short flag);
  41. void StoreBuffer();
  42. BYTE ReadByte();
  43. void Initialize_Fast_IDCT();
  44. void Fast_IDCT(int * block);
  45. void idctrow(int * blk);
  46. void idctcol(int * blk);
  47. //////////////////////////////////////////////////
  48. //global variable declaration
  49. BITMAPFILEHEADER   bf;
  50. BITMAPINFOHEADER   bi;
  51. HPALETTE           hPalette=NULL;
  52. HBITMAP            hBitmap=NULL;
  53. HGLOBAL            hImgData=NULL;
  54. DWORD              NumColors;
  55. DWORD              LineBytes;
  56. DWORD              ImgWidth=0 , ImgHeight=0;
  57. unsigned int       PcxBytesPerLine;
  58. LPSTR              lpPtr;
  59. //////////////////////////////////////////////////
  60. //variables used in jpeg function
  61. short SampRate_Y_H,SampRate_Y_V;
  62. short SampRate_U_H,SampRate_U_V;
  63. short SampRate_V_H,SampRate_V_V;
  64. short H_YtoU,V_YtoU,H_YtoV,V_YtoV;
  65. short Y_in_MCU,U_in_MCU,V_in_MCU;
  66. unsigned char   *lpJpegBuf;
  67. unsigned char   *lp;
  68. short qt_table[3][64];
  69. short comp_num;
  70. BYTE comp_index[3];
  71. BYTE     YDcIndex,YAcIndex,UVDcIndex,UVAcIndex;
  72. BYTE HufTabIndex;
  73. short     *YQtTable,*UQtTable,*VQtTable;
  74. BYTE And[9]={0,1,3,7,0xf,0x1f,0x3f,0x7f,0xff};
  75. short     code_pos_table[4][16],code_len_table[4][16];
  76. unsigned short code_value_table[4][256];
  77. unsigned short huf_max_value[4][16],huf_min_value[4][16];
  78. short BitPos,CurByte;
  79. short rrun,vvalue;
  80. short MCUBuffer[10*64];
  81. int QtZzMCUBuffer[10*64];
  82. short BlockBuffer[64];
  83. short ycoef,ucoef,vcoef;
  84. BOOL IntervalFlag;
  85. short interval=0;
  86. int Y[4*64],U[4*64],V[4*64];
  87. DWORD     sizei,sizej;
  88. short  restart;
  89. static  long iclip[1024];
  90. static  long *iclp;
  91. ///////////////////////////////////////////////////////////
  92. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  93.     LPSTR lpszCmdLine, int nCmdShow)
  94. {
  95. MSG       msg;
  96. WNDCLASS  wndclass;
  97. HWND      hWnd;
  99. if ( ! hPrevInstance ){
  100. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  101. wndclass.lpfnWndProc = MainWndProc;
  102. wndclass.cbClsExtra = 0;
  103. wndclass.cbWndExtra = 0;
  104. wndclass.hInstance = hInstance;
  105. wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  106. wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  107. wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  108. wndclass.lpszMenuName =  "BMPMENU";
  109. wndclass.lpszClassName = "phoenix ip system";
  110.     }
  112.     if ( ! RegisterClass (&wndclass) )
  113.     return FALSE;
  115. hWnd = CreateWindow ("phoenix ip system","Run length algorithm and Jpeg decoding",
  116.  WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
  117.  CW_USEDEFAULT, CW_USEDEFAULT, NULL,NULL,
  118.  hInstance, NULL);
  119. if (!hWnd)
  120. return FALSE;
  121. ShowWindow (hWnd, SW_SHOWMAXIMIZED);
  122. UpdateWindow (hWnd);
  124. while ( GetMessage (&msg, NULL, 0, 0) ){
  125. TranslateMessage (&msg);
  126. DispatchMessage (&msg);
  127.     }
  128. return msg.wParam;
  129. }
  130. ////////////////////////////////////////////////////////////////
  131. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)
  132. {
  133.     static  HDC    hDC,hMemDC;
  134.     PAINTSTRUCT    ps;
  136.     switch (message){
  137.     case WM_PAINT:
  138. {         
  139. hDC = BeginPaint(hWnd, &ps);
  140. if (hBitmap)
  141. { 
  142. hMemDC = CreateCompatibleDC(hDC);
  143. if (hPalette)
  144. {           
  145. SelectPalette (hDC, hPalette, FALSE); 
  146. SelectPalette (hMemDC, hPalette, FALSE);
  147. RealizePalette (hDC);
  148. }   
  149. SelectObject(hMemDC, hBitmap); 
  150. BitBlt(hDC, 0, 0, ImgWidth,ImgHeight, hMemDC, 0, 0, SRCCOPY);
  151. DeleteDC(hMemDC);
  152. }
  153. EndPaint(hWnd, &ps);
  154. break;
  155. }
  156. case WM_DESTROY: //注意释放内存和位图，调色板句柄
  157.         if(hBitmap!=NULL)
  158.         DeleteObject(hBitmap);
  159.     
  160. if(hPalette!=NULL)                     
  161.         DeleteObject(hPalette);
  163. if(hImgData!=NULL){
  164. GlobalUnlock(hImgData);
  165. GlobalFree(hImgData);
  166. }         
  167.     PostQuitMessage (0);
  168.     return 0;
  169. case WM_COMMAND:
  170.     switch (wParam){
  171. case IDM_RUNLENGTH:
  172. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  173.         if(hBitmap!=NULL){     
  174. DeleteObject(hBitmap);
  175.             hBitmap=NULL;
  176.         }
  177.         if(hPalette!=NULL){                     
  178. DeleteObject(hPalette);
  179.             hPalette=NULL;
  180.         }
  181. if(hImgData!=NULL){
  182. GlobalUnlock(hImgData);
  183. GlobalFree(hImgData);  
  184. hImgData=NULL;
  185. }         
  186. if(LoadPcxFile(hWnd,"c:\test.pcx")) //成功，则重画窗口
  187.                 InvalidateRect(hWnd,NULL,TRUE);
  188.         break;
  189. case IDM_JPEG:
  190. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  191.         if(hBitmap!=NULL){     
  192. DeleteObject(hBitmap);
  193.             hBitmap=NULL;
  194.         }
  195.         if(hPalette!=NULL){                     
  196. DeleteObject(hPalette);
  197.             hPalette=NULL;
  198.         }
  199. if(hImgData!=NULL){
  200. GlobalUnlock(hImgData);
  201. GlobalFree(hImgData);  
  202. hImgData=NULL;
  203. }         
  204. if(LoadJpegFile(hWnd,"c:\test.jpg")) //成功，则重画窗口
  205.                 InvalidateRect(hWnd,NULL,TRUE);
  206.         break;
  207. case IDM_EXIT:
  208.         SendMessage(hWnd,WM_DESTROY,0,0L);
  209.         break;
  210.     }
  211. break;                
  212.     }
  213.     return DefWindowProc (hWnd, message, wParam, lParam);
  214. }
  215. ////////////////////////////////////////////////////////////////
  216. BOOL LoadPcxFile (HWND hWnd,char *PcxFileName)
  217. {   
  218. //pcx header
  219. typedef struct{
  220.  char manufacturer;
  221.  char version;
  222.  char encoding;
  223.  char bits_per_pixel;
  224.  WORD xmin,ymin;
  225.  WORD xmax,ymax;
  226.  WORD hres;
  227.  WORD vres;
  228.  char palette[48];
  229.  char reserved;
  230.  char colour_planes;
  231.  WORD bytes_per_line;
  232.  WORD palette_type;
  233.  char filler[58];
  234.       } PCXHEAD;
  235. FILE               *PCXfp;
  236. PCXHEAD    header;
  237.     LOGPALETTE         *pPal;
  238.     HPALETTE           hPrevPalette; 
  239.     HDC                hDc;
  240. HLOCAL             hPal;
  241. DWORD         ImgSize;
  242. DWORD              BufSize;
  243. LPBITMAPINFOHEADER lpImgData;
  244. DWORD              i;
  245. LONG               x,y;
  246. int                PcxTag;
  247. unsigned char      LineBuffer[6400];
  248. LPSTR              lpPtr;
  249. HFILE              hfbmp;
  251.     if((PCXfp=fopen(PcxFileName,"rb"))==NULL){
  252.         MessageBox(hWnd,"File c:\test.pcx not found!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  253.         return FALSE;
  254. }
  255.     fread((char*)&header,1,sizeof(PCXHEAD),PCXfp);
  256.     if(header.manufacturer!=0x0a){
  257.     MessageBox(hWnd,"Not a valid Pcx file!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  258.     fclose(PCXfp);
  259.     return FALSE;
  260. }
  261. fseek(PCXfp,-769L,SEEK_END);
  262. PcxTag=fgetc(PCXfp)&0xff;
  263. if(PcxTag!=12){
  264.     MessageBox(hWnd,"Not a 256 colors Pcx file!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  265. fclose(PCXfp);
  266. return FALSE;
  267. }
  268. //create new bitmapfileheader and bitmapinfoheader
  269. memset((char *)&bf,0,sizeof(BITMAPFILEHEADER));
  270. memset((char *)&bi,0,sizeof(BITMAPINFOHEADER));
  272. bi.biSize=sizeof(BITMAPINFOHEADER);
  273. bi.biWidth=header.xmax-header.xmin+1;
  274. bi.biHeight=header.ymax-header.ymin+1;
  275. bi.biPlanes=1;
  276. bi.biBitCount=8;
  277. bi.biCompression=BI_RGB;
  278. ImgWidth=bi.biWidth;
  279. ImgHeight=bi.biHeight;
  280. NumColors=256;
  281. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  282. ImgSize=(DWORD)LineBytes*bi.biHeight;
  284. bf.bfType=0x4d42;
  285. bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  286. bf.bfOffBits=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
  287. if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)+
  288.      NumColors*sizeof(RGBQUAD)+ImgSize)))==NULL)
  289. {
  290.      MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|
  291.                    MB_ICONEXCLAMATION);
  292.     fclose(PCXfp);
  293. return FALSE;
  294. }
  295. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  296. memcpy(lpImgData,(char *)&bi,sizeof(BITMAPINFOHEADER));
  297. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  299.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  300.     pPal =(LOGPALETTE *)LocalLock(hPal);
  301.     pPal->palNumEntries =256;
  302. pPal->palVersion    = 0x300;
  303. for (i = 0; i < 256; i++) {
  304.     pPal->palPalEntry[i].peRed=(BYTE)fgetc(PCXfp);
  305. pPal->palPalEntry[i].peGreen=(BYTE)fgetc(PCXfp);
  306. pPal->palPalEntry[i].peBlue=(BYTE)fgetc(PCXfp);
  307. pPal->palPalEntry[i].peFlags=(BYTE)0;
  308. *(lpPtr++)=(unsigned char)pPal->palPalEntry[i].peBlue;
  309. *(lpPtr++)=(unsigned char)pPal->palPalEntry[i].peGreen;
  310. *(lpPtr++)=(unsigned char)pPal->palPalEntry[i].peRed;
  311. *(lpPtr++)=0;
  312. }
  313. hPalette=CreatePalette(pPal);
  314. LocalUnlock(hPal);
  315. LocalFree(hPal);
  317. hDc=GetDC(hWnd);
  318. if(hPalette){
  319.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  320. RealizePalette(hDc);
  321. }
  322. PcxBytesPerLine=(unsigned int)header.bytes_per_line;
  323. fseek(PCXfp,(LONG)sizeof(PCXHEAD),SEEK_SET);
  324. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  326. for(y=0;y<bi.biHeight;y++){
  327. lpPtr=(char *)lpImgData+BufSize-LineBytes-y*LineBytes;
  328. ReadPcxLine(LineBuffer,PCXfp);
  329. for(x=0;x<bi.biWidth;x++)
  330. *(lpPtr++)=LineBuffer[x];
  331. }
  333. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  334. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  335.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  337. if(hPalette && hPrevPalette){
  338. SelectPalette(hDc,hPrevPalette,FALSE);
  339. RealizePalette(hDc);
  340. }
  342. hfbmp=_lcreat("c:\pcx2bmp.bmp",0);
  344. _lwrite(hfbmp,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  345. _lwrite(hfbmp,(LPSTR)lpImgData,BufSize);
  346. _lclose(hfbmp);
  348. fclose(PCXfp); 
  349. ReleaseDC(hWnd,hDc);
  350. GlobalUnlock(hImgData);
  351. return TRUE; 
  352. }
  353. ////////////////////////////////////////////////////////////////
  354. void ReadPcxLine(unsigned char *p,FILE *fp) //decode one line of pcx file
  355. {
  356. unsigned int n=0,i;
  357. char c;
  359. memset(p,0,PcxBytesPerLine);
  360. do{
  361. //get a key byte
  362. c=fgetc(fp)&0xff;
  363. //if it's a run of BytePerLine field
  364. if((c&0xc0)==0xc0){
  365. //mask off the high bits
  366. i=c&0x3f;
  367. //get the run byte
  368. c=fgetc(fp);
  369. //run the byte  
  370. while(i--) p[n++]=c;
  371. }
  372. else p[n++]=c;
  373. }while (n<PcxBytesPerLine);
  374. }
  375. ////////////////////////////////////////////////////////////////
  376. BOOL LoadJpegFile (HWND hWnd,char *JpegFileName)
  377. {
  378. HFILE    hfjpg;
  379.     HDC                hDc;
  380. DWORD         ImgSize;
  381. DWORD              BufSize,JpegBufSize;
  382. HFILE              hfbmp;
  383. HGLOBAL    hJpegBuf;
  384. int    funcret;
  385. LPBITMAPINFOHEADER lpImgData;
  387. if((hfjpg=_lopen(JpegFileName,OF_READ))==HFILE_ERROR){
  388. showerror(FUNC_FILE_ERROR);
  389. return FALSE;
  390. }
  391. //get jpg file length
  392. JpegBufSize=_llseek(hfjpg,0L,SEEK_END);
  393. //rewind to the beginning of the file
  394. _llseek(hfjpg,0L,SEEK_SET);
  396. if((hJpegBuf=GlobalAlloc(GHND,JpegBufSize))==NULL){
  397. _lclose(hfjpg);
  398. showerror(FUNC_MEMORY_ERROR);
  399. return FALSE;
  400. }
  401. lpJpegBuf=(unsigned char  *)GlobalLock(hJpegBuf);
  402. _hread(hfjpg,(unsigned char  *)lpJpegBuf,JpegBufSize);
  403. _lclose(hfjpg);
  405. InitTable();
  407. if((funcret=InitTag())!=FUNC_OK){
  408. GlobalUnlock(hJpegBuf);
  409. GlobalFree(hJpegBuf);
  410. showerror(funcret);
  411. return FALSE;
  412. }
  413. //create new bitmapfileheader and bitmapinfoheader
  414. memset((char *)&bf,0,sizeof(BITMAPFILEHEADER));
  415. memset((char *)&bi,0,sizeof(BITMAPINFOHEADER));
  417. bi.biSize=(DWORD)sizeof(BITMAPINFOHEADER);
  418. bi.biWidth=(LONG)(ImgWidth);
  419. bi.biHeight=(LONG)(ImgHeight);
  420. bi.biPlanes=1;
  421. bi.biBitCount=24;
  422. bi.biClrUsed=0;
  423. bi.biClrImportant=0;
  424. bi.biCompression=BI_RGB;
  425. NumColors=0;
  426. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  427. ImgSize=(DWORD)LineBytes*bi.biHeight;
  429. bf.bfType=0x4d42;
  430. bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  431. bf.bfOffBits=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
  432. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  434. if((hImgData=GlobalAlloc(GHND,BufSize))==NULL){
  435. GlobalUnlock(hJpegBuf);
  436. GlobalFree(hJpegBuf);
  437. showerror(FUNC_MEMORY_ERROR);
  438. return FALSE;
  439. }
  440. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  441. memcpy(lpImgData,(char *)&bi,sizeof(BITMAPINFOHEADER));
  442. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  444. if((SampRate_Y_H==0)||(SampRate_Y_V==0)){
  445. GlobalUnlock(hJpegBuf);
  446. GlobalFree(hJpegBuf);
  447. GlobalUnlock(hImgData);
  448. GlobalFree(hImgData);
  449. hImgData=NULL;
  450. showerror(FUNC_FORMAT_ERROR);
  451. return FALSE ;
  452. }
  454. funcret=Decode();
  455. if(funcret==FUNC_OK){
  456. hDc=GetDC(hWnd);
  457. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  458. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  459.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  461. hfbmp=_lcreat("c:\jpeg2bmp.bmp",0);
  462. _lwrite(hfbmp,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  463. _lwrite(hfbmp,(LPSTR)lpImgData,BufSize);
  464. _lclose(hfbmp);
  465. ReleaseDC(hWnd,hDc);
  466. GlobalUnlock(hJpegBuf);
  467. GlobalFree(hJpegBuf);
  468. GlobalUnlock(hImgData);
  469. return TRUE;
  470. }
  471. else{
  472. GlobalUnlock(hJpegBuf);
  473. GlobalFree(hJpegBuf);
  474. GlobalUnlock(hImgData);
  475. GlobalFree(hImgData);
  476. hImgData=NULL;
  477. showerror(funcret);
  478. return FALSE;
  479. }
  480. }
  481. /////////////////////////////////////////////////
  482. void showerror(int funcret)
  483. {
  484. switch(funcret){
  485. case FUNC_MEMORY_ERROR:
  486.      MessageBox(NULL,"Error alloc memory!","ErrorMessage",MB_OK|MB_ICONEXCLAMATION);
  487. break;
  488. case FUNC_FILE_ERROR:
  489.      MessageBox(NULL,"File not found!","ErrorMessage",MB_OK|MB_ICONEXCLAMATION);
  490. break;
  491. case FUNC_FORMAT_ERROR:
  492. MessageBox(NULL,"File format error!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  493. break;
  494. }
  495. }
  496. ////////////////////////////////////////////////////////////////////////////////
  497. int InitTag()
  498. {
  499. BOOL finish=FALSE;
  500. BYTE id;
  501. short  llength;
  502. short  i,j,k;
  503. short  huftab1,huftab2;
  504. short  huftabindex;
  505. BYTE hf_table_index;
  506. BYTE qt_table_index;
  507. BYTE comnum;
  509. unsigned char  *lptemp;
  510. short  ccount;
  512. lp=lpJpegBuf+2;
  514. while (!finish){
  515. id=*(lp+1);
  516. lp+=2;
  517. switch (id){
  518. case M_APP0:
  519. llength=MAKEWORD(*(lp+1),*lp);
  520. lp+=llength;
  521. break;
  522. case M_DQT:
  523. llength=MAKEWORD(*(lp+1),*lp);
  524. qt_table_index=(*(lp+2))&0x0f;
  525. lptemp=lp+3;
  526. if(llength<80){
  527. for(i=0;i<64;i++)
  528. qt_table[qt_table_index][i]=(short)*(lptemp++);
  529. }
  530. else{
  531. for(i=0;i<64;i++)
  532. qt_table[qt_table_index][i]=(short)*(lptemp++);
  533.                 qt_table_index=(*(lptemp++))&0x0f;
  534.    for(i=0;i<64;i++)
  535. qt_table[qt_table_index][i]=(short)*(lptemp++);
  536.    }
  537.    lp+=llength;
  538. break;
  539. case M_SOF0:
  540.   llength=MAKEWORD(*(lp+1),*lp);
  541.   ImgHeight=MAKEWORD(*(lp+4),*(lp+3));
  542.   ImgWidth=MAKEWORD(*(lp+6),*(lp+5));
  543.             comp_num=*(lp+7);
  544.     if((comp_num!=1)&&(comp_num!=3))
  545.    return FUNC_FORMAT_ERROR;
  546. if(comp_num==3){
  547. comp_index[0]=*(lp+8);
  548.    SampRate_Y_H=(*(lp+9))>>4;
  549.    SampRate_Y_V=(*(lp+9))&0x0f;
  550.    YQtTable=(short *)qt_table[*(lp+10)];
  552. comp_index[1]=*(lp+11);
  553. SampRate_U_H=(*(lp+12))>>4;
  554.    SampRate_U_V=(*(lp+12))&0x0f;
  555.    UQtTable=(short *)qt_table[*(lp+13)];
  557.    comp_index[2]=*(lp+14);
  558.    SampRate_V_H=(*(lp+15))>>4;
  559.    SampRate_V_V=(*(lp+15))&0x0f;
  560. VQtTable=(short *)qt_table[*(lp+16)];
  561.    }
  562. else{
  563.    comp_index[0]=*(lp+8);
  564. SampRate_Y_H=(*(lp+9))>>4;
  565.    SampRate_Y_V=(*(lp+9))&0x0f;
  566.    YQtTable=(short *)qt_table[*(lp+10)];
  568. comp_index[1]=*(lp+8);
  569.    SampRate_U_H=1;
  570.    SampRate_U_V=1;
  571.    UQtTable=(short *)qt_table[*(lp+10)];
  573. comp_index[2]=*(lp+8);
  574. SampRate_V_H=1;
  575.    SampRate_V_V=1;
  576.    VQtTable=(short *)qt_table[*(lp+10)];
  577. }
  578.    lp+=llength;     
  579. break;
  580. case M_DHT:             
  581. llength=MAKEWORD(*(lp+1),*lp);
  582. if (llength<0xd0){
  583. huftab1=(short)(*(lp+2))>>4;     //huftab1=0,1
  584.   huftab2=(short)(*(lp+2))&0x0f;   //huftab2=0,1
  585. huftabindex=huftab1*2+huftab2;
  586.   lptemp=lp+3;
  587. for (i=0; i<16; i++)
  588. code_len_table[huftabindex][i]=(short)(*(lptemp++));
  589. j=0;
  590. for (i=0; i<16; i++)
  591. if(code_len_table[huftabindex][i]!=0){
  592. k=0;
  593. while(k<code_len_table[huftabindex][i]){
  594. code_value_table[huftabindex][k+j]=(short)(*(lptemp++));
  595. k++;
  596. }
  597. j+=k;
  598. }
  599. i=0;
  600. while (code_len_table[huftabindex][i]==0)
  601.   i++;
  602. for (j=0;j<i;j++){
  603. huf_min_value[huftabindex][j]=0;
  604. huf_max_value[huftabindex][j]=0;
  605. }
  606. huf_min_value[huftabindex][i]=0;
  607. huf_max_value[huftabindex][i]=code_len_table[huftabindex][i]-1;
  608. for (j=i+1;j<16;j++){
  609. huf_min_value[huftabindex][j]=(huf_max_value[huftabindex][j-1]+1)<<1;
  610. huf_max_value[huftabindex][j]=huf_min_value[huftabindex][j]+code_len_table[huftabindex][j]-1;
  611. }
  612. code_pos_table[huftabindex][0]=0;
  613. for (j=1;j<16;j++)
  614.    code_pos_table[huftabindex][j]=code_len_table[huftabindex][j-1]+code_pos_table[huftabindex][j-1];
  615.    lp+=llength;
  616. }  //if
  617. else{
  618.   hf_table_index=*(lp+2);
  619. lp+=2;
  620. while (hf_table_index!=0xff){
  621. huftab1=(short)hf_table_index>>4;     //huftab1=0,1
  622.   huftab2=(short)hf_table_index&0x0f;   //huftab2=0,1
  623. huftabindex=huftab1*2+huftab2;
  624. lptemp=lp+1;
  625. ccount=0;
  626. for (i=0; i<16; i++){
  627. code_len_table[huftabindex][i]=(short)(*(lptemp++));
  628. ccount+=code_len_table[huftabindex][i];
  629. }
  630. ccount+=17;
  631. j=0;
  632. for (i=0; i<16; i++)
  633. if(code_len_table[huftabindex][i]!=0){
  634. k=0;
  635. while(k<code_len_table[huftabindex][i])
  636. {
  637. code_value_table[huftabindex][k+j]=(short)(*(lptemp++));
  638. k++;
  639. }
  640. j+=k;
  641. }
  642. i=0;
  643. while (code_len_table[huftabindex][i]==0)
  644. i++;
  645. for (j=0;j<i;j++){
  646. huf_min_value[huftabindex][j]=0;
  647. huf_max_value[huftabindex][j]=0;
  648. }
  649. huf_min_value[huftabindex][i]=0;
  650. huf_max_value[huftabindex][i]=code_len_table[huftabindex][i]-1;
  651. for (j=i+1;j<16;j++){
  652. huf_min_value[huftabindex][j]=(huf_max_value[huftabindex][j-1]+1)<<1;
  653. huf_max_value[huftabindex][j]=huf_min_value[huftabindex][j]+code_len_table[huftabindex][j]-1;
  654. }
  655. code_pos_table[huftabindex][0]=0;
  656. for (j=1;j<16;j++)
  657. code_pos_table[huftabindex][j]=code_len_table[huftabindex][j-1]+code_pos_table[huftabindex][j-1];
  658. lp+=ccount;
  659. hf_table_index=*lp;
  660. }  //while
  661. }  //else
  662. break;
  663. case M_DRI:
  664. llength=MAKEWORD(*(lp+1),*lp);
  665. restart=MAKEWORD(*(lp+3),*(lp+2));
  666. lp+=llength;
  667. break;
  668. case M_SOS:
  669. llength=MAKEWORD(*(lp+1),*lp);
  670. comnum=*(lp+2);
  671. if(comnum!=comp_num)
  672. return FUNC_FORMAT_ERROR;
  673. lptemp=lp+3;
  674. for (i=0;i<comp_num;i++){
  675. if(*lptemp==comp_index[0]){
  676. YDcIndex=(*(lptemp+1))>>4;   //Y
  677. YAcIndex=((*(lptemp+1))&0x0f)+2;
  678. }
  679. else{
  680. UVDcIndex=(*(lptemp+1))>>4;   //U,V
  681. UVAcIndex=((*(lptemp+1))&0x0f)+2;
  682. }
  683. lptemp+=2;
  684. }
  685. lp+=llength;
  686. finish=TRUE;
  687. break;
  688. case M_EOI:    
  689. return FUNC_FORMAT_ERROR;
  690. break;
  691. default:
  692.   if ((id&0xf0)!=0xd0){
  693. llength=MAKEWORD(*(lp+1),*lp);
  694.   lp+=llength;
  695. }
  696. else lp+=2;
  697. break;
  698.    }  //switch
  699. } //while
  700. return FUNC_OK;
  701. }
  702. /////////////////////////////////////////////////////////////////
  703. void InitTable()
  704. {
  705. short i,j;
  706. sizei=sizej=0;
  707. ImgWidth=ImgHeight=0;
  708. rrun=vvalue=0;
  709. BitPos=0;
  710. CurByte=0;
  711. IntervalFlag=FALSE;
  712. restart=0;
  713. for(i=0;i<3;i++)
  714. for(j=0;j<64;j++)
  715. qt_table[i][j]=0;
  716. comp_num=0;
  717. HufTabIndex=0;
  718. for(i=0;i<3;i++)
  719. comp_index[i]=0;
  720. for(i=0;i<4;i++)
  721. for(j=0;j<16;j++){
  722. code_len_table[i][j]=0;
  723. code_pos_table[i][j]=0;
  724. huf_max_value[i][j]=0;
  725. huf_min_value[i][j]=0;
  726. }
  727. for(i=0;i<4;i++)
  728. for(j=0;j<256;j++)
  729. code_value_table[i][j]=0;
  731. for(i=0;i<10*64;i++){
  732. MCUBuffer[i]=0;
  733. QtZzMCUBuffer[i]=0;
  734. }
  735. for(i=0;i<64;i++){
  736. Y[i]=0;
  737. U[i]=0;
  738. V[i]=0;
  739. BlockBuffer[i]=0;
  740. }
  741. ycoef=ucoef=vcoef=0;
  742. }
  743. /////////////////////////////////////////////////////////////////////////
  744. int Decode()
  745. {
  746. int funcret;
  748. Y_in_MCU=SampRate_Y_H*SampRate_Y_V;
  749. U_in_MCU=SampRate_U_H*SampRate_U_V;
  750. V_in_MCU=SampRate_V_H*SampRate_V_V;
  751. H_YtoU=SampRate_Y_H/SampRate_U_H;
  752. V_YtoU=SampRate_Y_V/SampRate_U_V;
  753. H_YtoV=SampRate_Y_H/SampRate_V_H;
  754. V_YtoV=SampRate_Y_V/SampRate_V_V;
  755. Initialize_Fast_IDCT();
  756. while((funcret=DecodeMCUBlock())==FUNC_OK){
  757. interval++;
  758. if((restart)&&(interval % restart==0))
  759.  IntervalFlag=TRUE;
  760. else
  761. IntervalFlag=FALSE;
  762. IQtIZzMCUComponent(0);
  763. IQtIZzMCUComponent(1);
  764. IQtIZzMCUComponent(2);
  765. GetYUV(0);
  766. GetYUV(1);
  767. GetYUV(2);
  768. StoreBuffer();
  769. sizej+=SampRate_Y_H*8;
  770. if(sizej>=ImgWidth){
  771. sizej=0;
  772. sizei+=SampRate_Y_V*8;
  773. }
  774. if ((sizej==0)&&(sizei>=ImgHeight))
  775. break;
  776. }
  777. return funcret;
  778. }
  779. /////////////////////////////////////////////////////////////////////////////////////////
  780. void  GetYUV(short flag)
  781. {
  782. short H,VV;
  783. short i,j,k,h;
  784. int *buf;
  785. int *pQtZzMCU;
  787. switch(flag){
  788. case 0:
  789. H=SampRate_Y_H;
  790. VV=SampRate_Y_V;
  791. buf=Y;
  792. pQtZzMCU=QtZzMCUBuffer;
  793. break;
  794. case 1:
  795. H=SampRate_U_H;
  796. VV=SampRate_U_V;
  797. buf=U;
  798. pQtZzMCU=QtZzMCUBuffer+Y_in_MCU*64;
  799. break;
  800. case 2:
  801. H=SampRate_V_H;
  802. VV=SampRate_V_V;
  803. buf=V;
  804. pQtZzMCU=QtZzMCUBuffer+(Y_in_MCU+U_in_MCU)*64;
  805. break;
  806. }
  807. for (i=0;i<VV;i++)
  808. for(j=0;j<H;j++)
  809. for(k=0;k<8;k++)
  810. for(h=0;h<8;h++)
  811. buf[(i*8+k)*SampRate_Y_H*8+j*8+h]=*pQtZzMCU++;
  812. }
  813. ///////////////////////////////////////////////////////////////////////////////
  814. void StoreBuffer()
  815. {
  816. short i,j;
  817. unsigned char  *lpbmp;
  818. unsigned char R,G,B;
  819. int y,u,v,rr,gg,bb;
  821. for(i=0;i<SampRate_Y_V*8;i++){
  822. if((sizei+i)<ImgHeight){
  823. lpbmp=((unsigned char *)lpPtr+(DWORD)(ImgHeight-sizei-i-1)*LineBytes+sizej*3);
  824. for(j=0;j<SampRate_Y_H*8;j++){
  825. if((sizej+j)<ImgWidth){
  826. y=Y[i*8*SampRate_Y_H+j];
  827. u=U[(i/V_YtoU)*8*SampRate_Y_H+j/H_YtoU];
  828. v=V[(i/V_YtoV)*8*SampRate_Y_H+j/H_YtoV];
  829. rr=((y<<8)+18*u+367*v)>>8;
  830. gg=((y<<8)-159*u-220*v)>>8;
  831. bb=((y<<8)+411*u-29*v)>>8;
  832. R=(unsigned char)rr;
  833. G=(unsigned char)gg;
  834. B=(unsigned char)bb;
  835. if (rr&0xffffff00) if (rr>255) R=255; else if (rr<0) R=0;
  836. if (gg&0xffffff00) if (gg>255) G=255; else if (gg<0) G=0;
  837. if (bb&0xffffff00) if (bb>255) B=255; else if (bb<0) B=0;
  838. *lpbmp++=B;
  839. *lpbmp++=G;
  840. *lpbmp++=R;
  841. }
  842. else  break;
  843. }
  844. }
  845. else break;
  846. }
  847. }
  848. ///////////////////////////////////////////////////////////////////////////////
  849. int DecodeMCUBlock()
  850. {
  851. short *lpMCUBuffer;
  852. short i,j;
  853. int funcret;
  855. if (IntervalFlag){
  856. lp+=2;
  857. ycoef=ucoef=vcoef=0;
  858. BitPos=0;
  859. CurByte=0;
  860. }
  861. switch(comp_num){
  862. case 3:
  863. lpMCUBuffer=MCUBuffer;
  864. for (i=0;i<SampRate_Y_H*SampRate_Y_V;i++)  //Y
  865. {
  866. funcret=HufBlock(YDcIndex,YAcIndex);
  867. if (funcret!=FUNC_OK)
  868. return funcret;
  869. BlockBuffer[0]=BlockBuffer[0]+ycoef;
  870. ycoef=BlockBuffer[0];
  871. for (j=0;j<64;j++)
  872. *lpMCUBuffer++=BlockBuffer[j];
  873. }
  874. for (i=0;i<SampRate_U_H*SampRate_U_V;i++)  //U
  875. {
  876. funcret=HufBlock(UVDcIndex,UVAcIndex);
  877. if (funcret!=FUNC_OK)
  878. return funcret;
  879. BlockBuffer[0]=BlockBuffer[0]+ucoef;
  880. ucoef=BlockBuffer[0];
  881. for (j=0;j<64;j++)
  882. *lpMCUBuffer++=BlockBuffer[j];
  883. }
  884. for (i=0;i<SampRate_V_H*SampRate_V_V;i++)  //V
  885. {
  886. funcret=HufBlock(UVDcIndex,UVAcIndex);
  887. if (funcret!=FUNC_OK)
  888. return funcret;
  889. BlockBuffer[0]=BlockBuffer[0]+vcoef;
  890. vcoef=BlockBuffer[0];
  891. for (j=0;j<64;j++)
  892. *lpMCUBuffer++=BlockBuffer[j];
  893. }
  894. break;
  895. case 1:
  896. lpMCUBuffer=MCUBuffer;
  897. funcret=HufBlock(YDcIndex,YAcIndex);
  898. if (funcret!=FUNC_OK)
  899. return funcret;
  900. BlockBuffer[0]=BlockBuffer[0]+ycoef;
  901. ycoef=BlockBuffer[0];
  902. for (j=0;j<64;j++)
  903. *lpMCUBuffer++=BlockBuffer[j];
  904. for (i=0;i<128;i++)
  905. *lpMCUBuffer++=0;
  906. break;
  907. default:
  908. return FUNC_FORMAT_ERROR;
  909. }
  910. return FUNC_OK;
  911. }
  912. //////////////////////////////////////////////////////////////////
  913. int HufBlock(BYTE dchufindex,BYTE achufindex)
  914. {
  915. short count=0;
  916. short i;
  917. int funcret;
  919. //dc
  920. HufTabIndex=dchufindex;
  921. funcret=DecodeElement();
  922. if(funcret!=FUNC_OK)
  923. return funcret;
  925. BlockBuffer[count++]=vvalue;
  926. //ac
  927. HufTabIndex=achufindex;
  928. while (count<64){
  929. funcret=DecodeElement();
  930. if(funcret!=FUNC_OK)
  931. return funcret;
  932. if ((rrun==0)&&(vvalue==0)){
  933. for (i=count;i<64;i++)
  934. BlockBuffer[i]=0;
  935. count=64;
  936. }
  937. else{
  938. for (i=0;i<rrun;i++)
  939. BlockBuffer[count++]=0;
  940. BlockBuffer[count++]=vvalue;
  941. }
  942. }
  943. return FUNC_OK;
  944. }
  945. //////////////////////////////////////////////////////////////////////////////
  946. int DecodeElement()
  947. {
  948. int thiscode,tempcode;
  949. unsigned short temp,valueex;
  950. short codelen;
  951. BYTE hufexbyte,runsize,tempsize,sign;
  952. BYTE newbyte,lastbyte;
  954. if(BitPos>=1){
  955. BitPos--;
  956. thiscode=(BYTE)CurByte>>BitPos;
  957. CurByte=CurByte&And[BitPos];
  958. }
  959. else{
  960. lastbyte=ReadByte();
  961. BitPos--;
  962. newbyte=CurByte&And[BitPos];
  963. thiscode=lastbyte>>7;
  964. CurByte=newbyte;
  965. }
  966. codelen=1;
  967. while ((thiscode<huf_min_value[HufTabIndex][codelen-1])||
  968.   (code_len_table[HufTabIndex][codelen-1]==0)||
  969.   (thiscode>huf_max_value[HufTabIndex][codelen-1]))
  970. {
  971. if(BitPos>=1){
  972. BitPos--;
  973. tempcode=(BYTE)CurByte>>BitPos;
  974. CurByte=CurByte&And[BitPos];
  975. }
  976. else{
  977. lastbyte=ReadByte();
  978. BitPos--;
  979. newbyte=CurByte&And[BitPos];
  980. tempcode=(BYTE)lastbyte>>7;
  981. CurByte=newbyte;
  982. }
  983. thiscode=(thiscode<<1)+tempcode;
  984. codelen++;
  985. if(codelen>16)
  986. return FUNC_FORMAT_ERROR;
  987. }  //while
  988. temp=thiscode-huf_min_value[HufTabIndex][codelen-1]+code_pos_table[HufTabIndex][codelen-1];
  989. hufexbyte=(BYTE)code_value_table[HufTabIndex][temp];
  990. rrun=(short)(hufexbyte>>4);
  991. runsize=hufexbyte&0x0f;
  992. if(runsize==0){
  993. vvalue=0;
  994. return FUNC_OK;
  995. }
  996. tempsize=runsize;
  997. if(BitPos>=runsize){
  998. BitPos-=runsize;
  999. valueex=(BYTE)CurByte>>BitPos;
  1000. CurByte=CurByte&And[BitPos];
  1001. }
  1002. else{
  1003. valueex=CurByte;
  1004. tempsize-=BitPos;
  1005. while(tempsize>8){
  1006. lastbyte=ReadByte();
  1007. valueex=(valueex<<8)+(BYTE)lastbyte;
  1008. tempsize-=8;
  1009. }  //while
  1010. lastbyte=ReadByte();
  1011. BitPos-=tempsize;
  1012. valueex=(valueex<<tempsize)+(lastbyte>>BitPos);
  1013. CurByte=lastbyte&And[BitPos];
  1014. }  //else
  1015. sign=valueex>>(runsize-1);
  1016. if(sign)
  1017. vvalue=valueex;
  1018. else{
  1019. valueex=valueex^0xffff;
  1020. temp=0xffff<<runsize;
  1021. vvalue=-(short)(valueex^temp);
  1022. }
  1023. return FUNC_OK;
  1024. }
  1025. /////////////////////////////////////////////////////////////////////////////////////
  1026. void IQtIZzMCUComponent(short flag)
  1027. {
  1028. short H,VV;
  1029. short i,j;
  1030. int *pQtZzMCUBuffer;
  1031. short  *pMCUBuffer;
  1033. switch(flag){
  1034. case 0:
  1035. H=SampRate_Y_H;
  1036. VV=SampRate_Y_V;
  1037. pMCUBuffer=MCUBuffer;
  1038. pQtZzMCUBuffer=QtZzMCUBuffer;
  1039. break;
  1040. case 1:
  1041. H=SampRate_U_H;
  1042. VV=SampRate_U_V;
  1043. pMCUBuffer=MCUBuffer+Y_in_MCU*64;
  1044. pQtZzMCUBuffer=QtZzMCUBuffer+Y_in_MCU*64;
  1045. break;
  1046. case 2:
  1047. H=SampRate_V_H;
  1048. VV=SampRate_V_V;
  1049. pMCUBuffer=MCUBuffer+(Y_in_MCU+U_in_MCU)*64;
  1050. pQtZzMCUBuffer=QtZzMCUBuffer+(Y_in_MCU+U_in_MCU)*64;
  1051. break;
  1052. }
  1053. for(i=0;i<VV;i++)
  1054. for (j=0;j<H;j++)
  1055. IQtIZzBlock(pMCUBuffer+(i*H+j)*64,pQtZzMCUBuffer+(i*H+j)*64,flag);
  1056. }
  1057. //////////////////////////////////////////////////////////////////////////////////////////
  1058. void IQtIZzBlock(short  *s ,int * d,short flag)
  1059. {
  1060. short i,j;
  1061. short tag;
  1062. short *pQt;
  1063. int buffer2[8][8];
  1064. int *buffer1;
  1065. short offset;
  1067. switch(flag){
  1068. case 0:
  1069. pQt=YQtTable;
  1070. offset=128;
  1071. break;
  1072. case 1:
  1073. pQt=UQtTable;
  1074. offset=0;
  1075. break;
  1076. case 2:
  1077. pQt=VQtTable;
  1078. offset=0;
  1079. break;
  1080. }
  1082. for(i=0;i<8;i++)
  1083. for(j=0;j<8;j++){
  1084. tag=Zig_Zag[i][j];
  1085. buffer2[i][j]=(int)s[tag]*(int)pQt[tag];
  1086. }
  1087. buffer1=(int *)buffer2;
  1088. Fast_IDCT(buffer1);
  1089. for(i=0;i<8;i++)
  1090. for(j=0;j<8;j++)
  1091. d[i*8+j]=buffer2[i][j]+offset;
  1092. }
  1093. ///////////////////////////////////////////////////////////////////////////////
  1094. void Fast_IDCT(int * block)
  1095. {
  1096. short i;
  1098. for (i=0; i<8; i++)
  1099. idctrow(block+8*i);
  1101. for (i=0; i<8; i++)
  1102. idctcol(block+i);
  1103. }
  1104. ///////////////////////////////////////////////////////////////////////////////
  1105. BYTE  ReadByte()
  1106. {
  1107. BYTE  i;
  1109. i=*(lp++);
  1110. if(i==0xff)
  1111. lp++;
  1112. BitPos=8;
  1113. CurByte=i;
  1114. return i;
  1115. }
  1116. ///////////////////////////////////////////////////////////////////////
  1117. void Initialize_Fast_IDCT()
  1118. {
  1119. short i;
  1121. iclp = iclip+512;
  1122. for (i= -512; i<512; i++)
  1123. iclp[i] = (i<-256) ? -256 : ((i>255) ? 255 : i);
  1124. }
  1125. ////////////////////////////////////////////////////////////////////////
  1126. void idctrow(int * blk)
  1127. {
  1128. int x0, x1, x2, x3, x4, x5, x6, x7, x8;
  1129. //intcut
  1130. if (!((x1 = blk[4]<<11) | (x2 = blk[6]) | (x3 = blk[2]) |
  1131. (x4 = blk[1]) | (x5 = blk[7]) | (x6 = blk[5]) | (x7 = blk[3])))
  1132. {
  1133. blk[0]=blk[1]=blk[2]=blk[3]=blk[4]=blk[5]=blk[6]=blk[7]=blk[0]<<3;
  1134. return;
  1135. }
  1136. x0 = (blk[0]<<11) + 128; // for proper rounding in the fourth stage 
  1137. //first stage
  1138. x8 = W7*(x4+x5);
  1139. x4 = x8 + (W1-W7)*x4;
  1140. x5 = x8 - (W1+W7)*x5;
  1141. x8 = W3*(x6+x7);
  1142. x6 = x8 - (W3-W5)*x6;
  1143. x7 = x8 - (W3+W5)*x7;
  1144. //second stage
  1145. x8 = x0 + x1;
  1146. x0 -= x1;
  1147. x1 = W6*(x3+x2);
  1148. x2 = x1 - (W2+W6)*x2;
  1149. x3 = x1 + (W2-W6)*x3;
  1150. x1 = x4 + x6;
  1151. x4 -= x6;
  1152. x6 = x5 + x7;
  1153. x5 -= x7;
  1154. //third stage
  1155. x7 = x8 + x3;
  1156. x8 -= x3;
  1157. x3 = x0 + x2;
  1158. x0 -= x2;
  1159. x2 = (181*(x4+x5)+128)>>8;
  1160. x4 = (181*(x4-x5)+128)>>8;
  1161. //fourth stage
  1162. blk[0] = (x7+x1)>>8;
  1163. blk[1] = (x3+x2)>>8;
  1164. blk[2] = (x0+x4)>>8;
  1165. blk[3] = (x8+x6)>>8;
  1166. blk[4] = (x8-x6)>>8;
  1167. blk[5] = (x0-x4)>>8;
  1168. blk[6] = (x3-x2)>>8;
  1169. blk[7] = (x7-x1)>>8;
  1170. }
  1171. //////////////////////////////////////////////////////////////////////////////
  1172. void idctcol(int * blk)
  1173. {
  1174. int x0, x1, x2, x3, x4, x5, x6, x7, x8;
  1175. //intcut
  1176. if (!((x1 = (blk[8*4]<<8)) | (x2 = blk[8*6]) | (x3 = blk[8*2]) |
  1177. (x4 = blk[8*1]) | (x5 = blk[8*7]) | (x6 = blk[8*5]) | (x7 = blk[8*3])))
  1178. {
  1179. blk[8*0]=blk[8*1]=blk[8*2]=blk[8*3]=blk[8*4]=blk[8*5]
  1180. =blk[8*6]=blk[8*7]=iclp[(blk[8*0]+32)>>6];
  1181. return;
  1182. }
  1183. x0 = (blk[8*0]<<8) + 8192;
  1184. //first stage
  1185. x8 = W7*(x4+x5) + 4;
  1186. x4 = (x8+(W1-W7)*x4)>>3;
  1187. x5 = (x8-(W1+W7)*x5)>>3;
  1188. x8 = W3*(x6+x7) + 4;
  1189. x6 = (x8-(W3-W5)*x6)>>3;
  1190. x7 = (x8-(W3+W5)*x7)>>3;
  1191. //second stage
  1192. x8 = x0 + x1;
  1193. x0 -= x1;
  1194. x1 = W6*(x3+x2) + 4;
  1195. x2 = (x1-(W2+W6)*x2)>>3;
  1196. x3 = (x1+(W2-W6)*x3)>>3;
  1197. x1 = x4 + x6;
  1198. x4 -= x6;
  1199. x6 = x5 + x7;
  1200. x5 -= x7;
  1201. //third stage
  1202. x7 = x8 + x3;
  1203. x8 -= x3;
  1204. x3 = x0 + x2;
  1205. x0 -= x2;
  1206. x2 = (181*(x4+x5)+128)>>8;
  1207. x4 = (181*(x4-x5)+128)>>8;
  1208. //fourth stage
  1209. blk[8*0] = iclp[(x7+x1)>>14];
  1210. blk[8*1] = iclp[(x3+x2)>>14];
  1211. blk[8*2] = iclp[(x0+x4)>>14];
  1212. blk[8*3] = iclp[(x8+x6)>>14];
  1213. blk[8*4] = iclp[(x8-x6)>>14];
  1214. blk[8*5] = iclp[(x0-x4)>>14];
  1215. blk[8*6] = iclp[(x3-x2)>>14];
  1216. blk[8*7] = iclp[(x7-x1)>>14];
  1217. }