学步园

//jpeg转bmp的原理很简单，用ipciture读入jpg图像，然后在成bmp的，由于在vc 6.0里面可以自动存储的格式只有两种：bmp和ico，由此的来

void JpegToBmp(const char *resourcepath,const char *destnatepath)
{
    IPicture *m_picture;
   
    CFile file(resourcepath,CFile::modeRead);
    DWORD m_filelen=file.GetLength();
    HGLOBAL hglobal=GlobalAlloc(GMEM_MOVEABLE,m_filelen);
    LPVOID pdata=NULL;
    pdata=GlobalLock(hglobal);
    file.ReadHuge(pdata,m_filelen);
    IStream *m_stream;
    GlobalUnlock(hglobal);
    file.Close();
   
    CreateStreamOnHGlobal(hglobal,TRUE,&m_stream);
    OleLoadPicture(m_stream,m_filelen,TRUE,IID_IPicture,(LPVOID*)&m_picture); 
     
      LONG   size;  
      m_picture->SaveAsFile(m_stream,TRUE,&size);  
      char   pathbuf[1024];  
      CFile   iconfile;  
      iconfile.Open(destnatepath,CFile::modeCreate|CFile::modeWrite);  
      LARGE_INTEGER li;  
      li.HighPart = 0;  
      li.LowPart = 0;  
      ULARGE_INTEGER ulnewpos;  
      m_stream->Seek(li,STREAM_SEEK_SET,&ulnewpos);  
      ULONG  uReadCount = 1;  
      while(uReadCount>0)  
      {  
            m_stream->Read(pathbuf,sizeof(pathbuf),&uReadCount);  
            if(uReadCount>0)  
                                iconfile.Write(pathbuf,uReadCount);  
      }
   
    GlobalFree(hglobal);
    m_stream->Release();
    m_stream=NULL;
    m_picture->Release();            
}

