DPCM 压缩系统的实现和分析

最新推荐文章于 2022-07-12 09:48:34 发布
最新推荐文章于 2022-07-12 09:48:34 发布
阅读量106 收藏
点赞数
文章标签： 信息压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43399224/article/details/116027851
版权

DPCM基本原理

在这里插入图片描述

DPCM即查分预测编码调制，将一个像素与上一个像素的差量化，得到预测误差。
本实验中采用右侧减左侧得到差值来预测，量化器采用8比特均匀量化。

编码代码

/*
y_buffer:存储y分量的指针
x_dim:图像水平个数
y_dim:图像垂直个数
y_new_out[k + 1]:上图的yk'
differ[k+1]:上图的^ek
*/
for (int j = 0; j < y_dim; j++)	
	{
		y = y_buffer + j * x_dim;
		y_new_out[j * x_dim] = *y;
		differ[j * x_dim] = 0;
		for (int i = 0; i < x_dim-1; i++)
		{
			differ[j * x_dim + i + 1] = ((*(y + 1) - y_new_out[j * x_dim + i]) - (*(y + 1) - y_new_out[j * x_dim + i]) % 2) / 2;
			y_new_out[j * x_dim + i + 1] = y_new_out[j * x_dim + i] + differ[j * x_dim + i + 1];
			y++;
		}
	}
	for (int i = 0; i<size; i++)
		differ[i] = differ[i] + 128;

图像测试

原图：在这里插入图片描述
复原图
在这里插入图片描述
差值图：
在这里插入图片描述

原图：
在这里插入图片描述

复原图：
在这里插入图片描述

差值图：
在这里插入图片描述

采用huffman编码器进行编码：

原图原图压缩原图压缩比差值图差值图压缩差值图压缩比
Birds1,153KB1,099KB1.049576KB191KB3.016
Lena193KB184KB1.04996KB48KB2.000

计算psnr判断压缩质量：
PSNR：峰值信噪比
MSE：均方误差
PSNR越大，图像失真越小，即压缩质量越好
在这里插入图片描述

计算psnr的代码：

void CountPSNR(unsigned char* oldBuf, unsigned char* newBuf, int n)
{
	double mse;
	double psnr;
	double sum = 0;
	for (int i = 0; i < n; i++)
	{
		sum = sum + (oldBuf[i] - newBuf[i]) * (oldBuf[i] - newBuf[i]);
	}
	mse = sum / n;
	psnr = 10 * log10(255 * 255 / mse);
	printf("psnr=%lf", psnr);
}

经过计算，Birds的psnr=33.500681
Lena的psnr=27.042175

由数据可知，图像在经过DPCM前使用huffman编码压缩效果很差几乎无法压缩，经过DPCM编码后数据更容易被压缩，压缩效率大幅提高；经过DPCM后恢复出的图片压缩质量较好。

for (int i = 0; i < x_dim-1; i++)
		{
			differ[j * x_dim + i + 1] = ((*(y + 1) - y_new_out[j * x_dim + i]) - (*(y + 1) - y_new_out[j * x_dim + i]) % 4) / 4;//修改此处“% 2) / 2”中的两个2
			y_new_out[j * x_dim + i + 1] = y_new_out[j * x_dim + i] + differ[j * x_dim + i + 1];
			y++;
		}

通过修改上述代码编码代码中的2为32、128、256可将8比特量化改为4、2、1比特量化。（将2改为（2^n）即为9-n比特量化）

完整代码

rgb2yuv.h：

int RGB2YUV(int x_dim, int y_dim, void* bmp, void* y_out, void* u_out, void* v_out, int flip,unsigned char*y_new_out,unsigned char*differ_out);

void InitLookupTable();


#pragma once

rgb2yuv.cpp:

#include "stdlib.h"
#include "rgb2yuv.h"
#include <math.h>
#include <stdio.h>
static float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
static float RGBYUV01684[256], RGBYUV03316[256];
static float RGBYUV04187[256], RGBYUV00813[256];

