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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
cjpeg.txt
资源名称：cjpeg.rar　[点击查看]
上传用户：wangchao
上传日期：2021-02-19
资源大小：9k
文件大小：31k
源码类别：

压缩解压

开发平台：

C++ Builder

cjpeg.txt：源码内容
  1. #ifndef __JPEGDEC_H__
  2. #define __JPEGDEC_H__ 
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  9. #define BYTE unsigned char
  10. #define WORD unsigned short int
  12. #define DWORD unsigned int
  13. #define SDWORD signed int
  15. #define SBYTE signed char
  16. #define SWORD signed short int
  18. int load_JPEG_header(FILE *fp, DWORD *X_image, DWORD *Y_image);
  19. void decode_JPEG_image();
  20. int get_JPEG_buffer(WORD X_image,WORD Y_image, BYTE **address_dest_buffer);
  22. #endif
  25. #include <conio.h>
  26. #include <time.h>
  27. char *FileName="image.jpg";
  28. extern char error_string[90];
  30. typedef struct s_BM_header {
  31.   WORD BMP_id ; // 'B''M'
  32.   DWORD size; // size in bytes of the BMP file
  33.   DWORD zero_res; // 0
  34.   DWORD offbits; // 54
  35.   DWORD biSize; // 0x28
  36.   DWORD Width;  // X
  37.   DWORD Height;  // Y
  38.   WORD  biPlanes; // 1
  39.   WORD  biBitCount ; // 24
  40.   DWORD biCompression; // 0 = BI_RGB
  41.   DWORD biSizeImage; // 0
  42.   DWORD biXPelsPerMeter; // 0xB40
  43.   DWORD biYPelsPerMeter; // 0xB40
  44.   DWORD biClrUsed; //0
  45.   DWORD biClrImportant; //0
  46. } BM_header;
  47. typedef struct s_RGB {
  48.  BYTE B;
  49.      BYTE G;
  50.      BYTE R;
  51. } RGB;
  53. void exitmessage(char *message)
  54. {
  55.  printf("%sn",message);exit(0);
  56. }
  58. void write_buf_to_BMP(BYTE *im_buffer, WORD X_bitmap, WORD Y_bitmap, char *BMPname)
  59. {
  60.  SWORD x,y;
  61.  RGB *pixel;
  62.  BM_header BH;
  63.  FILE *fp_bitmap;
  64.  DWORD im_loc_bytes;
  65.  BYTE nr_fillingbytes, i;
  66.  BYTE zero_byte=0;
  68.  fp_bitmap=fopen(BMPname,"wb");
  69.  if (fp_bitmap==NULL) exitmessage("File cannot be created");
  71.  if (X_bitmap%4!=0) nr_fillingbytes=4-((X_bitmap*3L)%4);
  72.   else nr_fillingbytes=0;
  74.  BH.BMP_id = 'M'*256+'B';     fwrite(&BH.BMP_id,2,1,fp_bitmap);
  75.  BH.size=54+Y_bitmap*(X_bitmap*3+nr_fillingbytes);fwrite(&BH.size,4,1,fp_bitmap);
  76.  BH.zero_res = 0;             fwrite(&BH.zero_res,4,1,fp_bitmap);
  77.  BH.offbits = 54;             fwrite(&BH.offbits,4,1,fp_bitmap);
  78.  BH.biSize = 0x28;            fwrite(&BH.biSize,4,1,fp_bitmap);
  79.  BH.Width = X_bitmap;       fwrite(&BH.Width,4,1,fp_bitmap);
  80.  BH.Height = Y_bitmap;       fwrite(&BH.Height,4,1,fp_bitmap);
  81.  BH.biPlanes = 1;             fwrite(&BH.biPlanes,2,1,fp_bitmap);
  82.  BH.biBitCount = 24;          fwrite(&BH.biBitCount,2,1,fp_bitmap);
  83.  BH.biCompression = 0;        fwrite(&BH.biCompression,4,1,fp_bitmap);
  84.  BH.biSizeImage = 0;          fwrite(&BH.biSizeImage,4,1,fp_bitmap);
  85.  BH.biXPelsPerMeter = 0xB40;  fwrite(&BH.biXPelsPerMeter,4,1,fp_bitmap);
  86.  BH.biYPelsPerMeter = 0xB40;  fwrite(&BH.biYPelsPerMeter,4,1,fp_bitmap);
  87.  BH.biClrUsed = 0;           fwrite(&BH.biClrUsed,4,1,fp_bitmap);
  88.  BH.biClrImportant = 0;       fwrite(&BH.biClrImportant,4,1,fp_bitmap);
  90.  printf("Writing bitmap ...n");
  91.  im_loc_bytes=(DWORD)im_buffer+((DWORD)Y_bitmap-1)*X_bitmap*4;
  93.  for (y=0;y<Y_bitmap;y++)
  94.   {
  95.    for (x=0;x<X_bitmap;x++)
  96. {
  97.  pixel=(RGB *)im_loc_bytes;
  98.  fwrite(pixel, 3, 1, fp_bitmap);
  99.  im_loc_bytes+=4;
  100. }
  101.    for (i=0;i<nr_fillingbytes;i++)
  102.    fwrite(&zero_byte,1,1,fp_bitmap);
  103.    im_loc_bytes-=2L*X_bitmap*4;
  104.   }
  105.  printf("Done.n");
  106.  fclose(fp_bitmap);
  107. }
  111. // Used markers:
  112. #define SOI 0xD8
  113. #define EOI 0xD9
  114. #define APP0 0xE0
  115. #define SOF 0xC0
  116. #define DQT 0xDB
  117. #define DHT 0xC4
  118. #define SOS 0xDA
  119. #define DRI 0xDD
  120. #define COM 0xFE
  122. char error_string[90];
  123. #define exit_func(err) { strcpy(error_string, err); return 0;}
  125. static BYTE *buf; // the buffer we use for storing the entire JPG file
  127. static BYTE bp; //current byte
  128. static WORD wp; //current word
  130. static DWORD byte_pos; // current byte position
  131. #define BYTE_p(i) bp=buf[(i)++]
  132. #define WORD_p(i) wp=(((WORD)(buf[(i)]))<<8) + buf[(i)+1]; (i)+=2
  134. // WORD X_image_size,Y_image_size; // X,Y sizes of the image
  135. static WORD X_round,Y_round; // The dimensions rounded to multiple of Hmax*8 (X_round)
  136.   // and Ymax*8 (Y_round)
  138. static BYTE *im_buffer; // RGBA image buffer
  139. static DWORD X_image_bytes; // size in bytes of 1 line of the image = X_round * 4
  140. static DWORD y_inc_value ; // 32*X_round; // used by decode_MCU_1x2,2x1,2x2
  142. BYTE YH,YV,CbH,CbV,CrH,CrV; // sampling factors (horizontal and vertical) for Y,Cb,Cr
  143. static WORD Hmax,Vmax;
  146. static BYTE zigzag[64]={ 0, 1, 5, 6,14,15,27,28,
  147.   2, 4, 7,13,16,26,29,42,
  148.   3, 8,12,17,25,30,41,43,
  149.   9,11,18,24,31,40,44,53,
  150.  10,19,23,32,39,45,52,54,
  151.  20,22,33,38,46,51,55,60,
  152.  21,34,37,47,50,56,59,61,
  153.  35,36,48,49,57,58,62,63 };
  154. typedef struct {
  155.    BYTE Length[17];  // k =1-16 ; L[k] indicates the number of Huffman codes of length k
  156.    WORD minor_code[17];  // indicates the value of the smallest Huffman code of length k
  157.    WORD major_code[17];  // similar, but the highest code
  158.    BYTE V[65536];  // V[k][j] = Value associated to the j-th Huffman code of length k
  159. // High nibble = nr of previous 0 coefficients
  160. // Low nibble = size (in bits) of the coefficient which will be taken from the data stream
  161. } Huffman_table;
  163. static float *QT[4]; // quantization tables, no more than 4 quantization tables (QT[0..3])
  164. static Huffman_table HTDC[4]; //DC huffman tables , no more than 4 (0..3)
  165. static Huffman_table HTAC[4]; //AC huffman tables                  (0..3)
  167. static BYTE YQ_nr,CbQ_nr,CrQ_nr; // quantization table number for Y, Cb, Cr
  168. static BYTE YDC_nr,CbDC_nr,CrDC_nr; // DC Huffman table number for Y,Cb, Cr
  169. static BYTE YAC_nr,CbAC_nr,CrAC_nr; // AC Huffman table number for Y,Cb, Cr
  171. static BYTE Restart_markers; // if 1 => Restart markers on , 0 => no restart markers
  172. static WORD MCU_restart; //Restart markers appears every MCU_restart MCU blocks
  173. typedef void (*decode_MCU_func)(DWORD);
  176. static SWORD DCY, DCCb, DCCr; // Coeficientii DC pentru Y,Cb,Cr
  177. static SWORD DCT_coeff[64]; // Current DCT_coefficients
  178. static BYTE Y[64],Cb[64],Cr[64]; // Y, Cb, Cr of the current 8x8 block for the 1x1 case
  179. static BYTE Y_1[64],Y_2[64],Y_3[64],Y_4[64];
  180. static BYTE tab_1[64],tab_2[64],tab_3[64],tab_4[64]; // tabelele de supraesantionare pt cele 4 blocuri
  182. static SWORD Cr_tab[256],Cb_tab[256]; // Precalculated Cr, Cb tables
  183. static SWORD Cr_Cb_green_tab[65536];
  185. // Initial conditions:
  186. // byte_pos = start position in the Huffman coded segment
  187. // WORD_get(w1); WORD_get(w2);wordval=w1;
  189. static BYTE d_k=0;  // Bit displacement in memory, relative to the offset of w1
  190.  // it's always <16
  191. static WORD w1,w2; // w1 = First word in memory; w2 = Second word
  192. static DWORD wordval ; // the actual used value in Huffman decoding.
  193. static DWORD mask[17];
  194. static SWORD neg_pow2[17]={0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
  195. static DWORD start_neg_pow2=(DWORD)neg_pow2;
  197. static int shift_temp;
  198. #define RIGHT_SHIFT(x,shft)  
  199. ((shift_temp = (x)) < 0 ? 
  200.  (shift_temp >> (shft)) | ((~(0L)) << (32-(shft))) : 
  201.  (shift_temp >> (shft)))
  202. #define DESCALE(x,n)  RIGHT_SHIFT((x) + (1L << ((n)-1)), n)
  203. #define RANGE_MASK 1023L
  204. static BYTE *rlimit_table;
  205. void prepare_range_limit_table()
  206. /* Allocate and fill in the sample_range_limit table */
  207. {
  208.   int j;
  209.   rlimit_table = (BYTE *)malloc(5 * 256L + 128) ;
  210.   /* First segment of "simple" table: limit[x] = 0 for x < 0 */
  211.   memset((void *)rlimit_table,0,256);
  212.   rlimit_table += 256; /* allow negative subscripts of simple table */
  213.   /* Main part of "simple" table: limit[x] = x */
  214.   for (j = 0; j < 256; j++) rlimit_table[j] = j;
  215.   /* End of simple table, rest of first half of post-IDCT table */
  216.   for (j = 256; j < 640; j++) rlimit_table[j] = 255;
  217.   /* Second half of post-IDCT table */
  218.   memset((void *)(rlimit_table + 640),0,384);
  219.   for (j = 0; j < 128 ; j++) rlimit_table[j+1024] = j;
  220. }
  222. #ifdef _MSC_VER
  223. WORD lookKbits(BYTE k)
  224. {
  225.  _asm {
  226.  mov dl, k
  227.  mov cl, 16
  228.  sub cl, dl
  229.  mov eax, [wordval]
  230.  shr eax, cl
  231.  }
  232. }
  234. WORD WORD_hi_lo(BYTE byte_high,BYTE byte_low)
  235. {
  236. _asm {
  237.   mov ah,byte_high
  238.   mov al,byte_low
  239.  }
  240. }
  241. SWORD get_svalue(BYTE k)
  242. // k>0 always
  243. // Takes k bits out of the BIT stream (wordval), and makes them a signed value
  244. {
  245. _asm {
  246.    xor ecx, ecx
  247.    mov cl,k
  248.    mov eax,[wordval]
  249.    shl eax,cl
  250.    shr eax, 16
  251.    dec cl
  252.    bt eax,ecx
  253.    jc end_macro
  254. signed_value:inc cl
  255.    mov ebx,[start_neg_pow2]
  256.    add ax,word ptr [ebx+ecx*2]
  257.  end_macro:
  258. }
  259. }
  260. #endif
  262. #ifdef __WATCOMC__
  264. WORD lookKbits(BYTE k);
  265. #pragma aux lookKbits=
  266.   "mov eax,[wordval]"
  267.   "mov cl, 16"
  268.   "sub cl, dl"
  269.   "shr eax, cl"
  270.    parm [dl] 
  271.    value [ax] 
  272.    modify [eax cl];
  273. WORD WORD_hi_lo(BYTE byte_high,BYTE BYTE_low);
  274. #pragma aux WORD_hi_lo=
  275.    parm [ah] [al]
  276.    value [ax] 
  277.    modify [ax];
  279. SWORD get_svalue(BYTE k);
  280. // k>0 always
  281. // Takes k bits out of the BIT stream (wordval), and makes them a signed value
  282. #pragma aux get_svalue=
  283. "xor ecx, ecx"
  284. "mov cl, al"
  285. "mov eax,[wordval]"
  286. "shl eax, cl"
  287. "shr eax, 16"
  288. "dec cl"
  289. "bt eax,ecx"
  290. "jc end_macro"
  291. "signed_value:inc cl"
  292. "mov ebx,[start_neg_pow2]"
  293. "add ax,word ptr [ebx+ecx*2]"
  294. "end_macro:"
  295. parm [al]
  296. modify [eax ebx ecx]
  297. value [ax];
  298. #endif
  300. void skipKbits(BYTE k)
  301. {
  302.  BYTE b_high,b_low;
  303.  d_k+=k;
  304.  if (d_k>=16) { d_k-=16;
  305. w1=w2;
  306. // Get the next word in w2
  307. BYTE_p(byte_pos);
  308. if (bp!=0xFF) b_high=bp;
  309. else {
  310.   if (buf[byte_pos]==0) byte_pos++; //skip 00
  311.   else byte_pos--; // stop byte_pos pe restart marker
  312.   b_high=0xFF;
  313. }
  314. BYTE_p(byte_pos);
  315. if (bp!=0xFF) b_low=bp;
  316. else {
  317.   if (buf[byte_pos]==0) byte_pos++; //skip 00
  318.   else byte_pos--; // stop byte_pos pe restart marker
  319.   b_low=0xFF;
  320. }
  321. w2=WORD_hi_lo(b_high,b_low);
  322.  }
  324.  wordval = ((DWORD)(w1)<<16) + w2;
  325.  wordval <<= d_k;
  326.  wordval >>= 16;
  327. }
  329. SWORD getKbits(BYTE k)
  330. {
  331.  SWORD signed_wordvalue;
  332.  signed_wordvalue=get_svalue(k);
  333.  skipKbits(k);
  334.  return signed_wordvalue;
  335. }
  337. void calculate_mask()
  338. {
  339.   BYTE k;
  340.   DWORD tmpdv;
  341.   for (k=0;k<=16;k++) { tmpdv=0x10000;mask[k]=(tmpdv>>k)-1;} //precalculated bit mask
  342. }
  344. void init_QT()
  345. {
  346.  BYTE i;
  347.  for (i=0;i<=3;i++) QT[i]=(float *)malloc(sizeof(float)*64);
  348. }
  350. void load_quant_table(float *quant_table)
  351. {
  352.  float scalefactor[8]={1.0f, 1.387039845f, 1.306562965f, 1.175875602f,
  353.    1.0f, 0.785694958f, 0.541196100f, 0.275899379f};
  354.  BYTE j,row,col;
  355. // Load quantization coefficients from JPG file, scale them for DCT and reorder
  356. // from zig-zag order
  357.  for (j=0;j<=63;j++) quant_table[j]=buf[byte_pos+zigzag[j]];
  358.  j=0;
  359.  for (row=0;row<=7;row++)
  360.    for (col=0;col<=7;col++) {
  361. quant_table[j]*=scalefactor[row]*scalefactor[col];
  362. j++;
  363.    }
  364.  byte_pos+=64;
  365. }
  367. void load_Huffman_table(Huffman_table *HT)
  368. {
  369.   BYTE k,j;
  370.   DWORD code;
  372.   for (j=1;j<=16;j++) {
  373. BYTE_p(byte_pos);
  374. HT->Length[j]=bp;
  375.   }
  376.   for (k=1;k<=16;k++)
  377. for (j=0;j<HT->Length[k];j++) {
  378. BYTE_p(byte_pos);
  379. HT->V[WORD_hi_lo(k,j)]=bp;
  380. }
  382.   code=0;
  383.   for (k=1;k<=16;k++) {
  384.  HT->minor_code[k] = (WORD)code;
  385.  for (j=1;j<=HT->Length[k];j++) code++;
  386.  HT->major_code[k]=(WORD)(code-1);
  387.  code*=2;
  388.  if (HT->Length[k]==0) {
  389. HT->minor_code[k]=0xFFFF;
  390. HT->major_code[k]=0;
  391.  }
  392.   }
  393. }
  395. void process_Huffman_data_unit(BYTE DC_nr, BYTE AC_nr,SWORD *previous_DC)
  396. {
  397. // Process one data unit. A data unit = 64 DCT coefficients
  398. // Data is decompressed by Huffman decoding, then the array is dezigzag-ed
  399. // The result is a 64 DCT coefficients array: DCT_coeff
  400.    BYTE nr,k,j,EOB_found;
  401.    register WORD tmp_Hcode;
  402.    BYTE size_val,count_0;
  403.    WORD *min_code,*maj_code; // min_code[k]=minimum code of length k, maj_code[k]=similar but maximum
  404.    WORD *max_val, *min_val;
  405.    BYTE *huff_values;
  406.    SWORD DCT_tcoeff[64];
  407.    BYTE byte_temp;
  409. // Start Huffman decoding
  410. // First the DC coefficient decoding
  411.    min_code=HTDC[DC_nr].minor_code;
  412.    maj_code=HTDC[DC_nr].major_code;
  413.    huff_values=HTDC[DC_nr].V;
  415.    for (nr = 0; nr < 64 ; nr++) DCT_tcoeff[nr] = 0; //Initialize DCT_tcoeff
  417.    nr=0;// DC coefficient
  419.    min_val = &min_code[1]; max_val = &maj_code[1];
  420.    for (k=1;k<=16;k++) {
  421.  tmp_Hcode=lookKbits(k);
  422. //    max_val = &maj_code[k]; min_val = &min_code[k];
  423.  if ( (tmp_Hcode<=*max_val)&&(tmp_Hcode>=*min_val) ) { //Found a valid Huffman code
  424. skipKbits(k);
  425. size_val=huff_values[WORD_hi_lo(k,(BYTE)(tmp_Hcode-*min_val))];
  426. if (size_val==0) DCT_tcoeff[0]=*previous_DC;
  427. else {
  428. DCT_tcoeff[0]=*previous_DC+getKbits(size_val);
  429. *previous_DC=DCT_tcoeff[0];
  430. }
  431. break;
  432.  }
  433.  min_val++; max_val++;
  434.    }
  436. // Second, AC coefficient decoding
  437.    min_code=HTAC[AC_nr].minor_code;
  438.    maj_code=HTAC[AC_nr].major_code;
  439.    huff_values=HTAC[AC_nr].V;
  441.    nr=1; // AC coefficient
  442.    EOB_found=0;
  443.    while ( (nr<=63)&&(!EOB_found) )
  444. {
  445.  max_val = &maj_code[1]; min_val =&min_code[1];
  446.  for (k=1;k<=16;k++)
  447.  {
  448.    tmp_Hcode=lookKbits(k);
  449. //    max_val = &maj_code[k]; &min_val = min_code[k];
  450.    if ( (tmp_Hcode<=*max_val)&&(tmp_Hcode>=*min_val) )
  451.    {
  452. skipKbits(k);
  453. byte_temp=huff_values[WORD_hi_lo(k,(BYTE)(tmp_Hcode-*min_val))];
  454. size_val=byte_temp&0xF;
  455. count_0=byte_temp>>4;
  456. if (size_val==0) {if (count_0==0) EOB_found=1;
  457.   else if (count_0==0xF) nr+=16; //skip 16 zeroes
  458. }
  459. else
  460. {
  461.  nr+=count_0; //skip count_0 zeroes
  462.  DCT_tcoeff[nr++]=getKbits(size_val);
  463. }
  464. break;
  465.    }
  466.    min_val++; max_val++;
  467.  }
  468.  if (k>16) nr++;  // This should not occur
  469. }
  470.   for (j=0;j<=63;j++) DCT_coeff[j]=DCT_tcoeff[zigzag[j]]; // Et, voila ... DCT_coeff
  471. }
  473. void IDCT_transform(SWORD *incoeff,BYTE *outcoeff,BYTE Q_nr)
  474. // Fast float IDCT transform
  475. {
  476.  BYTE x;
  477.  SBYTE y;
  478.  SWORD *inptr;
  479.  BYTE *outptr;
  480.  float workspace[64];
  481.  float *wsptr;//Workspace pointer
  482.  float *quantptr; // Quantization table pointer
  483.  float dcval;
  484.  float tmp0,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7;
  485.  float tmp10,tmp11,tmp12,tmp13;
  486.  float z5,z10,z11,z12,z13;
  487.  BYTE *range_limit=rlimit_table+128;
  488.  // Pass 1: process COLUMNS from input and store into work array.
  489.  wsptr=workspace;
  490.  inptr=incoeff;
  491.  quantptr=QT[Q_nr];
  492.  for (y=0;y<=7;y++)
  493.   {
  494.    if( (inptr[8]|inptr[16]|inptr[24]|inptr[32]|inptr[40]|inptr[48]|inptr[56])==0)
  495. {
  496.  // AC terms all zero (in a column)
  497.  dcval=inptr[0]*quantptr[0];
  498.  wsptr[0]  = dcval;
  499.  wsptr[8]  = dcval;
  500.  wsptr[16] = dcval;
  501.  wsptr[24] = dcval;
  502.  wsptr[32] = dcval;
  503.  wsptr[40] = dcval;
  504.  wsptr[48] = dcval;
  505.  wsptr[56] = dcval;
  506.  inptr++;quantptr++;wsptr++;//advance pointers to next column
  507.  continue ;
  508. }
  509.   //Even part
  510. tmp0 = inptr[0] *quantptr[0];
  511. tmp1 = inptr[16]*quantptr[16];
  512. tmp2 = inptr[32]*quantptr[32];
  513. tmp3 = inptr[48]*quantptr[48];
  515. tmp10 = tmp0 + tmp2;// phase 3
  516. tmp11 = tmp0 - tmp2;
  518. tmp13 = tmp1 + tmp3;// phases 5-3
  519. tmp12 = (tmp1 - tmp3) * 1.414213562f - tmp13; // 2*c4
  521. tmp0 = tmp10 + tmp13;// phase 2
  522. tmp3 = tmp10 - tmp13;
  523. tmp1 = tmp11 + tmp12;
  524. tmp2 = tmp11 - tmp12;
  526. // Odd part
  527. tmp4 = inptr[8] *quantptr[8];
  528. tmp5 = inptr[24]*quantptr[24];
  529. tmp6 = inptr[40]*quantptr[40];
  530. tmp7 = inptr[56]*quantptr[56];
  532. z13 = tmp6 + tmp5;// phase 6
  533. z10 = tmp6 - tmp5;
  534. z11 = tmp4 + tmp7;
  535. z12 = tmp4 - tmp7;
  537. tmp7 = z11 + z13;// phase 5
  538. tmp11= (z11 - z13) * 1.414213562f; // 2*c4
  540. z5 = (z10 + z12) * 1.847759065f; // 2*c2
  541. tmp10 = 1.082392200f * z12 - z5; // 2*(c2-c6)
  542. tmp12 = -2.613125930f * z10 + z5;// -2*(c2+c6)
  544. tmp6 = tmp12 - tmp7;// phase 2
  545. tmp5 = tmp11 - tmp6;
  546. tmp4 = tmp10 + tmp5;
  548. wsptr[0]  = tmp0 + tmp7;
  549. wsptr[56] = tmp0 - tmp7;
  550. wsptr[8]  = tmp1 + tmp6;
  551. wsptr[48] = tmp1 - tmp6;
  552. wsptr[16] = tmp2 + tmp5;
  553. wsptr[40] = tmp2 - tmp5;
  554. wsptr[32] = tmp3 + tmp4;
  555. wsptr[24] = tmp3 - tmp4;
  556. inptr++;
  557. quantptr++;
  558. wsptr++;//advance pointers to the next column
  559.   }
  561. //  Pass 2: process ROWS from work array, store into output array.
  562. // Note that we must descale the results by a factor of 8 = 2^3
  563.  outptr=outcoeff;
  564.  wsptr=workspace;
  565.  for (x=0;x<=7;x++)
  566.   {
  567.    // Even part
  568. tmp10 = wsptr[0] + wsptr[4];
  569. tmp11 = wsptr[0] - wsptr[4];
  571. tmp13 = wsptr[2] + wsptr[6];
  572. tmp12 =(wsptr[2] - wsptr[6]) * 1.414213562f - tmp13;
  574. tmp0 = tmp10 + tmp13;
  575. tmp3 = tmp10 - tmp13;
  576. tmp1 = tmp11 + tmp12;
  577. tmp2 = tmp11 - tmp12;
  579.    // Odd part
  580. z13 = wsptr[5] + wsptr[3];
  581. z10 = wsptr[5] - wsptr[3];
  582. z11 = wsptr[1] + wsptr[7];
  583. z12 = wsptr[1] - wsptr[7];
  585. tmp7 = z11 + z13;
  586. tmp11= (z11 - z13) * 1.414213562f;
  588. z5 = (z10 + z12) * 1.847759065f; // 2*c2
  589. tmp10 = 1.082392200f * z12 - z5;  // 2*(c2-c6)
  590. tmp12 = -2.613125930f * z10 + z5; // -2*(c2+c6)
  592. tmp6 = tmp12 - tmp7;
  593. tmp5 = tmp11 - tmp6;
  594. tmp4 = tmp10 + tmp5;
  596.  // Final output stage: scale down by a factor of 8
  597. outptr[0] = range_limit[(DESCALE((int) (tmp0 + tmp7), 3)) & 1023L];
  598. outptr[7] = range_limit[(DESCALE((int) (tmp0 - tmp7), 3)) & 1023L];
  599. outptr[1] = range_limit[(DESCALE((int) (tmp1 + tmp6), 3)) & 1023L];
  600. outptr[6] = range_limit[(DESCALE((int) (tmp1 - tmp6), 3)) & 1023L];
  601. outptr[2] = range_limit[(DESCALE((int) (tmp2 + tmp5), 3)) & 1023L];
  602. outptr[5] = range_limit[(DESCALE((int) (tmp2 - tmp5), 3)) & 1023L];
  603. outptr[4] = range_limit[(DESCALE((int) (tmp3 + tmp4), 3)) & 1023L];
  604. outptr[3] = range_limit[(DESCALE((int) (tmp3 - tmp4), 3)) & 1023L];
  606. wsptr+=8;//advance pointer to the next row
  607. outptr+=8;
  608.   }
  609. }
  611. void precalculate_Cr_Cb_tables()
  612. {
  613.  WORD k;
  614.  WORD Cr_v,Cb_v;
  615.  for (k=0;k<=255;k++) Cr_tab[k]=(SWORD)((k-128.0)*1.402);
  616.  for (k=0;k<=255;k++) Cb_tab[k]=(SWORD)((k-128.0)*1.772);
  618.  for (Cr_v=0;Cr_v<=255;Cr_v++)
  619.   for (Cb_v=0;Cb_v<=255;Cb_v++)
  620.    Cr_Cb_green_tab[((WORD)(Cr_v)<<8)+Cb_v]=(int)(-0.34414*(Cb_v-128.0)-0.71414*(Cr_v-128.0));
  622. }
  624. void convert_8x8_YCbCr_to_RGB(BYTE *Y, BYTE *Cb, BYTE *Cr, DWORD im_loc, DWORD X_image_bytes, BYTE *im_buffer)
  625. // Functia (ca optimizare) poate fi apelata si fara parametrii Y,Cb,Cr
  626. // Stim ca va fi apelata doar in cazul 1x1
  627. {
  628.   DWORD x,y;
  629.   BYTE im_nr;
  630.   BYTE *Y_val = Y, *Cb_val = Cb, *Cr_val = Cr;
  631.   BYTE *ibuffer = im_buffer + im_loc;
  633.   for (y=0;y<8;y++)
  634.    {
  635. im_nr=0;
  636. for (x=0;x<8;x++)
  637.   {
  638.    ibuffer[im_nr++] = rlimit_table[*Y_val + Cb_tab[*Cb_val]]; //B
  639.    ibuffer[im_nr++] = rlimit_table[*Y_val + Cr_Cb_green_tab[WORD_hi_lo(*Cr_val,*Cb_val)]]; //G
  640.    ibuffer[im_nr++] = rlimit_table[*Y_val + Cr_tab[*Cr_val]]; // R
  641. /*
  642. // Monochrome display
  643.    im_buffer[im_nr++] = *Y_val;
  644.    im_buffer[im_nr++] = *Y_val;
  645.    im_buffer[im_nr++] = *Y_val;
  646. */
  647.    Y_val++; Cb_val++; Cr_val++; im_nr++;
  648.   }
  649. ibuffer+=X_image_bytes;
  650.    }
  651. }
  653. void convert_8x8_YCbCr_to_RGB_tab(BYTE *Y, BYTE *Cb, BYTE *Cr, BYTE *tab, DWORD im_loc, DWORD X_image_bytes, BYTE *im_buffer)
  654. // Functia (ca optimizare) poate fi apelata si fara parametrii Cb,Cr
  655. {
  656.   DWORD x,y;
  657.   BYTE nr, im_nr;
  658.   BYTE Y_val,Cb_val,Cr_val;
  659.   BYTE *ibuffer = im_buffer + im_loc;
  661.   nr=0;
  662.   for (y=0;y<8;y++)
  663.    {
  664. im_nr=0;
  665. for (x=0;x<8;x++)
  666.   {
  667.    Y_val=Y[nr];
  668.    Cb_val=Cb[tab[nr]]; Cr_val=Cr[tab[nr]]; // reindexare folosind tabelul
  669.    // de supraesantionare precalculat
  670.    ibuffer[im_nr++] = rlimit_table[Y_val + Cb_tab[Cb_val]]; //B
  671.    ibuffer[im_nr++] = rlimit_table[Y_val + Cr_Cb_green_tab[WORD_hi_lo(Cr_val,Cb_val)]]; //G
  672.    ibuffer[im_nr++] = rlimit_table[Y_val + Cr_tab[Cr_val]]; // R
  673.    nr++; im_nr++;
  674.   }
  675. ibuffer+=X_image_bytes;
  676.    }
  677. }
  679. void calculate_tabs()
  680. {
  681.  BYTE tab_temp[256];
  682.  BYTE x,y;
  684.  // Tabelul de supraesantionare 16x16
  685.  for (y=0;y<16;y++)
  686.  for (x=0;x<16;x++)
  687.    tab_temp[y*16+x] = (y/YV)* 8 + x/YH;
  689.  // Din el derivam tabelele corespunzatoare celor 4 blocuri de 8x8 pixeli
  690.  for (y=0;y<8;y++)
  691. {
  692.  for (x=0;x<8;x++)
  693.   tab_1[y*8+x]=tab_temp[y*16+x];
  694.  for (x=8;x<16;x++)
  695.   tab_2[y*8+(x-8)]=tab_temp[y*16+x];
  696. }
  697.  for (y=8;y<16;y++)
  698. {
  699.  for (x=0;x<8;x++)
  700.   tab_3[(y-8)*8+x]=tab_temp[y*16+x];
  701.  for (x=8;x<16;x++)
  702.   tab_4[(y-8)*8+(x-8)]=tab_temp[y*16+x];
  703. }
  704. }
  707. int init_JPG_decoding()
  708. {
  709.  byte_pos=0;
  710.  init_QT();
  711.  calculate_mask();
  712.  prepare_range_limit_table();
  713.  precalculate_Cr_Cb_tables();
  714.  return 1; //for future error check
  715. }
  717. DWORD filesize(FILE *fp)
  718. {
  719.  DWORD pos;
  720.  DWORD pos_cur;
  721.  pos_cur=ftell(fp);
  722.  fseek(fp,0,SEEK_END);
  723.  pos=ftell(fp);
  724.  fseek(fp,pos_cur,SEEK_SET);
  725.  return pos;
  726. }
  728. int load_JPEG_header(FILE *fp, DWORD *X_image, DWORD *Y_image)
  729. {
  730.  DWORD length_of_file;
  731.  BYTE vers,units;
  732.  WORD Xdensity,Ydensity,Xthumbnail,Ythumbnail;
  733.  WORD length;
  734.  float *qtable;
  735.  DWORD old_byte_pos;
  736.  Huffman_table *htable;
  737.  DWORD j;
  738.  BYTE precision,comp_id,nr_components;
  739.  BYTE QT_info,HT_info;
  740.  BYTE SOS_found,SOF_found;
  742.  length_of_file=filesize(fp);
  743.  buf=(BYTE *)malloc(length_of_file+4);
  744.  if (buf==NULL) exit_func("Not enough memory for loading file");
  745.  fread(buf,length_of_file,1,fp);
  747.  if ((buf[0]!=0xFF)||(buf[1]!=SOI)) exit_func("Not a JPG file ?n");
  748.  if ((buf[2]!=0xFF)||(buf[3]!=APP0)) exit_func("Invalid JPG file.");
  749.  if ( (buf[6]!='J')||(buf[7]!='F')||(buf[8]!='I')||(buf[9]!='F')||
  750.   (buf[10]!=0) ) exit_func("Invalid JPG file.");
  752.  init_JPG_decoding();
  753.  byte_pos=11;
  755.  BYTE_p(byte_pos);vers=bp;
  756.  if (vers!=1) exit_func("JFIF version not supported");
  757.  BYTE_p(byte_pos); // vers_lo=bp;
  758.  BYTE_p(byte_pos);  units=bp;
  759.  if (units!=0) //exit_func("JPG format not supported");
  760. ;// printf("units = %dn", units);
  761.  WORD_p(byte_pos); Xdensity=wp; WORD_p(byte_pos); Ydensity=wp;
  762.  if ((Xdensity!=1)||(Ydensity!=1)) //exit_func("JPG format not supported");
  763.  ;  //{printf("X density = %dn",Xdensity); printf("Y density = %dn",Ydensity);}
  764.  BYTE_p(byte_pos);Xthumbnail=bp;BYTE_p(byte_pos);Ythumbnail=bp;
  765.  if ((Xthumbnail!=0)||(Ythumbnail!=0))
  766. exit_func(" Cannot process JFIF thumbnailed filesn");
  767.  // Start decoding process
  768.  SOS_found=0; SOF_found=0; Restart_markers=0;
  769.  while ((byte_pos<length_of_file)&&!SOS_found)
  770.  {
  771.   BYTE_p(byte_pos);
  772.   if (bp!=0xFF) continue;
  773.   // A marker was found
  774.   BYTE_p(byte_pos);
  775.   switch(bp)
  776.   {
  777.    case DQT: WORD_p(byte_pos); length=wp; // length of the DQT marker
  778.  for (j=0;j<wp-2;)
  779. {
  780.  old_byte_pos=byte_pos;
  781.  BYTE_p(byte_pos); QT_info=bp;
  782.  if ((QT_info>>4)!=0)
  783.  exit_func("16 bit quantization table not supported");
  784.  qtable=QT[QT_info&0xF];
  785.  load_quant_table(qtable);
  786.  j+=byte_pos-old_byte_pos;
  787. }
  788.  break;
  789.    case DHT: WORD_p(byte_pos); length=wp;
  790.  for (j=0;j<wp-2;)
  791. {
  792.  old_byte_pos=byte_pos;
  793.  BYTE_p(byte_pos); HT_info=bp;
  794.  if ((HT_info&0x10)!=0) htable=&HTAC[HT_info&0xF];
  795.  else htable=&HTDC[HT_info&0xF];
  796.  load_Huffman_table(htable);
  797.  j+=byte_pos-old_byte_pos;
  798. }
  799.  break;
  800.    case COM: WORD_p(byte_pos); length=wp;
  801.  byte_pos+=wp-2;
  802.  break;
  803.    case DRI: Restart_markers=1;
  804.  WORD_p(byte_pos); length=wp; //should be = 4
  805.  WORD_p(byte_pos);  MCU_restart=wp;
  806.  if (MCU_restart==0) Restart_markers=0;
  807.  break;
  808.    case SOF: WORD_p(byte_pos); length=wp; //should be = 8+3*3=17
  809.  BYTE_p(byte_pos); precision=bp;
  810.  if (precision!=8) exit_func("Only 8 bit precision supported");
  811.  WORD_p(byte_pos); *Y_image=wp; WORD_p(byte_pos); *X_image=wp;
  812.  BYTE_p(byte_pos); nr_components=bp;
  813.  if (nr_components!=3) exit_func("Only truecolor JPGS supported");
  814.  for (j=1;j<=3;j++)
  815. {
  816.  BYTE_p(byte_pos); comp_id=bp;
  817.  if ((comp_id==0)||(comp_id>3)) exit_func("Only YCbCr format supported");
  818.  switch (comp_id)
  819. {
  820.  case 1: // Y
  821. BYTE_p(byte_pos); YH=bp>>4;YV=bp&0xF;
  822. BYTE_p(byte_pos); YQ_nr=bp;
  823. break;
  824.  case 2: // Cb
  825. BYTE_p(byte_pos); CbH=bp>>4;CbV=bp&0xF;
  826. BYTE_p(byte_pos); CbQ_nr=bp;
  827. break;
  828.  case 3: // Cr
  829. BYTE_p(byte_pos); CrH=bp>>4;CrV=bp&0xF;
  830. BYTE_p(byte_pos); CrQ_nr=bp;
  831. break;
  832. }
  833. }
  834.  SOF_found=1;
  835.  break;
  836.    case SOS: WORD_p(byte_pos); length=wp; //should be = 6+3*2=12
  837.  BYTE_p(byte_pos); nr_components=bp;
  838.  if (nr_components!=3) exit_func("Invalid SOS marker");
  839.  for (j=1;j<=3;j++)
  840.    {
  841. BYTE_p(byte_pos); comp_id=bp;
  842. if ((comp_id==0)||(comp_id>3)) exit_func("Only YCbCr format supported");
  843. switch (comp_id)
  844. {
  845.  case 1: // Y
  846. BYTE_p(byte_pos); YDC_nr=bp>>4;YAC_nr=bp&0xF;
  847. break;
  848.  case 2: // Cb
  849. BYTE_p(byte_pos); CbDC_nr=bp>>4;CbAC_nr=bp&0xF;
  850. break;
  851.  case 3: // Cr
  852. BYTE_p(byte_pos); CrDC_nr=bp>>4;CrAC_nr=bp&0xF;
  853. break;
  854. }
  855.    }
  856.  BYTE_p(byte_pos); BYTE_p(byte_pos); BYTE_p(byte_pos); // Skip 3 bytes
  857.  SOS_found=1;
  858.  break;
  859.    case 0xFF:
  860.  break; // do nothing for 0xFFFF, sequence of consecutive 0xFF are for
  861. // filling purposes and should be ignored
  862.    default:  WORD_p(byte_pos); length=wp;
  863.  byte_pos+=wp-2; //skip unknown marker
  864.  break;
  865.   }
  866.  }
  867.  if (!SOS_found) exit_func("Invalid JPG file. No SOS marker found.");
  868.  if (!SOF_found) exit_func("Progressive JPEGs not supported");
  870.  if ((CbH>YH)||(CrH>YH)) exit_func("Vertical sampling factor for Y should be >= sampling factor for Cb,Cr");
  871.  if ((CbV>YV)||(CrV>YV)) exit_func("Horizontal sampling factor for Y should be >= sampling factor for Cb,Cr");
  873.  if ((CbH>=2)||(CbV>=2)) exit_func("Cb sampling factors should be = 1");
  874.  if ((CrV>=2)||(CrV>=2)) exit_func("Cr sampling factors should be = 1");
  876. // Restricting sampling factors for Y,Cb,Cr should give us 4 possible cases for sampling factors
  877. // YHxYV,CbHxCbV,CrHxCrV: 2x2,1x1,1x1;  1x2,1x1,1x1; 2x1,1x1,1x1;
  878. // and 1x1,1x1,1x1 = no upsampling needed
  880.  Hmax=YH,Vmax=YV;
  881.  if ( *X_image%(Hmax*8)==0) X_round=*X_image; // X_round = Multiple of Hmax*8
  882.  else X_round=(*X_image/(Hmax*8)+1)*(Hmax*8);
  883.  if ( *Y_image%(Vmax*8)==0) Y_round=*Y_image; // Y_round = Multiple of Vmax*8
  884.  else Y_round=(*Y_image/(Vmax*8)+1)*(Vmax*8);
  886.  im_buffer=(BYTE *)malloc(X_round*Y_round*4);
  887.  if (im_buffer==NULL) exit_func("Not enough memory for storing the JPEG image");
  889.  return 1;
  890. }
  892. void resync()
  893. // byte_pos  = pozitionat pe restart marker
  894. {
  895.  byte_pos+=2;
  896.  BYTE_p(byte_pos);
  897.  if (bp==0xFF) byte_pos++; // skip 00
  898.  w1=WORD_hi_lo(bp, 0);
  899.  BYTE_p(byte_pos);
  900.  if (bp==0xFF) byte_pos++; // skip 00
  901.  w1+=bp;
  902.  BYTE_p(byte_pos);
  903.  if (bp==0xFF) byte_pos++; // skip 00
  904.  w2=WORD_hi_lo(bp, 0);
  905.  BYTE_p(byte_pos);
  906.  if (bp==0xFF) byte_pos++; // skip 00
  907.  w2+=bp;
  908.  wordval=w1; d_k=0; // Reinit bitstream decoding
  909.  DCY=0; DCCb=0; DCCr=0; // Init DC coefficients
  910. }
  912. void decode_MCU_1x1(DWORD im_loc)
  913. {
  914.  // Y
  915.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  916.  IDCT_transform(DCT_coeff,Y,YQ_nr);
  917.  // Cb
  918.  process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
  919.  IDCT_transform(DCT_coeff,Cb,CbQ_nr);
  920.  // Cr
  921.  process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
  922.  IDCT_transform(DCT_coeff,Cr,CrQ_nr);
  924.  convert_8x8_YCbCr_to_RGB(Y,Cb,Cr,im_loc,X_image_bytes,im_buffer);
  925. }
  926. void decode_MCU_2x1(DWORD im_loc)
  927. {
  928.  // Y
  929.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  930.  IDCT_transform(DCT_coeff,Y_1,YQ_nr);
  931.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  932.  IDCT_transform(DCT_coeff,Y_2,YQ_nr);
  933.  // Cb
  934.  process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
  935.  IDCT_transform(DCT_coeff,Cb,CbQ_nr);
  936.  // Cr
  937.  process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
  938.  IDCT_transform(DCT_coeff,Cr,CrQ_nr);
  940.  convert_8x8_YCbCr_to_RGB_tab(Y_1,Cb,Cr,tab_1,im_loc,X_image_bytes,im_buffer);
  941.  convert_8x8_YCbCr_to_RGB_tab(Y_2,Cb,Cr,tab_2,im_loc+32,X_image_bytes,im_buffer);
  942. }
  944. void decode_MCU_2x2(DWORD im_loc)
  945. {
  946.  // Y
  947.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  948.  IDCT_transform(DCT_coeff,Y_1,YQ_nr);
  949.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  950.  IDCT_transform(DCT_coeff,Y_2,YQ_nr);
  951.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  952.  IDCT_transform(DCT_coeff,Y_3,YQ_nr);
  953.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  954.  IDCT_transform(DCT_coeff,Y_4,YQ_nr);
  955.  // Cb
  956.  process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
  957.  IDCT_transform(DCT_coeff,Cb,CbQ_nr);
  958.  // Cr
  959.  process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
  960.  IDCT_transform(DCT_coeff,Cr,CrQ_nr);
  962.  convert_8x8_YCbCr_to_RGB_tab(Y_1,Cb,Cr,tab_1,im_loc,X_image_bytes,im_buffer);
  963.  convert_8x8_YCbCr_to_RGB_tab(Y_2,Cb,Cr,tab_2,im_loc+32,X_image_bytes,im_buffer);
  964.  convert_8x8_YCbCr_to_RGB_tab(Y_3,Cb,Cr,tab_3,im_loc+y_inc_value,X_image_bytes,im_buffer);
  965.  convert_8x8_YCbCr_to_RGB_tab(Y_4,Cb,Cr,tab_4,im_loc+y_inc_value+32,X_image_bytes,im_buffer);
  966. }
  968. void decode_MCU_1x2(DWORD im_loc)
  969. {
  970.  // Y
  971.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  972.  IDCT_transform(DCT_coeff,Y_1,YQ_nr);
  973.  process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
  974.  IDCT_transform(DCT_coeff,Y_2,YQ_nr);
  975.  // Cb
  976.  process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
  977.  IDCT_transform(DCT_coeff,Cb,CbQ_nr);
  978.  // Cr
  979.  process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
  980.  IDCT_transform(DCT_coeff,Cr,CrQ_nr);
  982.  convert_8x8_YCbCr_to_RGB_tab(Y_1,Cb,Cr,tab_1,im_loc,X_image_bytes,im_buffer);
  983.  convert_8x8_YCbCr_to_RGB_tab(Y_2,Cb,Cr,tab_3,im_loc+y_inc_value,X_image_bytes,im_buffer);
  984. }
  986. void decode_JPEG_image()
  987. {
  988.  decode_MCU_func decode_MCU;
  990.  WORD x_mcu_cnt,y_mcu_cnt;
  991.  DWORD nr_mcu;
  992.  WORD X_MCU_nr,Y_MCU_nr; // Nr de MCU-uri
  993.  DWORD MCU_dim_x; //dimensiunea in bufferul imagine a unui MCU pe axa x
  994.  DWORD im_loc_inc; // = 7 * X_round * 4 sau 15*X_round*4;
  995.  DWORD im_loc; //locatia in bufferul imagine
  997.  byte_pos-=2;
  998.  resync();
  1000.  y_inc_value = 32*X_round;
  1001.  calculate_tabs(); // Calcul tabele de supraesantionare, tinand cont de YH si YV
  1003.  if ((YH==1)&&(YV==1)) decode_MCU=decode_MCU_1x1;
  1004.  else {
  1005.    if (YH==2)
  1006.    {
  1007. if (YV==2) decode_MCU=decode_MCU_2x2;
  1008. else decode_MCU=decode_MCU_2x1;
  1009.    }
  1010.    else decode_MCU=decode_MCU_1x2;
  1011.  }
  1012.  MCU_dim_x=Hmax*8*4;
  1014.  Y_MCU_nr=Y_round/(Vmax*8); // nr of MCUs on Y axis
  1015.  X_MCU_nr=X_round/(Hmax*8); // nr of MCUs on X axis
  1017.  X_image_bytes=X_round*4; im_loc_inc = (Vmax*8-1) * X_image_bytes;
  1018.  nr_mcu=0; im_loc=0; // memory location of the current MCU
  1019.  for (y_mcu_cnt=0;y_mcu_cnt<Y_MCU_nr;y_mcu_cnt++)
  1020.  {
  1021.   for (x_mcu_cnt=0;x_mcu_cnt<X_MCU_nr;x_mcu_cnt++)
  1022.    {
  1023. decode_MCU(im_loc);
  1024. if ((Restart_markers)&&((nr_mcu+1)%MCU_restart==0)) resync();
  1025. nr_mcu++;
  1026. im_loc+=MCU_dim_x;
  1027.    }
  1028.   im_loc+=im_loc_inc;
  1029.  }
  1030. }
  1032. int get_JPEG_buffer(WORD X_image,WORD Y_image, BYTE **address_dest_buffer)
  1033. {
  1034.  WORD y;
  1035.  DWORD dest_loc=0;
  1036.  BYTE *src_buffer=im_buffer;
  1037.  BYTE *dest_buffer_start, *dest_buffer;
  1039.  DWORD src_bytes_per_line=X_round*4;
  1040.  DWORD dest_bytes_per_line=X_image*4;
  1043.  if ((X_round==X_image)&&(Y_round==Y_image))
  1044. *address_dest_buffer=im_buffer;
  1045.  else
  1046.  {
  1047.   dest_buffer_start = (BYTE *)malloc(X_image*Y_image*4);
  1048.   if (dest_buffer_start==NULL) exit_func("Not enough memory for storing the JPEG image");
  1049.   dest_buffer = dest_buffer_start;
  1050.   for (y=0;y<Y_image;y++) {
  1051.    memcpy(dest_buffer,src_buffer,dest_bytes_per_line);
  1052.    src_buffer+=src_bytes_per_line;
  1053.    dest_buffer+=dest_bytes_per_line;
  1054.   }
  1055.  *address_dest_buffer=dest_buffer_start;
  1056.  free(im_buffer);
  1057.  }
  1058. // release the buffer which contains the JPG file
  1059.  free(buf);
  1060.  return 1;
  1061. }
  1064. void main(int argc, char *argv[])
  1065. {
  1066.  FILE *fp;
  1067.  DWORD X_image, Y_image;
  1068.  BYTE *our_image_buffer;
  1069.  clock_t start_time, finish_time;
  1070.  float duration;
  1072.  if (argc<=1) fp=fopen(FileName,"rb");
  1073.   else fp=fopen(argv[1],"rb");
  1074.  if (fp==NULL) exitmessage("File not found ?");
  1075.  if (!load_JPEG_header(fp,&X_image,&Y_image)) {exitmessage(error_string);return;}
  1076.  fclose(fp);
  1078.  printf(" X_image = %dn",X_image);
  1079.  printf(" Y_image = %dn",Y_image);
  1081. /*
  1082.  printf("Sampling factors: n");
  1083.  printf("Y  : H=%d,V=%dn", YH,YV);
  1084.  printf("Cb : H=%d,V=%dn", CbH,CbV);
  1085.  printf("Cr : H=%d,V=%dn", CrH,CrV);
  1086.  printf("Restart markers  = %dn", Restart_markers);
  1087.  printf("MCU restart = %dn", MCU_restart);
  1088.  getch();
  1089. */
  1091.  printf("Decoding JPEG image...n");
  1092.  // main decoder
  1093.  start_time = clock();
  1094.  decode_JPEG_image();
  1095.  printf("Decoding finished.n");
  1096.  
  1097.  finish_time = clock();
  1098.  duration = (double)(finish_time - start_time) / CLK_TCK;
  1099.  printf( "Time elapsed: %2.1f secondsn", duration );
  1101.  if (!get_JPEG_buffer(X_image,Y_image,&our_image_buffer)) {exitmessage(error_string);return;}
  1103.  write_buf_to_BMP(our_image_buffer,X_image,Y_image, "image.bmp");
  1104.  getch();
  1105. }