实验目的：
掌握JPEG编解码系统的基本原理。初步掌握复杂的数据压缩算法实现，并能根据理论分析需要实现所对应数据的输出。
主要设备：
安装Windows和Visual Studio软件的个人计算机
实验内容：
一、JPEG：
1.基本定义：
JPEG（Joint Photographic Experts Group）是JPEG标准的产物,该标准由国际标准化组织（ISO）制订，是面向连续色调静止图像的一种压缩标准。 [1] JPEG格式是最常用的图像文件格式，后缀名为.jpg或.jpeg。

2.JPEG编码基本原理：
如上图所示，JPEG的编码基本原理如上图所示：
（1）Level offset(零电平偏置):
将输入的图像的所有像素点的值-128，使其原先范围由0～255变为-128～127
（2）8✖️8DCT变换：
将零电平偏置之后的图像分成88像素的块来处理，不足88的，则取边缘像素补齐，对每个块做DCT变换，直流系数在每个块的左上角，越右下角的分量频率越高。
（3）Uniform scalar quantization(量化)：
使用根据人眼视觉特性设计的量化的量化矩阵对DCT变换之后的结果进行量化，从而进而减少视觉冗余。
（4）DCT变换后DC系数值较大，且相邻块变化不大，利用这个特性对其进行DPCM，对相邻块的DC差值huffman编码
（5）对AC系数做之字形扫描，再进行游程编码和huffman编码
3.JPEG文件格式：
（1）Segment 的组织形式
JPEG 在文件中以 Segment 的形式组织，它具有以下特点：
(a)均以 0xFF 开始，后跟 1 byte 的 Marker 和 2 byte 的Segment length（包含表示 Length 本身所占用的 2 byte，不含“0xFF” + “Marker” 所占用的 2 byte）；
(b) 采用 Motorola 序（相对于 Intel 序），即保存时高位在前，低位在后；
©Data 部分中，0xFF 后若为 0x00，则跳过此字节不予处理；
（2）JPEG的Segment Marker
(备注：此部分截图中的表格均为三列格式：分别为：“symbol（符号）”，“Code Assignment（0xFF+Marker）（标记代码）”，“Description（说明）”)
（a）Start Of Frame markers, non hierarchical Huffman coding
(b)Start Of Frame markers, hierarchical Huffman coding

©Start Of Frame markers, non-hierarchical arithmetic coding

(d)Start Of Frame markers, hierarchical arithmetic coding

(e)Huffman table specification

(f)arithmetic coding conditioning specification

(g)Restart interval termination

(h)Other marker

(i)Reserved markers
（3）部分Segment marker介绍：
（a）SOI：START OF IMAGE，图像开始，标记代码两字节，固定值0xFFD8
（b）EOI：END OF IMAGE，图像结束，标记代码两字节，固定值0xFFD9
（c）APP0应用程序保留标记0:
标记代码：2字节，固定值0xFFE0

（d）DQT定义量化表：标记代码2字节，固定值0xFFDB
包含9个具体字段：
数据长度：2字节，字段1和多个字段2的总长度
量化表：数据长度-2字节
a）精度及量化表ID：1字节
高4位：精度，只有两个可选值 0:8位，1:16位
b）表项：（64*（精度+1））字节
（e）SOF0:帧图像开始：标记代码2字节，固定值0xFFC0
包含9个具体字段：
数据长度：2字节，整个部分6个字段的总长度
精度：1字节，代表每个数据样本的位数，通常为8位
图像高度：2字节，单位像素
图像宽度：2字节，单位像素
颜色分量数：1字节，3个数值可选：
1:灰度图，3:YCrCb或者YIQ，4:CMYK
而JFIF中使用TCrCb，故这里颜色分量数恒为3
颜色分量信息：通常为9字节（颜色分量数✖️3字节）
ea)颜色分量ID，1字节
eb)水平/垂直采样因子，1字节，高4位：水平采样因子；第四位，垂直采样因子
ec)量化表，1字节，当前分量使用的量化表ID
(f)DHT：定义huffman表，标记代码2字节，0xFFC4

(g)SOS：扫描开始，标记代码2字节，固定值0xFFDA

