H.264中整数DCT变换，量化，反量化，反DCT究竟是如何实现的？(无代码，无真相)

最新推荐文章于 2022-11-05 18:55:15 发布
最新推荐文章于 2022-11-05 18:55:15 发布
阅读量2w 收藏 34
点赞数 7
分类专栏： S1: C/C++ s6: 视频研究
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/8119041
版权

        H.264中采用的是整数DCT变换，在实现的时候，该变换和量化又杂糅在一起，那么这些错综复杂的关系究竟是怎样纠缠的呢？在参考H.264乐园论坛会员cs1860wd的帖子和H.264 and MPEG-4 VIDEO COMPRESSION(第一版)这本书后，基于帖子和书上的讲解，给出相应的实现代码，并验证代码的正确性.

 

        还是以foreman视频第一帧第一个宏块第一个4*4块为例. 下面给出像素值：

====================== Y Data ======================
+----------------+----------------+----------------+----------------+
| 43,216,254,249,|251,254,254,253,|251,252,254,254,|254,254,254,253,|
| 49,198,193,211,|228,205,213,185,|211,207,186,248,|198,203,208,183,|
| 48,194,177,171,|197,173,185,136,|191,195,138,179,|142,176,177,135,|
| 46,214,225,169,|177,189,198,160,|203,208,177,165,|173,196,191,156,|
+----------------+----------------+----------------+----------------+
| 41,185,208,180,|203,228,226,200,|214,226,225,227,|228,225,224,210,|
| 31,130,173,178,|215,230,221,212,|220,229,227,228,|229,227,226,226,|
| 29,119,194,216,|211,213,219,222,|225,223,220,219,|218,218,218,218,|
| 25,126,219,224,|217,224,227,227,|227,226,225,224,|220,220,221,222,|
+----------------+----------------+----------------+----------------+
| 26,131,215,223,|226,225,225,225,|225,226,223,219,|221,221,219,220,|
| 30,136,216,226,|223,224,225,225,|224,221,217,221,|222,219,220,226,|
| 30,136,216,227,|224,224,225,223,|221,218,221,216,|211,224,224,211,|
| 29,135,217,225,|222,221,222,222,|221,209,181,155,|186,210,186,164,|
+----------------+----------------+----------------+----------------+
| 29,134,216,224,|226,230,230,227,|206,177,146,113,|149,162,147,150,|
| 29,135,219,231,|225,201,190,185,|163,144,153,140,|127,143,165,184,|
| 30,139,210,192,|165,142,134,133,|143,141,129,138,|150,178,201,207,|
| 30,125,166,145,|144,154,132,111,|118,161,175,180,|204,214,213,209,|
+----------------+----------------+----------------+----------------+

 

           该块的预测值为128（16个位置都是128），之前分析过，在JM8.6中，这一块在编码端和解码端的QDCT均为：

         9   -12   -11   -5

         3    -3      1     0 

         3    -1     -2     1

         0     0      0     0

 

         且用H.264visa从码流中得到的DCT系数为：（注意解码端的DCT与编码端的DCT必然不同）

