jpg文件转化为bmp C++

// JPEG decoder module // Copyright 1999 Cristi Cuturicu #include "jpegdec.h" // Used markers: #define SOI 0xD8 #define EOI 0xD9 #define APP0 0xE0 #define SOF 0xC0 #define DQT 0xDB #define DHT 0xC4 #define SOS 0xDA #define DRI 0xDD #define COM 0xFE char error_string[90]; #define exit_func(err) { strcpy(error_string, err); return 0;} static BYTE *buf; // the buffer we use for storing the entire JPG file static BYTE bp; //current byte static WORD wp; //current word static DWORD byte_pos; // current byte position #define BYTE_p(i) bp=buf[(i)++] #define WORD_p(i) wp=(((WORD)(buf[(i)]))<<8) + buf[(i)+1]; (i)+=2 // WORD X_image_size,Y_image_size; // X,Y sizes of the image static WORD X_round,Y_round; // The dimensions rounded to multiple of Hmax*8 (X_round) // and Ymax*8 (Y_round) static BYTE *im_buffer; // RGBA image buffer static DWORD X_image_bytes; // size in bytes of 1 line of the image = X_round * 4 static DWORD y_inc_value ; // 32*X_round; // used by decode_MCU_1x2,2x1,2x2 BYTE YH,YV,CbH,CbV,CrH,CrV; // sampling factors (horizontal and vertical) for Y,Cb,Cr static WORD Hmax,Vmax; static BYTE zigzag[64]={ 0, 1, 5, 6,14,15,27,28, 2, 4, 7,13,16,26,29,42, 3, 8,12,17,25,30,41,43, 9,11,18,24,31,40,44,53, 10,19,23,32,39,45,52,54, 20,22,33,38,46,51,55,60, 21,34,37,47,50,56,59,61, 35,36,48,49,57,58,62,63 }; typedef struct { BYTE Length[17]; // k =1-16 ; L[k] indicates the number of Huffman codes of length k WORD minor_code[17]; // indicates the value of the smallest Huffman code of length k WORD major_code[17]; // similar, but the highest code BYTE V[65536]; // V[k][j] = Value associated to the j-th Huffman code of length k // High nibble = nr of previous 0 coefficients // Low nibble = size (in bits) of the coefficient which will be taken from the data stream } Huffman_table; static float *QT[4]; // quantization tables, no more than 4 quantization tables (QT[0..3]) static Huffman_table HTDC[4]; //DC huffman tables , no more than 4 (0..3) static Huffman_table HTAC[4]; //AC huffman tables (0..3) static BYTE YQ_nr,CbQ_nr,CrQ_nr; // quantization table number for Y, Cb, Cr static BYTE YDC_nr,CbDC_nr,CrDC_nr; // DC Huffman table number for Y,Cb, Cr static BYTE YAC_nr,CbAC_nr,CrAC_nr; // AC Huffman table number for Y,Cb, Cr static BYTE Restart_markers; // if 1 => Restart markers on , 0 => no restart markers static WORD MCU_restart; //Restart markers appears every MCU_restart MCU blocks typedef void (*decode_MCU_func)(DWORD); static SWORD DCY, DCCb, DCCr; // Coeficientii DC pentru Y,Cb,Cr static SWORD DCT_coeff[64]; // Current DCT_coefficients static BYTE Y[64],Cb[64],Cr[64]; // Y, Cb, Cr of the current 8x8 block for the 1x1 case static BYTE Y_1[64],Y_2[64],Y_3[64],Y_4[64]; static BYTE tab_1[64],tab_2[64],tab_3[64],tab_4[64]; // tabelele de supraesantionare pt cele 4 blocuri static SWORD Cr_tab[256],Cb_tab[256]; // Precalculated Cr, Cb tables static SWORD Cr_Cb_green_tab[65536]; // Initial conditions: // byte_pos = start position in the Huffman coded segment // WORD_get(w1); WORD_get(w2);wordval=w1; static BYTE d_k=0; // Bit displacement in memory, relative to the offset of w1 // it's always <16 static WORD w1,w2; // w1 = First word in memory; w2 = Second word static DWORD wordval ; // the actual used value in Huffman decoding. static DWORD mask[17]; static SWORD neg_pow2[17]={0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767}; static DWORD start_neg_pow2=(DWORD)neg_pow2; static int shift_temp; #define RIGHT_SHIFT(x,shft) \ ((shift_temp = (x)) < 0 ? \ (shift_temp >> (shft)) | ((~(0L)) << (32-(shft))) : \ (shift_temp >> (shft))) #define DESCALE(x,n) RIGHT_SHIFT((x) + (1L << ((n)-1)), n) #define RANGE_MASK 1023L static BYTE *rlimit_table; void prepare_range_limit_table() /* Allocate and fill in the sample_range_limit table */ { int j; rlimit_table = (BYTE *)malloc(5 * 256L + 128) ; /* First segment of "simple" table: limit[x] = 0 for x < 0 */ memset((void *)rlimit_table,0,256); rlimit_table += 256; /* allow negative subscripts of simple table */ /* Main part of "simple" table: limit[x] = x */ for (j = 0; j < 256; j++) rlimit_table[j] = j; /* End of simple table, rest of first half of post-IDCT table */ for (j = 256; j < 640; j++) rlimit_table[j] = 255; /* Second half of post-IDCT table */ memset((void *)(rlimit_table + 640),0,384); for (j = 0; j < 128 ; j++) rlimit_table[j+1024] = j; } #ifdef _MSC_VER WORD lookKbits(BYTE k) { _asm { mov dl, k mov cl, 16 sub cl, dl mov eax, [wordval] shr eax, cl } } WORD WORD_hi_lo(BYTE byte_high,BYTE byte_low) { _asm { mov ah,byte_high mov al,byte_low } } SWORD get_svalue(BYTE k) // k>0 always // Takes k bits out of the BIT stream (wordval), and makes them a signed value { _asm { xor ecx, ecx mov cl,k mov eax,[wordval] shl eax,cl shr eax, 16 dec cl bt eax,ecx jc end_macro inc cl mov ebx,[start_neg_pow2] add ax,word ptr [ebx+ecx*2] end_macro: } } #endif #ifdef __WATCOMC__ WORD lookKbits(BYTE k); #pragma aux lookKbits=\ "mov eax,[wordval]"\ "mov cl, 16"\ "sub cl, dl"\ "shr eax, cl"\ parm [dl] \ value [ax] \ modify [eax cl]; WORD WORD_hi_lo(BYTE byte_high,BYTE BYTE_low); #pragma aux WORD_hi_lo=\ parm [ah] [al]\ value [ax] \ modify [ax]; SWORD get_svalue(BYTE k); // k>0 always // Takes k bits out of the BIT stream (wordval), and makes them a signed value #pragma aux get_svalue=\ "xor ecx, ecx"\ "mov cl, al"\ "mov eax,[wordval]"\ "shl eax, cl"\ "shr eax, 16"\ "dec cl"\ "bt eax,ecx"\ "jc end_macro"\ "inc cl"\ "mov ebx,[start_neg_pow2]"\ "add ax,word ptr [ebx+ecx*2]"\ "end_macro:"\ parm [al]\ modify [eax ebx ecx]\ value [ax]; #endif void skipKbits(BYTE k) { BYTE b_high,b_low; d_k+=k; if (d_k>=16) { d_k-=16; w1=w2; // Get the next word in w2 BYTE_p(byte_pos); if (bp!=0xFF) b_high=bp; else { if (buf[byte_pos]==0) byte_pos++; //skip 00 else byte_pos--; // stop byte_pos pe restart marker b_high=0xFF; } BYTE_p(byte_pos); if (bp!=0xFF) b_low=bp; else { if (buf[byte_pos]==0) byte_pos++; //skip 00 else byte_pos--; // stop byte_pos pe restart marker b_low=0xFF; } w2=WORD_hi_lo(b_high,b_low); } wordval = ((DWORD)(w1)<<16) + w2; wordval <<= d_k; wordval >>= 16; } SWORD getKbits(BYTE k) { SWORD signed_wordvalue; signed_wordvalue=get_svalue(k); skipKbits(k); return signed_wordvalue; } void calculate_mask() { BYTE k; DWORD tmpdv; for (k=0;k<=16;k++) { tmpdv=0x10000;mask[k]=(tmpdv>>k)-1;} //precalculated bit mask } void init_QT() { BYTE i; for (i=0;i<=3;i++) QT[i]=(float *)malloc(sizeof(float)*64); } void load_quant_table(float *quant_table) { float scalefactor[8]={1.0f, 1.387039845f, 1.306562965f, 1.175875602f, 1.0f, 0.785694958f, 0.541196100f, 0.275899379f}; BYTE j,row,col; // Load quantization coefficients from JPG file, scale them for DCT and reorder // from zig-zag order for (j=0;j<=63;j++) quant_table[j]=buf[byte_pos+zigzag[j]]; j=0; for (row=0;row<=7;row++) for (col=0;col<=7;col++) { quant_table[j]*=scalefactor[row]*scalefactor[col]; j++; } byte_pos+=64; } void load_Huffman_table(Huffman_table *HT) { BYTE k,j; DWORD code; for (j=1;j<=16;j++) { BYTE_p(byte_pos); HT->Length[j]=bp; } for (k=1;k<=16;k++) for (j=0;j<HT->Length[k];j++) { BYTE_p(byte_pos); HT->V[WORD_hi_lo(k,j)]=bp; } code=0; for (k=1;k<=16;k++) { HT->minor_code[k] = (WORD)code; for (j=1;j<=HT->Length[k];j++) c