JPEG原理分析及JPEG解码器的调试

最新推荐文章于 2023-03-29 17:55:34 发布
最新推荐文章于 2023-03-29 17:55:34 发布
阅读量393 收藏 2
点赞数
分类专栏： 数据压缩课程实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxrabc/article/details/117523305
版权

这里写目录标题

一、实验任务

原始程序的输入为jpg图像，输出为output.Y、output.U、output.V和trace_jpeg.txt.
其中,trace_jpeg.txt已经包含了所有的HUFFMAN码表。

本次实验要求修改代码后，输出：

  • YUV图像
  • 所有的量化矩阵的txt文件

二、实验思路

1. JPEG格式解析

名称说明标志代码
SOI(Start of Image)图像开始FFD8
APPn(Application)应用程序保留标记nFFEn
DQT（Define Quantization Table）定义量化表FFDB
SOF0（Start of Frame）帧图像开始FFC0
DHT（Define Huffman Table）定义哈夫曼表FFC4
SOS（Start of Scan）扫描开始,12字节FFDA
EOI（End Of Image）图像结束FFD9

以该图片进行JPEG格式分析：
在这里插入图片描述

(1) 开头和结束

FFD8: SOI，Start of Image，图像开始，所有的 JPEG 文件必须以 SOI 开始
FFD9: End of Image，图像结束，JPEG 文件必须以 EOI 结束
在这里插入图片描述
在这里插入图片描述

(2)FFEn： APPn (Application，应用程序保留标记)
FFE0: APP0，Application，应用程序保留标记 0
在这里插入图片描述
长度：2字节，此处10表示长度有16字节。
“JFIF”＋“０”：共５字节。
Major version和Minor version：各１字节，此处为01 01.
X和Y方向密度单位：１字节，此例为０1。
水平方向和垂直方向像素密度：各２字节，此处为78，即120。
缩略图水平和垂直像素数目：各１字节。

(3) FFDB: DQT，Define Quantization Table，定义量化表
在这里插入图片描述
第一个FFDB定义第一张量化表

00 43 00 + qt_table（64字节）

第二个字节43表示这一部分长67字节，第三个字节表示索引号0，qt_table长64字节对应量化表的8*8个值

第二个FFDB定义第二章量化表，不同的是上张表的索引号为 00，这张表的索引号为 01，在后面的SOF0 的部分中我们将会知道上张表对应亮度量化表，这张表对应色度量化表，对这张图来说就这两张量化表。

(4)FFC0: SOF0 ，Start of Frame， 基线离散余弦变换
在这里插入图片描述

数据长度：长度本身占 2byte，这里00 11，长17。
图像精度: 1byte, 这里是 08，即精度为一个字节。
图像高度：2 byte, 以像素为单位。这里01 D9，高1024。
图像宽度：2 byte, 以像素为单位。这里02 10，宽1024
颜色分量数：一个字节，这里是 03，代表有三个分量，YCrCb。
颜色分量信息：每个分量有三个字节，第一个为分量的 ID，01：Y 02：U 03： V；第二个字节高位为水平采样因子，低位为垂直采样因子，这里采样格式为 4：2：2；第三个字节代表这个分量对应的量化表 ID，可以看出，Y 对应的量化表 ID 索引值为 00,而 UV 对应的量化表 ID都为 01，即它们共用一张量化表。

(5) FFC4: DHT，Define Huffman Table，定义 Huffman 树表

有四个FFC4，代表这张图片有4个Huffman表
以表1为例：
在这里插入图片描述

FFC4：标记代码，2 字节，代表定义 Huffman 表。
数据长度： 2 字节，这里是1F， 31 字节的长度(包括长度自身)
Huffman 表 ID 号和类型：1 字节，高 4 位为表的类型，0：DC 直流；1：AC 交流 可以看出这里是直流表；低四位为 Huffman 表 ID。 这里是00，可以看出这张表是直流 DC 的第 0 张表，在后面的扫描开始的部分中我们可以获右为亮度的直流系数表。
不同长度 Huffman 的码字数量：固定为 16 个字节，每个字节代表从长度为 1到长度为 16 的 码 字 的个 数 ， 以 表 中 的 分析， 这 16 个字节之后的1+5+1+1+1+1+1+1=12 个字节对应的就是每个符字对应的权值，这些权值的含义即
为 DC 系数经 DPCM 编码后幅度值的位长。
通过上面的码长与码字个数的关系来生成相应码长的码字，再对应上之后的权值即位长根据解码得到的位长来读取之后相应长度的码字，再查上面这张可变长二进制编码表，就可以得到直流系数的幅度值，注意这个幅度值是经过 DPCM 差
分编码得到的。