3.JPEG解码基本原理
（1）读取文件
（2）解析segment marker
(a)解析 SOI
(b)解析 APP0
检查标识“JFIF”及版本并得到一些参数
© 解析 DQT
得到量化表长度（可能包含多张量化表）
得到量化表的精度
得到及检查量化表的序号（只能是 0 —— 3）
得到量化表内容（64 个数据）
(d)解析 SOF0
得到每个 sample 的比特数、长宽、颜色分量数
得到每个颜色分量的 ID、水平采样因子、垂直采样因子、使用的量化表 序号（与 DQT 中序号对应）
(e) 解析 DHT
得到 Huffman 表的类型（AC、DC）、序号
依据数据重建 Huffman 表 3.2.6 解析 SOS
得到解析每个颜色分量的 DC、AC 值所使用的 Huffman 表序号（与 DHT 中序号对应）
(3)依据每个分量的水平、垂直采样因子计算 MCU 的大小，并得到每个 MCU 中 8*8 宏块的个数
(4) 对每个 MCU 解码（依照各分量水平、垂直采样因子对 MCU 中每个分量宏块解 码）
(a)对每个宏块进行 Huffman 解码，得到 DCT 系数
(b)对每个宏块的 DCT 系数进行 IDCT，得到 Y、Cb、Cr
©遇到 Segment Marker RST 时，清空之前的 DC DCT 系数
(5)解析到 EOI，解码结束
(6) 将 Y、Cb、Cr 转化为需要的色彩空间并保存。
二、具体实验步骤
1.逐步调试JPEG解码器程序。将输入的JPG文件进行解码，将输出文件保存为可供YUVViewer观看的YUV文件。
在本次实验中，我们主要采用本图片，test.jpg进行操作：（嗯，看着有点晕其实）

首先在命令行中按照主程序中的设置添加参数，先运行一下代码：


而后我们便可以发现文件夹中生成了三个名为test的新文件，即：test.u,test.v,test.y，分别存储的是test.jpg图片转化为yuv文件之后的三个分量。
所以，我们需要对于原来的代码进行修改：
首先，我们找到write_yuv这个函数，从代码注释中，我们可以看出，这段就是使之输出test.u,test.v,test.y的相关代码：

所以，我们对本段代码进行如下添加，使之可以输出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);
}

其中，需要注意的是，最开始输入命令行的时候可能出现报错：
“错误 D8016 “/ZI”和“/Gy-”命令行选项不兼容 ”
在查找了一下之后，发现需要做以下操作即可解决：


最后运行程序，可以看到，程序生成了一个test.yuv的文件，使用pyuv打开可以看到其和原图JPG形式的图片没有差别：

至此，本实验第一步完成。
2. 程序调试：
（1）程序运行的整体框架：（本部分的大部分介绍都以注释的形式，写在代码中）
首先介绍三个比较重要的结构体：
（a）struct huffman_table

struct huffman_table
{/* Fast look up table, using HUFFMAN_HASH_NBITS bits we can have directly the symbol,* if the symbol is <0, then we need to look into the tree table */short int lookup[HUFFMAN_HASH_SIZE];/* code size: give the number of bits of a symbol is encoded */unsigned char code_size[HUFFMAN_HASH_SIZE];/* some place to store value that is not encoded in the lookup table * FIXME: Calculate if 256 value is enough to store all values*/uint16_t slowtable[16-HUFFMAN_HASH_NBITS][256];
};

从这个结构体中，我们可以看出，其包含三个部分：其中lookup为short int型，用来加速查表，如果查找失败的话则就要使用慢速查找表。code_size为码字的长度。定义这个结构体的目的就是用来快速查找，从而加速程序的运行速度。
(b)struct component

struct component 
{unsigned int Hfactor;unsigned int Vfactor;float *Q_table;  /* Pointer to the quantisation table to use */struct huffman_table *AC_table;struct huffman_table *DC_table;short int previous_DC; /* Previous DC coefficient */short int DCT[64];  /* DCT coef */
#if SANITY_CHECKunsigned int cid;
#endif
};

这个结构体中，首先定义的Hfactor和Vfactor分别对应horizontal和vertical即水平和垂直方向的采样信息。而后定义Q_table则是对应此次DCT变换所对应的量化表，DCT[64]则代表这个8✖️8的宏块所存储的DCT系数，previousDC则指的是前一个直流系数。
这部分的主要用途就是用来存储每一个MCU的信息，用来进行DCT的变换。
（c）struct jdec_private

