C++实现JPEG格式图片解析(附代码)

目录

• 1.读取文件的信息
• 2.Huffman编码解码
• 3.直流交流编码解析
• 4.反量化
• 5.反Zig-Zag变化
• 6.反DCT变化
• 7.YCbCr转RGB
• 8.效果图
• 9.源码

1.读取文件的信息

JPEG格式中信息是以段（数据结构）来存储的。

段的格式如下

名称	字节数	数据	说明
段标识	1	FF	每个新段的开始标识
段类型	1		类型编码（称作“标记码”）
段长度	2		包括段内容和段长度本身,不包括段标识和段类型
段内容	≤65533字节

其余具体信息请见以下链接，我就不当复读机了。

JPEG标记的说明

格式介绍

值得注意的一点是一个字节的高位在左边，而且直流分量重置标记一共有8个，其他的格式说明在第二个链接中已经足够详细了

这些段中必须要读取的段：SOS, DHT, DQT, SOF, DRI，其他的只是锦上添花

这里面可能会出现多个SOF段，我们需要拿到这几个段中图片高度和宽度的最大值，和YCbCr的水平，垂直采样因子的最大值分别记为Hmax，Vmax，之后会用到
DRI中的开始间隔指的就是直流分量重置间隔，我们记为reset

2.Huffman编码解码

首先Huffman编码分直流表（DC）和交流表（AC），他们一般各自有两张表，具体使用哪张表是通过SOS里面的对应关系来的，一般Y对应第一张表，CbCr对应第二、三张表。

因为规定huffman编码最多16位，所以huffman编码的最大值位65535

以下代码为我的解码方式，直流交流均如此

int curPos = 16, curCode = 0;
for (int i = 0; i < 16; i++) {
    int count = temp[i];//count为二进制位数为i+1的个数
    curCode <<= 1;		//curCode为当前huffman编码数值
    while (count--) {	//一次循环生成一个
        uint16_t code=curCode;
        uint8_t bit=i+1;//比特位有几位 00为2位
        uint8_t weight=temp[curPos];//权重是按照顺序排列的，如比特位为两位的编码有两个，设为00，01，后面权重排列为1，2，则00对应1，01对应2
        pair t1(bit,weight);
        //
        pair> t2(curCode,t1);
        table.insert(t2);
        curCode++;
        curPos++;
    }
}

3.直流交流编码解析

SOS段之后就是真正的图片压缩数据了，可以选择一次性读取到内存中，也可以边读数据边做后面的解析步骤，我是选择了第二种。每读取一个MCU后做一次解析（我使用的是缓存队列）。在图片编码的时候需要划分MCU（最小编码单位），每个MCU由多个8×8矩阵组成，通过编码将二维数组转换为一维的，所以当读取的数据达到了64个，就代表一个8×8的块解析完成，直到读取到0xFFD9结束

然而，读取多少个8×8矩阵才能解析出一个MCU呢？

MCU里面的8×8矩阵个数，如果从编码角度来说的话，8×8矩阵个数是Hmax*Vmax个，但是从解码角度来说，因为此时的YCbCr已经分开成为了三张表，所以8×8矩阵个数应该是三个分量的水平、垂直采样因子的乘积之和（先乘积，再求和）记为SUMmcu，所以读取一次要读取SUMmcu个8×8矩阵（此时这里面有YCbCr三种表，之后通过公式将YCbCr转换为RGB数值）

好了，到这里我们知道了要读取多少个8×8的矩阵 （实际上，因为没有反Zig-Zag编码，此时还是有64个数据的一维数组）

接下来开始解析，解析需要使用上一步解码出来的Huffman编码。

解析方式如下：

1、对于直流（差分编码），按照一个比特位来读取图片压缩数据，若在Huffman表中发现该编码，并且位数相等，则读取该编码所对应的权重，该权重代表接下来读取多少个比特位作为直流分量的值，你以为这就完了？还要加上差分矫正变量 （YCbCr每张表都有一个，所以一共有3个）。

2、对于交流（游程编码），其他部分都一样（这个没有差分矫正变量），不同的地方举个例子，设读取的直流分量为0x37，则低4位（这里为7）代表接下来7个比特位是该交流分量的值，而高4位（此处为3）代表此交流分量前有3个0 （这里就不用加上前面的了）。注意直流交流使用的Huffman表不同

