实验4 DPCM压缩

文章目录

• • 实验4 DPCM压缩
  • • • 一.实验名称
      • 二.实验目的
      • 三.实验内容
      • • 1.DPCM编码原理
        • 2.DPCM编码系统的设计
      • 四.实验步骤
      • • 1.method.h头文件
        • 2.main函数
        • 3.dpcm函数
        • 4.psnr函数
        • 5. prob函数
      • 五.实验结果
      • • • 1.dpcm
          • 2.熵编码
          • 3.对比：
          • 4.总结：

持续更改中。。。

一.实验名称

DPCM 压缩系统的实现和分析

二.实验目的

掌握DPCM编解码系统的基本原理。初步掌握实验用C/C++等语言编程实现DPCM编码器，并分析其压缩效率。

三.实验内容

1.DPCM编码原理

DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器中虚线框中所示。在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。

2.DPCM编码系统的设计

在本次实验中，我们采用固定预测器和均匀量化器。

在DPCM编码器实现的过程中可同时输出预测误差图像和重建图像。将预测误差图像写入文件并将该文件输入Huffman编码器，得到输出码流、给出概率分布图并计算压缩比。

将原始图像文件输入Huffman编码器，得到输出码流、给出概率分布图并计算压缩比。

最后比较两种系统（1.DPCM+熵编码和2.仅进行熵编码）之间的编码效率（压缩比和图像质量）。压缩质量以PSNR进行计算。

四.实验步骤

1.method.h头文件

#pragma once
#define uchar unsigned char
void dpcm(int h, int w, uchar* origin_buf, uchar* rebuild_buf, uchar* error_buf, int Qbit);
double psnr(int h, int w, uchar* origin_buf, uchar* rebuild_buf, int Qbit);
void prob(int h, int w, uchar* input_buf, double* output_buf);

2.main函数

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
#include<windows.h>
#include"header.h"
#define uchar unsigned char
using namespace std;

int main()
{
	// 1.定义变量
	FILE* originFile = NULL;
	FILE* rebuildFile = NULL;
	FILE* errorFile = NULL;
	FILE* origintxt = NULL;
	FILE* errortxt = NULL;
	BITMAPINFOHEADER INFO_header;
	int Qbit = 2;
	
	
	// 2.打开文件
	if (fopen_s(&originFile, "Lena256B.yuv", "rb") == 0) cout << "原文件打开成功" << endl;
	if (fopen_s(&rebuildFile, "rebuildlena.yuv", "wb") == 0) cout << "重建文件创建成功" << endl;
	if (fopen_s(&errorFile, "errorlena.yuv", "wb") == 0) cout << "预测误差文件创建成功" << endl;
	if (fopen_s(&origintxt, "origin.txt", "wb") == 0) cout << "记录原图概率分布文件创建成功" << endl;
	if (fopen_s(&errortxt, "error.txt", "wb") == 0) cout << "记录预测误差的概率分布的文件创建成功" << endl;
	

	int height = 256;
	int weight = 256;

	// 3.开缓冲
	uchar* y_buffer = new uchar[weight * height];
	uchar* u_buffer = new uchar[(weight * height) /  4];
	uchar* v_buffer = new uchar[(weight * height) / 4];

	//uchar* y_buffer = (uchar*)malloc(sizeof(weight * height)*1.5);
	
	uchar* rebuild_buf = new uchar [height * weight];
	uchar* error_buf = new uchar[height * weight];
	double* origin_prob = new double[256];
	double* error_prob = new double[256];
	
	// 4.读取文件到buffer
	fread(y_buffer, sizeof(uchar), height * weight, originFile);
	fread(u_buffer, sizeof(uchar), (weight * height) / 4, originFile);
	fread(v_buffer, sizeof(uchar), (weight * height) / 4, originFile);

	// 5.dpcm
	dpcm(height, weight, y_buffer, rebuild_buf, error_buf,Qbit);

	// 6.psnr
	psnr(height, weight, y_buffer, rebuild_buf, Qbit);

	// 7.统计概率分布
	prob(height, weight, y_buffer, origin_prob);
	prob(height, weight, error_buf, error_prob);

	// 8.写入文件
	fwrite(rebuild_buf, sizeof(uchar), height * weight, rebuildFile);
	fwrite(u_buffer, sizeof(uchar), height * weight / 4, rebuildFile);
	fwrite(v_buffer, sizeof(uchar), height * weight / 4, rebuildFile);
	
	fwrite(error_buf, sizeof(uchar), height * weight, errorFile);
	fwrite(u_buffer, sizeof(uchar), height * weight / 4, errorFile);
	fwrite(v_buffer, sizeof(uchar), height * weight / 4, errorFile);
	// 概率分布写进txt中
	for (int i = 0; i < 256; i++)
	{
		fprintf(origintxt, "%lf\n", *(origin_prob + i));
		fprintf(errortxt, "%lf\n", *(error_prob + i));
	}
	
	// 9.关闭文件
	
	fclose(originFile);
	fclose(rebuildFile);
	fclose(errorFile);
	fclose(origintxt);
	fclose(errortxt);

	delete[] y_buffer;
	delete[] u_buffer;
	delete[] v_buffer;
	delete[] rebuild_buf;
	delete[] error_buf;
	delete[] origin_prob;
	delete[] error_prob;
	return 0;
}

3.dpcm函数

采用左向预测，第一列像素的误差值设为128.

预测误差图像：当前值-前一个像素的重建值
$$e(n)=y(n)-re(n-1)---预测误差$$