struct jdec_private
{/* Public variables */uint8_t *components[COMPONENTS];unsigned int width, height; /* Size of the image */unsigned int flags;/* Private variables */const unsigned char *stream_begin, *stream_end;unsigned int stream_length;const unsigned char *stream; /* Pointer to the current stream */unsigned int reservoir, nbits_in_reservoir;struct component component_infos[COMPONENTS];float Q_tables[COMPONENTS][64];  /* quantization tables */struct huffman_table HTDC[HUFFMAN_TABLES]; /* DC huffman tables   */struct huffman_table HTAC[HUFFMAN_TABLES]; /* AC huffman tables   */int default_huffman_table_initialized;int restart_interval;int restarts_to_go;    /* MCUs left in this restart interval */int last_rst_marker_seen;   /* Rst marker is incremented each time *//* Temp space used after the IDCT to store each components */uint8_t Y[64*4], Cr[64], Cb[64];jmp_buf jump_state;/* Internal Pointer use for colorspace conversion, do not modify it !!! */uint8_t *plane[COMPONENTS];};

此部分的结构体则是包含整合了以上两个结构体中的内容，在解码过程中，我们会频繁使用到这个结构体。在这个结构体中，其保存了图像的所有基本信息，在解码完成之后，该结构体存储JPEG文件中的具体信息。
而后我们再从主程序最开头开始理解程序的框架：

int main(int argc, char *argv[])
{int output_format = TINYJPEG_FMT_YUV420P;//将输出格式初始化为yuv420格式char *output_filename, *input_filename;//定义两个指针，用来输入输出文件clock_t start_time, finish_time;unsigned int duration;int current_argument;//定义变量用来选取命令参数int benchmark_mode = 0;
#if TRACE//在头文件中，已经定义了TRACE的初始化值为1，如果TRACE不为1，则这步不会调用p_trace=fopen(TRACEFILE,"w");if (p_trace==NULL){printf("trace file open error!");}
#endifif (argc < 3)usage();current_argument = 1;while (1){if (strcmp(argv[current_argument], "--benchmark")==0)benchmark_mode = 1;elsebreak;current_argument++;}if (argc < current_argument+2)usage();input_filename = argv[current_argument];//指向输入文件的文件路径if (strcmp(argv[current_argument+1],"yuv420p")==0)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;elseexitmessage("Bad format: need to be one of yuv420p, rgb24, bgr24, grey\n");//如果输入的格式这上面的格式都没有//那么这个程序就不能正常生效，也就是会显示这条提示output_filename = argv[current_argument+2];//指向命令参数的第三个，确认文件的输出路径start_time = clock();if (benchmark_mode)load_multiple_times(input_filename, output_filename, output_format);elseconvert_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 ticks\n", duration);
#if TRACEfclose(p_trace);
#endifreturn 0;
}

从主程序中，我们主要需要知道的是，整个解码器程序可以将JPEG文件转化为很多种其他格式的文件，而其解码的过程则是主要调用了convert_one_image这个函数，当然，也可以是调用load_mutiple_times这个函数，通过benchmatk_mode这个变量来进行选择，在本实验的运行中，我们会调用的是convert_one_image这个函数：