====================== Y Data ======================
+------------------------+------------------------+------------------------+------------------------+
| 2304,-3840,-2816,-1600,|  768,  640, -256,  640,| 1280,  320,  256, -640,|  768, -320, -768,    0,|
|  960,-1200,  320, 0,|    0,    0,  320,    0,| -640, -800,    0,    0,|  960, -800,  320,    0,|
|  768, -320, -512,  320,|  512, -640,    0, -320,| -768,  320, -512,  320,|  768,    0,  256,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,|    0,  400,    0,    0,| -320,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+
|-1024,-5120,-1792, -640,| 2560, -640, -256,    0,|  512,    0,    0,    0,|    0,    0,    0,    0,|
|    0, 1200, -640, -400,| -320,  400,    0,    0,|  640,    0,    0,    0,|  320,    0,    0,    0,|
|  512,    0, -256,    0,|    0,    0,    0,    0,|    0,    0,    0,    0,|    0,    0,    0,    0,|
|  320,    0,    0,    0,| -320,    0,    0,    0,|    0,    0,    0,    0,|    0,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+
|    0,  320,    0,    0,|    0,    0,    0,    0,| -768,  640,    0,    0,|  512,    0, -256,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,|  640, -800,    0,    0,| -640, -400,  320,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,| -256,  320,    0,    0,|    0,  320,    0,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,|  320, -400,    0,    0,| -320,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+
| -512,  640, -256,    0,|    0,    0,    0,    0,| 1024, -320, -256,    0,| 1024, -320,    0,    0,|
|  960,-1200,  320,    0,|  960, -800,  320,    0,|-1280,  800,    0,  400,| -640,  400,    0,    0,|
| -512,  320,    0,    0,|    0,    0, -256,    0,|    0,    0, -256,    0,|  512,  640,    0,    0,|
|    0,    0,    0,    0,| -320,    0,    0,    0,| -640,  800,    0,    0,|    0,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+

 

           下面根据变换，量化，反量化和反变换公式给出如下程序，看看是否与上述数据一致.(需要特别指出的是：JM8.6中并不是这么实现的，但本质是相同的，最后结果也一样.)

 

#include <iostream>
#include <cmath>
#define BLOCK_SIZE 4
using namespace std;

int QP = 28; // 量化参数

//原始的YUV矩阵
int orgYUV[BLOCK_SIZE][BLOCK_SIZE] =
{
	43, 216, 254, 249,
    49, 198, 193, 211,
    48, 194, 177, 171,
    46, 214, 225, 169
};

//预测值矩阵
int predYUV[BLOCK_SIZE][BLOCK_SIZE] =
{
	128, 128, 128, 128,
	128, 128, 128, 128,
	128, 128, 128, 128,
	128, 128, 128, 128
};

int D[BLOCK_SIZE][BLOCK_SIZE];  //中间矩阵
int Di[BLOCK_SIZE][BLOCK_SIZE]; //中间矩阵

int W[BLOCK_SIZE][BLOCK_SIZE];  //核矩阵
int Z[BLOCK_SIZE][BLOCK_SIZE];  //QDCT矩阵
int Wi[BLOCK_SIZE][BLOCK_SIZE]; //Wi矩阵

int Xi[BLOCK_SIZE][BLOCK_SIZE]; //解码的残差矩阵

//Cf矩阵
int Cf[BLOCK_SIZE][BLOCK_SIZE]=
{
    1, 1,  1, 1,
    2, 1, -1, -2,
    1,-1, -1, 1,
    1,-2,  2, -1
};

//Ci矩阵      
int Ci[BLOCK_SIZE][BLOCK_SIZE]=
{
    2,  2,  2,  1,
    2,  1, -2, -2,
    2, -1, -2,  2,
    2, -2,  2, -1
};

//MF矩阵
int MF[6][3]=
{
    13107, 5243, 8066,
    11916, 4660, 7490,
    10082, 4194, 6554,
    9362,  3647, 5825,
    8192,  3355, 5243,
    7282,  2893, 4559
};

//Qstep矩阵
int V[6][3]=
{
    10, 16, 13,
    11, 18, 14,
    13, 20, 16,
    14, 23, 18,
    16, 25, 20,
    18, 29, 23
};

//矩阵转置
void matrixTransform(int a[][BLOCK_SIZE])
{
	int i, j, tmp;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			if(i < j)
			{
				tmp = a[i][j];
				a[i][j] = a[j][i];
				a[j][i] = tmp;
			}
		}
	}
}

//矩阵求差
void  matrixSubtract(int a[][BLOCK_SIZE],int b[][BLOCK_SIZE])
{
    int i, j;
    for(i = 0;i < BLOCK_SIZE; i++)
	{
        for(j = 0; j < BLOCK_SIZE; j++)
        {
            a[i][j] -= b[i][j];
		}
	}
}

//矩阵求积
void  matrixMultiply(int a[][BLOCK_SIZE],int b[][BLOCK_SIZE],int c[][BLOCK_SIZE])
{
	int i, j, k;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			c[i][j] = 0;
			for(k = 0; k < BLOCK_SIZE; k++)
			{
				c[i][j] += a[i][k] * b[k][j];  
			}
		}
	}      
}

