数据压缩原理 实验四 DPCM压缩系统的实现和分析

最新推荐文章于 2023-11-11 09:45:00 发布
最新推荐文章于 2023-11-11 09:45:00 发布
阅读量566 收藏 1
点赞数
分类专栏： 实验报告 文章标签： 数据压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_yuchang/article/details/72823796
版权

实验原理

实验原理

DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器虚线框中所示。

在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。

在本次实验中，我们采用固定预测器和均匀量化器。预测器采用左侧、上方预测均可。量化器采用8bit均匀量化。本实验的目标是验证DPCM编码的编码效率。首先读取一个256级的灰度图像，采用自己设定的预测方法计算预测误差，并对预测误差进行8比特均匀量化（基本要求）。还可以对预测误差进行1比特、2比特和4比特的量化设计。

本实验我采用的是左侧预测，8比特均匀量化。

实验流程

先将BMP文件转换为YUV文件，提取Y数据，再对Y数据进行预测计算误差，然后对预测误差进行8bit均匀量化，再对量化后的预测误差进行反量化，求重建值。将误差图像和原图像传入上次实验的Huffman编码工程得到编码数据。

代码分析

main.cpp

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<Windows.h>
#include<math.h>
#include"DPCM.h"
#define u_int8_t    unsigned __int8
#define u_int       unsigned __int32
#define u_int32_t   unsigned __int32

BITMAPFILEHEADER File_header;
BITMAPINFOHEADER Info_header;

int main(int argc, char** argv)
{   
    bool flip = FALSE;                  //BMP图像倒序存储数据 需要翻转

    char* bmpFileName = NULL;           //输入
    char* yuvFileName = NULL;           //输出
    char* deviationFileName = NULL;     //误差
    char* rebuildFileName = NULL;       //重建
    FILE* bmpFile = NULL;
    FILE* yuvFile = NULL;
    FILE* deviationFile = NULL;
    FILE* rebuildFile = NULL;

    u_int8_t* rgbBuf = NULL;
    u_int8_t* yBuf = NULL;
    u_int8_t* uBuf = NULL;
    u_int8_t* vBuf = NULL;
    u_int8_t* deviationBuf = NULL;
    u_int8_t* rebuildBuf = NULL;

    u_int frameWidth, frameHeight;      //宽高
    int i = 0, j = 0;

    bmpFileName = argv[1];              //输入
    yuvFileName = argv[2];              //输出
    deviationFileName = argv[3];        //误差
    rebuildFileName = argv[4];          //重建

    /read files/
    bmpFile = fopen(bmpFileName, "rb");
    if (bmpFile == NULL)
    {
        printf("cannot find bmp file\n");
        exit(1);
    }
    else
    {
        printf("The input bmp file is %s\n", bmpFileName);
    }

    yuvFile = fopen(yuvFileName, "wb");
    if (yuvFile == NULL)
    {
        printf("cannot find yuv file\n");
        exit(1);
    }
    else
    {
        printf("The output yuv file is %s\n", yuvFileName);
    }

    deviationFile = fopen(deviationFileName, "wb");
    if (deviationFile == NULL)
    {
        printf("cannot find deviation file\n");
        exit(1);
    }
    else
    {
        printf("The output deviation file is %s\n", deviationFileName);
    }

    rebuildFile = fopen(rebuildFileName, "wb");
    if (rebuildFile == NULL)
    {
        printf("cannot find rebuild file\n");
        exit(1);
    }
    else
    {
        printf("The output rebuild file is %s\n", rebuildFileName);
    }
    printf("\n");
    /read BMP fileheader & infoheader/
    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);
    }
    else
    {
        printf("this is a bmp file.\n");
    }
    if (fread(&Info_header, sizeof(BITMAPINFOHEADER), 1, bmpFile) != 1)
    {
        printf("read info header error!");
        exit(0);
    }
    printf("bitcount==%d\n", (unsigned char)Info_header.biBitCount);
    /end read header/

    frameWidth = Info_header.biWidth;               //宽高赋值
    frameHeight = Info_header.biHeight;

    /开缓存区/
    rgbBuf = (u_int8_t *)malloc(sizeof(u_int8_t)*frameHeight*frameWidth * 3);
    memset(rgbBuf, 0, frameHeight*frameWidth * 3);
    yBuf = (u_int8_t*)malloc(sizeof(u_int8_t)*frameHeight*frameWidth);
    uBuf = (u_int8_t*)malloc(sizeof(u_int8_t)*frameHeight*frameWidth / 4);
    vBuf = (u_int8_t*)malloc(sizeof(u_int8_t)*frameHeight*frameWidth / 4);
    deviationBuf = (u_int8_t*)malloc(sizeof(u_int8_t)*frameHeight*frameWidth);
    rebuildBuf = (u_int8_t*)malloc(sizeof(u_int8_t)*frameHeight*frameWidth);

    ReadRGB(rgbBuf, bmpFile, File_header, Info_header);
    if (RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
    {
        printf("Color transferring failed");
        return 0;
    }

    printf("framewidth==%d,frameheight==%d.\n", frameWidth, frameHeight);       //输出图像宽高

    DO_DPCM(yBuf, deviationBuf, rebuildBuf,frameWidth,frameHeight);                 //进行DPCM编码

    fwrite(yBuf, 1, frameWidth * frameHeight, yuvFile);                         //写输出文件
    fwrite(deviationBuf, 1, frameHeight*frameWidth, deviationFile);
    fwrite(rebuildBuf, 1, frameHeight*frameWidth, rebuildFile);

    /关缓存/
    if (rgbBuf != NULL) 
        free(rgbBuf);
    if (yBuf != NULL) 
        free(yBuf);
    if (uBuf != NULL) 
        free(uBuf);
    if (vBuf != NULL) 
        free(vBuf);
    if (deviationBuf != NULL) 
        free(deviationBuf);
    if (rebuildBuf != NULL) 
        free(rebuildBuf);
    /关文件/
    if (bmpFile != NULL) 
        fclose(bmpFile);
    if (yuvFile != NULL) 
        fclose(yuvFile);
    if(deviationFile != NULL) 
        fclose(deviationFile);
    if(rebuildFile != NULL) 
        fclose(rebuildFile);

    system("pause");
    return 0;
}