/*** Load one jpeg image, and decompress it, and save the result.*/
int convert_one_image(const char *infilename, const char *outfilename, int output_format)
{FILE *fp;//定义文件指针fpunsigned int length_of_file;//定义变量用以保存读入文件的大小unsigned int width, height;//定义图像的长宽unsigned char *buf;//定义缓冲区struct jdec_private *jdec;unsigned char *components[3];/* Load the Jpeg into memory */fp = fopen(infilename, "rb");//读取JPEG文件if (fp == NULL)exitmessage("Cannot open filename\n");length_of_file = filesize(fp);//保存读入文件的大小buf = (unsigned char *)malloc(length_of_file + 4);if (buf == NULL)exitmessage("Not enough memory for loading file\n");fread(buf, length_of_file, 1, fp); //将JPEG数据读入bufferfclose(fp);/* Decompress it */jdec = tinyjpeg_init();//初始化解压缩成一块表和数组的结构体if (jdec == NULL)exitmessage("Not enough memory to alloc the structure need for decompressing\n");if (tinyjpeg_parse_header(jdec, buf, length_of_file)<0)exitmessage(tinyjpeg_get_errorstring(jdec));/* Get the size of the image */tinyjpeg_get_size(jdec, &width, &height);snprintf(error_string, sizeof(error_string),"Decoding JPEG image...\n");if (tinyjpeg_decode(jdec, output_format) < 0)exitmessage(tinyjpeg_get_errorstring(jdec));/* * Get address for each plane (not only max 3 planes is supported), and* depending of the output mode, only some components will be filled * RGB: 1 plane, YUV420P: 3 planes, GREY: 1 plane*/tinyjpeg_get_components(jdec, components);/* Save it */switch (output_format)//进行格式判断，用以调用相应的函数，从而按要求输出文件{case TINYJPEG_FMT_RGB24:case TINYJPEG_FMT_BGR24:write_tga(outfilename, output_format, width, height, components);break;case TINYJPEG_FMT_YUV420P:write_yuv(outfilename, width, height, components);break;case TINYJPEG_FMT_GREY:write_pgm(outfilename, width, height, components);break;}/* Only called this if the buffers were allocated by tinyjpeg_decode() */tinyjpeg_free(jdec);/* else called just free(jdec); */free(buf);return 0;
}

convert_one_image的主要作用是读取我们所输入的JPEG文件，并对其进行解压缩。其中我们首先用到了tinyjpeg_parse_header这个函数用来解析文件头：

int tinyjpeg_parse_header(struct jdec_private *priv, const unsigned char *buf, unsigned int size)
{int ret;/* Identify the file */if ((buf[0] != 0xFF) || (buf[1] != SOI))snprintf(error_string, sizeof(error_string),"Not a JPG file ?\n");priv->stream_begin = buf+2;priv->stream_length = size-2;priv->stream_end = priv->stream_begin + priv->stream_length;ret = parse_JFIF(priv, priv->stream_begin);return ret;
}

而后，我们也用到了tinyjpeg_get_siz函数来获取图像大小和长宽：

void tinyjpeg_get_size(struct jdec_private *priv, unsigned int *width, unsigned int *height)
{*width = priv->width;*height = priv->height;
}

再然后又用到了tinyjpeg_decode用来解码：

int tinyjpeg_decode(struct jdec_private *priv, int pixfmt)
{unsigned int x, y, xstride_by_mcu, ystride_by_mcu;unsigned int bytes_per_blocklines[3], bytes_per_mcu[3];decode_MCU_fct decode_MCU;const decode_MCU_fct *decode_mcu_table;const convert_colorspace_fct *colorspace_array_conv;convert_colorspace_fct convert_to_pixfmt;if (setjmp(priv->jump_state))return -1;/* To keep gcc happy initialize some array */bytes_per_mcu[1] = 0;bytes_per_mcu[2] = 0;bytes_per_blocklines[1] = 0;bytes_per_blocklines[2] = 0;decode_mcu_table = decode_mcu_3comp_table;switch (pixfmt) {case TINYJPEG_FMT_YUV420P:colorspace_array_conv = convert_colorspace_yuv420p;if (priv->components[0] == NULL)priv->components[0] = (uint8_t *)malloc(priv->width * priv->height);if (priv->components[1] == NULL)priv->components[1] = (uint8_t *)malloc(priv->width * priv->height/4);if (priv->components[2] == NULL)priv->components[2] = (uint8_t *)malloc(priv->width * priv->height/4);bytes_per_blocklines[0] = priv->width;bytes_per_blocklines[1] = priv->width/4;bytes_per_blocklines[2] = priv->width/4;bytes_per_mcu[0] = 8;bytes_per_mcu[1] = 4;bytes_per_mcu[2] = 4;break;case TINYJPEG_FMT_RGB24:colorspace_array_conv = convert_colorspace_rgb24;if (priv->components[0] == NULL)priv->components[0] = (uint8_t *)malloc(priv->width * priv->height * 3);bytes_per_blocklines[0] = priv->width * 3;bytes_per_mcu[0] = 3*8;break;case TINYJPEG_FMT_BGR24:colorspace_array_conv = convert_colorspace_bgr24;if (priv->components[0] == NULL)priv->components[0] = (uint8_t *)malloc(priv->width * priv->height * 3);bytes_per_blocklines[0] = priv->width * 3;bytes_per_mcu[0] = 3*8;break;case TINYJPEG_FMT_GREY:decode_mcu_table = decode_mcu_1comp_table;colorspace_array_conv = convert_colorspace_grey;if (priv->components[0] == NULL)priv->components[0] = (uint8_t *)malloc(priv->width * priv->height);bytes_per_blocklines[0] = priv->width;bytes_per_mcu[0] = 8;break;default:
#if TRACEfprintf(p_trace,"Bad pixel format\n");fflush(p_trace);
#endifreturn -1;}

同时也调用了tinyjpeg_get_components：

int tinyjpeg_get_components(struct jdec_private *priv, unsigned char **components)
{int i;for (i=0; priv->components[i] && i<COMPONENTS; i++)components[i] = priv->components[i];return 0;
}

最后又会调用write_yuv函数，用来将转化完成的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);
}