(6) FFDA: 标记代码 SOS，Start of Scan，扫描开始**
在这里插入图片描述

数据长度：2 字节，这里是00 0C,长度为 12 字节。
颜色分量数：1 字节 应该和 SOF 中的颜色分量数相同
颜色分量信息：每个分量对应 3 个字节，第一个字节是颜色分量 ID，1，2，3
对应 YUV，第二个字节高位为直流分量使用的哈夫曼树编号，这里 Y 的直流分量用的是 DC 的第 0 张表，低四位代表交流分量使用的哈夫曼树编号，这里 Y的交流分量用的是 AC 的第 0 张表，而两个色度信号的直流分量都用的是 DC
的第 1 张表，交流分量用的是 AC 的第 1 张表.压缩图像数据
a)谱选择开始 1 字节 固定值 0x00
b)谱选择结束 1 字节 固定值 0x3F
c)谱选择 1 字节 在基本 JPEG 中总为 00

2. JPEG编解码原理

在这里插入图片描述

（1）. 零偏置
为了使像素的绝对值出现3位10进制的概率大大减少，对于灰度级是2的n次方的像素，通过减去2的n-1次方，将无符号的整数值变成有符号数。

（2）. 8*8DCT变换
对每个单独的彩色图像分量，把整个分量图像分成8*8的图像块，作为二维离散余弦变换DCT的输入，并进行DCT变换。
DCT变换的优点：能量守恒 能量集中 去相关
经过DCT变换后，能量集中在左上角，使得左上角数值较大，右下角数值较小。

（3）. 量化
因为人眼对亮度信号比对色差信号更敏感，因此使用了两种量化表：亮度量化值和色差量化值。由于人眼对低频敏感，对高频不太敏感，因此对低频分量采取较细的量化，对高频分量采取较粗的量化。
（4）. DC系数差分编码
经过8*8DCT变换后，DC直流系数的数值都比较大，且相邻图像块之间的DC系数变化不大（容易造成冗余），因此JPEG算法使用了差分脉冲调制编码DPCM技术对相邻图像块之间的量化DC系数的差值DIFF进行编码。
（5）. AC系数Z字扫描及游程编码
经过DCT变换后，AC系数大多集中在左上角的低频分量区，因此采用Z字形按频率的高低顺序读出可以出现很多连零的情况，便于使用游程编码，若最后的数据均为０，则直接给出EOB。
（6）. Huffman编码
对DC系数DPCM的结果和AC系数RLE的结果进行Huffman编码，类别ID采用一元码编码，类内索引采用定长码编码。共有亮度DC、亮度AC、色差DC、色差AC四张码表。

解码过程是编码过程的反过程

三、程序部分

1.主函数

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;

  //以下为添加的内容
  const char* qtabFileName = "DQ_table.txt"; 
  fopen_s(&dqt, qtabFileName, "wb");

#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.主功能函数

int convert_one_image(const char *infilename, const char *outfilename, int output_format) //读取JPEG文件，开始解码，存储结果
{
  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 将JPEG文件读入缓冲区*/
  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)　　／／解析JEPG文件头信息
    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.解析 Segment Marker

首先，在tinyjpeg_parse_header中，解析了JPEG的文件头。读完后，对Segment Marker进行解析。

JPEG文件头解析

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");
    //JPEG文件规定以SOI marker为起始

  priv->stream_begin = buf+2;  //跳过2字节的标识符
  priv->stream_length = size-2;
  priv->stream_end = priv->stream_begin + priv->stream_length;

  ret = parse_JFIF(priv, priv->stream_begin);  // 开始解析

  return ret;
}

解析marker标识

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++;   //获取0xFF后的1字节标识符
     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;
}

3.解析DQT

解析DQT

static int parse_DQT(struct jdec_private *priv, const unsigned char *stream)
{
  int qi;  //量化表id
  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++;  // 将系数赋给qi
#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;
}

建立量化表

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;  //Z字形扫描

  for (i=0; i<8; i++) {
     for (j=0; j<8; j++) {
       *qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];
     }
   }

}

5.解析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;
}

6.解析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;  //解析使用的Huffman码表号
  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;
}

7.解析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++;　　 //获得分量id
     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;
}

8.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;
  //根据输出格式计算MCU
  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 TRACE
		 fprintf(p_trace,"Bad pixel format\n");
		 fflush(p_trace);
