文章目录
JPEG原理分析及其解码器的调试
一·、实验原理
1. 标题JPEG编码器
1）零偏置：即把[0,255]的像素值减128变为[-128,127]；（对于灰度级是2n的像素，通过减去2n-1，将无符号 的整数值变成有符号数，使像素的绝对值出现3位10进制的概率大大 减少）
（2）8×8DCT变换：能量集中和去相关，减小空间冗余；
（3）量化：根据人眼视觉特性，低频细量化，高频粗量化，减小视觉冗余；
（4）编码：直流系数进行差分和VLC编码，交流系数进行之字形扫描、游程编码和VLC编码，减少数据冗余。
2.JPEG文件格式
SOI ：Start of Image，图像开始；标记代码：2字节，固定值：0xFFD8
APP0：Application，应用程序，保留标记 0；标记代码 ：2字节，固定值：0xFFE0
包含9个具体字段：
① 数据长度 2字节 ①~⑨9个字段的总长度
② 标识符 5字节 固定值0x4A46494600，即字符串“JFIF0”
③ 版本号 2字节 一般是0x0102，表示JFIF的版本号1.2
④ X和Y的密度单位 1字节 只有三个值可选：
0：无单位；1：点数/英寸；2：点数/厘米
⑤ X方向像素密度 2字节 取值范围未知
⑥ Y方向像素密度 2字节 取值范围未知
⑦ 缩略图水平像素数目 1字节 取值范围未知
⑧ 缩略图垂直像素数目 1字节 取值范围未知
⑨ 缩略图RGB位图 长度可能是3的倍数 缩略图RGB位图数据
DQT：Define Quantization Table，定义量化表 ；标记代码：2字节，固定值：0xFFDB
包含9个具体字段：
① 数据长度 2字节 字段①和多个字段②的总长度
② 量化表 数据长度-2字节
a) 精度及量化表ID 1字节
高4位：精度，只有两个可选值 0：8位；1：16位
低4位：量化表ID，取值范围为0～3
b) 表项 (64×(精度+1))字节
例如8位精度的量化表,其表项长度为64×（0+1）=64字节
本标记段中，字段②可以重复出现，表示多个量化表，但最多只能出现4次
SOF0:Start of Frame，帧图像开始；标记代码：2字节；固定值：0xFFC0
包含9个具体字段：
① 数据长度 2字节 ①~⑥六个字段的总长度
② 精度 1字节 每个数据样本的位数 通常是8位，一般软件都不支持 12位和16位
③ 图像高度 2字节 图像高度（单位：像素）
④ 图像宽度 2字节 图像宽度（单位：像素）
⑤ 颜色分量数 1字节 只有3个数值可选 1：灰度图；3：YCrCb或YIQ；4：CMYK 而JFIF中使用YCrCb，故这里颜色分量数恒为3
⑥颜色分量信息 颜色分量数×3字节（通常为9字节）
a)颜色分量ID 1字节
b)水平/垂直采样因子 1字节
高4位：水平采样因子
低4位：垂直采样因子
c) 量化表 1字节 当前分量使用的量化表的ID
DHT：Define Huffman Table，定义哈夫曼表；标记代码：2字节；固定值：0xFFC4
包含2个具体字段：
① 数据长度 2字节
② huffman表 数据长度-2字节
表ID和表类型 1字节
高4位：类型，只有两个值可选
0：DC直流；1：AC交流 低4位：哈夫曼表ID，
注意，DC表和AC表分开编码
不同位数的码字数量 16字节
编码内容：16个不同位数的码字数量之和（字节）本标记段中，字段②可以重复出现（一般4次），也可以只出现1次。
SOS：Start of Scan，扫描开始：12字节；标记代码：2字节；固定值：0xFFDA
包含2个具体字段：
①数据长度 2字节 ①~④两个字段的总长度
②颜色分量数 1字节 应该和SOF中的字段⑤的值相同，即： 1：灰度图是；3： YCrCb或YIQ；4：CMYK。
③颜色分量信息
a) 颜色分量ID 1字节
b) 直流/交流系数表号 1字节
高4位：直流分量使用的哈夫曼树编号
低4位：交流分量使用的哈夫曼树编号
④ 压缩图像数据
a)谱选择开始 1字节 固定值0x00
b)谱选择结束 1字节 固定值0x3F
c)谱选择 1字节 在基本JPEG中总为00
EOI：End of Image，图像结束：2字节；标记代码：2字节，固定值：0xFFD9
3. JPEG 的解码流程
3.1 读取文件
3.2 解析 Segment Marker
3.2.1 解析 SOI
3.2.2 解析 APP0
检查标识“JFIF”及版本
得到一些参数
3.2.3 解析 DQT
得到量化表长度（可能包含多张量化表）
得到量化表的精度 得到及检查量化表的序号（只能是 0 —— 3）
得到量化表内容（64 个数据）
3.2.4 解析 SOF0
得到每个 sample 的比特数、长宽、颜色分量数
得到每个颜色分量的 ID、水平采样因子、垂直采样因子、使用的量化表 序号（与 DQT 中序号对应）
3.2.5 解析 DHT
得到 Huffman 表的类型（AC、DC）、序号
依据数据重建 Huffman 表 3.2.6 解析 SOS
得到解析每个颜色分量的 DC、AC 值所使用的 Huffman 表序号（与 DHT 中序号对应）
3.3 依据每个分量的水平、垂直采样因子计算 MCU 的大小，并得到每个 MCU 中 8*8 宏块的个数
3.4 对每个 MCU 解码（依照各分量水平、垂直采样因子对 MCU 中每个分量宏块解 码）
3.4.1 对每个宏块进行 Huffman 解码，得到 DCT 系数
3.4.2 对每个宏块的 DCT 系数进行 IDCT，得到 Y、Cb、Cr
3.4.3 遇到 Segment Marker RST 时，清空之前的 DC DCT 系数
3.5 解析到 EOI，解码结束 3.6 将 Y、Cb、Cr 转化为需要的色彩空间并保存
二、程序实现
main函数
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 (argc < 3)//如果输入的参数小于3，显示使用指南
usage();
current_argument = 1;//目前进行到的argument
while (1)
{
if (strcmp(argv[current_argument], "--benchmark")==0)//调试界面中的可选项[option]
benchmark_mode = 1;
else
break;
current_argument++;//指向下一串字符
}
if (argc < current_argument+2)//参数不合要求
usage();//再次显示使用指南
input_filename = argv[current_argument];//输入文件名
//if判断要求哪种format，选择不同的输出形式
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");//format错误
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;
}
load_multiple_times
/**
* Load one jpeg image, and try to decompress 1000 times, and save the result.
* This is mainly used for benchmarking the decoder, or to test if between each
* called of the library the DCT is corrected reset (a bug was found).
*/
int load_multiple_times(const char *filename, const char *outfilename, int output_format)
{
FILE *fp;
int cout, length_of_file;//定义计数和输入文件长度
unsigned int width, height;//定义宽和高
unsigned char *buf;//定义一个buf的缓冲区
struct jdec_private *jdec;//定义一个jdec_private类型的jdec
unsigned char *components[4];//定义指针数组
jdec = tinyjpeg_init();
count = 0;
/* Load the Jpeg into memory */
fp = fopen(filename, "rb");
if (fp == NULL)
exitmessage("Cannot open filename\n");
length_of_file = filesize(fp);
buf = (unsigned char *)malloc(length_of_file + 4);
fread(buf, length_of_file, 1, fp);
fclose(fp);
while (count<1000)//图像解码1000次
{
if (tinyjpeg_parse_header(jdec, buf, length_of_file)<0)
exitmessage(tinyjpeg_get_errorstring(jdec));
tinyjpeg_decode(jdec, output_format);
count++;
}
/*
* 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);
tinyjpeg_get_size(jdec, &width, &height);
/* 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;
}
free(buf);
tinyjpeg_free(jdec);
return 0;
}
convert_one_image
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;//定义一个buf的缓冲区
struct jdec_private *jdec;//定义一个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)//解压缩JPEG图像的头信息
exitmessage(tinyjpeg_get_errorstring(jdec));
/* Get the size of the image */
tinyjpeg_get_size(jdec, &width, &height);
DCT_0_mat = (short int*)malloc(width * height / 64 * sizeof(short int));
DCT_1_mat = (short int*)malloc(width * height / 64 * sizeof(short int));
DC_pos = 0;
AC_pos = 0;
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);
write_DC_AC(width, height);
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;
}
tinyjpeg.c
1.4个函数处理数据流
fill_ nbits：数据放入存储库。将任何0xff，0x00转换为0xff。
get_ nbits：从流中读取nbits，并写入结果，nbits从流中移除，寄存器被自动填满。
look_ nbits：从流中读取nbits，而不将其标记为已读。
Skip_nbits：从流中读取nbits，但不返回结果。
流：当前指针在JPEG数据(每字节读取字节)
reservoir：包含信息位的寄存器。只有nbits_ in_ reservoir
有效。
#define fill_nbits(reservoir,nbits_in_reservoir,stream,nbits_wanted) do { \
while (nbits_in_reservoir<nbits_wanted) \
{ \
unsigned char c; \
if (stream >= priv->stream_end) \
longjmp(priv->jump_state, -EIO); \
c = *stream++; \
reservoir <<= 8; \
if (c == 0xff && *stream == 0x00) \
stream++; \
reservoir |= c; \
nbits_in_reservoir+=8; \
} \
} while(0);
/* Signed version !!!! */
#define get_nbits(reservoir,nbits_in_reservoir,stream,nbits_wanted,result) do { \
fill_nbits(reservoir,nbits_in_reservoir,stream,(nbits_wanted)); \
result = ((reservoir)>>(nbits_in_reservoir-(nbits_wanted))); \
nbits_in_reservoir -= (nbits_wanted); \
reservoir &= ((1U<<nbits_in_reservoir)-1); \
if ((unsigned int)result < (1UL<<((nbits_wanted)-1))) \
result += (0xFFFFFFFFUL<<(nbits_wanted))+1; \
} while(0);
#define look_nbits(reservoir,nbits_in_reservoir,stream,nbits_wanted,result) do { \
fill_nbits(reservoir,nbits_in_reservoir,stream,(nbits_wanted)); \
result = ((reservoir)>>(nbits_in_reservoir-(nbits_wanted))); \
} while(0);
/* To speed up the decoding, we assume that the reservoir have enough bit
* slow version:
* #define skip_nbits(reservoir,nbits_in_reservoir,stream,nbits_wanted) do { \
* fill_nbits(reservoir,nbits_in_reservoir,stream,(nbits_wanted)); \
* nbits_in_reservoir -= (nbits_wanted); \
* reservoir &= ((1U<<nbits_in_reservoir)-1); \
* } while(0);
*/
#define skip_nbits(reservoir,nbits_in_reservoir,stream,nbits_wanted) do { \
nbits_in_reservoir -= (nbits_wanted); \
reservoir &= ((1U<<nbits_in_reservoir)-1); \
} while(0);
创建霍夫曼表
/**
*
* Decode a single block that contains the DCT coefficients.
* The table coefficients is already dezigzaged at the end of the operation.
*
*/
static void process_Huffman_data_unit(struct jdec_private *priv, int component)
{
unsigned char j;
unsigned int huff_code;
unsigned char size_val, count_0;
struct component *c = &priv->component_infos[component];
short int DCT[64];
/* Initialize the DCT coef table */
memset(DCT, 0, sizeof(DCT));
/* DC coefficient decoding */
huff_code = get_next_huffman_code(priv, c->DC_table);
//trace("+ %x\n", huff_code);
if (huff_code) {
get_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, huff_code, DCT[0]);
DCT[0] += c->previous_DC;
c->previous_DC = DCT[0];
} else {
DCT[0] = c->previous_DC;
}
/* AC coefficient decoding */
j = 1;
while (j<64)
{
huff_code = get_next_huffman_code(priv, c->AC_table);
//trace("- %x\n", huff_code);
size_val = huff_code & 0xF;
count_0 = huff_code >> 4;
if (size_val == 0)
{ /* RLE */
if (count_0 == 0)
break; /* EOB found, go out */
else if (count_0 == 0xF)
j += 16; /* skip 16 zeros */
}
else
{
j += count_0; /* skip count_0 zeroes */
if (__unlikely(j >= 64))
{
snprintf(error_string, sizeof(error_string), "Bad huffman data (buffer overflow)");
break;
}
get_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, size_val, DCT[j]);
j++;
}
}
for (j = 0; j < 64; j++)
c->DCT[j] = DCT[zigzag[j]];
}
/*
* Takes two array of bits, and build the huffman table for size, and code
*
* lookup will return the symbol if the code is less or equal than HUFFMAN_HASH_NBITS.
* code_size will be used to known how many bits this symbol is encoded.
* slowtable will be used when the first lookup didn't give the result.
*/
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 void build_default_huffman_tables(struct jdec_private *priv)
{
if ( (priv->flags & TINYJPEG_FLAGS_MJPEG_TABLE)
&& priv->default_huffman_table_initialized)
return;
build_huffman_table(bits_dc_luminance, val_dc_luminance, &priv->HTDC[0]);
build_huffman_table(bits_ac_luminance, val_ac_luminance, &priv->HTAC[0]);
build_huffman_table(bits_dc_chrominance, val_dc_chrominance, &priv->HTDC[1]);
build_huffman_table(bits_ac_chrominance, val_ac_chrominance, &priv->HTAC[1]);
priv->default_huffman_table_initialized = 1;
}
建立量化表
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++) {
*qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];
}
}
}
解析DQT
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;
}
解析SOF
static int parse_SOF(struct jdec_private *priv, const unsigned char *stream)
{
int i, width, height, nr_components, cid, sampling_factor;
int Q_table;
struct component *c;
#if TRACE
fprintf(p_trace,"> SOF marker\n");
fflush(p_trace);
#endif
print_SOF(stream);
height = be16_to_cpu(stream+3);
width = be16_to_cpu(stream+5);
nr_components = stream[7];
#if SANITY_CHECK
if (stream[2] != 8)
snprintf(error_string, sizeof(error_string),"Precision other than 8 is not supported\n");
if (width>JPEG_MAX_WIDTH || height>JPEG_MAX_HEIGHT)
snprintf(error_string, sizeof(error_string),"Width and Height (%dx%d) seems suspicious\n", width, height);
if (nr_components != 3)
snprintf(error_string, sizeof(error_string),"We only support YUV images\n");
if (height%16)
snprintf(error_string, sizeof(error_string),"Height need to be a multiple of 16 (current height is %d)\n", height);
if (width%16)
snprintf(error_string, sizeof(error_string),"Width need to be a multiple of 16 (current Width is %d)\n", width);
#endif
stream += 8;
for (i=0; i<nr_components; i++) {
cid = *stream++;
sampling_factor = *stream++;
Q_table = *stream++;
c = &priv->component_infos[i];
#if SANITY_CHECK
c->cid = cid;
if (Q_table >= COMPONENTS)
snprintf(error_string, sizeof(error_string),"Bad Quantization table index (got %d, max allowed %d)\n", Q_table, COMPONENTS-1);
#endif
c->Vfactor = sampling_factor&0xf;
c->Hfactor = sampling_factor>>4;
c->Q_table = priv->Q_tables[Q_table];
#if TRACE
fprintf(p_trace,"Component:%d factor:%dx%d Quantization table:%d\n",
cid, c->Hfactor, c->Hfactor, Q_table );
fflush(p_trace);
#endif
}
priv->width = width;
priv->height = height;
#if TRACE
fprintf(p_trace,"< SOF marker\n");
fflush(p_trace);
#endif
return 0;
}
解析sos
static int parse_SOS(struct jdec_private *priv, const unsigned char *stream)
{
unsigned int i, cid, table;
unsigned int nr_components = stream[2];
#if TRACE
fprintf(p_trace,"> SOS marker\n");
fflush(p_trace);
#endif
#if SANITY_CHECK
if (nr_components != 3)
snprintf(error_string, sizeof(error_string),"We only support YCbCr image\n");
#endif
stream += 3;
for (i=0;i<nr_components;i++) {
cid = *stream++;
table = *stream++;
#if SANITY_CHECK
if ((table&0xf)>=4)
snprintf(error_string, sizeof(error_string),"We do not support more than 2 AC Huffman table\n");
if ((table>>4)>=4)
snprintf(error_string, sizeof(error_string),"We do not support more than 2 DC Huffman table\n");
if (cid != priv->component_infos[i].cid)
snprintf(error_string, sizeof(error_string),"SOS cid order (%d:%d) isn't compatible with the SOF marker (%d:%d)\n",
i, cid, i, priv->component_infos[i].cid);
#if TRACE
fprintf(p_trace,"ComponentId:%d tableAC:%d tableDC:%d\n", cid, table&0xf, table>>4);
fflush(p_trace);
#endif
#endif
priv->component_infos[i].AC_table = &priv->HTAC[table&0xf];
priv->component_infos[i].DC_table = &priv->HTDC[table>>4];
}
priv->stream = stream+3;
#if TRACE
fprintf(p_trace,"< SOS marker\n");
fflush(p_trace);
#endif
return 0;
}
解析DHT
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;
}
解析DRI
static int parse_DRI(struct jdec_private *priv, const unsigned char *stream)
{
unsigned int length;
#if TRACE
fprintf(p_trace,"> DRI marker\n");
fflush(p_trace);
#endif
length = be16_to_cpu(stream);
#if SANITY_CHECK
if (length != 4)
snprintf(error_string, sizeof(error_string),"Length of DRI marker need to be 4\n");
#endif
priv->restart_interval = be16_to_cpu(stream+2);
#if TRACE
fprintf(p_trace,"Restart interval = %d\n", priv->restart_interval);
fprintf(p_trace,"< DRI marker\n");
fflush(p_trace);
#endif
return 0;
}
parse_JFIF
完成标记解析
static int parse_JFIF(struct jdec_private *priv, const unsigned char *stream)
{
int chuck_len;
int marker;
int sos_marker_found = 0;
int dht_marker_found = 0;
const unsigned char *next_chunck;
/* Parse marker */
while (!sos_marker_found)
{
if (*stream++ != 0xff)
goto bogus_jpeg_format;
/* Skip any padding ff byte (this is normal) */
while (*stream == 0xff)
stream++;
marker = *stream++;
chuck_len = be16_to_cpu(stream);
next_chunck = stream + chuck_len;
switch (marker)
{
case SOF:
if (parse_SOF(priv, stream) < 0)
return -1;
break;
case DQT:
if (parse_DQT(priv, stream) < 0)
return -1;
break;
case SOS:
if (parse_SOS(priv, stream) < 0)
return -1;
sos_marker_found = 1;
break;
case DHT:
if (parse_DHT(priv, stream) < 0)
return -1;
dht_marker_found = 1;
break;
case DRI:
if (parse_DRI(priv, stream) < 0)
return -1;
break;
default:
#if TRACE
fprintf(p_trace,"> Unknown marker %2.2x\n", marker);
fflush(p_trace);
#endif
break;
}
stream = next_chunck;
}
if (!dht_marker_found) {
#if TRACE
fprintf(p_trace,"No Huffman table loaded, using the default one\n");
fflush(p_trace);
#endif
build_default_huffman_tables(priv);
}
#ifdef SANITY_CHECK
if ( (priv->component_infos[cY].Hfactor < priv->component_infos[cCb].Hfactor)
|| (priv->component_infos[cY].Hfactor < priv->component_infos[cCr].Hfactor))
snprintf(error_string, sizeof(error_string),"Horizontal sampling factor for Y should be greater than horitontal sampling factor for Cb or Cr\n");
if ( (priv->component_infos[cY].Vfactor < priv->component_infos[cCb].Vfactor)
|| (priv->component_infos[cY].Vfactor < priv->component_infos[cCr].Vfactor))
snprintf(error_string, sizeof(error_string),"Vertical sampling factor for Y should be greater than vertical sampling factor for Cb or Cr\n");
if ( (priv->component_infos[cCb].Hfactor!=1)
|| (priv->component_infos[cCr].Hfactor!=1)
|| (priv->component_infos[cCb].Vfactor!=1)
|| (priv->component_infos[cCr].Vfactor!=1))
snprintf(error_string, sizeof(error_string),"Sampling other than 1x1 for Cr and Cb is not supported");
#endif
return 0;
bogus_jpeg_format:
#if TRACE
fprintf(p_trace,"Bogus jpeg format\n");
fflush(p_trace);
#endif
return -1;
}
解析文件头 初始化准备
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;
}
指向宏块解码
typedef void (*decode_MCU_fct) (struct jdec_private *priv);
static const decode_MCU_fct decode_mcu_3comp_table[4] = {
decode_MCU_1x1_3planes,
decode_MCU_1x2_3planes,
decode_MCU_2x1_3planes,
decode_MCU_2x2_3planes,
};
static const decode_MCU_fct decode_mcu_1comp_table[4] = {
decode_MCU_1x1_1plane,
decode_MCU_1x2_1plane,
decode_MCU_2x1_1plane,
decode_MCU_2x2_1plane,
};
指向彩色空间转换
typedef void (*convert_colorspace_fct) (struct jdec_private *priv);
static const convert_colorspace_fct convert_colorspace_yuv420p[4] = {
YCrCB_to_YUV420P_1x1,
YCrCB_to_YUV420P_1x2,
YCrCB_to_YUV420P_2x1,
YCrCB_to_YUV420P_2x2,
};
static const convert_colorspace_fct convert_colorspace_rgb24[4] = {
YCrCB_to_RGB24_1x1,
YCrCB_to_RGB24_1x2,
YCrCB_to_RGB24_2x1,
YCrCB_to_RGB24_2x2,
};
static const convert_colorspace_fct convert_colorspace_bgr24[4] = {
YCrCB_to_BGR24_1x1,
YCrCB_to_BGR24_1x2,
YCrCB_to_BGR24_2x1,
YCrCB_to_BGR24_2x2,
};
static const convert_colorspace_fct convert_colorspace_grey[4] = {
YCrCB_to_Grey_1x1,
YCrCB_to_Grey_1x2,
YCrCB_to_Grey_2x1,
YCrCB_to_Grey_2x2,
};
理解三个结构体的设计目的
• 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
保存宏块的信息
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];
};
理解在视音频编解码调试中TRACE的目的和含义
trace：输出中间过程中的某些变量，或者错误信息。
将TRACE的值置为1，打开，进行上述说明的信息的输出
将TRACE的值置为0，关闭，跳过。
#if TRACE
//添加希望看到的信息代码
#endif
三、实验结果
输出yuv
1.解码过程中会多次使用该结构体；
2.stream是当前流的指针，
quantization tables是量化表，
huffman tables有直流和交流
3.内部指针用于颜色空间转换，不能修改
该结构体用于存储图像信息。
理解在视音频编解码调试中TRACE的目的和含义
TRACE用来跟踪记录过程中的信息，是可以人为控制的；
信息记录在trace_jpeg.txt中。
（3）以txt文件输出所有的量化矩阵和所有的HUFFMAN码表。