DPCM.cpp

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

bool MakePalette(FILE * pFile, BITMAPFILEHEADER &file_h, BITMAPINFOHEADER & info_h, RGBQUAD *pRGB_out)
{
    /*若图像开始位置与INFOHEADER结束处位置，还有pow(2, info_h.biBitCount）个
    结构体RGBQUAQ的空间（颜色数为2的biBitCount次方，调色板为数组），则说明
    该bmp图像有调色板。*/
    if ((file_h.bfOffBits - sizeof(BITMAPFILEHEADER) - info_h.biSize) == sizeof(RGBQUAD)*pow(2.0, info_h.biBitCount))
    {
        fseek(pFile, sizeof(BITMAPFILEHEADER) + info_h.biSize, 0);
        fread(pRGB_out, sizeof(RGBQUAD), (unsigned int)pow(2.0, info_h.biBitCount), pFile);
        return true;
    }
    else
        return false;
}

void ReadRGB(unsigned char * rgbbuf, FILE *bmpfile, BITMAPFILEHEADER &file_h, BITMAPINFOHEADER & info_h)
{
    u_int Width = 0, Height = 0;
    long Loop = 0;
    unsigned char *bmpbuf = NULL;
    unsigned char *rgb = NULL;
    unsigned char mask = 0;
    int deltaw = 0;
    rgb = rgbbuf;

    if (((info_h.biWidth  * info_h.biBitCount / 8) % 4) == 0)
        Width = info_h.biWidth*info_h.biBitCount / 8;
    else
        Width = (info_h.biWidth  * info_h.biBitCount + 31) / 32 * 4;

    if ((info_h.biHeight % 2) == 0)
        Height = info_h.biHeight;
    else
        Height = info_h.biHeight + 1;

    deltaw = Width - info_h.biWidth * info_h.biBitCount / 8;
    bmpbuf = (unsigned char *)malloc(sizeof(unsigned char)*Height*Width);
    printf("word_width :%d , word_height: %d \n", Width, Height);
    RGBQUAD *pRGB = (RGBQUAD *)malloc(sizeof(RGBQUAD) * (unsigned int)pow(2.0, (double)info_h.biBitCount));

    if (!MakePalette(bmpfile, file_h, info_h, pRGB))
    {
        printf("No palette!\n");                        //没有调色板
    }

    fread(bmpbuf, 1, Height*Width, bmpfile);
    if (info_h.biBitCount == 24)                        //24位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;
                }
            }
            *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++;
            }
        }
    }
}

实验结果与总结

实验图片进行预测误差和重建结果如下：

birds
birds误差
birds重建
birds图表
birds误差图表

相机男
相机男误差
相机男重建
相机男图表
相机男误差图表

小丑
小丑误差
小丑重建
小丑图表
小丑误差图表

水果
水果误差
水果重建
水果图表
水果误差图表