#endif
       return -1;
  }

  xstride_by_mcu = ystride_by_mcu = 8;  //初始化-MCU的宽和高都为8
  if ((priv->component_infos[cY].Hfactor | priv->component_infos[cY].Vfactor) == 1) {
     decode_MCU = decode_mcu_table[0];
     convert_to_pixfmt = colorspace_array_conv[0]; //水平和垂直采样因子均为1，则MCU含有1个Y
#if TRACE
     fprintf(p_trace,"Use decode 1x1 sampling\n");
	 fflush(p_trace);
#endif
  } else if (priv->component_infos[cY].Hfactor == 1) {
     decode_MCU = decode_mcu_table[1];
     convert_to_pixfmt = colorspace_array_conv[1];
     ystride_by_mcu = 16; //水平采样因子为1，垂直采样因子为2，则MCU含有２个Y－高１６ｐｘ，宽８ｐｘ
#if TRACE
     fprintf(p_trace,"Use decode 1x2 sampling (not supported)\n");
	 fflush(p_trace);
#endif
  } else if (priv->component_infos[cY].Vfactor == 2) {
     decode_MCU = decode_mcu_table[3];
     convert_to_pixfmt = colorspace_array_conv[3];
     xstride_by_mcu = 16;
     ystride_by_mcu = 16; //水平和垂直采样因子均为２，则MCU含有４个Y－高１６ｐｘ，宽１６ｐｘ
#if TRACE 
	 fprintf(p_trace,"Use decode 2x2 sampling\n");
	 fflush(p_trace);
#endif
  } else {
     decode_MCU = decode_mcu_table[2];
     convert_to_pixfmt = colorspace_array_conv[2];
     xstride_by_mcu = 16;　//水平采样因子为２，垂直采样因子为１，则MCU含有２个Y－高８ｐｘ，宽１６ｐｘ
#if TRACE
     fprintf(p_trace,"Use decode 2x1 sampling\n");
	 fflush(p_trace);
#endif
  }

  resync(priv);

  /* Don't forget to that block can be either 8 or 16 lines */
  bytes_per_blocklines[0] *= ystride_by_mcu;
  bytes_per_blocklines[1] *= ystride_by_mcu;
  bytes_per_blocklines[2] *= ystride_by_mcu;

  bytes_per_mcu[0] *= xstride_by_mcu/8;
  bytes_per_mcu[1] *= xstride_by_mcu/8;
  bytes_per_mcu[2] *= xstride_by_mcu/8;

  /* Just the decode the image by macroblock (size is 8x8, 8x16, or 16x16) */
  for (y=0; y < priv->height/ystride_by_mcu; y++)
   {
     //trace("Decoding row %d\n", y);
     priv->plane[0] = priv->components[0] + (y * bytes_per_blocklines[0]);
     priv->plane[1] = priv->components[1] + (y * bytes_per_blocklines[1]);
     priv->plane[2] = priv->components[2] + (y * bytes_per_blocklines[2]);
     for (x=0; x < priv->width; x+=xstride_by_mcu)
      {
	decode_MCU(priv);
	convert_to_pixfmt(priv);
	priv->plane[0] += bytes_per_mcu[0];
	priv->plane[1] += bytes_per_mcu[1];
	priv->plane[2] += bytes_per_mcu[2];
	if (priv->restarts_to_go>0)
	 {
	   priv->restarts_to_go--;
	   if (priv->restarts_to_go == 0)
	    {
	      priv->stream -= (priv->nbits_in_reservoir/8);
	      resync(priv);
	      if (find_next_rst_marker(priv) < 0)
		return -1;
	    }
	 }
      }
   }
#if TRACE
  fprintf(p_trace,"Input file size: %d\n", priv->stream_length+2);
  fprintf(p_trace,"Input bytes actually read: %d\n", priv->stream - priv->stream_begin + 2);
  fflush(p_trace);
#endif

  return 0;
}

9.修改内容

任务一：输出test.jpg对应的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);

  //以下为修改内容
   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);
}

任务二：输出含有所有的量化矩阵的TXT文件：

首先，在tinyjpeg.h中添加

FILE* dqt;  //量化表文件指针

在tinyjpeg.c中添加

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(dqt,"%-6d",ref_table[*zz]);
		 if(j==7)
			 fprintf(dqt,"\n");
       *qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];
     }
   }
  fprintf(dqt,"\n\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(dqt,"DQT [%d] :\n",qi);   
	 //
     build_quantization_table(table, stream);
     stream += 64;
   }
#if TRACE
  fprintf(p_trace,"< DQT marker\n");
  fflush(p_trace);