int RGB2YUV(int x_dim, int y_dim, void* bmp, void* y_out, void* u_out, void* v_out, int flip,unsigned char* y_new_out,unsigned char* differ)
{
	static int init_done = 0;

	long i, j, size;
	unsigned char* r, * g, * b;
	unsigned char* y, * u, * v;
	unsigned char* pu1, * pu2, * pv1, * pv2, * psu, * psv;
	unsigned char* y_buffer, * u_buffer, * v_buffer;
	unsigned char* sub_u_buf, * sub_v_buf;

	if (init_done == 0)
	{
		InitLookupTable();
		init_done = 1;
	}

	// check to see if x_dim and y_dim are divisible by 2
	if ((x_dim % 2) || (y_dim % 2)) return 1;
	size = x_dim * y_dim;

	// allocate memory
	y_buffer = (unsigned char*)y_out;
	sub_u_buf = (unsigned char*)u_out;
	sub_v_buf = (unsigned char*)v_out;
	u_buffer = (unsigned char*)malloc(size * sizeof(unsigned char));
	v_buffer = (unsigned char*)malloc(size * sizeof(unsigned char));
	if (!(u_buffer && v_buffer))
	{
		if (u_buffer) free(u_buffer);
		if (v_buffer) free(v_buffer);
		return 2;
	}

	b = (unsigned char*)bmp;
	y = y_buffer;
	u = u_buffer;
	v = v_buffer;

	// convert RGB to YUV
	if (!flip) {
		for (j = 0; j < y_dim; j++)
		{
			y = y_buffer + (y_dim - j - 1) * x_dim;
			u = u_buffer + (y_dim - j - 1) * x_dim;
			v = v_buffer + (y_dim - j - 1) * x_dim;

			for (i = 0; i < x_dim; i++) {
				g = b + 1;
				r = b + 2;
				*y = (unsigned char)(RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
				*u = (unsigned char)128;
				*v = (unsigned char)128;
				b += 3;
				y++;
				u++;
				v++;
			}
		}
	}
	else {
		for (j = 0; j < y_dim; j++)
		{
			for (i = 0; i < x_dim; i++)
			{
				g = b + 1;
				r = b + 2;
				*y = (unsigned char)(RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
				*u = (unsigned char)128;
				*v = (unsigned char)128;		
				b += 3;
				y++;
				u++;
				v++;
			}
		}
	}

	for (int j = 0; j < y_dim; j++)	
	{
		y = y_buffer + j * x_dim;
		y_new_out[j * x_dim] = *y;
		differ[j * x_dim] = 0;
		for (int i = 0; i < x_dim-1; i++)
		{
			differ[j * x_dim + i + 1] = ((*(y + 1) - y_new_out[j * x_dim + i]) - (*(y + 1) - y_new_out[j * x_dim + i]) % 2) / 2;
			y_new_out[j * x_dim + i + 1] = y_new_out[j * x_dim + i] + differ[j * x_dim + i + 1];
			y++;
		}
	}
	for (int i = 0; i<size; i++)
		differ[i] = differ[i] + 128;
	// subsample UV
	for (j = 0; j < y_dim / 2; j++)
	{
		psu = sub_u_buf + j * x_dim / 2;
		psv = sub_v_buf + j * x_dim / 2;
		pu1 = u_buffer + 2 * j * x_dim;
		pu2 = u_buffer + (2 * j + 1) * x_dim;
		pv1 = v_buffer + 2 * j * x_dim;
		pv2 = v_buffer + (2 * j + 1) * x_dim;
		for (i = 0; i < x_dim / 2; i++)
		{
			*psu = (*pu1 + *(pu1 + 1) + *pu2 + *(pu2 + 1)) / 4;
			*psv = (*pv1 + *(pv1 + 1) + *pv2 + *(pv2 + 1)) / 4;
			psu++;
			psv++;
			pu1 += 2;
			pu2 += 2;
			pv1 += 2;
			pv2 += 2;
		}
	}

	free(u_buffer);
	free(v_buffer);

	return 0;
}


void InitLookupTable()
{
	int i;

	for (i = 0; i < 256; i++) RGBYUV02990[i] = (float)0.2990 * i;
	for (i = 0; i < 256; i++) RGBYUV05870[i] = (float)0.5870 * i;
	for (i = 0; i < 256; i++) RGBYUV01140[i] = (float)0.1140 * i;
	for (i = 0; i < 256; i++) RGBYUV01684[i] = (float)0.1684 * i;
	for (i = 0; i < 256; i++) RGBYUV03316[i] = (float)0.3316 * i;
	for (i = 0; i < 256; i++) RGBYUV04187[i] = (float)0.4187 * i;
	for (i = 0; i < 256; i++) RGBYUV00813[i] = (float)0.0813 * i;
}

main.cpp:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <windows.h>
#include "rgb2yuv.h"
#include"math.h"
BITMAPFILEHEADER File_header;
BITMAPINFOHEADER Info_header;
#pragma warning(disable:4996)
#define u_int8_t	unsigned __int8
#define u_int		unsigned __int32
#define u_int32_t	unsigned __int32
#define FALSE		false
#define TRUE		true

/*
 * rgb2yuv
 * required arg1 should be the input RAW RGB24 file
 * required arg2 should be the output RAW YUV12 file
 */
int main()
{
	/* variables controlable from command line */
	u_int frameWidth;			/* --width=<uint> */
	u_int frameHeight;		/* --height=<uint> */
	bool flip = FALSE;				/* --flip */
	unsigned int i;
	void Write(const char* bmpflie, const char* yuvfile, u_int8_t * rgbBuf, u_int8_t * yBuf, u_int8_t * uBuf, u_int8_t * vBuf, u_int frameWidth, u_int frameHeight);
	void CountPSNR(unsigned char* oldBuf, unsigned char* newBuf, int n);
	/* internal variables */
	const char* bmpFileName = NULL;
	const char* yuvFileName1 = NULL;
	const char* yuvFileName2 = NULL;
	FILE* bmpFile = NULL;
	FILE* yuvFile1 = NULL;
	FILE* yuvFile2 = NULL;
	u_int8_t* rgbBuf = NULL;
	u_int8_t* yBuf = NULL;
	u_int8_t* yNewBuf = NULL;
	u_int8_t* differBuf = NULL;
	u_int8_t* uBuf = NULL;
	u_int8_t* vBuf = NULL;
	u_int32_t videoFramesWritten = 0;

	/* begin process command line */
	/* point to the specified file names */
	bmpFileName = "Birds.bmp";
	yuvFileName1 = "Birds_out.yuv";
	yuvFileName2 = "Birds_out_re.yuv";
	//yuvFileName = "Birds_outwhole.yuv";

	/* open the RGB file */
	bmpFile = fopen(bmpFileName, "rb");
	if (bmpFile == NULL)
	{
		printf("cannot find bmp file\n");
		exit(1);
	}
	if (fread(&File_header, sizeof(BITMAPFILEHEADER), 1, bmpFile) != 1)
	{
		printf("read file header error!");
		exit(0);
	}
	if (File_header.bfType != 0x4D42)
	{
		printf("Not bmp file!");
		exit(0);
	}
	if (fread(&Info_header, sizeof(BITMAPINFOHEADER), 1, bmpFile) != 1)
	{
		printf("read info header error!");
		exit(0);
	}
	printf("The input bmp file is %s\n", bmpFileName);
	frameWidth = Info_header.biWidth;
	frameHeight = Info_header.biHeight;
	printf("width: %d , height: %d\n ", frameWidth, frameHeight);
	/* open the RAW file */

	yuvFile1 = fopen(yuvFileName1, "wb");
	yuvFile2 = fopen(yuvFileName2, "wb");
	if (yuvFile1 == NULL|| yuvFile2 == NULL)
	{
		printf("cannot find yuv file\n");
		exit(1);
	}
	else
	{
		printf("The output yuv file is %s and %s\n", yuvFileName1, yuvFileName2);
	}

	/* get an input buffer for a frame */
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

	/* get the output buffers for a frame */
	yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	yNewBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	differBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);


	if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
	{
		printf("no enought memory\n");
		exit(1);
	}

	while (fread(rgbBuf, 1, frameWidth * frameHeight * 3, bmpFile))
	{
		if (RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip,yNewBuf,differBuf))
		{
			printf("error");
			return 0;
		}
		fwrite(differBuf, 1, frameWidth * frameHeight, yuvFile1);
		fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile1);
		fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile1);
		fwrite(yNewBuf, 1, frameWidth * frameHeight, yuvFile2);
		fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile2);
		fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile2);

	}
	CountPSNR(yBuf, yNewBuf, frameWidth * frameHeight);
	/* cleanup */
	free(rgbBuf);
	free(yBuf);
	free(uBuf);
	free(vBuf);
	fclose(bmpFile);
	fclose(yuvFile1);
	fclose(yuvFile2);

	return(0);
}
void CountPSNR(unsigned char* oldBuf, unsigned char* newBuf, int n)
{
	double mse;
	double psnr;
	double sum = 0;
	for (int i = 0; i < n; i++)
	{
		sum = sum + (oldBuf[i] - newBuf[i]) * (oldBuf[i] - newBuf[i]);
	}
	mse = sum / n;
	psnr = 10 * log10(255 * 255 / mse);
	printf("psnr=%lf", psnr);
}
tonymqz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DPCM 压缩系统的实现和分析 数据压缩实验4
05-14
DPCM 压缩系统的实现和分析，掌握DPCM编解码系统的基本原理。初步掌握实验用C语言编程实现DPCM编码器并分析其压缩效率。
利用DPCM编码进行图像压缩
steve21248的博客
05-09 1893
一幅图像往往像素与像素之间是有关联的，比如说一张人脸的照片，肉色像素的隔壁基本还是肉色像素，那么这两个像素之间的差别就会很小。因此当我们处理一幅图片的时候，可以考虑到这种特性，在压缩时减小这种相关的空间冗余度，DPCM就是基于这种思想一种编码手段。 DPCM的思想十分简单，就是用前一个像素（左边或者上边）来作为下一个像素值的预测值，而一个像素存储值的就会变成预测值与当前实际值的差值。 计算机中8bit能存储的无符号数是从0到255，而差值的取值范围为-255到255，因此需要在得到的差值上加一个255来使之
DPCM
citongke1的专栏
04-05 1617
转自百度百科： DPCM(Differential Pulse Code Modulation)差分脉冲编码调制，简称差值编码。 它是利用声音信号的相关性找出可反映信号变化特性的一个差值编码。 是对模拟信号幅度抽样的差值进行量化编码的调制方式(抽样差值的含义请参见“增量调制”)。这种方式是用已经过去的抽样值来预测当前的抽样值，对它们的差值进行编码。差值编码可以提高编码频率，这种技
DPCM编码原理及代码实现
不会编程的芝麻张的博客
07-12 4760
数据压缩作业：DPCM编码
实验四：DPCM 压缩系统的实现和分析
CUC_ENGINEER的博客
05-11 338
实验原理   DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中， 需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是 因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实 际内嵌了一个解码器，如编码器中虚线框中所示。   在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器 和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和 量化器的优化设计。 DPCM编解码原理图 实验内
dpcm算法研究 语音压缩编码算法：差分脉冲编码调制算法的实现
06-30
差分脉冲编码调制算法研究 ： 用Matlab实现DPCM算法 ，文件包括源码、运行结果分析、实验问报告文档。该文件演示了DPCM压缩文件和对文件进行解压缩的过程以及一些参数的分析，含有详细注释。
实验指导书4_DPCM编码1
08-04
一、实验课程编码：103050 二、实验课程名称：数据压缩原理与应用 A 三、实验项目名称：DPCM 压缩系统的实现和分析 四、实验目的 五、主要设备 六、实验
JPEG_图像压缩_matlab.zip
06-25
2.基本要求：参考JPEG图像编码标准，设计一个基于变换编码、量化技术和哈夫曼编码的有损图像压缩系统。 2.1 编码器的输入为任意bmp/png文件；输出为二进制码流文件。 2.2 解码器的输入为二进制码流文件，输出为bmp/...
MATLAB通信仿真及应用实例详解pdf-MATLAB通信仿真及应用实例详解.part5.rar
08-12
本书着重介绍了MATLAB在通信仿真，尤其是移动通信仿真中的应用，通过丰富具体的实例来加深读者对通信系统仿真的理解和掌握。 全书共分10章，前3章介绍MATLAB通信仿真的基础，包括Simulink和S-函数；第4~8章分别介绍...
使用DPCM进行图像压缩的C++实现方法
nikoniko_chik的博客
06-17 511
一、实验课程名称：数据压缩原理与应用 A 二、实验项目名称：DPCM 压缩系统的实现和分析 三、实验目的 掌握DPCM编解码系统的基本原理。初步掌握实验用C/C++/Python等语言编程实现DPCM 编码器，并分析其压缩效率。 四、主要设备 安装 Windows 和 Visual Studio 软件的个人计算机 五、实验内容 1．DPCM编解码原理 DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中， 需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是
数据压缩 DPCM编码
Sssssusu的博客
05-08 2434
DPCMcoding实验原理在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。 在本次实验中，我们采用固定预测器和均匀量化器。预测器采用左侧、上方预测均可。 量化器采用8比特均匀量化。预测编码基本原理 信源的相邻符号通常是相关的。 相邻像素具有相关性。 预测编码： 利用信
数据压缩试验四：使用 DPCM 编码进行图像压缩
Zachary_Chia的博客
05-05 1243
使用 DPCM 编码进行图像压缩 基本原理 DPCM，即差分脉冲编码调制（Differential Pulse Code Modulation），通过对图像进行预测编码并缩减图片预测误差的动态范围来实现图像的压缩。本次试验中只对亮度信号 Y 通道进行编码压缩，将图片的第一列像素值作为原始参考值进行预测，通过与左侧的像素值取差计算预测误差，然后进行量化编码。以下为 DPCM 编码端与解码端的原理图 ...
数据压缩实验 | DPCM压缩系统的实现和分析
layata的博客
05-10 251
实验内容： 1.DPCM编解码原理 DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器中虚线框中所示。 在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。 2．DPCM编码系统的设
数据压缩（8）：DPCM 压缩系统的实现和分析
weixin_46338503的博客
05-10 778
1、DPCM编解码原理 DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器中虚线框中所示。 在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。 2、代码实现 main.cpp #
DPCM压缩系统的原理及实现
weixin_45442965的博客
05-10 1377
DPCM 压缩系统 原理介绍 DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器中虚线框中所示。 在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。 代码实现 编写代码实现量化比
基于matlab实现人工免疫算法的解决TSP问题的方法
最新发布
05-21
基于matlab实现人工免疫算法的解决TSP问题的方法，体现了免疫算法在进化计算过程中的抗原学习、记忆机制、浓度调节机制以及多样性抗体保持策略等优良特性.rar
麦肯锡图表绘制培训.pptx
05-21
麦肯锡图表绘制培训.pptx
dpcm 压缩系统的实现和分析
05-12
再者，DPCM 压缩系统的计算和编码速度较快，可以在硬件中实现，适用于实时视频或音频传输。 然而，DPCM 压缩系统也有一些缺点。首先，差分编码容易受到干扰和噪声的影响，从而导致误差传播和失真的增加。此外，DPCM...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值