//矩阵显示
void matrixShow(int a[][BLOCK_SIZE])
{
    int i, j;
    cout << "*****************************" << endl;
    for(i = 0; i < BLOCK_SIZE; i++)
	{
        for(j = 0; j < BLOCK_SIZE; j++)
        {
            cout << a[i][j] << "\t";
        }
		cout << endl;
	}

    cout << "*****************************" << endl << endl;
}

//求QDCT
void quantizeDCT(int W[][BLOCK_SIZE])
{
	// QP决定了qbits和f, QP和位置(i, j)共同决定了mf
	int qbits = 15 + floor(QP / 6);
	int f = (int)( pow(2.0, qbits) / 3 );
	int mf;

	int i, j, k;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			//以下均依公式实现
			
			//(0, 0), (2, 0), (0, 2), (2, 2)  mf为 MF[QP % 6][0]
			//(1, 1), (3, 1), (1, 3), (3, 3)  mf为 MF[QP % 6][1];
			// other positions                mf为 MF[QP % 6][2];

			if((0 == i || 2 == i) && (0 == j || 2 == j))
				k = 0;
			else if((1 == i || 3 == i) && (1 == j || 3 == j))
				k = 1;
			else
				k = 2;

			mf = MF[QP % 6][k];
              
			Z[i][j] = ( abs(W[i][j]) * mf + f ) >> qbits;

			if(W[i][j] < 0)
				Z[i][j] = -Z[i][j];
		} 
		
	}
}

//求Wi(即解码端的DCT) (Z为QDCT)
void reverseQuantize(int Z[][BLOCK_SIZE])
{     
	int t = floor(QP / 6);                
	int f = (int)pow(2, t); 
	int v;
	
	int i, j, k;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			//以下均依公式实现
			  
			if((0 == i || 2 == i) && (0 == j || 2 == j))
				k = 0;
			else if((1 == i || 3 == i) && (1 == j || 3 == j))
				k = 1;
			else
				k = 2;

			v = V[QP % 6 ][k];
			Wi[i][j] = Z[i][j] * v * f;
		}
	}
}

int main()
{
	matrixSubtract(orgYUV, predYUV);
	cout << "Residual matrix is" << endl;
    matrixShow(orgYUV);

	//此时orgYUV变为残差矩阵
    matrixMultiply(Cf, orgYUV, D);
    matrixTransform(Cf);
    matrixMultiply(D, Cf, W);        

	//得到的W即为核
	cout << "Matrix Core（W） is" << endl;
    matrixShow(W);

	//利用核W来得到QDCT（Z）
    quantizeDCT(W);
	cout << "Matrix QDCT(Z) is" << endl;
    matrixShow(Z);
  
    //利用QDCT(Z)得到解码端的DCT(Wi).(Wi与编码端DCT必然不同）
    reverseQuantize(Z);
	cout << "Matrix W'(解码端DCT) is" << endl;
    matrixShow(Wi);

    //利用Wi得到解码的残差矩阵Xi
    matrixMultiply(Ci, Wi, Di); 
	matrixTransform(Ci);        
    matrixMultiply(Di, Ci, Xi);
	int i,j;
    for(i = 0;i < 4; i++)
	{
        for(j = 0; j < 4; j++)
		{
			Xi[i][j] = int( Xi[i][j] / 256.0 + 0.5 );
		}
	}
	cout << "Matrix Xi(解码端残差) is" << endl;
    matrixShow(Xi);

	return 0;
}



           结果为：(可以看出，结果中的QDCT和解码端的DCT都与之前的数据吻合，从而证明上面程序的实现是正确的.)

 

Residual matrix is
*****************************
-85     88      126     121
-79     70      65      83
-80     66      49      43
-82     86      97      41
*****************************

Matrix Core（W） is
*****************************
609     -1255   -685    -560
277     -476    113     -73
175     -159    -119    98
-14     -13     4       1
*****************************

Matrix QDCT(Z) is
*****************************
9       -12     -11     -5
3       -3      1       0
3       -1      -2      1
0       0       0       0
*****************************