#endif
  return 0;
}

在loadjpeg.c中添加内容

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;
  //添加内容
  const char* qtabFileName = "DQ_table.txt"; // 量化表文件名
  fopen_s(&dqt, qtabFileName, "wb");

#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

  fclose(dqt);
  return 0;
}

四、实验结果

得到的yuv格式的图片：
在这里插入图片描述

得到的量化表：
在这里插入图片描述

cxrabc
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JPEG图片格式解析工具
06-03
win32控制台程序，JPEG格式文件解析查看，提取缩略图，详情和使用说明移步：https://blog.csdn.net/u013752202
开源JPEG分析器（程序+源代码）
01-14
自己做的JPEG分析工具。主要可以用于JPEG编码标准的学习。同时也支持解码，以及输出相关信息。 本着开源的原则，包含了源代码。工程使用VC2010和MFC开发完成。
数据压缩（十一）——JPEG原理分析及JPEG解码器调试
CRR的博客
05-31 1923
文章目录一、JPEG编码原理二、JPEG解码原理三、调试JPEG解码器程序2.1 理解程序设计的整体框架2.2 理解三个结构体的设计目的2.2.1 struct huffman_table2.2.2 struct component2.2.3 struct jdec_private2.3 理解在视音频编解码调试中TRACE的目的和含义四、修改JPEG解码器将输出文件保存为YUV文件以TXT文件输出所有量化矩阵和HUFFMAN码表输出DC图像并统计其概率分布输出某一个AC值图像并统计其概率分布 一、JPEG
JPEG原理分析及JPEG解码器的解析
Cross_Entropy的博客
05-23 3613
JPEG原理分析及JPEG解码器的调试 原理分析 JPEG编解码流程图 将传入的图像进行零电平偏置，其实就是将所有像素的数值减去128，将其范围从[0,255]变成[-128,127]。 进行8×8的DCT变换，实现能量集中和去相关，便于去除图像的空间冗余度。 使用量化表进行量化。利用根据人眼视觉特性设计的量化的量化矩阵进行量化，低频细量化，高频粗量化，进而减少视觉冗余。 最后对量化后的直流系数进行差分和VLC编码；对交流系数进行zig-zag扫描和游程编码最后再进行VLC编码。从而减少数据冗余。 D
【Android 内存优化】Android 原生 API 图片压缩原理 ( 哈夫曼编码开关 | 哈夫曼编码原理 | libjpeg-turbo 函数库 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
06-28 809
一、 哈夫曼编码开关、 二、 哈夫曼编码原理、 三、 libjpeg-turbo 函数库、 四、 libjpeg-turbo 函数库下载
JPEG原理分析及JPEG解码器的调试1
08-08
本文将对JPEG的原理进行分析，并简要介绍JPEG解码器的调试。 JPEG文件格式由一系列标记组成，每个标记指示特定的信息或操作。例如，SOI（Start of Image）标记作为文件的起始点，而EOI（End of Image）标记则表示...
原代码1JPEG基本系统的解码器.rar_JPEG基本系统_jpeg_jpeg解码器
09-23
在"原代码1JPEG基本系统的解码器"中，提供的可能是一个JPEG解码器的源代码实现。开发者或研究者可以通过阅读和分析这些代码，了解JPEG解码的具体步骤，以及如何在实际程序中实现这些步骤。"www.pudn.com.txt"可能是...
JPEG分析器 1.1 （源代码）
08-16
本项目“JPEG分析器 1.1”提供了对JPEG编码标准的深入理解和学习的平台，通过源代码的形式，帮助开发者更直观地理解JPEG格式的内部工作原理。 首先，让我们来看看这个分析工具的主要功能： 1. **JPEG文件解析**：...
JPEG解码C源代码及一些解释
05-31
`JPEGDEC.C`、`JPEGAPI.c` 和 `JPEGAPP.C` 这三个文件很可能是JPEG解码器的核心部分。`JPEGDEC.C` 可能包含了解码JPEG图像的基本算法，如霍夫曼编码、DCT（离散余弦变换）、量化和反量化等步骤。`JPEGAPI.c` 可能...
JPEG编解码matlab
11-24
- **熵解码**：恢复量化后的DCT系数，通过霍夫曼或算术解码器进行逆操作。 - **反量化**：将解码得到的系数乘以量化表，得到连续的频域数据。 - **逆离散余弦变换（IDCT）**：对每个8x8块进行逆DCT，将频率域数据...
利用libjpeg在内存中进行图像压缩和解压缩
01-27
本软件包含修改后的libjpeg源代码，并提供了测试程序，演示了使用libjpeg直接处理内存中的图像，而无需借助文件操作。 针对有人说我是骗子这件事，特别说明：我的标题已经说的很清楚了，这个库本来就是我在Libjpeg库的源码基础上改的，原来的库在压缩和解压缩时必须提供一个文件句柄，也就是必须基于文件操作，当然也可以基于数据流操作，只是个人觉得有点麻烦。本例子提供的时候是吧压缩后的数据存到内存，然后保存到文件中的，懂的人一看就明白，从函数调用的参数就可以看出来，原来要提供FILE *作为参数的，现在提供char *作为参数，也就是说，原来参数是文件句柄，现在是内存地址。上次有人说我是骗分的，我就很气愤，很想把这个资源删掉，后来看到删除资源很麻烦的，暂时保留，现在又有人这样说，真的很让人难过，为了避免有更多人“受骗”，我将本资源的资源分提到最高的10分，如果有人甘愿受骗，请直接给我发邮件索取源码，如果给谁带来不便，我只能说抱歉！
ITU-T.83-JPEG-标准协议
05-29
ITU-T.83-JPEG-标准协议，ITU-T.83-JPEG-标准协议，ITU-T.83-JPEG-标准协议，ITU-T.83-JPEG-标准协议
itu-t81 JPEG standard.pdf
07-17
itu-t81 JPEG standard.pdf 英文版 标准文档 适合参考。
Lab5 JPEG原理分析及JPEG解码器的调试——C++代码实现
zsy_cuc_18的博客
06-01 1004
Lab5 JPEG原理分析及JPEG解码器的调试——C++代码实现 一、JPEG编解码原理 JPEG是一种针对数字图像的有损压缩标准方法，由于JPEG编码算法可以在提供较大的压缩比的同时，保持较好的显示质量，所以该算法逐渐成为最为熟知和广泛使用的数字图像格式和通用标准。 JPEG编码器的系统原理框图如下： 其中各环节的作用分别是： 零偏置：对于灰度级为2n 的像素，通过减去2(n-1)，将无符号整数变为有符号数，以将绝对值大的数出现的概率大大减小，提高编码效率。 8*8DCT变换：对每个单独的彩色图像分
数码相框——7、 libjpeg的使用（1）
qq_40674996的博客
09-04 298
1、回顾下，LCD显示图像的原理： LCD控制器从显存里，拿数据，这个数据由RGB构成的，然后等LCD显示出最后一个像素了，又从头从显存里拿数据。 2、ibjpeg库 为什么jpg格式的文件比bmp格式小那么多？ jpg文件是压缩的文件。 1）使用libjpeg库，把jpg文件解压出RGB原始数据。 2）使用libjpeg的应用程序是以“scanline”为单位进行图像处理 3）步骤 4）co...
花一天写了个JPEG解码器，来整理一下JPEG格式的原理
whl0071的专栏
03-29 400
花一天写了个JPEG解码器，来整理一下JPEG格式的原理
JPEG算法解密 JPEG原理详解 (转载 by jinchao)
VS2021的专栏
03-29 2168
（转载，个人笔记）https://www.cnblogs.com/Arvin-JIN/p/9133745.html （随便夸一下CSDN的粘贴功能好强大） 图片压缩有多重要，可能很多人可能并没有一个直观上的认识，举个例子，一张800X800大小的普通图片，如果未经压缩，大概在1.7MB左右，这个体积如果存放文本文件的话足够保存一部92万字的鸿篇巨著《红楼梦》，现如今互联网上绝大部分图片都使用了...
Android开发——JPEG码流分析
Chinalihuanyu的博客
10-24 1874
Android解码JPEG
在VS2010下编译libjpeg及其应用例子
L_Andy的专栏
01-21 581
下载到libjpeg源码后，解压，可以看到很多文档，想在VS2010中编辑使用，主要参考文件：install.txt 在字段Microsoft Windows, Microsoft Visual C++ 2010 Developer Studio (v10):下的部分有详细说明。 下面是我参考了说明文档以及网上一些资料后的编译过程： 编译过程： 1，下载libjpeg的源代码  下载地址：
怎么开发xilinx的jpeg2000编解码器
最新发布
07-11
C知道：要开发Xilinx的JPEG2000编解码器，你可以使用Xilinx的开发工具和IP核来实现。以下是一个简单的开发流程： 1. 确定需求：首先，你需要明确你的JPEG2000编解码器的功能和性能要求。例如，你希望实现哪些JPEG...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值