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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 输入法编程 > 查看源码
Jpeg.cpp
资源名称：JSiemXP2008-11-14.rar　[点击查看]
上传用户：hyb6888
上传日期：2016-01-24
资源大小：5186k
文件大小：31k
源码类别：

输入法编程

开发平台：

Visual C++

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