lena
lena误差
lena重建
lena图表
lena误差图表

噪声
噪声误差
噪声重建
噪声图表
噪声误差图表

欧弟
欧弟误差
欧弟重建
欧弟图表
欧弟误差图表

圆圈
圆圈误差
圆圈重建
圆圈图表
圆圈误差图表

由于量化误差是由[-127,127]上移128得到的，所以所得的误差数据会集中分布在128处。

将实验图片直接进行Huffman编码和进行DPCM后做Huffman编码的文件进行比较，结果如下：
数据分析

liu_yuchang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DPCM 压缩系统的实现和分析 数据压缩实验4
05-14
在本实验中，我们将深入探讨数字预测差分脉冲编码调制（DPCM）这一数据压缩技术，并通过C语言实现DPCM编码器来理解和分析其压缩效率。DPCM是一种常用的预测编码方法，常用于音频和图像数据的压缩，它利用了信号的...
数据压缩实验二——图像文件的读写和转换
willshant的博客
03-29 1233
一、           实验基本原理 1.   BMP文件的组成结构          BMP（全称 Bitmap）是 Windows 操作系统中的标准图像文件格式，可以分成两类：设备相关位图（DDB）和设备无关位图（DIB），使用非常广。它采用位映射存储格式，除了图像深度可选以外，在绝大多数应用中不采用其他任何压缩，因此，BMP 文件所占用的空间很大。BMP 文件的图像深度可选1b
DPCM编码原理及代码实现
不会编程的芝麻张的博客
07-12 4953
数据压缩作业：DPCM编码
DPCM 压缩系统的实现和分析
qq_43850979的博客
04-25 277
DPCM 压缩系统的实现和分析一. DPCM编解码1. 原理2. 注意事项二. DPCM编码器1. 代码实现2. 图像展示3. 概率分布图三. 仅进行熵编码 PK DPCM+熵编码1. 压缩比2. 压缩图像质量-PSNR四. 总结 一. DPCM编解码 1. 原理 预测编码：利用信源相邻符合之间的相关性 ➢ 根据某一模型利用以往的样本值对新样本进行预测，然后将样本的实际值与其预测值相减得到一个误差值，最后对这一误差值进行编码。 ➢ 如果模型足够好，且样本序列在时间上相关性较强，则误差信号的幅度将远远小于原始
通信原理板块——差分脉码调制（DPCM）和自适应差分脉码调制（ADPCM）
最新发布
小灰灰的FPGA的博客
11-11 445
预测编码中，每个抽样值不是独立地编码，而是先根据前几个抽样值计算出一个预测值，再取当前抽样值和预测值之差。预测编码为了利用邻近抽样值的相关性获得压缩效果，需要存储过去的抽样值，以便计算和当前抽样值的相关性，故是一种有记忆的编码。编码器的输入是原始模拟语音信号m(t),在时刻kTs被抽样，抽样信号为mk，其中Ts为抽样间隔时间，k为整数。在差分脉冲编码调制DPCM中，只将前一个抽样值当作预测值，再取当前抽样值和预测值之差进行编码并传输。利用前面的几个抽样值的线性组合来预测当前的抽样值，称为线性预测。
DPCM差分预测编码的原理即实现
weixin_48318588的博客
05-05 1213
一 DPCM原理 如下图所示为原理实现图 由原理图中不难得出整个实现的过程，以本次实验为例，本次实验对图像的各个像素点进行压缩，并且采用左侧预测的方法，即每一个像素点的值输入后，与左边前一个像素点的预测值进行相减，随后经过量化与反量化得到差值，而后用来更新当前的预测值，并为下一个进来的值做准备，那么这个原理的实现过程中，误差的产生主要集中于量化与反量化之间产生的误差，采用不同的量化方式时误差也会不同，举一个实际的例子： 比如当前点灰度值为127，当前预测值为120，则dn为7 采用八比特量化，于是先除以二
dpcm算法研究 语音压缩编码算法：差分脉冲编码调制算法的实现
06-30
它基于预测编码原理，通过预测当前采样值并仅编码预测误差来实现数据压缩。DPCM的核心思想是减少需要传输或存储的信息量，同时尽可能保持信号的质量。 在本项目中，DPCM算法被实现并用Matlab编程语言进行演示。...
DPCM.zip_C8051F360_单片机 压缩_语音算法
09-22
总的来说，DPCM语音压缩在C8051F360单片机上的应用展示了嵌入式系统在音频处理中的潜力，同时也揭示了如何在资源受限的环境中实现高效的数据压缩，这对于物联网(IoT)、移动通信和各种便携式设备来说具有重要意义。
差分脉冲编码调制算法研究 ： 用Matlab实现DPCM算法
06-12
本文件详细介绍了如何利用Matlab环境来实现DPCM算法，包括编码和解码过程，并通过实验分析了其性能。 DPCM的核心思想是通过对原始信号的差分进行量化，而不是直接量化原始信号本身。它基于预测模型，预测下一个样本...
信源编码课程实验三：量化
LLcannotcode的博客
11-16 2663
实验要求 （1）使用uqimg_enc.c和uqimg_dec.c对图像进行均匀量化编解码。 （2）使用vqimg_enc.c和vqimg_dec.c对图像进行矢量量化编解码。 实验内容 1、均匀量化 uqimg_enc.c程序获取灰度图像（8 bits/pixel）和使用均匀量化以有损方式压缩它。量化器标签使用固定长度代码编码。可以使用可变长度对输出进行进一步编码进一步压缩的编码器。量化器的步长是最大值和最小值之间的差值除以级别数。最大值和最小值可由用户指定。默认值为255和0...
基于HSV非均匀量化直方图的图像检索
05-05
基于HSV非均匀量化直方图的图像检索算法，采用matlab编程。实验结果较传统颜色直方图要好很多。
DPCM的基本原理,DPCM就是通过预测和差分编码方式来减少冗余,实现数据压缩的目的
04-15
DPCM的基本原理 任何信号,不论语音或图像,采用直接采样-量化-编码的方式进行编码,都会发现码组之间具有很强的相关性。由于相关性的存在,传输数据中存在大量不需要传输的信息,称为冗余。 DPCM就是通过预测和差分编码方式来减少冗余,实现数据压缩的目的。
DPCM压缩系统
BIN_markie的博客
05-13 487
DPCM编解码原理、代码实现和分析
DPCM编码算法实现
tony5243的博客
05-06 787
DPCM编码原理和算法实现
DPCM压缩系统的原理及实现
weixin_45442965的博客
05-10 1425
DPCM 压缩系统 原理介绍 DPCM是差分预测编码调制的缩写，是比较典型的预测编码系统。在DPCM系统中，需要注意的是预测器的输入是已经解码以后的样本。之所以不用原始样本来做预测，是因为在解码端无法得到原始样本，只能得到存在误差的样本。因此，在DPCM编码器中实际内嵌了一个解码器，如编码器中虚线框中所示。 在一个DPCM系统中，有两个因素需要设计：预测器和量化器。理想情况下，预测器和量化器应进行联合优化。实际中，采用一种次优的设计方法：分别进行线性预测器和量化器的优化设计。 代码实现 编写代码实现量化比
数据压缩实验四（DPCM）
m0_64019609的博客
07-12 169
实验四
【数据压缩】实验四——DPCM 压缩系统的实现和分析
weixin_49587657的博客
07-16 208
DCMP编码
实验四——DPCM编码（1bit、2bit、4bit、8bit量化）
weixin_52189060的博客
04-24 4067
一.实验要求 本实验的目标是验证DPCM编码的编码效率。首先读取一个256级的灰度图像，采用自己设定的预测方法计算预测误差（本次实验报告使用左向预测），并对预测误差进行8比特均匀量化（基本要求）。还可对预测误差进行1比特、2比特和4比特的量化设计（提高要求）。 在DPCM编码器实现的过程中可同时输出预测误差图像和重建图像。将预测误差图像写入文件并将该文件输入Huffman编码器，得到输出码流、给出概率分布图并计算压缩比。将原始图像文件输入Huffman编码器，得到输出码流、给出概率分布图并计算压缩比。.
信号均匀量化和误差
热门推荐
Fleargwe
06-26 1万+
    将模拟声频信号经过采样以后变成在时间上离散的脉冲序列信号，每一个脉冲幅度的大小都等于采样瞬间的模拟信号的幅度值，用来描述这个量所需要的位数，理论上来说应该是无限大的。也就是说，这时的采样脉冲序列（PAM）在幅值上仍然是连续的模拟信号。    模拟信号数字化过程中的量化，实际上就是将采样后得到的PAM脉冲序列以一定的单位进行度量，并以整数倍的数值来标识的过程。换句话说，就是将信号的连续幅度分...
MATLAB实现DPCM编码解码系统详解与仿真分析
4. 数据分析：根据实验结果和波形，学生将分析系统的性能，包括但不限于编码效率、误码率和抗噪性，以此来验证理论知识，并优化设计。 5. 文档编写：撰写课程设计报告时，需包含清晰的步骤描述、关键代码片段、结果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值