3、接下来就是循环读取交流分量了，那么什么时候退出呢？

有两个条件，只要达成一个就可以退出

• 读取了63个交流分量
• 交流分量的权值为0，此位后面全是0

对于根据权重所读出来的值（不区分直流交流），对于最高位（最左边）若为0则是负数，否则为正数，判断代码如下，curValue为读取的值，curValueLength为读取的值有多少位

curValue = (curValue >= pow(2, curValueLength - 1) ? curValue : curValue - pow(2, curValueLength) + 1);

这里面还有两个坑（若DRI读出来的直流分量重置间隔reset为0，不用管这步）

假设reset为332（这是我图片的间隔），就是隔了332个MCU（也就是332×SUMmcu个8×8的矩阵），需要将所有差分矫正变量全部置为0，并且当这332个MCU读取完后，你要读取两个字节（这两个字节是一个段），这两个字节应该正好是0xFF 0xD0~0xD7，并且D0到D7是按顺序出现的，例如，上一个是0xFFD0那么下一个肯定是0xD1，到D7后下一个是D0，若对不上那就有问题了。还有，这读出来的两个字节不是图片的压缩数据不需要解码若读取到了0xFF00则00忽略

到此，我们得到了一个有64个元素的一维数组

4.反量化

我们用之前读出来的量化表（也是64个元素的，你说巧不巧嘿嘿）与上面解码得到的元素对应项相乘，反量化完成！！！

5.反Zig-Zag变化

编码方式如下

我使用的模拟法，将一维数组转为8×8矩阵

函数如下，写的不好

double** UnZigZag(int* originArray){
    double** table=new double*[ROW];
    for(int i=0;i7 || y>7) flag = !flag;
        if (x < 0 && y>7) { x = 1; y = 7; }
        if (x < 0) x = 0;
        else if (x > 7) { x = 7; y += 2; }
        if (y < 0) y = 0;
        else if (y > 7) { y = 7; x += 2; }
    }
    return table;

也可以使用另外一种方法，手动记录一个数组，将位置写好，转换只需要4行代码

6.反DCT变化

那个公式太慢了，有这个公式的简化版本，公式可以化为矩阵乘法，只需要一个转换矩阵

矩阵我是用下面的代码计算得到的

