JPEG原理分析及JPEG解码器的调试
JPEG文件格式
JPEG（ Joint Photographic Experts Group）即联合图像专家组，是用于连续色调静态图像压缩的一种标准，文件后缀名为.jpg或.jpeg，是最常用的图像文件格式。其主要是采用预测编码（DPCM）、离散余弦变换（DCT）以及熵编码的联合编码方式，以去除冗余的图像和彩色数据，属于有损压缩格式，它能够将图像压缩在很小的储存空间，一定程度上会造成图像数据的损伤。
JPEG编解码原理
上图为JPEG编码的过程，JPEG解码为其逆过程。
JPEG编码
零偏置电平下移（Level Offset）
对于灰度级是 2n的像素，我们将其减去2n-1，使值域变为[-2n-1,2n-1]，将无符号整数变为符号数；n=8时，将 [0,255]的灰度值，减去 128，使值域变为[-128,127] 。这样可以使像素的绝对值减小。
离散余弦变换（DCT）
将每个分量图像分为8x8的像块，若图像的宽或高不达到是8的整数倍，需要在图像边缘填充像素。以像块为单位对其进行8x8DCT变换，达到能量集中与去相关的目的，去除空间冗余，提高编码效率。
DCT核矩阵为：
量化
根据混合高频原理，人眼对彩色细节的分辨能力更低，而对亮度细节更为敏感。我们采用了两种量化表，分别是亮度（Y）量化表与色差（UV）量化表。再由于人眼对低频分量更敏感，因此量化表内对低频成分细量化，对高频成分粗量化。
DC系数差分编码
由于DC系数数值较大而相邻像块的DC系数差值不大，因而采用差分脉冲编码调制（DPCM）对相邻DC系数差值编码，之后再进行哈夫曼编码，实现压缩，提高编码效率。
AC系数游程编码
DCT变换后得到的系数块中，能量主要集中在左上角的低频区，而右下角的高频区大部分系数都很小，采用之字形读出后，会出现许多连零，使用游程编码后，再进行哈夫曼编码，进一步提高编码效率。
之字形扫描图：
哈夫曼编码（Huffman）
对亮度与色差分量的DC系数差分编码结果与AC系数游程编码的结果分别哈夫曼编码，得到四张哈夫曼码表，分别是：亮度 DC、亮度 AC、色度 DC、色度 AC。
JPEG解码
JPEG解码即为编码的逆过程。
其解码流程为：
1.读取文件
2.解析 Segment Marker
2.1 解析 SOI
2.2 解析 APP0
检查标识“JFIF”及版本
得到一些参数
2.3 解析 DQT
得到量化表长度（可能包含多张量化表）
得到量化表的精度
得到及检查量化表的序号（只能是 0-3）
得到量化表内容（64 个数据）
2.4 解析 SOF0
得到每个 sample 的比特数、长宽、颜色分量数
得到每个颜色分量的 ID、水平采样因子、垂直采样因子、使用的量化表序号（与 DQT 中序号对应）
2.5 解析 DHT
得到 Huffman 表的类型（AC、DC）、序号
依据数据重建 Huffman 表
2.6 解析 SOS
得到解析每个颜色分量的 DC、AC 值所使用的 Huffman 表序号（与 DHT
中序号对应）
3.依据每个分量的水平、垂直采样因子计算 MCU 的大小，并得到每个 MCU 中 8*8像块的个数
4.对每个 MCU 解码（依照各分量水平、垂直采样因子对 MCU 中每个分量宏块解
码）
4.1 对每个宏块进行 Huffman 解码，得到 DCT 系数
4.2 对每个宏块的 DCT 系数进行 IDCT，得到 Y、Cb、Cr
4.3 遇到 Segment Marker RST 时，清空之前的 DC DCT 系数
5.解析到 EOI，解码结束
6.将 Y、Cb、Cr 转化为需要的色彩空间并保存。
实现程序
命令参数
结构体
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];
};
struct component
用于存储解码信息，说明了水平和垂直采样情况、量化表、AC系数哈夫曼表、DC系数哈夫曼表、前一个DC系数、DCT系数块。
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_CHECK
unsigned int cid;
#endif
};
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];
};
main函数
读取一张JPEG图像，对其解码，并输出指定格式文件。
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;
}
保存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);
/*以下为添加部分，输出4:2:0yuv图像文件*/
snprintf(temp, 1024, "%s.yuv", filename);
F = fopen(temp, "wb");
fwrite(components[0], width * height, 1, F);
fwrite(components[1], width * height / 4, 1, F);
fwrite(components[2], width * height / 4, 1, F);
fclose(F);
}
YUV查看结果为：
TRACE
用于记录解码过程中的各种信息，输出在文件中。包括输入文件的大小，图像的宽高，YUV分量与量化表及哈夫曼码表的对应关系，亮度量化表和色差量化表，哈夫曼表：亮度DC、亮度AC、色差DC、色差AC。
#define TRACE 1 //1表示TRACE打开，0表示关闭
#define TRACEFILE "trace_jpeg.txt" //TRACE输出文件名
输出量化矩阵
建立量化表与解析DQT
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++) {
fprintf(p_trace, "%-4d", ref_table[*zz]); //添加部分，输出量化矩阵
*qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];
}
fprintf(p_trace, "\n"); //添加部分，输出换行
}
}
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];
fprintf(p_trace, "Quantization table:%d\n", qi);//添加部分，输出量化表序号
build_quantization_table(table, stream);
stream += 64;
}
#if TRACE
fprintf(p_trace,"< DQT marker\n");
fflush(p_trace);
#endif
return 0;
}
输出结果为：
第一张量化表序号为0，用于亮度分量Y；第一张量化表序号为1，用于色差分量UV。
输出哈夫曼码表
建立哈夫曼码表与解析DHT
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 */
}
}
}
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;
}
输出结果为：
哈夫曼码表依次为DC[0]（亮度DC）、AC[0]（亮度AC）、DC[1]（色差DC）、AC[1]（色差AC）。
1243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