bmp转jpg的麻烦一点儿，因为jpg需要复杂的解压，从网上download了一个，可用主要是通过两个类实现：// CompressEncode.h: interface for the CCompressEncode class.<br /> //<br /> //////////////////////////////////////////////////////////////////////<br /> #if !defined(AFX_COMPRESSENCODE_H__0EF37988_FDDE_4229_9EF1_CA5B1E51BEFF__INCLUDED_)<br /> #define AFX_COMPRESSENCODE_H__0EF37988_FDDE_4229_9EF1_CA5B1E51BEFF__INCLUDED_<br /> #if _MSC_VER > 1000<br /> #pragma once<br /> #endif // _MSC_VER > 1000<br /> typedef struct tag_HUFFMAN_TABLE {<br /> unsigned int code[256]; // code for each symbol<br /> char size[256]; // length of code for each symbol<br /> //If no code has been allocated for a symbol S, size[S] is 0 </p> <p> /* These two fields directly represent the contents of a JPEG DHT marker */<br /> unsigned char bits[17]; /* bits[k] = # of symbols with codes of */<br /> /* length k bits; bits[0] is unused */<br /> unsigned char huffval[256]; /* The symbols, in order of incr code length */<br /> /* This field is used only during compression. It's initialized FALSE when<br /> * the table is created, and set TRUE when it's been output to the file.<br /> * You could suppress output of a table by setting this to TRUE.<br /> * (See jpeg_suppress_tables for an example.)*/<br /> }HUFFMAN_TABLE;<br /> class CCompressEncode<br /> {<br /> public:<br /> CCompressEncode();<br /> virtual ~CCompressEncode();<br /> CCompressEncode( int nQuality );<br /> bool CompressImage(<br /> unsigned char *pInBuf, //source data, bgr format, 3 bytes per pixel<br /> unsigned char *pOutBuf, //destination buffer, in jpg format<br /> int nWidthPix, //image width in pixels<br /> int nHeight, //height<br /> int& nOutputBytes //return number of bytes being written<br /> ); </p> <p> ////////////////////////////////////////////////////////////////////////////<br /> // Following data members should be computed in initialization </p> <p> unsigned short m_nQuality, m_nScale; </p> <p> //RGB转化YCbCr颜色对应表<br /> int m_RToY[256], m_GToY[256], m_BToY[256];<br /> int m_RToCb[256], m_GToCb[256], m_BToCb[256];<br /> int m_RToCr[256], m_GToCr[256], m_BToCr[256]; </p> <p> // To speed up, we precompute two DCT quant tables<br /> unsigned short m_qtblY[64], m_qtblCbCr[64]; </p> <p> //用来写入JPG文件头<br /> unsigned char m_dqtY[64], m_dqtCbCr[64]; </p> <p> HUFFMAN_TABLE m_htblYDC, m_htblYAC, m_htblCbCrDC, m_htblCbCrAC; </p> <p> //////////////////////////////////////////////////////////////////////////// </p> <p> ////////////////////////////////////////////////////////////////////////////<br /> // Following are should be initialized for compressing every image </p> <p> unsigned short m_nWidth, m_nHeight; </p> <p> // Three dc records, used for dc differentize for Y/Cb/Cr<br /> int m_dcY, m_dcCb, m_dcCr; </p> <p> // The size (in bits) and value (in 4 byte buffer) to be written out<br /> int m_nPutBits, m_nPutVal; </p> <p> unsigned char *m_pOutBuf; </p> <p> //////////////////////////////////////////////////////////////////////////// </p> <p>private: </p> <p> void InitEncoder( void ); </p> <p> void InitColorTable( void ); </p> <p> void InitQuantTable( void ); </p> <p> void ScaleQuantTable(<br /> unsigned short* tblRst,<br /> unsigned char* tblStd,<br /> unsigned short* tblAan<br /> ); </p> <p> void ScaleTable(unsigned char* tbl, int scale, int max); </p> <p> void InitHuffmanTable( void ); </p> <p> void ComputeHuffmanTable(<br /> unsigned char * pBits,<br /> unsigned char * pVal,<br /> HUFFMAN_TABLE * pTbl<br /> ); </p> <p> bool CompressOneTile(<br /> unsigned char * pBgr //source data, in BGR format<br /> ); </p> <p> void BGRToYCbCr(<br /> unsigned char * pBgr, //tile source data, in BGR format, 768 bytes<br /> unsigned char * pY, //out, Illuminance, 256 bytes<br /> unsigned char * pCb, //out, Cb, 256 bytes<br /> unsigned char * pCr //out, Cr, 256 bytes<br /> ); </p> <p> void BGRToYCbCrEx(<br /> unsigned char * pBgr, //in, tile data, in BGR format, 768 bytes<br /> int * pBlock //out, Y: 256; Cb: 64; Cr: 64<br /> ); </p> <p> void ForwardDct(<br /> int* data, //source data, length is 64<br /> int* coef //output dct coefficients<br /> ); </p> <p> void Quantize(<br /> int* coef, //coef is both in and out<br /> int iBlock //block id; Y: 0,1,2,3; Cb: 4; Cr: 5<br /> ); </p> <p> bool HuffmanEncode(<br /> int* pCoef, // DCT coefficients<br /> int iBlock // 0,1,2,3:Y; 4:Cb; 5:Cr;<br /> ); </p> <p> bool EmitBits(<br /> unsigned int code, //Huffman code<br /> int size //Size in bits of the Huffman code<br /> ); </p> <p> void EmitLeftBits(void); </p> <p> void WriteJpegHeader(void);<br /> void write_sos(void);<br /> void write_sof(int code);<br /> void write_app0(void);<br /> void write_soi(void);<br /> void write_dht(int IsCbCr, int IsAc);<br /> void write_dqt(int index); </p> <p>};<br /> #endif // !defined(AFX_COMPRESSENCODE_H__0EF37988_FDDE_4229_9EF1_CA5B1E51BEFF__INCLUDED_) #ifndef __PICTUREOPERATE_H__<br /> #define __PICTUREOPERATE_H__ </p> <p>class PictureOperate<br /> {<br /> public:<br /> PictureOperate();<br /> ~PictureOperate(); </p> <p> //加载位图<br /> BOOL Load( const char * ); </p> <p> //进行编码压缩并且保存文件<br /> void picCompressEncode(CString filename, BOOL color, int quality); </p> <p> UINT m_width, m_height, m_rowbytes; </p> <p>private:<br /> DWORD m_dwDibSize;<br /> unsigned char *m_pDib, *m_pDibBits;<br /> BITMAPINFOHEADER *m_pBIH; </p> <p> CPalette m_Palette;<br /> RGBQUAD *m_pPalette;<br /> int m_nPaletteEntries;<br /> };<br /> #endif
 #include "stdafx.h"<br /> #include "PicOperate.h"<br /> #include "CompressEncode.h"<br /> ///////////////////////////////////////////////////////////////////////////////<br /> //构造函数<br /> PictureOperate::PictureOperate()<br /> {<br /> m_pDib = NULL;<br /> }<br /> //析构函数<br /> PictureOperate::~PictureOperate()<br /> {<br /> if( m_pDib != NULL )<br /> delete [] m_pDib;<br /> }<br /> //加载位图<br /> BOOL PictureOperate::Load( const char *pszFilename )<br /> { </p> <p> CFile cf; </p> <p> // Attempt to open the Dib file for reading.<br /> if( !cf.Open( pszFilename, CFile::modeRead ) )<br /> return( FALSE ); </p> <p> // Get the size of the file and store<br /> // in a local variable. Subtract the<br /> // size of the BITMAPFILEHEADER structure<br /> // since we won't keep that in memory.<br /> DWORD dwDibSize;<br /> dwDibSize =<br /> cf.GetLength() - sizeof( BITMAPFILEHEADER ); </p> <p> // Attempt to allocate the Dib memory.<br /> unsigned char *pDib;<br /> pDib = new unsigned char [dwDibSize];<br /> if( pDib == NULL )<br /> return( FALSE ); </p> <p> BITMAPFILEHEADER BFH; </p> <p> // Read in the Dib header and data.<br /> try{ </p> <p> // Did we read in the entire BITMAPFILEHEADER?<br /> if( cf.Read( &BFH, sizeof( BITMAPFILEHEADER ) )<br /> != sizeof( BITMAPFILEHEADER ) || </p> <p> // Is the type 'MB'?<br /> BFH.bfType != 'MB' || </p> <p> // Did we read in the remaining data?<br /> cf.Read( pDib, dwDibSize ) != dwDibSize ){ </p> <p> // Delete the memory if we had any<br /> // errors and return FALSE.<br /> delete [] pDib;<br /> return( FALSE );<br /> }<br /> } </p> <p> // If we catch an exception, delete the<br /> // exception, the temporary Dib memory,<br /> // and return FALSE.<br /> catch( CFileException *e ){<br /> e->Delete();<br /> delete [] pDib;<br /> return( FALSE );<br /> } </p> <p> // If we got to this point, the Dib has been<br /> // loaded. If a Dib was already loaded into<br /> // this class, we must now delete it.<br /> if( m_pDib != NULL )<br /> delete m_pDib; </p> <p> // Store the local Dib data pointer and<br /> // Dib size variables in the class member<br /> // variables.<br /> m_pDib = pDib;<br /> m_dwDibSize = dwDibSize; </p> <p> // Pointer our BITMAPINFOHEADER and RGBQUAD<br /> // variables to the correct place in the Dib data.<br /> m_pBIH = (BITMAPINFOHEADER *) m_pDib;<br /> m_pPalette =<br /> (RGBQUAD *) &m_pDib[sizeof(BITMAPINFOHEADER)]; </p> <p> // get image width and height<br /> m_width = m_pBIH->biWidth;<br /> m_height = m_pBIH->biHeight; </p> <p> // Calculate the number of palette entries.<br /> m_nPaletteEntries = 1 << m_pBIH->biBitCount;<br /> if( m_pBIH->biBitCount > 8 )<br /> m_nPaletteEntries = 0;<br /> else if( m_pBIH->biClrUsed != 0 )<br /> m_nPaletteEntries = m_pBIH->biClrUsed; </p> <p> // Point m_pDibBits to the actual Dib bits data.<br /> m_pDibBits =<br /> &m_pDib[sizeof(BITMAPINFOHEADER)+<br /> m_nPaletteEntries*sizeof(RGBQUAD)]; </p> <p> // If we have a valid palette, delete it.<br /> if( m_Palette.GetSafeHandle() != NULL )<br /> m_Palette.DeleteObject(); </p> <p> // If there are palette entries, we'll need<br /> // to create a LOGPALETTE then create the<br /> // CPalette palette.<br /> if( m_nPaletteEntries != 0 ){ </p> <p> // Allocate the LOGPALETTE structure.<br /> LOGPALETTE *pLogPal = (LOGPALETTE *) new char<br /> [sizeof(LOGPALETTE)+<br /> m_nPaletteEntries*sizeof(PALETTEENTRY)]; </p> <p> if( pLogPal != NULL ){ </p> <p> // Set the LOGPALETTE to version 0x300<br /> // and store the number of palette<br /> // entries.<br /> pLogPal->palVersion = 0x300;<br /> pLogPal->palNumEntries = m_nPaletteEntries; </p> <p> // Store the RGB values into each<br /> // PALETTEENTRY element.<br /> for( int i=0; i<m_nPaletteEntries; i++){<br /> pLogPal->palPalEntry[i].peRed =<br /> m_pPalette[i].rgbRed;<br /> pLogPal->palPalEntry[i].peGreen =<br /> m_pPalette[i].rgbGreen;<br /> pLogPal->palPalEntry[i].peBlue =<br /> m_pPalette[i].rgbBlue;<br /> } </p> <p> // Create the CPalette object and<br /> // delete the LOGPALETTE memory.<br /> m_Palette.CreatePalette( pLogPal );<br /> delete [] pLogPal;<br /> }<br /> } </p> <p> return( TRUE ); </p> <p>} </p> <p>///////////////////////////////////////////////////////////////////////////////<br /> //对位图进行基于DCT的压缩编码，并且保存为JPG文件<br /> void PictureOperate::picCompressEncode(CString filename, BOOL color, int quality)<br /> { </p> <p> //压缩后的字节数<br /> int nOutputBytes = 0; </p> <p> unsigned char *pJpg;<br /> pJpg = new unsigned char [m_dwDibSize]; </p> <p> LARGE_INTEGER iLarge;<br /> QueryPerformanceFrequency( &iLarge );<br /> double dbFreq = (double) iLarge.QuadPart; </p> <p> //获得起始时间<br /> QueryPerformanceCounter( &iLarge );<br /> double dbBegin = (double) iLarge.QuadPart; </p> <p> ///////////////////////////////////////////////////// </p> <p> //quality为压缩质量<br /> CCompressEncode encoder( quality ); </p> <p> encoder.CompressImage( m_pDibBits, pJpg,<br /> m_pBIH->biWidth, m_pBIH->biHeight, nOutputBytes ); </p> <p> ////////////////////////////////////////////////////// </p> <p> //获得压缩结束后时间<br /> QueryPerformanceCounter( &iLarge );<br /> double dbEnd = (double) iLarge.QuadPart; </p> <p> int nms = (int) (( dbEnd - dbBegin ) * 1000.0 / dbFreq ); </p> <p> float ratio = (float) m_dwDibSize / nOutputBytes;<br /> CString str;<br /> //输出压缩后信息<br /> str.Format( "压缩后字节数 = %d, 压缩比 = %f, 耗时 = %d ",<br /> nOutputBytes, ratio, nms );<br /> AfxMessageBox( str ); </p> <p> //保存JPG文件<br /> CFile cf;<br /> if( !cf.Open( filename, CFile::modeCreate | CFile::modeWrite ) )<br /> {<br /> AfxMessageBox("Can not create jpg file!");<br /> return;<br /> } </p> <p> cf.Write( pJpg, nOutputBytes ); </p> <p> delete []pJpg;<br /> } // CompressEncode.cpp: implementation of the CCompressEncode class.<br /> //<br /> //////////////////////////////////////////////////////////////////////<br /> #include "stdafx.h"<br /> #include "bmptojpg.h"<br /> #include "CompressEncode.h"<br /> #ifdef _DEBUG<br /> #undef THIS_FILE<br /> static char THIS_FILE[]=__FILE__;<br /> #define new DEBUG_NEW<br /> #endif<br /> //////////////////////////////////////////////////////////////////////<br /> // Construction/Destruction<br /> //////////////////////////////////////////////////////////////////////<br /> ////////////////////////////////////////////////////////////////////////////////<br /> //JPEG标志码<br /> typedef enum {<br /> M_SOF0 = 0xc0,<br /> M_SOF1 = 0xc1,<br /> M_SOF2 = 0xc2,<br /> M_SOF3 = 0xc3, </p> <p> M_SOF5 = 0xc5,<br /> M_SOF6 = 0xc6,<br /> M_SOF7 = 0xc7, </p> <p> M_JPG = 0xc8,<br /> M_SOF9 = 0xc9,<br /> M_SOF10 = 0xca,<br /> M_SOF11 = 0xcb, </p> <p> M_SOF13 = 0xcd,<br /> M_SOF14 = 0xce,<br /> M_SOF15 = 0xcf, </p> <p> M_DHT = 0xc4, </p> <p> M_DAC = 0xcc, </p> <p> M_RST0 = 0xd0,<br /> M_RST1 = 0xd1,<br /> M_RST2 = 0xd2,<br /> M_RST3 = 0xd3,<br /> M_RST4 = 0xd4,<br /> M_RST5 = 0xd5,<br /> M_RST6 = 0xd6,<br /> M_RST7 = 0xd7, </p> <p> M_SOI = 0xd8,<br /> M_EOI = 0xd9,<br /> M_SOS = 0xda,<br /> M_DQT = 0xdb,<br /> M_DNL = 0xdc,<br /> M_DRI = 0xdd,<br /> M_DHP = 0xde,<br /> M_EXP = 0xdf, </p> <p> M_APP0 = 0xe0,<br /> M_APP1 = 0xe1,<br /> M_APP2 = 0xe2,<br /> M_APP3 = 0xe3,<br /> M_APP4 = 0xe4,<br /> M_APP5 = 0xe5,<br /> M_APP6 = 0xe6,<br /> M_APP7 = 0xe7,<br /> M_APP8 = 0xe8,<br /> M_APP9 = 0xe9,<br /> M_APP10 = 0xea,<br /> M_APP11 = 0xeb,<br /> M_APP12 = 0xec,<br /> M_APP13 = 0xed,<br /> M_APP14 = 0xee,<br /> M_APP15 = 0xef, </p> <p> M_JPG0 = 0xf0,<br /> M_JPG13 = 0xfd,<br /> M_COM = 0xfe, </p> <p> M_TEM = 0x01, </p> <p> M_ERROR = 0x100<br /> } JPEG_MARKER; </p> <p>//Z字型扫描数组<br /> static const int jpeg_natural_order[64+16] = {<br /> 0, 1, 8, 16, 9, 2, 3, 10,<br /> 17, 24, 32, 25, 18, 11, 4, 5,<br /> 12, 19, 26, 33, 40, 48, 41, 34,<br /> 27, 20, 13, 6, 7, 14, 21, 28,<br /> 35, 42, 49, 56, 57, 50, 43, 36,<br /> 29, 22, 15, 23, 30, 37, 44, 51,<br /> 58, 59, 52, 45, 38, 31, 39, 46,<br /> 53, 60, 61, 54, 47, 55, 62, 63,<br /> 63, 63, 63, 63, 63, 63, 63, 63,//extra entries for safety<br /> 63, 63, 63, 63, 63, 63, 63, 63<br /> }; </p> <p> unsigned char std_luminance_quant_tbl[64] =<br /> {<br /> 16, 11, 10, 16, 24, 40, 51, 61,<br /> 12, 12, 14, 19, 26, 58, 60, 55,<br /> 14, 13, 16, 24, 40, 57, 69, 56,<br /> 14, 17, 22, 29, 51, 87, 80, 62,<br /> 18, 22, 37, 56, 68, 109, 103, 77,<br /> 24, 35, 55, 64, 81, 104, 113, 92,<br /> 49, 64, 78, 87, 103, 121, 120, 101,<br /> 72, 92, 95, 98, 112, 100, 103, 99<br /> };<br /> unsigned char std_chrominance_quant_tbl[64] =<br /> {<br /> 17, 18, 24, 47, 99, 99, 99, 99,<br /> 18, 21, 26, 66, 99, 99, 99, 99,<br /> 24, 26, 56, 99, 99, 99, 99, 99,<br /> 47, 66, 99, 99, 99, 99, 99, 99,<br /> 99, 99, 99, 99, 99, 99, 99, 99,<br /> 99, 99, 99, 99, 99, 99, 99, 99,<br /> 99, 99, 99, 99, 99, 99, 99, 99,<br /> 99, 99, 99, 99, 99, 99, 99, 99<br /> }; </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>#define emit_byte(val) *m_pOutBuf++=(unsigned char)(val); </p> <p>#define emit_2bytes(val) *m_pOutBuf=(unsigned char)(((val)>>8)&0xFF); *(m_pOutBuf+1)=(unsigned char)((val)&0xFF); m_pOutBuf+=2; </p> <p>#define emit_marker(val) *m_pOutBuf=0xFF; *(m_pOutBuf+1)=(unsigned char)(val); m_pOutBuf+=2; </p> <p>//////////////////////////////////////////////////////////////////////<br /> CCompressEncode::CCompressEncode()<br /> {<br /> m_nQuality = 50;<br /> InitEncoder( );<br /> }<br /> CCompressEncode::CCompressEncode(int nQuality)<br /> {<br /> m_nQuality = nQuality;<br /> InitEncoder( );<br /> }<br /> CCompressEncode::~CCompressEncode()<br /> {<br /> }<br /> //////////////////////////////////////////////////////////////////////////<br /> //初始化颜色转化表、量化表、Huffman表<br /> void CCompressEncode::InitEncoder( )<br /> { </p> <p> InitColorTable( ); </p> <p> InitQuantTable( ); </p> <p> InitHuffmanTable( );<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>//从RGB转换成YCbCr<br /> /* </p> <p> * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B<br /> * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + 128<br /> * Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + 128 </p> <p> */<br /> void CCompressEncode::InitColorTable( void )<br /> {<br /> int i;<br /> int nScale = 1L << 16;<br /> int CBCR_OFFSET = 128<<16; </p> <p> int nHalf = nScale >> 1; </p> <p> for( i=0; i<256; i++ )<br /> {<br /> m_RToY[ i ] = (int)( 0.29900 * nScale + 0.5 ) * i;<br /> m_GToY[ i ] = (int)( 0.58700 * nScale + 0.5 ) * i;<br /> m_BToY[ i ] = (int)( 0.11400 * nScale + 0.5 ) * i + nHalf; </p> <p> m_RToCb[ i ] = (int)( 0.16874 * nScale + 0.5 ) * (-i);<br /> m_GToCb[ i ] = (int)( 0.33126 * nScale + 0.5 ) * (-i);<br /> m_BToCb[ i ] = (int)( 0.50000 * nScale + 0.5 ) * i +<br /> CBCR_OFFSET + nHalf - 1; </p> <p> m_RToCr[ i ] = m_BToCb[ i ];<br /> m_GToCr[ i ] = (int)( 0.41869 * nScale + 0.5 ) * (-i);<br /> m_BToCr[ i ] = (int)( 0.08131 * nScale + 0.5 ) * (-i);<br /> }<br /> } </p> <p>////////////////////////////////////////////////////////////////////////////////<br /> //初始化量化表<br /> //m_tblYQuant[0..63] 和m_tblCbCrQuant[0..63] </p> <p>void CCompressEncode::InitQuantTable( void )<br /> { </p> <p> static unsigned short aanscales[64] = { </p> <p> 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,<br /> 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,<br /> 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,<br /> 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,<br /> 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,<br /> 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,<br /> 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,<br /> 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247<br /> }; </p> <p> m_nScale = m_nQuality; </p> <p> if (m_nScale <= 0)<br /> m_nScale = 1;<br /> if (m_nScale > 100)<br /> m_nScale = 100; </p> <p> if (m_nScale < 50)<br /> m_nScale = 5000 / m_nScale;<br /> else<br /> m_nScale = 200 - m_nScale*2; </p> <p> memcpy( m_dqtY, std_luminance_quant_tbl, 64 );<br /> memcpy( m_dqtCbCr, std_chrominance_quant_tbl, 64 ); </p> <p> ScaleTable( m_dqtY, m_nScale, 100 );<br /> ScaleTable( m_dqtCbCr, m_nScale, 100 ); </p> <p> ScaleQuantTable( m_qtblY, &std_luminance_quant_tbl[0], aanscales );<br /> ScaleQuantTable( m_qtblCbCr, &std_chrominance_quant_tbl[0], aanscales );<br /> } </p> <p>////////////////////////////////////////////////////////////////////////////////<br /> void CCompressEncode::ScaleTable(unsigned char* tbl, int scale, int max)<br /> {<br /> int i, temp, half = max/2; </p> <p> for (i = 0; i < 64; i++)<br /> { </p> <p> temp = (int)(( m_nScale * tbl[i] + half ) / max ); </p> <p> if (temp <= 0)<br /> temp = 1;<br /> if (temp > 255)<br /> temp = 255; </p> <p> tbl[i] = (unsigned char)temp;<br /> }<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>void CCompressEncode::ScaleQuantTable(<br /> unsigned short* tblRst,<br /> unsigned char* tblStd,<br /> unsigned short* tblAan<br /> )<br /> {<br /> int i, temp, half = 1<<10;<br /> for (i = 0; i < 64; i++)<br /> { </p> <p> temp = (int)(( m_nScale * tblStd[i] + 50 ) / 100 ); </p> <p> if (temp <= 0)<br /> temp = 1;<br /> if (temp > 255)<br /> temp = 255; </p> <p> tblRst[i] = (unsigned short)(( temp * tblAan[i] + half )>>11 );<br /> }<br /> } </p> <p>////////////////////////////////////////////////////////////////////////////////<br /> //初始化Huffman表:<br /> // HUFFMAN_TABLE m_htblYDC, m_htblYAC, m_htblCbCrDC, m_htblCbCrAC; </p> <p>void CCompressEncode::InitHuffmanTable( void )<br /> {<br /> // Y dc系数<br /> static unsigned char bitsYDC[17] =<br /> { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };<br /> static unsigned char valYDC[] =<br /> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; </p> <p> // CbCr dc<br /> static unsigned char bitsCbCrDC[17] =<br /> { 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };<br /> static unsigned char valCbCrDC[] =<br /> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; </p> <p> // Y ac系数<br /> static unsigned char bitsYAC[17] =<br /> { 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };<br /> static unsigned char valYAC[] =<br /> { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,<br /> 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,<br /> 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,<br /> 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,<br /> 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,<br /> 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,<br /> 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,<br /> 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,<br /> 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,<br /> 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,<br /> 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,<br /> 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,<br /> 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,<br /> 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,<br /> 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,<br /> 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,<br /> 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,<br /> 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,<br /> 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,<br /> 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,<br /> 0xf9, 0xfa }; </p> <p> // CbCr ac<br /> static unsigned char bitsCbCrAC[17] =<br /> { 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };<br /> static unsigned char valCbCrAC[] =<br /> { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,<br /> 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,<br /> 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,<br /> 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,<br /> 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,<br /> 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,<br /> 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,<br /> 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,<br /> 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,<br /> 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,<br /> 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,<br /> 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,<br /> 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,<br /> 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,<br /> 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,<br /> 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,<br /> 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,<br /> 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,<br /> 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,<br /> 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,<br /> 0xf9, 0xfa }; </p> <p> // 计算生成Huffman表<br /> ComputeHuffmanTable( bitsYDC, valYDC, &m_htblYDC );<br /> ComputeHuffmanTable( bitsYAC, valYAC, &m_htblYAC ); </p> <p> ComputeHuffmanTable( bitsCbCrDC, valCbCrDC, &m_htblCbCrDC );<br /> ComputeHuffmanTable( bitsCbCrAC, valCbCrAC, &m_htblCbCrAC );<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>// 计算生成Huffman表<br /> void CCompressEncode::ComputeHuffmanTable(<br /> unsigned char * pBits,<br /> unsigned char * pVal,<br /> HUFFMAN_TABLE * pTbl )<br /> {<br /> int p, i, l, lastp, si;<br /> char huffsize[257];<br /> unsigned int huffcode[257];<br /> unsigned int code; </p> <p> // First we copy bits and huffval<br /> memcpy( pTbl->bits, pBits, sizeof(pTbl->bits) );<br /> memcpy( pTbl->huffval, pVal, sizeof(pTbl->huffval) ); </p> <p> /* Figure C.1: make table of Huffman code length for each symbol */<br /> /* Note that this is in code-length order. */ </p> <p> p = 0;<br /> for (l = 1; l <= 16; l++) {<br /> for (i = 1; i <= (int) pBits[l]; i++)<br /> huffsize[p++] = (char) l;<br /> }<br /> huffsize[p] = 0;<br /> lastp = p; </p> <p> /* Figure C.2: generate the codes themselves */<br /> /* Note that this is in code-length order. */ </p> <p> code = 0;<br /> si = huffsize[0];<br /> p = 0;<br /> while (huffsize[p]) {<br /> while (((int) huffsize[p]) == si) {<br /> huffcode[p++] = code;<br /> code++;<br /> }<br /> code <<= 1;<br /> si++;<br /> } </p> <p> /* Figure C.3: generate encoding tables */<br /> /* These are code and size indexed by symbol value */ </p> <p> /* Set any codeless symbols to have code length 0;<br /> * this allows EmitBits to detect any attempt to emit such symbols.<br /> */<br /> memset( pTbl->size, 0, sizeof( pTbl->size ) ); </p> <p> for (p = 0; p < lastp; p++) {<br /> pTbl->code[ pVal[p] ] = huffcode[p];<br /> pTbl->size[ pVal[p] ] = huffsize[p];<br /> }<br /> } </p> <p>/////////////////////////////////////////////////////////////////////////////// </p> <p>//写入JPG头，soi, app0, Y_dqt, CbCr_dqt, sof, 4 * dht, sos.<br /> void CCompressEncode::WriteJpegHeader(void)<br /> {<br /> write_soi(); </p> <p> write_app0(); </p> <p> write_dqt(0);//Y </p> <p> write_dqt(1);//cbcr </p> <p> write_sof(M_SOF0); </p> <p> write_dht(0, 0);//m_htblYDC<br /> write_dht(0, 1);//m_htblYAC<br /> write_dht(1, 0);//m_htblCbCrDC<br /> write_dht(1, 1);//m_htblCbCrAC </p> <p> write_sos();<br /> } </p> <p>/////////////////////////////////////////////////////////////////////////////// </p> <p>void CCompressEncode::write_soi()<br /> {<br /> emit_marker(M_SOI);<br /> } </p> <p>void CCompressEncode::write_app0()<br /> { </p> <p> emit_marker(M_APP0); </p> <p> emit_2bytes(2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */ </p> <p> emit_byte(0x4A); /* Identifier: ASCII "JFIF" */<br /> emit_byte(0x46);<br /> emit_byte(0x49);<br /> emit_byte(0x46);<br /> emit_byte(0); </p> <p> emit_byte(1); /* Major version */<br /> emit_byte(1); /* Minor version */<br /> emit_byte(1); /* Pixel size information */<br /> emit_2bytes(300);<br /> emit_2bytes(300);<br /> emit_byte(0); /* No thumbnail image */<br /> emit_byte(0);<br /> } </p> <p>void CCompressEncode::write_dqt(int index)//0:Y;1:CbCr<br /> {<br /> unsigned char* dqt;<br /> if( index == 0 )<br /> dqt = &m_dqtY[0];//changed from std with quality<br /> else<br /> dqt = &m_dqtCbCr[0]; </p> <p> //only allow prec = 0; </p> <p> emit_marker(M_DQT);<br /> emit_2bytes(67);//length<br /> emit_byte(index); </p> <p> int i;<br /> unsigned char qval;<br /> for (i = 0; i < 64; i++)<br /> {<br /> qval = (unsigned char) (dqt[jpeg_natural_order[i]]);<br /> emit_byte(qval);<br /> }<br /> } </p> <p>//currently support M_SOF0 baseline implementation<br /> void CCompressEncode::write_sof(int code)<br /> {<br /> emit_marker(code);<br /> emit_2bytes(17); //length </p> <p> emit_byte(8);//cinfo->data_precision);<br /> emit_2bytes(m_nHeight);<br /> emit_2bytes(m_nWidth);<br /> emit_byte(3);//cinfo->num_components); </p> <p> //for Y<br /> emit_byte(1);//compptr->component_id);<br /> emit_byte(34);//(compptr->h_samp_factor << 4) + compptr->v_samp_factor);<br /> emit_byte(0);//quant_tbl_no </p> <p> //for Cb<br /> emit_byte(2);//compptr->component_id);<br /> emit_byte(17);//(compptr->h_samp_factor << 4) + compptr->v_samp_factor);<br /> emit_byte(1);//quant_tbl_no </p> <p> //for Cr<br /> emit_byte(3);//compptr->component_id);<br /> emit_byte(17);//(compptr->h_samp_factor << 4) + compptr->v_samp_factor);<br /> emit_byte(1);//quant_tbl_no<br /> } </p> <p>void CCompressEncode::write_dht(int IsCbCr, int IsAc)<br /> {<br /> HUFFMAN_TABLE *htbl;<br /> int index;<br /> if( IsCbCr )<br /> {<br /> if( IsAc )<br /> {<br /> htbl = &m_htblCbCrAC;<br /> index = 17;<br /> }<br /> else<br /> {<br /> htbl = &m_htblCbCrDC;<br /> index = 1;<br /> }<br /> }<br /> else<br /> {<br /> if( IsAc )<br /> {<br /> htbl = &m_htblYAC;<br /> index = 16;<br /> }<br /> else<br /> {<br /> htbl = &m_htblYDC;<br /> index = 0;<br /> }<br /> } </p> <p> emit_marker(M_DHT); </p> <p> int i, length = 0;<br /> for (i = 1; i <= 16; i++)<br /> length += htbl->bits[i]; </p> <p> emit_2bytes(length + 2 + 1 + 16); </p> <p> emit_byte(index); </p> <p> for (i = 1; i <= 16; i++)<br /> emit_byte(htbl->bits[i]); </p> <p> for (i = 0; i < length; i++)//varible-length<br /> emit_byte(htbl->huffval[i]);<br /> } </p> <p>void CCompressEncode::write_sos()<br /> {<br /> emit_marker(M_SOS); </p> <p> int length = 2 * 3 + 2 + 1 + 3;<br /> emit_2bytes(length); </p> <p> emit_byte(3);//cinfo->comps_in_scan </p> <p> //Y<br /> emit_byte(1);//index<br /> emit_byte(0);//dc and ac tbl use 0-th tbl </p> <p> //Cb<br /> emit_byte(2);//index<br /> emit_byte(0x11);//dc and ac tbl use 1-th tbl </p> <p> //Cr<br /> emit_byte(3);//index<br /> emit_byte(0x11);//dc and ac tbl use 1-th tbl </p> <p> emit_byte(0);//Ss<br /> emit_byte(0x3F);//Se<br /> emit_byte(0);// Ah/Al<br /> }<br /> //////////////////////////////////////////////////////////////////////////////// </p> <p>////////////////////////////////////////////////////////////////////////////////<br /> //对图像进行压缩编码的主函数<br /> bool CCompressEncode::CompressImage(<br /> unsigned char *pInBuf, //源数据<br /> unsigned char *pOutBuf,//目标数据<br /> int nWidthPix, //图像宽<br /> int nHeight, //图像高<br /> int& nOutputBytes //转化后字节数<br /> )<br /> {<br /> // 错误处理<br /> if(( pInBuf == 0 )||( pOutBuf == 0 ))<br /> return false; </p> <p> m_nWidth = nWidthPix;<br /> m_nHeight = nHeight;<br /> m_pOutBuf = pOutBuf; </p> <p> //写入JPG头<br /> WriteJpegHeader(); </p> <p> int nHeadBytes = m_pOutBuf - pOutBuf; </p> <p> int nRowBytes = ( m_nWidth * 3 + 3 ) / 4 * 4; </p> <p> //异常<br /> if(( nWidthPix <= 0 )||( nRowBytes <= 0 )||( nHeight <= 0 ))<br /> return false; </p> <p> int xPixel, yPixel, xTile, yTile, cxTile, cyTile, cxBlock, cyBlock;<br /> int x, y, nTrueRows, nTrueCols, nTileBytes;<br /> unsigned char byTile[768], *pTileRow, *pLastPixel, *pHolePixel; </p> <p> // 水平和垂直MCU的数量<br /> // MCU(Minimum Coded Unit), 16*16 象素<br /> cxTile = (nWidthPix + 15)>> 4;<br /> cyTile = (nHeight + 15) >> 4; </p> <p> // 水平和垂直块的数量 8*8 象素<br /> cxBlock = cxTile << 1;<br /> cyBlock = cyTile << 1; </p> <p> //初始化<br /> nTileBytes = 0; </p> <p> m_dcY = m_dcCb = m_dcCr = 0; </p> <p> m_nPutBits = 0;<br /> m_nPutVal = 0; </p> <p> //循环对每个MCU进行处理 </p> <p> for( yTile = 0; yTile < cyTile; yTile++ )<br /> {<br /> for( xTile = 0; xTile < cxTile; xTile++ )<br /> {<br /> //获得此MCU初始相似<br /> xPixel = xTile << 4;<br /> yPixel = yTile << 4; </p> <p> // 获得列和栏数<br /> nTrueRows = 16;<br /> nTrueCols = 16;<br /> if( yPixel + nTrueRows > nHeight )<br /> nTrueRows = nHeight - yPixel;<br /> if( xPixel + nTrueCols > nWidthPix )<br /> nTrueCols = nWidthPix - xPixel; </p> <p> pTileRow = pInBuf + (m_nHeight - yPixel) * nRowBytes + xPixel * 3; </p> <p> //获得数据<br /> for( y = 0; y < 16; y ++ )<br /> {<br /> if( y < nTrueRows )<br /> { </p> <p> pTileRow -= nRowBytes;<br /> memcpy( byTile + y * 16 * 3, pTileRow, nTrueCols * 3 ); </p> <p> if( nTrueCols < 16 )<br /> {<br /> pLastPixel = pTileRow + (nTrueCols - 1) * 3;<br /> pHolePixel = byTile + y * 16 * 3 + nTrueCols * 3;<br /> for( x = nTrueCols; x < 16; x ++ )<br /> {<br /> memcpy( pHolePixel, pLastPixel, 3 );<br /> pHolePixel += 3;<br /> }<br /> }<br /> }<br /> else<br /> { </p> <p> memcpy( byTile + y * 16 * 3,<br /> byTile + (nTrueRows - 1) * 16 * 3,<br /> 16 * 3 );<br /> }<br /> } </p> <p> //调用函数对此MCU进行压缩编码<br /> if( ! CompressOneTile( byTile ))<br /> return false;<br /> }<br /> } </p> <p> //处理剩余部分<br /> if( m_nPutBits > 0 )<br /> {<br /> EmitLeftBits( );<br /> } </p> <p> //写入结束标志<br /> emit_marker(M_EOI);<br /> nOutputBytes = m_pOutBuf - pOutBuf;<br /> return true;<br /> } </p> <p>////////////////////////////////////////////////////////////////////////////////<br /> // 对一个16*16象素的块进行基于DCT的压缩编码 </p> <p>bool CCompressEncode::CompressOneTile(<br /> unsigned char * pBgr<br /> )<br /> {<br /> // 三个颜色部分<br /> int pYCbCr[384]; </p> <p> // DCT变换输出<br /> int coef[64]; </p> <p> // 颜色转换<br /> BGRToYCbCrEx( pBgr, pYCbCr ); </p> <p> // 分别对Y/Cb/Cr几个部分进行压缩编码 Y: 4 blocks; Cb: 1 block; Cr: 1 block<br /> int i;<br /> for( i=0; i<6; i++ )<br /> {<br /> ForwardDct( pYCbCr + i*64, coef ); </p> <p> Quantize( coef, i ); </p> <p> HuffmanEncode( coef, i );<br /> } </p> <p> return true;<br /> } </p> <p>////////////////////////////////////////////////////////////////////////////////<br /> // 颜色转换<br /> void CCompressEncode::BGRToYCbCr(<br /> unsigned char * pBgr, //tile source data, in BGR format, 768 bytes<br /> unsigned char * pY, //out, Illuminance, 256 bytes<br /> unsigned char * pCb, //out, Cb, 256 bytes<br /> unsigned char * pCr //out, Cr, 256 bytes<br /> )<br /> {<br /> int i;<br /> unsigned char r, g, b, *pByte = pBgr, *py = pY, *pcb = pCb, *pcr = pCr; </p> <p> for( i=0; i<256; i++ )<br /> {<br /> b = *(pByte ++);<br /> g = *(pByte ++);<br /> r = *(pByte ++); </p> <p> *(py++) = (unsigned char)((m_RToY[r] + m_GToY[g] + m_BToY[b] )>>16);<br /> *(pcb++) = (unsigned char)((m_RToCb[r] + m_GToCb[g] + m_BToCb[b])>>16);<br /> *(pcr++) = (unsigned char)((m_RToCr[r] + m_GToCr[g] + m_BToCr[b])>>16);<br /> }<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>void CCompressEncode::BGRToYCbCrEx(<br /> unsigned char * pBgr, //in, tile data, in BGR format, 768 bytes<br /> int * pBlock //out, Y: 256; Cb: 64; Cr: 64<br /> )<br /> {<br /> int x, y, *py[4], *pcb, *pcr;<br /> unsigned char r, g, b, *pByte; </p> <p> pByte = pBgr;<br /> for( x = 0; x < 4; x++ )<br /> py[ x ] = pBlock + 64 * x;<br /> pcb = pBlock + 256;<br /> pcr = pBlock + 320; </p> <p> for( y=0; y<16; y++ )<br /> {<br /> for( x=0; x<16; x++ )<br /> {<br /> b = *(pByte ++);<br /> g = *(pByte ++);<br /> r = *(pByte ++); </p> <p> // block number is ((y/8) * 2 + x/8): 0, 1, 2, 3<br /> *( py[((y>>3)<<1) + (x>>3)] ++ ) =<br /> ((m_RToY[ r ] + m_GToY[ g ] + m_BToY[ b ] )>>16) -128; </p> <p> // Equal to: (( x%2 == 0 )&&( y%2 == 0 ))<br /> if( (!(y & 1L)) && (!(x & 1L)) )<br /> {<br /> *(pcb++) =<br /> ((m_RToCb[ r ] + m_GToCb[ g ] + m_BToCb[ b ])>>16) -128;<br /> *(pcr++) =<br /> ((m_RToCr[ r ] + m_GToCr[ g ] + m_BToCr[ b ])>>16) -128;<br /> }<br /> }<br /> }<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>//离散余弦正变换<br /> void CCompressEncode::ForwardDct(<br /> int* data, //source data, length is 64<br /> int* coef //output dct coefficients<br /> )<br /> { </p> <p>////////////////////////////////////////////////////////////////////////////<br /> //为了方便计算定义几个宏<br /> #define FIX_0_382683433 ((int)98) /* FIX(0.382683433) */<br /> #define FIX_0_541196100 ((int)139) /* FIX(0.541196100) */<br /> #define FIX_0_707106781 ((int)181) /* FIX(0.707106781) */<br /> #define FIX_1_306562965 ((int)334) /* FIX(1.306562965) */ </p> <p>#define MULTIPLY(var,cons) (int)(((cons) * (var)) >> 8 ) </p> <p>//////////////////////////////////////////////////////////////////////////// </p> <p> static const int DCTSIZE = 8;<br /> int x, y;<br /> int *dataptr;<br /> int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;<br /> int tmp10, tmp11, tmp12, tmp13;<br /> int z1, z2, z3, z4, z5, z11, z13, *coefptr; </p> <p> /* Pass 1: process rows. */ </p> <p> dataptr = data; //input<br /> coefptr = coef; //output<br /> for( y = 0; y < 8; y++ )<br /> {<br /> tmp0 = dataptr[0] + dataptr[7];<br /> tmp7 = dataptr[0] - dataptr[7];<br /> tmp1 = dataptr[1] + dataptr[6];<br /> tmp6 = dataptr[1] - dataptr[6];<br /> tmp2 = dataptr[2] + dataptr[5];<br /> tmp5 = dataptr[2] - dataptr[5];<br /> tmp3 = dataptr[3] + dataptr[4];<br /> tmp4 = dataptr[3] - dataptr[4]; </p> <p> /* Even part */ </p> <p> tmp10 = tmp0 + tmp3; /* phase 2 */<br /> tmp13 = tmp0 - tmp3;<br /> tmp11 = tmp1 + tmp2;<br /> tmp12 = tmp1 - tmp2; </p> <p> coefptr[0] = tmp10 + tmp11; /* phase 3 */<br /> coefptr[4] = tmp10 - tmp11; </p> <p> z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */<br /> coefptr[2] = tmp13 + z1; /* phase 5 */<br /> coefptr[6] = tmp13 - z1; </p> <p> /* Odd part */ </p> <p> tmp10 = tmp4 + tmp5; /* phase 2 */<br /> tmp11 = tmp5 + tmp6;<br /> tmp12 = tmp6 + tmp7; </p> <p> /* The rotator is modified from fig 4-8 to avoid extra negations. */<br /> z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */<br /> z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */<br /> z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */<br /> z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ </p> <p> z11 = tmp7 + z3; /* phase 5 */<br /> z13 = tmp7 - z3; </p> <p> coefptr[5] = z13 + z2; /* phase 6 */<br /> coefptr[3] = z13 - z2;<br /> coefptr[1] = z11 + z4;<br /> coefptr[7] = z11 - z4; </p> <p> dataptr += 8; /* advance pointer to next row */<br /> coefptr += 8;<br /> } </p> <p> /* Pass 2: process columns. */ </p> <p> coefptr = coef; //both input and output<br /> for ( x = 0; x < 8; x++ )<br /> {<br /> tmp0 = coefptr[DCTSIZE*0] + coefptr[DCTSIZE*7];<br /> tmp7 = coefptr[DCTSIZE*0] - coefptr[DCTSIZE*7];<br /> tmp1 = coefptr[DCTSIZE*1] + coefptr[DCTSIZE*6];<br /> tmp6 = coefptr[DCTSIZE*1] - coefptr[DCTSIZE*6];<br /> tmp2 = coefptr[DCTSIZE*2] + coefptr[DCTSIZE*5];<br /> tmp5 = coefptr[DCTSIZE*2] - coefptr[DCTSIZE*5];<br /> tmp3 = coefptr[DCTSIZE*3] + coefptr[DCTSIZE*4];<br /> tmp4 = coefptr[DCTSIZE*3] - coefptr[DCTSIZE*4]; </p> <p> /* Even part */ </p> <p> tmp10 = tmp0 + tmp3; /* phase 2 */<br /> tmp13 = tmp0 - tmp3;<br /> tmp11 = tmp1 + tmp2;<br /> tmp12 = tmp1 - tmp2; </p> <p> coefptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */<br /> coefptr[DCTSIZE*4] = tmp10 - tmp11; </p> <p> z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */<br /> coefptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */<br /> coefptr[DCTSIZE*6] = tmp13 - z1; </p> <p> /* Odd part */ </p> <p> tmp10 = tmp4 + tmp5; /* phase 2 */<br /> tmp11 = tmp5 + tmp6;<br /> tmp12 = tmp6 + tmp7; </p> <p> /* The rotator is modified from fig 4-8 to avoid extra negations. */<br /> z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */<br /> z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */<br /> z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */<br /> z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ </p> <p> z11 = tmp7 + z3; /* phase 5 */<br /> z13 = tmp7 - z3; </p> <p> coefptr[DCTSIZE*5] = z13 + z2; /* phase 6 */<br /> coefptr[DCTSIZE*3] = z13 - z2;<br /> coefptr[DCTSIZE*1] = z11 + z4;<br /> coefptr[DCTSIZE*7] = z11 - z4; </p> <p> coefptr++; /* advance pointer to next column */<br /> }<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>//进行量化<br /> void CCompressEncode::Quantize(<br /> int* coef, //coef is both in and out<br /> int iBlock //block id; Y: 0,1,2,3; Cb: 4; Cr: 5<br /> )<br /> {<br /> int temp;<br /> unsigned short qval, *pQuant; </p> <p> if( iBlock < 4 )<br /> pQuant = m_qtblY;<br /> else<br /> pQuant = m_qtblCbCr; </p> <p> for (int i = 0; i < 64; i++)<br /> {<br /> qval = pQuant[i];<br /> temp = coef[i]; </p> <p>#define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0 </p> <p> if ( temp < 0)<br /> {<br /> temp = -temp;<br /> temp += qval>>1; /* for rounding */<br /> DIVIDE_BY(temp, qval);<br /> temp = -temp;<br /> }<br /> else<br /> {<br /> temp += qval>>1; /* for rounding */<br /> DIVIDE_BY(temp, qval);<br /> } </p> <p> coef[i] = temp;<br /> }<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>//Huffman编码<br /> bool CCompressEncode::HuffmanEncode(<br /> int* pCoef, // DCT coefficients<br /> int iBlock // 0,1,2,3:Y; 4:Cb; 5:Cr;<br /> )<br /> {<br /> //对AC系数进行Z字型扫描<br /> static const int jpeg_natural_order[64+16] = {<br /> 0, 1, 8, 16, 9, 2, 3, 10,<br /> 17, 24, 32, 25, 18, 11, 4, 5,<br /> 12, 19, 26, 33, 40, 48, 41, 34,<br /> 27, 20, 13, 6, 7, 14, 21, 28,<br /> 35, 42, 49, 56, 57, 50, 43, 36,<br /> 29, 22, 15, 23, 30, 37, 44, 51,<br /> 58, 59, 52, 45, 38, 31, 39, 46,<br /> 53, 60, 61, 54, 47, 55, 62, 63,<br /> 63, 63, 63, 63, 63, 63, 63, 63,//extra entries for safety<br /> 63, 63, 63, 63, 63, 63, 63, 63<br /> }; </p> <p> int temp, temp2, nbits, k, r, i;<br /> int *block = pCoef;<br /> int *pLastDc = &m_dcY;<br /> HUFFMAN_TABLE *dctbl, *actbl; </p> <p> if( iBlock < 4 )<br /> {<br /> dctbl = & m_htblYDC;<br /> actbl = & m_htblYAC;<br /> // pLastDc = &m_dcY;<br /> }<br /> else<br /> {<br /> dctbl = & m_htblCbCrDC;<br /> actbl = & m_htblCbCrAC; </p> <p> if( iBlock == 4 )<br /> pLastDc = &m_dcCb;<br /> else<br /> pLastDc = &m_dcCr;<br /> } </p> <p> //对DC系数进行编码 </p> <p> temp = temp2 = block[0] - (*pLastDc);<br /> *pLastDc = block[0]; </p> <p> if (temp < 0) {<br /> temp = -temp; /* temp is abs value of input */ </p> <p> temp2 --;<br /> } </p> <p> /* Find the number of bits needed for the magnitude of the coefficient */<br /> nbits = 0;<br /> while (temp) {<br /> nbits ++;<br /> temp >>= 1;<br /> } </p> <p> // Write category number<br /> if (! EmitBits( dctbl->code[nbits], dctbl->size[nbits] ))<br /> return FALSE; </p> <p> // Write category offset<br /> if (nbits) /* EmitBits rejects calls with size 0 */<br /> {<br /> if (! EmitBits( (unsigned int) temp2, nbits ))<br /> return FALSE;<br /> } </p> <p> ////////////////////////////////////////////////////////////////////////////<br /> //对AC系数进行编码 </p> <p> r = 0; /* r = run length of zeros */ </p> <p> for (k = 1; k < 64; k++)<br /> {<br /> if ((temp = block[jpeg_natural_order[k]]) == 0)<br /> {<br /> r++;<br /> }<br /> else<br /> {<br /> /* if run length > 15, must emit special run-length-16 codes (0xF0) */<br /> while (r > 15) {<br /> if (! EmitBits( actbl->code[0xF0], actbl->size[0xF0] ))<br /> return FALSE;<br /> r -= 16;<br /> } </p> <p> temp2 = temp;<br /> if (temp < 0) {<br /> temp = -temp; /* temp is abs value of input */<br /> /* This code assumes we are on a two's complement machine */<br /> temp2--;<br /> } </p> <p> /* Find the number of bits needed for the magnitude of the coefficient */<br /> nbits = 1; /* there must be at least one 1 bit */<br /> while ((temp >>= 1))<br /> nbits++; </p> <p> /* Emit Huffman symbol for run length / number of bits */<br /> i = (r << 4) + nbits;<br /> if (! EmitBits( actbl->code[i], actbl->size[i] ))<br /> return FALSE; </p> <p> // Write Category offset<br /> if (! EmitBits( (unsigned int) temp2, nbits ))<br /> return FALSE; </p> <p> r = 0;<br /> }<br /> } </p> <p> if (r > 0)<br /> {<br /> if (! EmitBits( actbl->code[0], actbl->size[0] ))<br /> return FALSE;<br /> } </p> <p> return TRUE;<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>inline bool CCompressEncode::EmitBits(<br /> unsigned int code, //Huffman code<br /> int size //Size in bits of the Huffman code<br /> )<br /> {<br /> /* This routine is heavily used, so it's worth coding tightly. */<br /> int put_buffer = (int) code;<br /> int put_bits = m_nPutBits; </p> <p> /* if size is 0, caller used an invalid Huffman table entry */<br /> if (size == 0)<br /> return false; </p> <p> put_buffer &= (((int)1)<<size) - 1; /* mask off any extra bits in code */ </p> <p> put_bits += size; /* new number of bits in buffer */ </p> <p> put_buffer <<= 24 - put_bits; /* align incoming bits */ </p> <p> put_buffer |= m_nPutVal; /* and merge with old buffer contents */ </p> <p> // If there are more than 8 bits, write it out<br /> unsigned char uc;<br /> while (put_bits >= 8)<br /> {<br /> // Write one byte out !!!!<br /> uc = (unsigned char) ((put_buffer >> 16) & 0xFF);<br /> emit_byte(uc); </p> <p> if (uc == 0xFF) { //need to stuff a zero byte?<br /> emit_byte(0); // Write one byte out !!!!<br /> } </p> <p> put_buffer <<= 8;<br /> put_bits -= 8;<br /> } </p> <p> m_nPutVal = put_buffer; /* update state variables */<br /> m_nPutBits = put_bits; </p> <p> return TRUE;<br /> } </p> <p>//////////////////////////////////////////////////////////////////////////////// </p> <p>inline void CCompressEncode::EmitLeftBits(void)<br /> {<br /> if (! EmitBits(0x7F, 7)) /* fill 7 bits with ones */<br /> return; </p> <p> m_nPutVal = 0;<br /> m_nPutBits = 0;<br /> } </p> <p>////////////////////////////////////////////////////////////////////////////////

CompressEncode.h

CompressEncode.cpp

PicOperate.h

PicOperate.cpp

使用规则：

    char *bmppath="1.bmp";
    CString jpgpath="2.jpg";
    int qui=30;
    m_op.Load( bmppath);
    m_op.picCompressEncode(jpgpath,TRUE,qui);

哈哈