Matrix W'(解码端DCT) is
*****************************
2304    -3840   -2816   -1600
960     -1200   320     0
768     -320    -512    320
0       0       0       0
*****************************

Matrix Xi(解码端残差) is
*****************************
-77     88      132     110
-80     63      67      77
-82     62      48      39
-79     87      93      32
*****************************

           下面，简要看看整数DCT变换的原理.(关于整数DCT变换公式的推倒，请参考余兆明的《图像编码标准H.264技术》). 

          

           DCT变换为:      DCT = A * X * At

           量化为:           QDCT =  floor(DCT/Qstep)

           反量化为:        DCT‘  = QDCT * Qstep

           反DCT为:              X’ = At * DCT‘ * A

 

           但在H.264中采用的是整数DCT, 在JM8.6中的实现方式也很有讲究：( .* 表示矩阵对应元素相乘)

          整数DCT变化为：       DCT = (Cf * X *Cft) .*Ef 

          量化为：                    QDCT = floor(DCT/Qstep)

          反量化为：                  DCT‘ = QDCT * Qstep

          整数反DCT变换为：        X’ = Ci * (DCT‘ .* Ei) *Ci

 

          在实现的时候，经常不直接得到DCT系数，而是将变换和量化结合在一起实现. 整数DCT变换有很多好处：没有除法，没有浮点数，所以高效且准确，而且减少了矩阵运算.    

        

           最后感慨一下：如果上面的程序用matlab来仿真，就简单多了，matlab太适合处理矩阵问题了.

 

 

 

涛歌依旧
关注
  • 7
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 17
    评论