double** JPEGData::createDCTAndIDCTArray(int row){
    double** res=new double*[row];
    for(int i=0;i> temp(ROW,vector(COL,0));
    for(int i=0;i> temp(ROW,vector(COL,0));
    for(int i=0;i 
 

7.YCbCr转RGB

公式如下，这个是真好使

R=128+y+1.402 cr
G=128+y-0.71414cr-0.34414*cb
B=128+y+1.772 *cb

struct RGB{
	uint8_t red;
	uint8_t green;
	uint8_t blue;
};
RGB** JPEGData::YCbCrToRGB(const int* YUV){
    RGB **res = new RGB *[ROW * max_v_samp_factor];
    int matrixCount = YUV[0] + YUV[1] + YUV[2];
    int crCount = 0, cbCount = 0;
    //1＝Y, 2＝Cb, 3＝Cr
    //式子 scale*x,scale*y
    double cb_h_samp_scale=component[1].h_samp_factor*1.0/max_h_samp_factor,
           cb_v_samp_scale=component[1].v_samp_factor*1.0/max_v_samp_factor,
           cr_h_samp_scale=component[2].h_samp_factor*1.0/max_h_samp_factor,
           cr_v_samp_scale=component[2].v_samp_factor*1.0/max_v_samp_factor;
    for (int i = 0; i < ROW * max_v_samp_factor; i++)
        res[i] = new RGB[COL * max_h_samp_factor];
    //此处直接生成rgb值
    //注意，此处YCbCr的对应关系与采样因子有关
    //这个ycbcr存的是一个MCU，假设YUV为411，那么ycbcr有6个
    //这种方式转换不了YUV为420的，因为数组越界了，不过可以加个判断，我懒得改了
    // cout< 
 

8.效果图

这个是JPEG

这是位图

9.源码

最最后，如何把图片显示出来呢？，我将信息转换为位图，就能看见了。

下面源码附上

Image.h

#pragma once
#define _USE_MATH_DEFINES
#include 
#include 
#include 
#include 
#ifndef _IMAGE_
#define _IMAGE_
#include "Util.h"
#include 
#include 
#include 
using namespace std;
NAME_SPACE_START(myUtil)
#define ROW 8
#define COL 8
#define HUFFMAN_DECODE_DEQUE_CACHE 64//单位：位
// #define _DEBUG_
// #define _DEBUGOUT_
#define FREE_VECTOR_LP(vectorName) \
    for(auto item : vectorName){	\
		for(int i=0;i
	map> componentHuffmanMap;
	bool Init(fstream& file,uint16_t len);
};
//APP
class JPEGInfo{
public:
	uint16_t version;
};
//DHT
class JPEGHuffmanCode{
public:
	using iterator = map>::iterator;
	//
	map> table;
	//init huffman table
	bool Init(fstream& file,uint16_t len);
	//find-true not find-false
	bool findKey(const uint16_t& code,const uint8_t& bit,iterator& it);
};
//DQT
//quality table
class JPEGQuality{
public:
	uint8_t precision;
	uint8_t id;
	vector table;
	bool Init(fstream& file,uint16_t len);
};
//SOF segment
class JPEGComponent{
public:
	//1＝Y, 2＝Cb, 3＝Cr, 4＝I, 5＝Q
	uint8_t colorId;
	uint8_t h_samp_factor;
	uint8_t v_samp_factor;
	uint8_t qualityId;
	bool Init(fstream& file,uint16_t len);
};
class JPEGData{
	int max_h_samp_factor;//行MCU
	int max_v_samp_factor;//列MCU
	int width;
	int height;
	int precision;
	bool isYUV411=false;
	bool isYUV422=false;
	bool isYUV111=false;
	uint8_t curDRI=0;//当前重置直流分量标识,这里只取个位方便计算
	uint16_t resetInterval=0;//单位是MCU
	int preDCValue[3]={0};  //用于直流差分矫正
	//量化表
	vector quality;
	//huffman码表
	vector dc_huffman;
	vector ac_huffman;
	//component每个颜色分量
	vector component;
	JPEGScan scan;
	//vector deHuffman;
	vector ycbcr;
	vector rgb;
	double** DCTAndIDCTArray;
	streampos pos;
	bool EOI{false};
public:
	JPEGData():
			max_h_samp_factor(0),
			max_v_samp_factor(0),
			width(0),
			height(0),
			precision(0){
				DCTAndIDCTArray=createDCTAndIDCTArray(ROW);
			}
	~JPEGData(){
		FREE_LP_2(DCTAndIDCTArray,ROW-1)
		// FREE_LP_2(DCTArray,ROW-1)
		// FREE_LP_2(IDCTArray,ROW-1)
		FREE_VECTOR_LP(rgb)
	}
	bool readJPEG(const char* filePath);
	int getWidth() const {return width;}
	int getHeight() const {return height;}
	vector getRGB() const {return rgb;}
	int getMaxHSampFactor() const {return max_h_samp_factor;}
	int getMaxVSampFactor() const {return max_v_samp_factor;}
	double** createDCTAndIDCTArray(int row);
	//double** createIDCTArray(int row);
	void DCT(double** originMatrix);
	void IDCT(double** originMatrix);
protected:
	bool readSOF(fstream& file,uint16_t len);
	bool readData(fstream& file);
	bool huffmanDecode(fstream& file);
	void deQuality(double** originMatrix,int qualityID);
	//隔行正负纠正
	void PAndNCorrect(double** originMatrix);
	RGB** YCbCrToRGB(const int* YUV);
	//标记位检查 是否结束,是否重置直流矫正数值，返回要添加的数值
	string FlagCkeck(fstream& file,int byteInfo);
	uint16_t ReadByte(fstream& file,int len);
	uint16_t findHuffmanCodeByBit(fstream& file,int& length,int& pos,string& deque,int curValue,int& curValLen);
};
NAME_SPACE_END()
#endif //!_IMAGE_

Image.cpp

#include "Image.h"
#include "Util.h"
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
NAME_SPACE_START(myUtil)
int RGBValueLimit(double input){
    if(input<0) return 0;
    else if(input>255) return 255;
    // 四舍五入、取整均可
    // return (int)(input);
    return round(input);
}
void print(double** originMatrix){
    cout<7 || y>7) flag = !flag;
        if (x < 0 && y>7) { x = 1; y = 7; }
        if (x < 0) x = 0;
        else if (x > 7) { x = 7; y += 2; }
        if (y < 0) y = 0;
        else if (y > 7) { y = 7; x += 2; }
    }
    return table;
}
bool JPEGScan::Init(fstream &file, uint16_t len){
    try {
        uint8_t count=file.get();
        len--;
        while(count--){
            uint8_t componentId=file.get();
            uint8_t table=file.get();
            uint8_t dcId=table>>4;
            uint8_t acId=table&0x0f;
            pair info1(dcId,acId);
            pair> info2(componentId,info1);
            componentHuffmanMap.insert(info2);
        }
    } catch (...) {
        return false;
    }
    return true;
}
bool JPEGHuffmanCode::Init(fstream &file, uint16_t len){
    try{
        vector temp;
        while(len--){
            int info=file.get();
            temp.push_back(info);
        }
        int curPos = 16, curCode = 0;
        for (int i = 0; i < 16; i++) {
            int count = temp[i];
            curCode <<= 1;
            while (count--) {
                uint16_t code=curCode;
                uint8_t bit=i+1;
                uint8_t weight=temp[curPos];
                pair t1(bit,weight);
                pair> t2(curCode,t1);
                table.insert(t2);
                curCode++;
                curPos++;
            }
        }
    }
    catch(...){
        return false;
    }
    return true;
}
bool JPEGHuffmanCode::findKey(const uint16_t& code,const uint8_t& bit,iterator& it)
{
    it=table.find(code);
    if(it==table.end()) return true;
    return it->second.first!=bit;
}
bool JPEGQuality::Init(fstream &file, uint16_t len){
    try{
        int info=file.get();
        precision=info>>4;
        id=info&0x0f;
        len--;
        while(len--){
            int t=file.get();
            table.push_back(t);
        }
    }
    catch(...){
        return false;
    }
    return true;
}
bool JPEGComponent::Init(fstream &file, uint16_t len){
    try {
        int info1=file.get();
        int info2=file.get();
        int info3=file.get();
        colorId=info1;
        h_samp_factor=info2>>4;
        v_samp_factor=info2&0x0f;
        qualityId=info3;
    } catch (...) {
        return false;
    }
    return true;
}
bool JPEGData::readJPEG(const char *filePath){
    fstream file(filePath,ios::in|ios::binary);
    if(file.fail()) return false;
    file.seekg(0,ios::end);
    pos = file.tellg();
    file.seekg(2,ios::beg);
    dc_huffman.resize(2);
    ac_huffman.resize(2);
    try {
        //do read data through using other method
        uint16_t pLen=0;
        uint16_t pMarker=0xFF;
        uint16_t pType=0x00;
        while(!file.eof()){
            pMarker=file.get();
            pType=file.get();
            if(pType==EOI) break;
            pLen=file.get();
            pLen=(pLen<<8)+file.get();
            // cout<>4)&1) ac_huffman[tableId]=huf;
                    else dc_huffman[tableId]=huf;
                    break;
                }
                //case SOI:
                //case EOI:
                case SOS:{
                    flag=scan.Init(file, pLen-2);
                    int count=3;
                    // cout<(file.get()).to_string());
        curBitDequeLength=8;
        // cout<=quality.size()) qualityId=0;
                    // cout<16) 
                            return true;
                        #ifdef _DEBUGOUT_
                        //cout<0){
                resetInterval--;
                if(resetInterval==0){
                    resetInterval=restart;
                    curDRI+=1;
                    curDRI&=0x7;
                    //需要在此处读取两字节信息，看是否为重置标识
                    file.get();
                    if(file.get()==0xD9) EOI=true;
                    curBitPos=curBitDequeLength;
                    preDCValue[0]=0;
                    preDCValue[1]=0;
                    preDCValue[2]=0;
                }
            }
            // cout<<"curMCUCount="<> temp(ROW,vector(COL,0));
    for(int i=0;i> temp(ROW,vector(COL,0));
    for(int i=0;i(0xFF).to_string();
        if(info==0xD9) {EOI=true;return "false";}
        else if(info==0x00) return res;
        return res + bitset<8>(info).to_string();
    }
    return bitset<8>(byteInfo).to_string();
}
uint16_t JPEGData::ReadByte(fstream& file,int len){
    uint16_t res=file.get();
    if(len!=1){
        res=(res<<8)+(uint8_t)file.get();
    }
    return res;
}
uint16_t JPEGData::findHuffmanCodeByBit(fstream& file,int& length,int& pos,string& deque,int curValue,int& curValLen){
    if(pos==length&&length>=HUFFMAN_DECODE_DEQUE_CACHE){//达到最大缓存
        deque = deque.substr(pos);
        int info=file.get();
        string res=FlagCkeck(file,info);
        string str=bitset<8>(info).to_string();
        if(res=="false") res=bitset<8>(file.get()).to_string();
        deque.append(res);
        length = deque.length();
        pos = 0;
    }
    else if(length==0 || pos>=length){
        if(length==0){
            deque="";
            pos=0;
        }
        int info=file.get();
        string res=FlagCkeck(file,info);
        string str=bitset<8>(info).to_string();
        if(res=="false") res=bitset<8>(file.get()).to_string();
        deque.append(res);
        length+=8;
    }
    curValue = (curValue << 1) + (uint8_t)(deque.at(pos++) - '0');
    curValLen++;
    return curValue;
}
NAME_SPACE_END()

BmpEncoder.h

#pragma once
#include 
#include 
#include "Image.h"
using namespace myUtil;
/* Bitmap Header, 54 Bytes  */
static 
unsigned char BmpHeader[54] = 
{
	0x42, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x60, 0xCD, 0x04, 0x00, 0x23, 0x2E, 0x00, 0x00, 0x23, 0x2E, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
void SetBitmapInfo(unsigned int size, int height, int width)
{
	for (int i = 0; i < 4; i++)
	{
		// size of image ( header + data )
		BmpHeader[2 + i] = size & 0xff;
		size >>= 8;
		// width of image
		BmpHeader[18 + i] = width & 0xff;
		width >>= 8;
		// height of image
		BmpHeader[22  + i] = height & 0xff;
		height >>= 8;
	}
}
/* BGR format 这是我粘来的改了映射部分代码 */
unsigned char *Encoder(const vector& buf, int height, int width, int mcu_height, int mcu_width, int &size)
{
	uint8_t *bitmap = nullptr;
	int rowSize = (24 * width + 31) / 32 * 4;
	// compute the size of total bytes of image
	size = rowSize * height + 54; // data size + header size
	bitmap = new uint8_t [ size ];
	// set the header info
	SetBitmapInfo(size, height, width);
	// fill the header area
	for (int i = 0; i < 54; i++)
	{
		bitmap[i] = BmpHeader[i];
	}
	// fill the data area
	for (int i = 0; i < height; i++)
	{
		// compute the offset of destination bitmap and source image
		int idx = height - 1 - i;
		int offsetDst = idx * rowSize + 54; // 54 means the header length
		// int offsetSrc = i * width;
		int offsetHeight = (int)floor(i*1.0/mcu_height)*(int)ceil(width*1.0/mcu_width);
		// fill data
		for (int j = 0; j < width * 3; j++)
		{
			int pos=(j/3)/mcu_width+offsetHeight;
			if(pos>=buf.size()) pos=buf.size()-1;
			RGB temp=buf[pos][i%mcu_height][(j/3)%mcu_height];
			if(j%3==0) bitmap[offsetDst + j] = temp.blue;
			else if(j%3==1) bitmap[offsetDst + j] = temp.green;
			else if(j%3==2) bitmap[offsetDst + j] = temp.red;
			// cout< 
 

主程序

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "Image.h"
#include "BmpEncoder.h"
using namespace std;
using namespace myUtil;
// void print(double** input){
// 	cout< 
 

项目环境gcc 7.3.0 工具CMake，源码链接

到此这篇关于C++实现JPEG格式图片解析(附代码)的文章就介绍到这了,更多相关C++图片解析内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！