数据压缩原理 实验四 DPCM压缩系统的实现和分析
实验原理
DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器虚线框中所示。
在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。
在本次实验中，我们采用固定预测器和均匀量化器。预测器采用左侧、上方预测均可。量化器采用8bit均匀量化。本实验的目标是验证DPCM编码的编码效率。首先读取一个256级的灰度图像，采用自己设定的预测方法计算预测误差，并对预测误差进行8比特均匀量化（基本要求）。还可以对预测误差进行1比特、2比特和4比特的量化设计。
本实验我采用的是左侧预测，8比特均匀量化。
实验流程
先将BMP文件转换为YUV文件，提取Y数据，再对Y数据进行预测计算误差，然后对预测误差进行8bit均匀量化，再对量化后的预测误差进行反量化，求重建值。将误差图像和原图像传入上次实验的Huffman编码工程得到编码数据。
代码分析
main.cpp
#includeDPCM.cpp
#includeif (deltaw != 0)
{
if (deltaw == 1)
{
if ((Loop + 1) % Width == 0)
continue;
}
else if (deltaw == 2)
{
if ((Loop + 1) % Width == 0 || (Loop + 2) % Width == 0)
continue;
}
else
{
if ((Loop + 1) % Width == 0 || (Loop + 2) % Width == 0 || (Loop + 3) % Width == 0)
continue;
}
}
*rgb = *(bmpbuf + Loop);
rgb++;
}
}
else if (info_h.biBitCount == 16) //16位bmp
{
for (Loop = 0; Loop < Height * Width; Loop += 2)
{
*rgb = (bmpbuf[Loop] & 0x1F) << 3;
*(rgb + 1) = ((bmpbuf[Loop] & 0xE0) >> 2) + ((bmpbuf[Loop + 1] & 0x03) << 6);
*(rgb + 2) = (bmpbuf[Loop + 1] & 0x7C) << 1;
rgb += 3;
}
}
else if (info_h.biBitCount == 32) //32位bmp
{
for (Loop = 0; Loop < info_h.biWidth*info_h.biHeight; Loop++)
{
*(rgb + 3 * Loop) = *(bmpbuf + 4 * Loop);
*(rgb + 3 * Loop + 1) = *(bmpbuf + 4 * Loop + 1);
*(rgb + 3 * Loop + 2) = *(bmpbuf + 4 * Loop + 2);
}
}
else //其他位bmp
{
for (Loop = 0; Loop < Height*Width; Loop++)
{
if (deltaw != 0)
{
if (deltaw == 1)
{
if ((Loop + 1) % Width == 0)
continue;
}
else if (deltaw == 2)
{
if ((Loop + 1) % Width == 0 || (Loop + 2) % Width == 0)
continue;
}
else
{
if ((Loop + 1) % Width == 0 || (Loop + 2) % Width == 0 || (Loop + 3) % Width == 0)
continue;
}
}
switch (info_h.biBitCount) //蒙版
{
case 1:
mask = 0x80; //10000000
break;
case 2:
mask = 0xC0; //11000000
break;
case 4:
mask = 0xF0; //11110000
break;
case 8:
mask = 0xFF; //11111111
break;
}
int shiftCnt = 1;
while (mask)
{
/*根据从数据中提取出的索引号index，以index为调色板数组下标去查询
数据中每info_h.biBitCount位所代表的颜色。
while 循环的次数：
1bit 图像 每字节循环8次
2bit 图像 每字节循环4次
4bit 图像 每字节循环2次
8bit 图像 每字节循环1次。
*/
unsigned char index =
mask == 0xFF ? bmpbuf[Loop] : ((bmpbuf[Loop] & mask) >> (8 - shiftCnt *info_h.biBitCount));
*rgb = pRGB[index].rgbBlue;
*(rgb + 1) = pRGB[index].rgbGreen;
*(rgb + 2) = pRGB[index].rgbRed;
if (info_h.biBitCount == 8) mask = 0;
else mask >>= info_h.biBitCount;
rgb += 3;
shiftCnt++;
}
}
}
if (pRGB != NULL)
free(pRGB);
if (bmpbuf != NULL)
free(bmpbuf);
}
int RGB2YUV(int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip)
{
static int init_done = 0;
long i, j, size;
float yf, uf, vf;
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;
}
if ((x_dim % 2) || (y_dim % 2)) return 1;
size = x_dim * y_dim;
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;
/////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;
yf = (RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
uf = (-RGBYUV01684[*r] - RGBYUV03316[*g] + (*b) / 2 + 128);
vf = ((*r) / 2 - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
*y = (unsigned char)(yf>16 ? (yf>235 ? 235 : (unsigned char)yf) : 16);
*u = (unsigned char)(uf>16 ? (uf>240 ? 240 : (unsigned char)uf) : 16);
*v = (unsigned char)(vf>16 ? (vf>240 ? 240 : (unsigned char)vf) : 16);
b += 3;
y++;
u++;
v++;
}
}
}
else
{
for (i = 0; i < size; i++)
{
g = b + 1;
r = b + 2;
*y = (unsigned char)(RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
*u = (unsigned char)(-RGBYUV01684[*r] - RGBYUV03316[*g] + (*b) / 2 + 128);
*v = (unsigned char)((*r) / 2 - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
b += 3;
y++;
u++;
v++;
}
}
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;
}
void DO_DPCM(void * yBuf, void * deviationBuf, void *rebuildBuf, unsigned int width, unsigned int height)
{
unsigned char *ybuffer = NULL;
unsigned char *deviationbuffer = NULL;
unsigned char *rebuildbuffer = NULL;
int deviation = 0;
int i = 0, j = 0;
ybuffer = (unsigned char *)yBuf; //原始图像缓冲区
deviationbuffer = (unsigned char *)deviationBuf; //误差图像缓冲区
rebuildbuffer = (unsigned char *)rebuildBuf; //重建图像缓冲区
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
/*256级的灰度图像，预测值范围为[-255,255]，
8bit量化则除以2，将预测值范围变为[-127,127]，
再加128后可转到正常灰度显示
*/
if (j == 0) //对第一个像素进行误差预测
{
deviation = (*ybuffer - 128)/2+128; //量化后的预测误差
*deviationbuffer = (unsigned char)deviation;
deviation = (*deviationbuffer - 128)*2+128; //反量化后的预测误差
*rebuildbuffer = (unsigned char)deviation;
ybuffer++;
deviationbuffer++;
rebuildbuffer++;
}
else //对其余像素进行误差预测
{
deviation = (*ybuffer - *(rebuildbuffer-1))/2+128; //量化后的预测误差
*deviationbuffer = (unsigned char)deviation;
deviation = (*deviationbuffer - 128)*2 + *(rebuildbuffer - 1); //反量化后的预测误差
*rebuildbuffer = (unsigned char)deviation;
ybuffer++;
deviationbuffer++;
rebuildbuffer++;
}
}
}
}
实验结果与总结
实验图片进行预测误差和重建结果如下：
由于量化误差是由[-127,127]上移128得到的，所以所得的误差数据会集中分布在128处。
将实验图片直接进行Huffman编码和进行DPCM后做Huffman编码的文件进行比较，结果如下：