（3）Trace的目的及含义：
TRACE随着文件的解析，也会一直输出中间信息，在使用过程中，我们初始状态设置了：

#define TRACE 1//add by nxn

也就是说，只要TRACE的值为1，那么就代表TRACE被打开，可以用来记录程序运行过程中的重要中间信息。
例如利用TRACE的一个例子如下：

#if TRACE//在头文件中，已经定义了TRACE的初始化值为1，如果TRACE不为1，则这步不会调用p_trace=fopen(TRACEFILE,"w");if (p_trace==NULL){printf("trace file open error!");}
#endif

根据自己的要求修改TRACE：
首先，正常情况下，TRACE的内容会生成到文件夹中的trace_jpeg.txt中：

此时，生成SOF marker处的代码为：

#if TRACEfprintf(p_trace,"> SOF marker\n");fprintf(p_trace,"Size:%dx%d nr_components:%d (%s)  precision:%d\n", width, height,nr_components, nr_components_to_string[nr_components],precision);fflush(p_trace);
#endif

之后，我们删除了写出precision的部分，代码如下：

#if TRACEfprintf(p_trace,"> SOF marker\n");fprintf(p_trace,"Size:%dx%d nr_components:%d (%s)\n", width, height,nr_components, nr_components_to_string[nr_components]);fflush(p_trace);
#endif
}

输出结果如下，可见已经完成了TRACE的调试操作：

3．以txt文件输出所有的量化矩阵和所有的HUFFMAN码表。
首先：在头文件tinyjpeg.h中添加下列代码：

FILE *p_trace;//add by nxn
FILE* huffmantable;//新建一个文件指针，并利用它来生成一个txt，用来存放输出的huffman码表
FILE* DC;//新建一个文件指针，并利用它来生成一个yuv，用来存放输出的DC图像
FILE* AC;//新建一个文件指针，并利用它来生成一个yuv，用来存放输出的AC图像
FILE* quantization;//新建一个文件指针，并利用它来生成一个txt，用来存放输出的量化矩阵

而后在主函数中的trace部分添加如下代码：

if TRACE//在头文件中，已经定义了TRACE的初始化值为1，如果TRACE不为1，则这步不会调用p_trace=fopen(TRACEFILE,"w");if (p_trace==NULL){printf("trace file open error!\n");}if ((fopen_s(&huffmantable, "huffmantable.txt", "ab")) != 0){printf("Failed to open the txt file.\n");}else{printf("Successfully opened the txt file.\n");}if ((fopen_s(&DC, "DC.yuv", "ab")) != 0){printf("Failed to open the yuv file.\n");}else{printf("Successfully opened the yuv file.\n");}if ((fopen_s(&AC, "AC.yuv", "ab")) != 0){printf("Failed to open the yuv file.\n");}else{printf("Successfully opened the yuv file.\n");}if ((fopen_s(&quantization, "quantization.txt", "ab")) != 0){printf("Failed to open the txt file.\n");}else{printf("Successfully opened the txt file.\n");}#endif

而后在build_huffman_table的trace中添加：

#if TRACEfprintf(p_trace,"val=%2.2x code=%8.8x codesize=%2.2d\n", val, code, code_size);fprintf(huffmantable, "val=%2.2x code=%8.8x codesize=%2.2d\n", val, code, code_size);//添加fflush(p_trace);#endif

最后在parse_DHT的trace中添加：

