JPEG（ Joint Photographic Experts Group）即联合图像专家组，是用于连续色调静态图像压缩的一种标准，文件后缀名为.jpg或.jpeg，是最常用的图像文件格式。
其主要是采用预测编码（DPCM）、离散余弦变换（DCT）以及熵编码的联合编码方式，以去除冗余的图像和彩色数据，属于有损压缩格式，它能够将图像压缩在很小的储存空间，一定程度上会造成图像数据的损伤。尤其是使用过高的压缩比例，将使最终解压缩后恢复的图像质量降低，如果追求高品质图像，则不宜采用过高的压缩比例。
JPEG的性能，用质量与比特率之比来衡量，是相当优越的。
它的优点是：
支持极高的压缩率，因此JPEG图像的下载速度大大加快。
能够轻松地处理16.8M颜色，可以很好地再现全彩色的图像。
在对图像的压缩处理过程中，该图像格式可以允许自由地在最小文件尺寸（最低图像质量）和最大文件尺寸（最高图像质量）之间选择。
该格式的文件尺寸相对较小，下载速度快，有利于在带宽并不“富裕”的情况下传输。
JPEG的缺点是：
并非所有的浏览器都支持将各种JPEG图像插入网页。
压缩时，可能使图像的质量受到损失，因此不适宜用该格式来显示高清晰度的图像。
JPEG文件格式
概述
JPEG文件的存储格式有很多种，但最常用的是JFIF格式 。
JPEG在文件中以Segment的形式组织的，它具有以下特点：
① 标记码：由两个字节构成，其中，前一个字节是固定值0xFF代表了一个标记码的开始，后一个字节不同的值代表着不同的含义。连续多个0xFF可以理解为一个0xFF，并表示一个标记码的开始。另外，标记码在文件中一般是以标记代码的形式出现的。标记码后是2字节的Segment length（含length本身所占用的2字节，不包含0xFF和Marker所占用的字节），之后是该标记对应的payload；
②保存时高位在前，低位在后；
③Data部分中，0xFF后若为0x00，则跳过此字节不予处理
编码原理
JPEG编码的过程如上图，解码就是编码的逆过程，简单介绍一下编码过程：
1.零偏置（level offset）
JPEG编码将图像分为8×8的块作为数据处理的最小单位，对于灰度级为2 n 2^n2
n
的像素，通过减去2 n − 1 2^{n-1}2
n−1
，将无符号数变成有符号数。以灰度级n=8为例，原来图像的灰度范围是[0,255]，减去128之后变为了[-128,127]。经过零偏置后，图像平均亮度降低，像素灰度的绝对值被控制在较小的范围内，有利于后续编码。
2.DCT变换
对零偏置后的图像进行DCT变换，以进行能量集中和去相关，同时去除图像的空间冗余，变换后图像的能量都集中在右上角，同时DCT变换是一种无损变换，在变换过程中没有精度损失。如果有些图片并非8×8的整数倍，那么就需要在边缘进行像素填充。
3.量化
因为人眼对亮度信号比对色差信号更敏感，因此使用了两种量化表，分别是亮度量化值和色差量化值。同时因为人眼对低频敏感高频不太敏感，因此对低频分量采取较细的量化，对高频分量采取较粗的量化，因此细节少的原始图像在压缩时去掉的数据要少
4.DC系数的差分编码
8×8的图像块经过DCT变换之后得到的DC直流系数有两个特点：系数的数值比较大；相邻8×8图像块的DC系数值变化不大（存在冗余），因此可以采用DPCM方法，对相邻图像块之间量化DC系数的差值进行编码，编码方式采用熵编码（Huffman编码），亮度信号与色度信号的DC系数采用不同的Huffman编码表
5.AC系数的zig-zag扫描与游程编码
由于经过DCT变换后，系数大多集中在左上角，也就是低频分量区，因此采用Z字形扫描，按频率的高低顺序读出，这样会出现很多的连零，可以使用RLE游程编码，尤其是在最后，如果都是零，直接给出EOB（End of Block）即可
在JPEG编码中，游程编码的形式为：（run，level）
表示连续run个0后有值为level的系数
run最多15个，用4位表示RRRR
level，类似DC，分成16个类别，用4位SSSS表示类别号，类内索引
对（RRRR,SSSS）采用Huffman编码，对类内索引采用定长编码
亮度信号和色度信号的AC系数也有不同的Huffman码表
综上可以知道，在JPEG编码的过程中用到了两张量化表（亮度和色度）以及四张Huffman码表（亮度DC、亮度AC、色度DC和色度AC）
解码原理解码就是编码的逆过程，其大致流程如下：
读取文件
解析文件segment
解析SOI，判断是否是JPEG文件
解析SOF
解析DQT，获取量化表相关信息
解析SOS
解析DHT，获取Huffman码表相关信息
解析DRI
以MCU为单位进行解码
解码Huffman数据
解码DC差值
重构量化后的系数
DCT逆变换
丢弃填充的行/列
反0偏置
对丢失的CbCr分量差值（下采样的逆过程）
YCbCr->RGB
int main(int argc, char *argv[])
{
int output_format = TINYJPEG_FMT_YUV420P;
char *output_filename, *input_filename;
clock_t start_time, finish_time;
unsigned int duration;
int current_argument;
int benchmark_mode = 0;
#if TRACE //设定trace，边解码边写入文件
p_trace=fopen(TRACEFILE,"w");
if (p_trace==NULL)
{
printf("trace file open error!");
}
#endif
if (argc < 3)
usage();
current_argument = 1;
while (1)
{
if (strcmp(argv[current_argument], "--benchmark")==0) //strcmp字符串比较，用于比较两个字符串，如果二者相等返回0
benchmark_mode = 1; //如果相等，说明设置了benchmark，因此benchmark_mode置1
else
break;
current_argument++;
}
if (argc < current_argument+2)
usage();
input_filename = argv[current_argument]; //输入文件名，是argv[1]
if (strcmp(argv[current_argument+1],"yuv420p")==0) //argv[2]判断输出格式，这里选择yuv420p
output_format = TINYJPEG_FMT_YUV420P;
else if (strcmp(argv[current_argument+1],"rgb24")==0)
output_format = TINYJPEG_FMT_RGB24;
else if (strcmp(argv[current_argument+1],"bgr24")==0)
output_format = TINYJPEG_FMT_BGR24;
else if (strcmp(argv[current_argument+1],"grey")==0)
output_format = TINYJPEG_FMT_GREY;
else
exitmessage("Bad format: need to be one of yuv420p, rgb24, bgr24, greyn");
output_filename = argv[current_argument+2]; //输出文件名，设为argv[3]
start_time = clock(); //开始
if (benchmark_mode) //是否多次解码，若设置了benchmark_mode就调用load_multiple_times，否则就调用convert_one_image
load_multiple_times(input_filename, output_filename, output_format);
else
convert_one_image(input_filename, output_filename, output_format); //核心函数
finish_time = clock(); //结束
duration = finish_time - start_time;
snprintf(error_string, sizeof(error_string),"Decoding finished in %u ticksn", duration);
#if TRACE
fclose(p_trace);
#endif
return 0;
}
结构体分析
struct huffman_table
huffman查找表有两种实现方法，分别为huffman树的遍历和loookup查找表。优先选用lookup查找表，code_size给出每个符号的编码比特位数。
struct huffman_table
{
short int lookup[HUFFMAN_HASH_SIZE];
unsigned char code_size[HUFFMAN_HASH_SIZE];
uint16_t slowtable[16-HUFFMAN_HASH_NBITS][256];
};
struct component
包含struct huffman_table。
定义了采样因子，量化表，AC和DC huffman表，前一个块的直流DCT系数（亮度编码为DPCM，需要使用上一个块的直流系数来解码），当前块的DCT系数。
struct component
{
unsigned int Hfactor;//水平采样因子
unsigned int Vfactor;//垂直采样因子
float *Q_table;//量化表
struct huffman_table *AC_table;//交流AC huffman表
struct huffman_table *DC_table;//直流DC huffman表
short int previous_DC;
short int DCT[64];
#if SANITY_CHECK
unsigned int cid;
#endif
};
struct jdec_private
包含struct huffman_table，struct component 。
定义了图像宽高，数据流起始，数据流长度，量化表和huffman表
struct jdec_private
{
uint8_t *components[COMPONENTS];
unsigned int width, height;
unsigned int flags;
const unsigned char *stream_begin, *stream_end;
unsigned int stream_length;
const unsigned char *stream;
unsigned int reservoir, nbits_in_reservoir;
struct component component_infos[COMPONENTS];
float Q_tables[COMPONENTS][64];
struct huffman_table HTDC[HUFFMAN_TABLES];
struct huffman_table HTAC[HUFFMAN_TABLES];
int default_huffman_table_initialized;
int restart_interval;
int restarts_to_go;
int last_rst_marker_seen;
uint8_t Y[64*4], Cr[64], Cb[64];
jmp_buf jump_state;
uint8_t *plane[COMPONENTS];
};
实验步骤
1.JPG文件输出YUV文件
修改loadjpg.c中的write_yuv函数：
static void write_yuv(const char *filename, int width, int height, unsigned char **components)
{
FILE *F;
char temp[1024];
snprintf(temp, 1024, "%s.Y", filename);
F = fopen(temp, "wb");
fwrite(components[0], width, height, F);
fclose(F);
snprintf(temp, 1024, "%s.U", filename);
F = fopen(temp, "wb");
fwrite(components[1], width*height/4, 1, F);
fclose(F);
snprintf(temp, 1024, "%s.V", filename);
F = fopen(temp, "wb");
fwrite(components[2], width*height/4, 1, F);
fclose(F);
//添加代码
snprintf(temp, 1024, "%s.YUV", filename);
F = fopen(temp,"wb");
fwrite(components[0], width, height, F);
fwrite(components[1], width*height/4,1, F);
fwrite(components[2], width*height / 4, 1, F);
fclose(F);
}
2.以txt文件输出所有的量化矩阵和所有的HUFFMAN码表
量化矩阵
在build_quantization_table函数中增加代码：
static void build_quantization_table(float *qtable, const unsigned char *ref_table)
{
int i, j;
static const double aanscalefactor[8] = {
1.0, 1.387039845, 1.306562965, 1.175875602,
1.0, 0.785694958, 0.541196100, 0.275899379
};
const unsigned char *zz = zigzag;
for (i=0; i<8; i++) {
for (j=0; j<8; j++) {
*qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];
}
}
//增加代码
#if TRACE
const unsigned char* zz1 = zigzag;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
fprintf(p_trace, "%d", ref_table[*zz1++]);
if (j == 7) {
fprintf(p_trace, "n");
}
}
}
#endif
}
输出量化矩阵：
HUFFMAN码表
build_huffman_table函数可以输出HUFFMAN码表
static void build_huffman_table(const unsigned char *bits, const unsigned char *vals, struct huffman_table *table)
{
unsigned int i, j, code, code_size, val, nbits;
unsigned char huffsize[HUFFMAN_BITS_SIZE+1], *hz;
unsigned int huffcode[HUFFMAN_BITS_SIZE+1], *hc;
int next_free_entry;
hz = huffsize;
for (i=1; i<=16; i++)
{
for (j=1; j<=bits[i]; j++)
*hz++ = i;
}
*hz = 0;
memset(table->lookup, 0xff, sizeof(table->lookup));
for (i=0; i<(16-HUFFMAN_HASH_NBITS); i++)
table->slowtable[i][0] = 0;
code = 0;
hc = huffcode;
hz = huffsize;
nbits = *hz;
while (*hz)
{
while (*hz == nbits)
{
*hc++ = code++;
hz++;
}
code <<= 1;
nbits++;
}
next_free_entry = -1;
for (i=0; huffsize[i]; i++)
{
val = vals[i];
code = huffcode[i];
code_size = huffsize[i];
#if TRACE
fprintf(p_trace,"val=%2.2x code=%8.8x codesize=%2.2dn", val, code, code_size);
fflush(p_trace);
#endif
table->code_size[val] = code_size;
if (code_size <= HUFFMAN_HASH_NBITS)
{
int repeat = 1UL<<(HUFFMAN_HASH_NBITS - code_size);
code <<= HUFFMAN_HASH_NBITS - code_size;
while ( repeat-- )
table->lookup[code++] = val;
}
else
{
uint16_t *slowtable = table->slowtable[code_size-HUFFMAN_HASH_NBITS-1];
while(slowtable[0])
slowtable+=2;
slowtable[0] = code;
slowtable[1] = val;
slowtable[2] = 0;
}
}
}
输出DC，AC图像并统计其概率分布
在tinyjpeg_decode中添加代码
int file_length = 0;
FILE* DC_file = fopen("DC.yuv", "wb");
FILE* AC_file = fopen("AC.yuv", "wb");
unsigned char dc;
unsigned char ac;
dc = (unsigned char)((priv->component_infos->DCT[0] + 512.0) / 4);//DC系数的取值范围[-512,511],转换为[0,255]的范围
ac = (unsigned char)(priv->component_infos->DCT[1] + 128);//AC系数的取值范围为[-128,127]，将其转换为[0,255]的范围
fwrite(&dc, 1, 1, DC_file);
fwrite(&ac, 1, 1, AC_file);
file_length++;
unsigned char uv = 128;
for (int i = 0; i < file_length / 4 * 2; i++) {
fwrite(&uv, 1, 1, DC_file);
fwrite(&uv, 1, 1, AC_file);
}
fclose(DC_file);
fclose(AC_file);
得到DC,AC图像：