$$\hat{e}(n)=\frac{e(n)+255}{🔺}\ast 0.5🔺---量化后的预测误差$$

重建图像：预测误差值+前一个像素的重建值
$$re(n)=\hat{e}(n)+re(n-1)$$

#include<iostream>
#include<math.h>
#define uchar unsigned char
using namespace std;

double Quant(int Qbit, int error)
{
	double k = ((error + 255) / pow(2, 9 - Qbit));
	return k;
}

double InverseQuant(int Qbit, uchar pred)
{
	double k = (pred * pow(2, 9 - Qbit) - 255);
	return k;
}
void dpcm(int h, int w, uchar* origin_buf, uchar* rebuild_buf, uchar* error_buf, int Qbit)
{
	int error;
	for(int i=0;i<h;i++)
	{
		for (int j = 0; j < w; j++)
		{
			if (j == 0)
			{
				// 当前像素-预测值=误差值
				error = (origin_buf[i * w + j]) - 128;//假设第一列的预测值为128;
				// 对第一列像素值做量化
				error_buf[i * w + j] = Quant(Qbit, error);
				cout <<(int) error_buf[i * w + j] << endl;
				// 重建像素做反量化
				rebuild_buf[i * w + j] = InverseQuant(Qbit, error_buf[i * w + j])+128;
			}
			else
			{
				// e(n)=y(n)-re(n-1)
				error = (origin_buf[i * w + j]) - rebuild_buf[i * w + j - 1];
				error_buf[i * w + j] = Quant(Qbit, error);
				cout << (int)error_buf[i * w + j] << endl;
				// re(n)=\hat e(n)+re(n-1)
				rebuild_buf[i * w + j] = InverseQuant(Qbit, error_buf[i * w + j]) + rebuild_buf[i * w + j-1];
			}
		}
	}
	int max = pow(2, Qbit) - 1;
	for (int i = 0; i < h * w; i++)
	{
		if (error_buf[i] < 0)
			error_buf[i] = 0;
		if (error_buf[i] > max)
			error_buf[i] = max;
		if (rebuild_buf[i] < 0)
			rebuild_buf[i] = 0;
		if (rebuild_buf[i] > 255)
			rebuild_buf[i] = 255;
	}
}

4.psnr函数

PSNR，峰值信噪比，通过判断psnr的值来衡量压缩质量。计算规则如下：
$$PSNR=10lg\frac{(2^{bits}-1{)}^2}{MSE}$$
均方误差MSE：
$$MSE=\frac{{\sum }_{i=0}^M{\sum }_{j=0}^N[f(I,j)-f^{‘}(I,j){]}^2}{MN}$$
图像压缩质量衡量规则：

• PSNR>40dB,图形质量非常好，接近于原图像
• 30dB<PSNR<40dB,图像有可查觉的失真，质量仍可接受
• 20dB<PSNR<30dB,图像质量较差
• PSNR<20,图像质量无法接受

double psnr(int h, int w, uchar* origin_buf, uchar* rebuild_buf, int Qbit)
{
	double mse = 0, psnr = 0;
	for (int i = 0; i < h * w; i++)
	{
		mse += pow((origin_buf[i] - rebuild_buf[i]), 2);
	}
	mse = mse / (h * w);
	psnr = 10 * log10(pow(255, 2) / mse);
	cout << Qbit << "比特量化时psnr=" << psnr << endl;
	return psnr;
}

5. prob函数

void prob(int h, int w, uchar* input_buf, double* output_buf)
{
	double size = h * w;
	int num[256] = { 0 };
	double prob[256] = { 0 };
	
	for (int i = 0; i < size; i++)
	{
		num[(int)*(input_buf + i)]++;
		prob[(int)*(input_buf + i)] = num[(int)*(input_buf + i)] / size;
	}
	for (int i = 0; i < 256; i++)
	{
		*(output_buf + i) = prob[i];
	}
}

五.实验结果

1.dpcm

原图：

原图	原图的灰度值的概率分布

2.熵编码

• 批处理文件

熵编码结果：

• 原图的熵编码文件+预测误差图像的熵编码文件

• 原图和预测误差图像的字符、码长、码字组成的txt文件

3.对比：

压缩比	大小/kB	压缩比
原图	96	1
仅熵编码	69	1.6
8bitDPCM+熵编码	46	2.1
4bitDPCM+熵编码	24	4
2bitDPCM+熵编码	23	4.17

4.总结：

量化器的选择：

• 图像失真方面：量化比特数越小，图像失真越明显。
• 图像压缩效率方面：量化比特数越小，压缩效率越高。
• 折中考虑图像的失真与码率，选择8bit以上的量化器。

压缩方案的选择：

• 仅用熵编码压缩的系统的压缩效率远不如量化+熵编码的压缩系统.

为什么先有失真编码再无失真编码？

• 老师讲信息论的时候，这个问题也是要求重点掌握的知识点。做过实验后才真正明白其中的意义。根据无失真信源编码定理（香农第一定理），平均码长的下界为信源熵。在压缩方面，信源熵越小，平均码长越短，压缩效率越高。

• 这样一来，问题转变为要使得信源熵变小。也就是要使得信源序列的分布变得不均匀。利用信源间的相关性进行差分预测编码或去除信源间的相关性的变换编码可以使得信源序列的分布变得不均匀。

和实际信号的分布相比，差分预测误差是关于0的高尖峰。因此，预测误差总是具有比原始密度更小的熵。这意味着，预测的过程是把样值间的大部分冗余给去掉了。

疑问

❓huffman编码后的概率分布有点问题

128那里有个奇怪的值，不懂为啥。