文章目录
一、实验目的
掌握JPEG编解码系统的基本原理。初步掌握复杂的数据压缩算法实现，并能根据理论分析需要实现所对应数据的输出。
二、实验原理
1）JPEG简介
JPEG 是 Joint Photographic Exports Group 的英文缩写，中文称之为联合图像专家小组。该小组隶属于 ISO 国际标准化组织，主要负责定制静态数字图像的编码方法，即所谓的 JPEG算法。
JPEG图像压缩算法能够在提供良好的压缩性能的同时，具有比较好的重建质量，被广泛应用于图像、视频处理领域，网站上80%的图像都采用了JPEG压缩标准。
2）JPEG编码流程
(1) DCT变换
DCT 变换是指对每个单独的彩色图像分量，把整个分量图像分成 8×8 的图像块，再以8×8 的图像块为一个单位进行量化和编码处理。我们可以利用 DCT 变换去相关的特性，去除冗余信息，提高编码效率。
(2) 零偏置（level offset）
对于灰度级是 2n 的像素，通过减去 2n-1，将无符号的整数值变成有符号数；对于 n=8，即将 0~255 的值域，通过减去 128，转换为值域在-128~127 之间的值。这样做的目的是：
使像素的绝对值出现 3 位 10 进制的概率大大减少。
(3) 量化(quantization)。
我们可以通过量化减少数据的编码位数，提高编码效率；因为人眼对亮度信号比对色差信号更敏感，因此使用了两种量化表：亮度量化值和色差量化值；根据人眼的视觉特性（对低频敏感，对高频不太敏感）对低频分量采取较细的量化，对高频分量采取较粗的量化。
(4)DC 系数差分编码
8×8 图像块经过 DCT 变换之后得到的 DC 直流系数有两个特点：
1）系数的数值比较大
2）相邻 8×8 图像块的 DC 系数值变化不大：冗余；
根据这个特点， JPEG 算法使用了差分脉冲调制编码(DPCM)技术，对相邻图像块之间量化 DC 系数的差值 DIFF 进行编码
再对 DIFF 进行 Huffman 编码。
(5) Z字形编码(zigzag scan)。
由于经 DCT 变换后，系数大多数集中在左上角，即低频分量区，因此采用 Z 字形按频率的高低顺序读出，可以出现很多连零的机会。可以使用游程编码。尤其在最后，如果都是零，给出 EOB (End of Block)即可。
zigzag 扫描如下图：
在经过之字形扫描排序后的 AC 系数，存在很多连 0。为了进一步提高编码效率，因此对 AC 系数进行游程编码（RLC）处理之后，再进一步进行 Huffman 编码。
(6) AC 和 DC 系数分别进行 Huffman 编码
JPEG 中共采用了四张 Huffman 码表：亮度 DC、亮度 AC、色度 DC、色度 AC，即分别对图像的亮度和色度，直流和交流数据进行编码处理。
三、JPEG解码流程
1.读取文件
2.解析 Segment Marker
– 解析 SOI
解析 APP0: 检查标识“ JFIF”及版本，得到一些参数。（APPn 可选）
– 解析 DQT:
· 得到量化表长度（可能包含多张量化表）；
· 得到量化表的精度；
· 得到及检查量化表的序号（只能是 0 —— 3）；
· 得到量化表内容（64 个数据）。
– 解析 SOF0:
· 得到每个 sample 的比特数、长宽、颜色分量数
· 得到每个颜色分量的 ID、水平采样因子、垂直采样因子、使用的量化表序号（与 DQT 中序号对应）
– 解析 DHT: 得到 Huffman 表的类型（AC、DC）、序号,依据数据重建 Huffman 表。
建立 Huffman 表的方法：
（1）第一个码字一定为 0，如果第一个码字位数为 1，则码字为 0；如果第一个码字位数为 2，则码字为 00；如此类推。
（2）从第二个码字开始，如果它和前面的码字位数相同，则当前码字为前面码字加 1；如果它的位数比它前面的码字位数大，则当前码字是前面的码字加 1后再在右边添若干个 0，直至满足位数长度为止。
– 解析 SOS: 得到解析每个颜色分量的 DC、 AC 值所使用的 Huffman 表序号（与 DHT中序号对应）。
3 . 依据每个分量的水平、垂直采样因子计算 MCU 的大小，并得到每个 MCU 中 8*8 宏块的个数
4. 对每个 MCU 解码（依照各分量水平、垂直采样因子对 MCU 中每个分量宏块解码）
对每个宏块进行 Huffman 解码；解码 DC 差值，重构量化后的系数；DCT 逆变换；丢弃填充的行/列；反 0 偏置。 遇到 Segment Marker RST 时，清空之前的 DC DCT 系数
5. 解析到 EOI，解码结束
6. 将 Y、 Cb、 Cr 转化为需要的色彩空间并保存。
四、代码解析
(1)main()
接受输入输出文件名称参数，打开TRACEFILE。通过输入参数选择要输出的文件格式（此实验为YUV420），调用convert_one_image（）
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
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)
benchmark_mode = 1;
else
break;
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;
else
exitmessage("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);
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 ticks\n", duration);
#if TRACE
fclose(p_trace);
#endif
return 0;
}
(2)convert_one_image()
打开输入输出文件，初始化jdec结构体，获得文件参数信息，主要调用*tinyjpeg_parse_header()解码jpeg图像，最后调用write_yuv()*写入yuv文件。
int convert_one_image(const char *infilename, const char *outfilename, int output_format)
{
FILE *fp;
unsigned 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");
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);
fclose(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;
}
(3) tinyjpeg_parse_header()
控制指针移动，调用parse_JFIF()
(4)parse_JFIF()
在到达SOS之前，循环调用parse_SOF()，parse_DQT()，parse_SOS()，parse_DHT()，parse_DRI()
(5) parse_DQT()
解码量化表，调用*build_quantization_table()*创建量化表。
static int parse_DQT(struct jdec_private *priv, const unsigned char *stream)
{
int qi;
float *table;
const unsigned char *dqt_block_end;
#if TRACE
fprintf(p_trace,"> DQT marker\n");
fflush(p_trace);
#endif
dqt_block_end = stream + be16_to_cpu(stream);
stream += 2; /* Skip length */
while (stream < dqt_block_end)
{
qi = *stream++;
#if SANITY_CHECK
if (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
table = priv->Q_tables[qi];
build_quantization_table(table, stream);
stream += 64;
}
#if TRACE
fprintf(p_trace,"< DQT marker\n");
fflush(p_trace);
#endif
return 0;
}
(6)parse_DHT()
解析霍夫曼码表，调用 *build_huffman_table()*创建表。
static int parse_DHT(struct jdec_private *priv, const unsigned char *stream)
{
unsigned int count, i;
unsigned char huff_bits[17];
int length, index;
length = be16_to_cpu(stream) - 2;
stream += 2; /* Skip length */
#if TRACE
fprintf(p_trace,"> DHT marker (length=%d)\n", length);
fflush(p_trace);
#endif
while (length>0) {
index = *stream++;
/* We need to calculate the number of bytes 'vals' will takes */
huff_bits[0] = 0;
count = 0;
for (i=1; i<17; i++) {
huff_bits[i] = *stream++;
count += huff_bits[i];
}
#if SANITY_CHECK
if (count >= HUFFMAN_BITS_SIZE)
snprintf(error_string, sizeof(error_string),"No more than %d bytes is allowed to describe a huffman table", HUFFMAN_BITS_SIZE);
if ( (index &0xf) >= HUFFMAN_TABLES)
snprintf(error_string, sizeof(error_string),"No more than %d Huffman tables is supported (got %d)\n", HUFFMAN_TABLES, index&0xf);
#if TRACE
fprintf(p_trace,"Huffman table %s[%d] length=%d\n", (index&0xf0)?"AC":"DC", index&0xf, count);
fflush(p_trace);
#endif
#endif
if (index & 0xf0 )
build_huffman_table(huff_bits, stream, &priv->HTAC[index&0xf]);
else
build_huffman_table(huff_bits, stream, &priv->HTDC[index&0xf]);
length -= 1;
length -= 16;
length -= count;
stream += count;
}
#if TRACE
fprintf(p_trace,"< DHT marker\n");
fflush(p_trace);
#endif
return 0;
}
(7)结构体
huffman_table
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];
};
component
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];
};
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];
};
(8) TRACE
条件编译是指预处理器根据条件编译指令，有条件地选择源程序代码中的一部分代码作为输出，送给编译器进行编译。主要是为了有选择性地执行相应操作，防止宏替换内容（如文件等）的重复包含。
在本实验中，TRACE就使用了条件编译。
#define TRACE 1//add by nxn
#if TRACE
p_trace=fopen(TRACEFILE,"w");
if (p_trace==NULL)
{
printf("trace file open error!");
}
#endif
也就是说，当TRACE被设定为1，程序的if条件成立，就会执行这段宏内的条件编译内容，完成对于trace文件的写入。
五、实验结果
（1）输出YUV图像
输出图像的代码在函数*write_yuv()*中，逐步调试JPEG解码器程序。将输入的JPG文件进行解码，将输出文件保存为可供YUVViewer观看的YUV文件。
static void write_yuv(const char *filename, int width, int height, unsigned char **components)
{
FILE *F;
char temp[1024];
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）输出量化矩阵
量化表的代码在函数*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
}
Unknown marker e0
DQT marker
2 1 1 2 2 4 5 6
1 1 1 2 3 6 6 6
1 1 2 2 4 6 7 6
1 2 2 3 5 9 8 6
2 2 4 6 7 11 10 8
2 4 6 6 8 10 11 9
5 6 8 9 10 12 12 10
7 9 10 10 11 10 10 10
< DQT marker
DQT marker
2 2 2 5 10 10 10 10
2 2 3 7 10 10 10 10
2 3 6 10 10 10 10 10
5 7 10 10 10 10 10 10
10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10
< DQT marker
SOF marker
SOF marker
Size:1024×1024 nr_components:3 (YCbCr) precision:8
Component:1 factor:1×1 Quantization table:0
Component:2 factor:1×1 Quantization table:1
Component:3 factor:1×1 Quantization table:1
< SOF marker
（3）输出HUFFMAN码表
输出霍夫曼码表的代码已在函数*build_huffman_table()*中写好，直接调用即可。
实验流程：
读入文件第一次扫描文件；
统计各字符出现概率；
建立huff树，将码表其他信息写入输出文件；
第二次扫描文件，对源文件编码输出。
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;
/*
* Build a temp array
* huffsize[X] => numbers of bits to write vals[X]
*/
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;
/* Build a temp array
* huffcode[X] => code used to write vals[X]
*/
code = 0;
hc = huffcode;
hz = huffsize;
nbits = *hz;
while (*hz)
{
while (*hz == nbits)
{
*hc++ = code++;
hz++;
}
code <<= 1;
nbits++;
}
/*
* Build the lookup table, and the slowtable if needed.
*/
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.2d\n", val, code, code_size);
fflush(p_trace);
#endif
table->code_size[val] = code_size;
if (code_size <= HUFFMAN_HASH_NBITS)
{
/*
* Good: val can be put in the lookup table, so fill all value of this
* column with value val
*/
int repeat = 1UL<<(HUFFMAN_HASH_NBITS - code_size);
code <<= HUFFMAN_HASH_NBITS - code_size;
while ( repeat-- )
table->lookup[code++] = val;
}
else
{
/* Perhaps sorting the array will be an optimization */
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;
/* TODO: NEED TO CHECK FOR AN OVERFLOW OF THE TABLE */
}
}
}
DHT marker (length=27)
Huffman table DC[0] length=10
val=04 code=00000000 codesize=02
val=05 code=00000001 codesize=02
val=06 code=00000002 codesize=02
val=03 code=00000006 codesize=03
val=02 code=0000000e codesize=04
val=01 code=0000001e codesize=05
val=00 code=0000003e codesize=06
val=09 code=0000007e codesize=07
val=07 code=000000fe codesize=08
val=08 code=000001fe codesize=09
< DHT marker
DHT marker (length=60)
Huffman table AC[0] length=43
val=00 code=00000000 codesize=02
val=01 code=00000002 codesize=03
val=03 code=00000003 codesize=03
val=02 code=00000008 codesize=04
val=04 code=00000009 codesize=04
val=05 code=0000000a codesize=04
val=11 code=0000000b codesize=04
val=21 code=0000000c codesize=04
val=22 code=0000001a codesize=05
val=31 code=0000001b codesize=05
val=61 code=0000001c codesize=05
val=06 code=0000003a codesize=06
val=12 code=0000003b codesize=06
val=a1 code=0000003c codesize=06
val=32 code=0000007a codesize=07
val=41 code=0000007b codesize=07
val=62 code=0000007c codesize=07
val=13 code=000000fa codesize=08
val=51 code=000000fb codesize=08
val=23 code=000001f8 codesize=09
val=42 code=000001f9 codesize=09
val=71 code=000001fa codesize=09
val=81 code=000001fb codesize=09
val=91 code=000001fc codesize=09
val=15 code=000003fa codesize=10
val=52 code=000003fb codesize=10
val=63 code=000003fc codesize=10
val=07 code=000007fa codesize=11
val=14 code=000007fb codesize=11
val=33 code=000007fc codesize=11
val=53 code=000007fd codesize=11
val=16 code=00000ffc codesize=12
val=43 code=00000ffd codesize=12
val=08 code=00001ffc codesize=13
val=b1 code=00001ffd codesize=13
val=34 code=00003ffc codesize=14
val=c1 code=00003ffd codesize=14
val=24 code=00007ffc codesize=15
val=d1 code=0000fffa codesize=16
val=09 code=0000fffb codesize=16
val=72 code=0000fffc codesize=16
val=f0 code=0000fffd codesize=16
val=a2 code=0000fffe codesize=16
< DHT marker
DHT marker (length=28)
Huffman table DC[1] length=11
val=04 code=00000000 codesize=02
val=05 code=00000001 codesize=02
val=06 code=00000002 codesize=02
val=03 code=00000006 codesize=03
val=02 code=0000000e codesize=04
val=01 code=0000001e codesize=05
val=00 code=0000003e codesize=06
val=07 code=0000007e codesize=07
val=0a code=000000fe codesize=08
val=09 code=000001fe codesize=09
val=08 code=000003fe codesize=10
< DHT marker
DHT marker (length=45)
Huffman table AC[1] length=28
val=00 code=00000000 codesize=02
val=04 code=00000001 codesize=02
val=01 code=00000004 codesize=03
val=02 code=00000005 codesize=03
val=03 code=00000006 codesize=03
val=31 code=0000001c codesize=05
val=61 code=0000001d codesize=05
val=11 code=0000003c codesize=06
val=12 code=0000003d codesize=06
val=05 code=0000007c codesize=07
val=21 code=0000007d codesize=07
val=13 code=000000fc codesize=08
val=14 code=000000fd codesize=08
val=41 code=000000fe codesize=08
val=51 code=000001fe codesize=09
val=06 code=000007fc codesize=11
val=22 code=000007fd codesize=11
val=32 code=000007fe codesize=11
val=07 code=00001ffc codesize=13
val=15 code=00001ffd codesize=13
val=42 code=00001ffe codesize=13
val=08 code=0000fff8 codesize=16
val=71 code=0000fff9 codesize=16
val=23 code=0000fffa codesize=16
val=24 code=0000fffb codesize=16
val=33 code=0000fffc codesize=16
val=81 code=0000fffd codesize=16
val=a1 code=0000fffe codesize=16
< DHT marker
SOS marker
ComponentId:1 tableAC:0 tableDC:0
ComponentId:2 tableAC:1 tableDC:1
ComponentId:3 tableAC:1 tableDC:1
< SOS marker
Use decode 1×1 sampling
Input file size: 170416
Input bytes actually read: 170415
六 、实验反思
（1）jpeg变换编码核心在于DCT变换，DCT将有记忆信源转变为无记忆信源，实现能量集中和去相关，便于去除空间冗余，提高编码效率。
（2）huffman码表的编码原则是，码字出现的概率越高，则码字约短。其权值就是解码时需要的再读入的bit位数。
（3）直接对原始数据进行量化，量化步长增加，直接方法开始产生快效应，而DCT系数重构效果仍然很平滑。
（4）DCT变换，能量大多集中在左上角，在变换域量化通常能得到更好的结果。
（5）由于DCT快的量化程度不同，忽略了高频分量，会使得边缘模糊锯齿状。
（6）当压缩比较高时，压缩相当于经过了一个低通滤波器，时域体现为于sa函数的卷积，卷积的衰减波纹造成像素间的串扰。