if TRACEfprintf(p_trace,"Huffman table %s[%d] length=%d\n", (index&0xf0)?"AC":"DC", index&0xf, count);fprintf(huffmantable, "Huffman table %s[%d] length=%d\n", (index & 0xf0) ? "AC" : "DC", index & 0xf, count);//添加fflush(p_trace);
#endif

最后运行程序，可以看见文件夹中输出了一个huffmantable.txt的文件，打开后内容如下：

对于量化表方面，则是要首先对parse_DQT函数中的这部分进行添加

#if SANITY_CHECKif (qi >> 4)snprintf(error_string, sizeof(error_string), "16 bits quantization table is not supported\n");if (qi > 4)snprintf(error_string, sizeof(error_string), "No more 4 quantization table is supported (got %d)\n", qi);
#endif
#if TRACEfprintf(quantization, "Quantization_table [%d]:\n", qi);fflush(quantization);
#endiftable = priv->Q_tables[qi];build_quantization_table(table, stream);stream += 64;}

而后，再对函数build_quantization_table进行添加：

static void build_quantization_table(float *qtable, const unsigned char *ref_table)
{/* Taken from libjpeg. Copyright Independent JPEG Group's LLM idct.* For float AA&N IDCT method, divisors are equal to quantization* coefficients scaled by scalefactor[row]*scalefactor[col], where*   scalefactor[0] = 1*   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7* We apply a further scale factor of 8.* What's actually stored is 1/divisor so that the inner loop can* use a multiplication rather than a division.*/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++) {
#if TRACEfprintf(quantization, "%d\t", ref_table[*zz]);//输出量化表fflush(quantization);if (j == 7){fprintf(quantization, "\n");//每八个换一次行（8*8矩阵）fflush(quantization);}
#endif*qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];}}}

运行程序之后，可以发现文件夹中生成了一个名为quantizaiton的txt文件，打开后结果如下：
4&5． 输出DC图像并统计其概率分布，输出某一个AC值图像并统计其概率分布。
在这一步中，我们需要对tinyjpeg_decode函数中的for循环部分添加如下代码用来输出其DC图像和AC图像：

unsigned char* DC_BUFFER = NULL;unsigned char* AC_BUFFER = NULL;DC_BUFFER = (unsigned char)((priv->component_infos->DCT[0] + 512.0) / 4 + 0.5);AC_BUFFER = (unsigned char)(priv->component_infos->DCT[1] + 128);fwrite(&DC_BUFFER, 1, 1, DC);fwrite(&AC_BUFFER, 1, 1, AC);

运行程序，我们可以得到两个名字为AC和DC的YUV文件，使用PYUV软件打开并将其转化为bmp文件之后，我们可以得到DC图像和AC图像：
DC图像：

AC图像：

其中，此时输出的DC图像和AC图像的尺寸均为128128，因为原本的图像为10241024，1024/8之后得出的尺寸即为新图像的长宽。
最后，我们调用之前写好的计算概率分布和熵的函数，即可统计其概率分布：

#include<iostream>
#include<math.h>
using namespace std;
#define w 128
#define h 128
int main()
{FILE* YUV = NULL;FILE* OUTPUT = NULL;if ((fopen_s(&YUV, "AC.yuv", "rb")) != 0){cout << "Failed to open the YUV file!" << endl;}else{cout << "File successfully opened!" << endl;}if ((fopen_s(&OUTPUT, "AC.txt", "wb")) != 0){cout << "Failed to open the txt file!" << endl;}else{cout << "File successfully opened!" << endl;}unsigned char* YUV_BUFFER = NULL;YUV_BUFFER = new unsigned char[w*h];fread(YUV_BUFFER, sizeof(unsigned char), w*h, YUV);double Frequency[256] = { 0 };int calculate[256] = { 0 };double Entropy = 0;for (int i = 0; i < 256; i++){for (int j = 0; j < w * h; j++){if (i == int(YUV_BUFFER[j])){calculate[i]++;}}}for (int i = 0; i < 256; i++){Frequency[i] = (double)calculate[i] / w / h;if (Frequency[i] != 0){Entropy += (-1) * Frequency[i] * (log(Frequency[i]) / log(2));}}fprintf(OUTPUT, "symbol\tfrequency\n");for (int i = 0; i < 256; i++){fprintf(OUTPUT, "%d\t%f\n", i, Frequency[i]);}cout << "The Entorpy of is:" << Entropy << endl;}

DC概率分布：

AC概率分布：