【数据压缩】JPEG编码原理和码流分析

已于 2022-04-01 11:19:26 修改
阅读量892 收藏 7
点赞数
分类专栏： 数据压缩 文章标签： 音视频
于 2021-06-09 14:03:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdkks/article/details/117740566
版权

文章目录

一、实验目的

掌握JPEG编解码系统的基本原理。初步掌握复杂的数据压缩算法实现，并能根据理论分析需要实现所对应数据的输出。

二、实验原理

JPEG编码原理

JPEG编码包含以下几个主要内容：

  1. 8*8分块。
  2. 正向离散余弦变换(FDCT)
  3. 量化(quantization)
  4. Z字形编码(zigzag scan)
  5. 使用差分脉冲编码调制(DPCM)对直流系数(DC)进行编码
  6. 使用行程长度编码(RLE)对交流系数(AC)进行编码。
  7. 熵编码。

编码框图如图所示，分别对应着上述过程。
在这里插入图片描述

JPEG格式文件解析

图像开始SOI标记（0xFFD8）和图像结束EOI标记（0xFFD9）

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

FFDB: DQT，Define Quantization Table，定义量化表

第一个FFDB定义第一张量化表

00 43 00 + qt_table（64字节）

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

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

在这里插入图片描述

FFC4: DHT，Define Huffman Table，定义 Huffman 树表
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 差分编码得到的。

在这里插入图片描述

** 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
在这里插入图片描述

三、代码调试与分析

阅读JPEG解码相关代码，分析主要解码部分如下：

tinyjpeg_parse_header 文件头解析

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;
}

parse_JFIF 解析marker标识

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;
}

parse_DQT 解析量化表

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;
}

build_quantization_table 建立量化表

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;
}

parse_DHT 解析Huffman码表

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;
}

build_huffman_table 建立Huffman码表

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;
}

parse_SOS 解析SOS

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;
}

parse_SOF 解析SOF

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;
}

tinyjpeg_decode 解析实际图像数据

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;
}

输出YUV文件

添加函数 YUV_write:

static void YUV_write(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);
}

输出量化矩阵：

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

四、实验结果

huffman码表

huffman码表包含在trace_jpeg.txt中：
在这里插入图片描述

可供观看的YUV文件

使用YUVViewer查看YUV文件，结果如下：
在这里插入图片描述

量化矩阵

得到量化矩阵输出如下：

量化表1

在这里插入图片描述

量化表2

在这里插入图片描述