专栏目录
Matlab DCT详解
三哥的博客
09-29 6万+
DCT变换DCT又称离散余弦变换，是一种块变换方式，只使用余弦函数来表达信号，与傅里叶变换紧密相关。常用于图像数据的压缩，通过将图像分成大小相等（一般为8*8）的块，利用DCT对其进行变换，得到更加简洁的数据。因为图像像素间存在较大的空间相关性，DCT可以大大减小这些相关性，使图像能量集中在左上角区域，从而利于数据压缩。变换后得到的数据称为DCT系数。这一过程是无损的。二维DCT变换这里来看看二维D
论文研究-基于整数变换的H.264标准量化过程.pdf
07-22
详细地分析了两大标准化组织最新提出的视频编码国际标准H.264中的整数变换及量化过程。H.264视频编码的基本框架类似于当前流行的视频编码标准，采用变换编码和预测编码的混合编码技术，其优异的性能来源于引入的4×4...
一文搞懂H264量化原理以及计算过程
qq_42139383的博客
06-30 5494
1.概述 量化是使数据比特率下降的有效工具。量化过程的输入值动态范围很大，需要较多的比特才能表示一个数值，量化后的输出则只需要较小比特表示。 量化是不可逆过程，处理过程中有信息丢失，存在量化误差。 H.264采用标量量化技术，它将每个图像样点编码映射成较小的数值。一般标量量化器的原理为： FQ=round(y/QP)FQ=round(y/QP)FQ=round(y/QP) 其中，y 为输入样本点编码，QP 为量化步长，FQ 为 y 的量化值，round()为取整函数（其输出为与输入实数最近的整数） 在量化和
H.264的整数DCT变换编码与量化过程
08-17
H.264的整数DCT变换编码与量化过程
视频压缩编码问与答
comhere的专栏
04-04 9812
1、什么是H.261编码协议        答：H.261是最早出现的视频编码建议，它采用的算法结合了可减少时间冗余的帧间预测和可减少空间冗余的DCT变换的混合编码方法，其输出码率是p×64kbit/s。p取值较小时，只能传清晰度不太高的图像，适合于面对面的电视电话；p取值较大时（如 p＞6），可以传输清晰度较好的会议电视图像。该标准主要针对ISDN电话线的视频会议，可视电话等，ISDN的基本
JPEG图片存储格式及原理
huangxy10的专栏
10-27 3万+
JPEG是联合图象专家组(Joint Picture Expert Group)的英文缩写，是国际标准化组织(ISO)和CCITT联合制定的静态图象的压缩编码标准。和相同图象质量的其它常用文件格式(如GIF，TIFF，PCX)相比，JPEG是目前静态图象中压缩比最高的。我们给出具体的数据来对比一下。例图采用Windows95目录下的Clouds.bmp，原图大小为640*480，256色。用工具S
H263&H264&MPEG4
weixin_33694172的博客
03-24 629
1.H263　　H.263历史　　H.263是国际电联ITU-T的一个标准草案，是为低码流通信而设计的。但实际上这个标准可 用在很宽的码流范围，而非只用于低码流应用，它在许多应用中可以认为被用于取代H.261。H.263的编码算法与H.261一样，但做了一些改善和改 变，以提高性能和纠错能力。.263标准在低码率下能够提供比H.261更好的图像效果，两者的区别有：(1)H.263的运动补偿使用...
DCT变换编码matlab,图像压缩编解码实验(DCT编码+量化+熵编码(哈夫曼编码))【MATLAB】...
weixin_39846364的博客
03-17 1317
Input: an intra-frame or a residue picture after motion compensation.Task: Code the input picture into a bitstream and decode the picture from the generated bitstream.Specifications: Implement a tran...
【编解码：H.264原理浅析】
weixin_47852035的博客
11-05 527
H264原理
H264量化
workspace
11-29 2436
前言 残差矩阵经过整数DCT变换后即需要对变换后的DCT系数进行量化操作。且注意：前期DCT变换Mn⋅X⋅MnTM_n·X·M_n^TMn​⋅X⋅MnT​以及优化成了整数DCT变换Cf⋅X⋅CfT⨂SfCf·X·Cf^T\bigotimes SfCf⋅X⋅CfT⨂Sf，其中的⨂Sf\bigotimes Sf⨂Sf动作放到了量化的过程中实现。 规定 QP是量化参数，是量化步长Qstep的编号，...
H.264 VS H.265 变换编码及量化过程分析（2）
biaobiao009的专栏
07-19 1487
量化是视频编码中产生失真的根本原因，它同时影响着编码质量和比特率。 Quantize原理 Quantization parameter and step Quantization在编码中的应用 Quantization在编码中的实现 Quantization在编码中，不同系数采用的方案 Quantization在编码中，优化方案 Quantization在编码中，涉及的码流参数 Quantize原理 量化是指将信号的连续取值，映射为有限多个离散幅值的过程，实现信号多对一的映射。量.
H.264_AVC整数DCT变换与量化的FPGA实现.pdf
07-13
H.264_AVC整数DCT变换与量化的FPGA实现.pdf
H264-DCT-Quanter.rar_H.264_H.264 quantization _dct_h264_x264
09-19
H264中的整数DCT变换编码及量化代码,并附有原文的DCT编码、量化的说明文档。本源码从X264及JM中抽取后整理得来，并用原文档中的示例数据进行了测试，与原文档结果完全一样，是学习H.264不可多得的参考资源.
基于H.264的DCT变换系数解码的FPGA实现 (2010年)
05-27
根据H.264码流解码过程中整数DCT逆变换逆量化的算法原理,优化设计出一种基于FPGA的新型解决方案。设计采用VHDL和C语言相结合的编程方式,其中源数据的获取和分析在NIOSII软核处理器中用C编程完成,各高效算法则用硬件...
H.264中IPCM宏块简介
热门推荐
认知 行动 坚持
11-19 7万+
在H.264中，一个宏块包括16*16个像素，I宏块有三种形式： 1. 16个I4x4编码方式组成的宏块(为了方便，简称I4x4方式的宏块); 2. I16x16宏块; 3. IPCM宏块（特殊） 为什么一个宏块有时要分成16个I4x4方式的宏块呢？因为分块越细，就越准确，所以I4x4编码方式适合编码那些纹理比较复杂的宏块，而
也谈matlab中读取视频的一个重要函数mmreader
认知 行动 坚持
12-31 2万+
在matlab中输入help mmreader来查阅一下该函数，有如下信息： MMREADER Create a multimedia reader object. OBJ = MMREADER(FILENAME) constructs a multimedia reader object, OBJ, that can read in video data from
H.264中NALU、RBSP、SODB的关系 (弄清码流结构)
认知 行动 坚持
11-25 2万+
NALU：Coded H.264 data is stored or transmitted as a series of packets known as NetworkAbstraction LayerUnits.（NALU单元） RBSP ：A NALU contains a Raw Byte Sequence Payload, a sequence of by
视频资源下载网站汇集
认知 行动 坚持
10-22 2万+
H.264/AVC Reference Software （Joint Model）下载网站： http://iphome.hhi.de/suehring/tml/download/old_jm/
matlab对图像dct变换和添加量化环节
最新发布
06-28
### 回答1： MATLAB可以使用dct2函数对图像进行DCT变换，该函数将图像分块并对每个块进行DCT变换。例如，以下代码将对名为img的图像进行8x8块的DCT变换： ```matlab img_dct = dct2(img, [8 8]); ``` 添加量化环节可以通过将DCT系数除以一个量化矩阵来实现。例如，以下代码将使用名为q_mtx的8x8量化矩阵对DCT系数进行量化： ```matlab q_mtx = [16 11 10 16 24 40 51 61; 12 12 14 19 26 58 60 55; 14 13 16 24 40 57 69 56; 14 17 22 29 51 87 80 62; 18 22 37 56 68 109 103 77; 24 35 55 64 81 104 113 92; 49 64 78 87 103 121 120 101; 72 92 95 98 112 100 103 99]; img_quantized = round(img_dct ./ q_mtx); ``` 在这个例子中，我们使用了JPEG标准中的量化矩阵。注意，我们使用了round函数来将量化后的系数四舍五入到最接近的整数。 ### 回答2： MATLAB可以通过内置函数实现图像的DCT变换和添加量化环节，下面进行详细介绍。 DCT变换 DCT（离散余弦变换）是一种基于余弦函数的信号处理方法，它可以将图像从时域（空间域）转换到频域，得到其重要特征，是图像编码和压缩中常用的一种手段。MATLAB内置了dct2函数，可以直接进行二维DCT变换。具体步骤如下： 1. 读取图像数据 image = imread('lena.jpg'); 2. 将图像转换为灰度图像 gray_img = rgb2gray(image); 3. 对灰度图像进行DCT变换 dct_img = dct2(gray_img); 4. 对DCT变换后的图像进行反变换得到重构后的图像 recon_img = idct2(dct_img); 添加量化环节 DCT变换后的图像数据为浮点数，需经过量化后转换为整数，以便进行压缩。MATLAB提供了两种量化方法：均匀量化和非均匀量化。均匀量化需要指定量化步长，而非均匀量化需要指定量化表。这里以均匀量化为例，具体步骤如下： 1. 设定量化步长 Q = 1; % 量化步长 2. 计算量化矩阵 quant_mat = Q * floor(dct_img/Q + 0.5); 3. 对量化矩阵进行反量化，得到反量化后的图像 recon_quant_mat = quant_mat/Q; 4. 将反量化后的图像进行反变换，得到重构后的图像 recon_quant_img = idct2(recon_quant_mat); 以上即为MATLAB对图像DCT变换和添加量化环节的实现方法，通过这些步骤可以对图像进行编码压缩。 ### 回答3： DCT（离散余弦变换）是一种在图像处理中广泛应用的数学变换方法，MATLAB是图像处理领域中最常用的工具，自然也对DCT变换有不少的支持。在MATLAB中，可以使用“dct2”函数进行二维DCT变换。 在对图像进行DCT变换之后，为了压缩图像并减小数据量，我们需要进行量化。量化是将数值分组并用一个可表示的数字进行代表的过程。在MATLAB中，可以使用“quantization”函数来实现量化。在量化过程中，需要选择一个合适的量化系数，以获得更好的效果。 在添加量化环节之后，图像中的数据被大幅压缩，只有量化系数中的数据被保留下来。这样可以减少数据的存储空间，使得图像文件的大小变得更小。但同时也会降低图像的质量，因为一些信息被削减了。 综上所述，MATLAB对图像的DCT变换和添加量化环节的支持非常完善。使用MATLAB进行图像压缩和处理，可以使我们的工作更加方便快捷。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值