3木目
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于JPG图片之JPEG编解码过程详解
cpq37的专栏
06-10 1万+
JPEG（Joint Photographic Experts Group）是联合图像专家小组的英文缩写。它由国际电话与电报咨询委员会CCITT（The International Telegraph and Telephone Consultative Committee）与国际标准化组织ISO于1986年联合成立的一个小组，负责制定静态数字图像的编码标准。       小组一直致力于标准化工作，开发研制出连续色调、多级灰度、静止图像的数字图像压缩编码方法，即JPEG算法。JPEG算法被确定为国际通用标准
Android开发——JPEG码流分析
Chinalihuanyu的博客
10-24 1881
Android解码JPEG
JPEG编码格式（2）—量化及熵编码
最新发布
q15516221118的博客
04-23 1266
JPEG编解码标准
JPEG编解码流程_C/C++代码编写_详细
weixin_40279971的博客
04-20 6262
JPEG的文件格式，算法原理，编解码流程，源码地址
Tegra_Multimedia API 例程学习之6--06_jpeg_decode
一米阳光
10-26 1368
Jpeg硬件解码概述编译运行流程图先看decodeToBuffer再看DecodeToFd整个代码 概述 使用硬件解码一张jpeg的图片,这里也使用了两个方法实现，一种效率高一些，另一种效率低一些。 编译运行 编译就不说了，进入源码直接make 运行 $ ./jpeg_decode num_files <number of files to decode> \ <in...
JPEG系列一 JPEG图片的文件格式
老鹰不捉小鸡
12-02 1275
JPEG图片的文件布局 一个典型的EXIF JPEG文件布局：
JPEG编码压缩率调整
喵小林菌的博客
01-08 5025
图像质量 u32Qfactor：量化表因子范围为[1, 99]，u32Qfactor 越大，量化表中的量化系数越小，得到的图像质量会更好，同时，编码压缩率更低。同理 u32Qfactor 越小，量化表中的量化系数越大，得到的图像质量会更差，同时，编码压缩率更高。具体的 u32Qfactor 与量化表的关系请见 RFC2435 标准。 量化表的的量化系数越大，得到的量化系数就越小，高频信息消失的更多。因此量化表因子其实就是控制图像所保留各个频率信息的范围，如果想压缩更低，那就保留频率信息越少。 ...
JPEG_jpeg编码解码_jpeg图像压缩编码_
10-03
以下是关于JPEG编码解码和图像压缩编码的详细知识： 1. **JPEG编码流程**： - **颜色空间转换**：JPEG通常将RGB图像转换为YCbCr颜色空间，因为Y（亮度）分量对人类视觉更重要，Cb和Cr（色度）则可以使用更低的位深...
jpeg.rar_jpeg压缩编码
09-22
JPEG（Joint Photographic Experts Group）是一种广泛用于数字图像和照片的有损压缩标准，由一个国际组织制定。这种压缩方法可以有效地减少文件的...通过学习和实践，我们可以更深入地了解数字图像处理和数据压缩技术。
jpeg.rar_cjpeg_jpeg压缩编码
09-23
- **JPEG压缩编码系统源代码**：包含实现JPEG压缩编码的C语言源代码，用户可以通过阅读和分析这些代码来理解JPEG压缩的过程，并可能用于自定义的图像处理项目。 通过深入学习和理解这些源代码，开发者可以更好地...
jpeg.rar_jpeg_jpeg 压缩原理_matlab JPEG
09-23
`huffman.m`可能包含了哈夫曼编码的实现，而`实验三四－压缩－增强.pdf`可能提供了详细的实验原理和指导，包括MATLAB代码的使用方法和压缩效果的分析。 通过这个MATLAB实现，我们可以亲自操作并观察不同参数设置...
jpeg decode源码
03-15
很好的jpeg decode源代码，占用极小的系统内存，代码量很小。支持使用RGB565、888、555等各种数据格式。适用于小型化的嵌入式机器。
基于DCT的JPEG图像编码器原理及设计
06-27
基于DCT的JPEG图像编码器原理及设计，还有MATLAB实现代码
JPEG.rar_jpeg_jpeg 压缩_jpeg 编码 _jpeg压缩_jpeg编码
09-24
JPEG（Joint Photographic Experts Group）是一种广泛应用于数字图像和照片的有损压缩标准。这个“JPEG.rar_jpeg_jpeg 压缩_jpeg 编码 _jpeg压缩_...理解并掌握JPEG编码原理对于图像处理和网络传输领域的工作至关重要。
详解JPEG编码格式
weixin_43998552的博客
04-23 1641
MJPEG是一种视频压缩格式，其中的每一帧图像都使用JPEG编码。，JPEG文件包含多条数据段，每条数据段包括段标识码和数据流
实验 JPEG原理分析及解码器调试
weixin_48930931的博客
06-11 260
一、实验目的掌握JPEG编解码系统的基本原理。初步掌握复杂的数据压缩算法实现，并能根据理论分析需要实现所对应数据的输出。二、实验环境安装Windows和Visual Studio软件的个人计算机三、实验内容1．JPEG编解码原理图示为JPEG编码过程图，解码时编码的逆过程1）彩色空间JPEG标准本身没有规定具体的颜色空间，只是对各分量分别进行编码。实现中通常将高度相关到的RGB颜色空间转换到相关性较小的YUV颜色空间。图像的主要信息包括在Y通道，U、V更平滑，更易压缩。由于人眼对色度分量不敏感，可以对色度分
JPEG实验五
Distancedd的博客
07-01 157
一、实验目的 掌握JPEG编解码系统的基本原理。初步掌握复杂的数据压缩算法实现，并能根据理论分析需要实现所对应数据的输出。 二、实验原理 1、JPEG编解码原理 （1）编码原理 零偏置（Level Offset）：对于灰度级是的像素，通过减去，将无符号的整数值变成有符号数;对于n=8，即将0~255的值域，通过减去128，转换为值域在-128~127之间的值 DCT变换：对每个单独的彩色图像分量，把整个分量图像分成8×8的图像块，不足8×8的图像块，取边缘像素补齐，对每个块做DCT变换，直流系数
JPEG2000帧格式详解（一）
stefanjoe的博客
03-28 6680
写作背景 工作原因，临时需要在内存中解析JPEG2000格式的码流图片，（本来opencv是支持读写jpeg2000格式的图片的，但由于图片是在内存中，无法通过imread函数读取磁盘图片，因此不能使用opencv），由于网上JPEG2000的资料十分少，中间过程也是有点坎坷。为了帮助大家更好的理解JPEG2000图片的码流格式，这里放上自己的笔记。 格式简介 先放上JPEG2000的格式，可以看到图片是由很多的box组成的，每个box代表着一些图片信息，如File Type Box表示文件的类型，C
Jpeg编码压缩比例
jzwjzw19900922的博客
11-07 1538
原始一张图大小： 1920x1536*2 /1024 =5760KB。压缩比例= 5760 : 325 = 17.7 : 1。Jpeg编码后一张图大小： 325KB。数据格式： YUV422 8bit。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值