H.264 Quantization

最新推荐文章于 2025-02-21 08:30:28 发布
转载 最新推荐文章于 2025-02-21 08:30:28 发布 · 1.1k 阅读 · 0

本文深入探讨H.264视频压缩标准中的量化器原理，包括量化步长、量化偏移量等关键概念及其对图像质量和压缩效率的影响。介绍了量化矩阵的设计方法以及非一致性量化对图像真实感提升的作用。

H.264 Quantizer

一般的量化器，可用下面的公式来表示：

Z=±⌊|W|△⌋

反量化可表示为：

W′=△⋅Z

量化步长△

决定了量化器的编码压缩率与图像精度。如果△比较大，相应的编码长度较小，图像细节损失较多；如果△比较小，相应的编码长度较大，图像损失细节较少。编码器需根据实际图像来改变△

值。

 

Quantization Offset

可以看到，这种量化器是求下整，也就是会把区间[0,△)

的值量化成0。这种量化器显然不是最优的，最优的量化器在某区间上的量化值应该为该区间的期望值。为此需要知道残差变换系数的统计分布，这个分布是经过统计实验得出来的，其中帧间比帧内分布得更为集中。

为了表明分布集中于区间的期望值，引入了参数——offset（量化偏移量）f

。相应的量化公式变为：

Z=±⌊|W|+f△⌋

反量化保持不变:

W′=±(△⋅Z)

H.264参考模型建议：当帧内预测时f=△/3

，帧间预测时f=△/6

。

 

另外参数f

可以控制量化死区（量化后为0区域）大小。

当f

变大时，量化死区减少；当f变小时，量化死区增加。死区大小可以直接影响到视频图像的主观质量。变换后，图像高频部分的数值比较小，也就是说离0值比较接近。如果死区比较大，0值附近的值会被量化为0，则图像会损失这些细节。这个特性在电影中特别有用：在电影胶片上会随机分布着一些斑点，这些斑点是胶片化学物质的结晶体，由于这些斑点与视频的内容在时间、空间上的不相关性，其值没法在预测模块中预测到。因此这些斑点表现为变换后的一些小的高频系数。为了消除这些斑点，可取较小的f值，这样量化死区就会较大。在字幕区域的细节比较多，可对字幕区域取比较大的f

值。

从上方的例子可以看出，死区特征的应用是与应用直接相关的，最好能根据不同的应用相应加以调整。

我们注意到通过参数f

可以控制量化区间的偏移，以及控制死区大小。两者耦合在一起了。JVT-K026有个直接的解耦方法：加入一个新的参数Θ

来控制量化死区的大小，并将量化公式修改为：

Z=±⌊|W|+Θ+f△⌋

W′=±(△⋅Z−Θ)

但是这种方法并没有被标准采用。

 

Quantization Step

H．264标准共设计了52个不同的量化步长Qstep

，如下表所示，其中QP是量化参数，也就是量化步长的序号。QP由小变大，意味着量化步长的增大，也就是由精细变粗糙。

QP

Qstep

QP

Qstep

QP

Qstep

QP

Qstep

QP

Qstep

0

0.625

12

2.5

24

10

36

40

48

160

1

0.6875

13

2.75

25

11

37

44

49

176

2

0.8125

14

3.25

26

13

38

52

50

208

3

0.875

15

3.5

27

14

39

56

51

224

4

1

16

4

28

16

40

64

  

5

1.125

17

4.5

29

18

41

72

  

6

1.25

18

5

30

20

42

80

  

7

1.375

19

5.5

31

22

43

88

  

8

1.625

20

6.5

32

26

44

104

  

9

1.75

21

7

33

28

45

112

  

10

2

22

8

34

32

46

128

  

11

2.25

23

9

35

36

47

144

  

 

Qstep

变化有明显的规律：QP每增加1，量化步长就增加12.25%（即2√6−1）;QP每增加6，量化步长就增加一倍，即Qstep(QP+6)=2Qstep(QP)。这样做就可以显著减少量化表与反量化表的大小，仅用0~5这6个QP的Qstep，通过右移就可以得到剩下所有的Qstep，即Qstep(QP)=Qstep(QP%6)⋅2QP/6

。

在讲述变换的时候说过，变换的⨂

运算矩阵Ef

可以合并到量化表中。下面来看一下该运算矩阵

Ef[i][j]=⎡⎣⎢⎢⎢⎢⎢a212aba212ab12ab14b212ab14b2a212aba212ab12ab14b212ab14b2⎤⎦⎥⎥⎥⎥⎥

得到量化矩阵所进行的合并运算如下(归一化为215

)

Q(QP,i,j)=Ef[i][j]Qstep(QP)×215+QP/6=Ef[i][j]Qstep(QP%6)×2QP/6×215+QP/6=Ef[i][j]Qstep(QP%6)⋅215

上式表明Q(QP,i,j)=Q(QP%6,i,j)

以Q(0,0,0)

为例，

Q(0,0,0)=a2Qstep(QP)×215=0.250.625×215=13107

 

把0~5这6个QP的Qstep

分别与⨂运算矩阵Ef合并后，可以得到以下6个矩阵，即Q(QP%6,i,j)


Q(0,i,j)=⎡⎣⎢⎢⎢13107806613107806680665243806652431310780661310780668066524380665243⎤⎦⎥⎥⎥

Q(1,i,j)=⎡⎣⎢⎢⎢11916749011916749074904660749046601191674901191674907490466074904660⎤⎦⎥⎥⎥

Q(2,i,j)=⎡⎣⎢⎢⎢10082655410082655465544194655441941008265541008265546554419465544194⎤⎦⎥⎥⎥

 

Q(3,i,j)=⎡⎣⎢⎢⎢9362582593625825582536475825364793625825936258255825364758253647⎤⎦⎥⎥⎥

Q(4,i,j)=⎡⎣⎢⎢⎢8192524381925243524333555243335581925243819252435243335552433355⎤⎦⎥⎥⎥

Q(5,i,j)=⎡⎣⎢⎢⎢7282455972824559455928934559289372824559728245594559289345592893⎤⎦⎥⎥⎥

 

在Ef

矩阵中，可以看到里面有3个数值a2,ab,b2，合并到量化矩阵后，就有3×52=156个参数。采用了上面的QP每增加6，量化步长增加一倍的方法后，参数就只有3×6=18

个参数：

QuantMatrix[6][3]=⎡⎣⎢⎢⎢⎢⎢⎢⎢⎢131071191610082936281927282524346604194364733552893806674906554582552434559⎤⎦⎥⎥⎥⎥⎥⎥⎥⎥

 

 

采用量化矩阵的方式后，4x4整数DCT变换的量化公式为

 

Zij=Yij⨂Ef[i][j]+f′Qstep(QP)=Yij⨂Ef[i][j]+fQstep(QP%6)÷2QP/6=Yij⨂Q(QP%6,i,j)÷215+QP/6

 

同样道理，逆量化矩阵为(归一化为210

)：

R(QP,i,j)=ERf[i][j]×Qstep(QP)×210−QP/6=ERf[i][j]×Qstep(QP%6)×2QP/6×210−QP/6=ERf[i][j]×Qstep(QP%6)×210

上式表明R(QP,i,j)=R(QP%6,i,j)

逆量化公式为：

Y′ij=Zij⨂ERf[i][j]×Qstep=Zij⨂R(QP%6,i,j)÷210−QP/6

逆量化矩阵为

dequantMat[6][3]=⎡⎣⎢⎢⎢⎢⎢⎢⎢⎢160176208224256288256288320368400464208224256288320368⎤⎦⎥⎥⎥⎥⎥⎥⎥⎥

 

Nonuniformity Quantization

非一致性量化就是4x4或8x8矩阵上各个位置的量化权重不同，通过这种方法可以在进行量化之前调整量化步长，得到更适合人类视觉系统，更真实的图像。

加入权重矩阵Wij

后，量化矩阵与逆量化矩阵分别为：

Q(QP,i,j)=1Wij⋅Ef[i][j]Qstep(QP%6)×215+QP/6

R(QP,i,j)=Wij⋅ERf[i][j]×Qstep(QP%6)×210−QP/6

其中Wij

会被归一为16，即2<<4

 

JM18.6参考代码如下

量化矩阵：

View Code

 

量化偏移矩阵

复制代码
/*!
 ************************************************************************
 * \brief
 *    Init quantization offset parameters
 *
 * \par Input:
 *    none
 *
 * \par Output:
 *    none
 ************************************************************************
 */

void InitOffsetParam (QuantParameters *p_Quant, InputParameters *p_Inp)
{
  int i, k;
  int max_qp_luma = (4 + 6*(p_Inp->output.bit_depth[0]));
  int max_qp_cr   = (4 + 6*(p_Inp->output.bit_depth[1]));

  for (i = 0; i < (p_Inp->AdaptRoundingFixed ? 1 : imax(max_qp_luma, max_qp_cr)); i++)
  {
    if (p_Inp->OffsetMatrixPresentFlag)
    {
      memcpy(&(p_Quant->OffsetList4x4[i][0][0]),&(p_Quant->OffsetList4x4input[0][0]), 400 * sizeof(short)); // 25 * 16
      memcpy(&(p_Quant->OffsetList8x8[i][0][0]),&(p_Quant->OffsetList8x8input[0][0]), 960 * sizeof(short)); // 15 * 64
    }
    else
    {
      if (p_Inp->OffsetMatrixFlat == 1)
      {
        // 0 (INTRA4X4_LUMA_INTRA)
        memcpy(&(p_Quant->OffsetList4x4[i][0][0]),&(Offset_intra_flat_intra[0]), 16 * sizeof(short));
        for (k = 1; k < 3; k++) // 1,2 (INTRA4X4_CHROMA_INTRA)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_flat_chroma[0]),  16 * sizeof(short));
        for (k = 3; k < 9; k++) // 3,4,5,6,7,8 (INTRA4X4_LUMA/CHROMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_flat_inter[0]),  16 * sizeof(short));
        for (k = 9; k < 25; k++) // 9,10,11,12,13,14 (INTER4X4)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_inter_flat[0]),  16 * sizeof(short));
  
        // 0 (INTRA8X8_LUMA_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][0][0]),&(Offset8_intra_flat_intra[0]), 64 * sizeof(short));
        for (k = 1; k < 3; k++)  // 1,2 (INTRA8X8_LUMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_flat_inter[0]),  64 * sizeof(short));
        for (k = 3; k < 5; k++)  // 3,4 (INTER8X8_LUMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_flat[0]),  64 * sizeof(short));
  
        // 5 (INTRA8X8_CHROMAU_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][5][0]),&(Offset8_intra_flat_chroma[0]), 64 * sizeof(short));
        for (k = 6; k < 8; k++)  // 6,7 (INTRA8X8_CHROMAU_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_flat_inter[0]),  64 * sizeof(short));
        for (k = 8; k < 10; k++)  // 8,9 (INTER8X8_CHROMAU_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_flat[0]),  64 * sizeof(short));

        // 10 (INTRA8X8_CHROMAV_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][10][0]),&(Offset8_intra_flat_chroma[0]), 64 * sizeof(short));
        for (k = 11; k < 13; k++)  // 11,12 (INTRA8X8_CHROMAV_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_flat_inter[0]),  64 * sizeof(short));
        for (k = 13; k < 15; k++)  // 8,9 (INTER8X8_CHROMAV_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_flat[0]),  64 * sizeof(short));
      }
      else if (p_Inp->OffsetMatrixFlat == 2)
      {
        // 0 (INTRA4X4_LUMA_INTRA)
        memcpy(&(p_Quant->OffsetList4x4[i][0][0]),&(Offset_intra_default_intra[0]), 16 * sizeof(short));
        for (k = 1; k < 3; k++) // 1,2 (INTRA4X4_CHROMA_INTRA)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_flat_chroma[0]),  16 * sizeof(short));
        memcpy(&(p_Quant->OffsetList4x4[i][3][0]),&(Offset_intra_default_inter[0]),  16 * sizeof(short));
        for (k = 4; k < 6; k++) // 4,5 (INTRA4X4_CHROMA_INTERP)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_flat_inter[0]),  16 * sizeof(short));
        memcpy(&(p_Quant->OffsetList4x4[i][6][0]),&(Offset_intra_default_inter[0]),  16 * sizeof(short));
        for (k = 7; k < 9; k++) // 7,8 (INTRA4X4_CHROMA_INTERB)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_flat_inter[0]),  16 * sizeof(short));
        for (k = 9; k < 25; k++) // 9,10,11,12,13,14 (INTER4X4)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_inter_default[0]),  16 * sizeof(short));
  
        // 0 (INTRA8X8_LUMA_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][0][0]),&(Offset8_intra_default_intra[0]), 64 * sizeof(short));
        for (k = 1; k < 3; k++)  // 1,2 (INTRA8X8_LUMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
        for (k = 3; k < 5; k++)  // 3,4 (INTER8X8_LUMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
  
        // 5 (INTRA8X8_CHROMAU_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][5][0]),&(Offset8_intra_flat_chroma[0]), 64 * sizeof(short));
        for (k = 6; k < 8; k++)  // 6,7 (INTRA8X8_CHROMAU_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_flat_inter[0]),  64 * sizeof(short));
        for (k = 8; k < 10; k++)  // 8,9 (INTER8X8_CHROMAU_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));

        // 10 (INTRA8X8_CHROMAV_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][10][0]),&(Offset8_intra_flat_chroma[0]), 64 * sizeof(short));
        for (k = 11; k < 13; k++)  // 11,12 (INTRA8X8_CHROMAV_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_flat_inter[0]),  64 * sizeof(short));
        for (k = 13; k < 15; k++)  // 8,9 (INTER8X8_CHROMAV_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
      }
      else
      {
        // 0 (INTRA4X4_LUMA_INTRA)
        memcpy(&(p_Quant->OffsetList4x4[i][0][0]),&(Offset_intra_default_intra[0]), 16 * sizeof(short));
        for (k = 1; k < 3; k++) // 1,2 (INTRA4X4_CHROMA_INTRA)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_default_chroma[0]),  16 * sizeof(short));
        for (k = 3; k < 9; k++) // 3,4,5,6,7,8 (INTRA4X4_LUMA/CHROMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_intra_default_inter[0]),  16 * sizeof(short));
        for (k = 9; k < 25; k++) // 9,10,11,12,13,14 (INTER4X4)
          memcpy(&(p_Quant->OffsetList4x4[i][k][0]),&(Offset_inter_default[0]),  16 * sizeof(short));
  
        // 0 (INTRA8X8_LUMA_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][0][0]),&(Offset8_intra_default_intra[0]), 64 * sizeof(short));
        for (k = 1; k < 3; k++)  // 1,2 (INTRA8X8_LUMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
        for (k = 3; k < 5; k++)  // 3,4 (INTER8X8_LUMA_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
  
        // 5 (INTRA8X8_CHROMAU_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][5][0]),&(Offset8_intra_default_chroma[0]), 64 * sizeof(short));
        for (k = 6; k < 8; k++)  // 6,7 (INTRA8X8_CHROMAU_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
        for (k = 8; k < 10; k++)  // 8,9 (INTER8X8_CHROMAU_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));

        // 10 (INTRA8X8_CHROMAV_INTRA)
        memcpy(&(p_Quant->OffsetList8x8[i][10][0]),&(Offset8_intra_default_chroma[0]), 64 * sizeof(short));
        for (k = 11; k < 13; k++)  // 11,12 (INTRA8X8_CHROMAV_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_intra_default_inter[0]),  64 * sizeof(short));
        for (k = 13; k < 15; k++)  // 8,9 (INTER8X8_CHROMAV_INTERP/INTERB)
          memcpy(&(p_Quant->OffsetList8x8[i][k][0]),&(Offset8_inter_default[0]),  64 * sizeof(short));
      }
    }
  }  
}


/*!
 ************************************************************************
 * \brief
 *    Calculation of the quantization offset parameters at the frame level
 *
 * \par Input:
 *    none
 *
 * \par Output:
 *    none
 ************************************************************************
 */
void CalculateOffset4x4Param (VideoParameters *p_Vid)
{
  QuantParameters *p_Quant = p_Vid->p_Quant;
  int k;  
  int qp_per, qp;
  int img_type = ((p_Vid->type == SI_SLICE) ? I_SLICE : (p_Vid->type == SP_SLICE ? P_SLICE : p_Vid->type));

  int max_qp_scale = imax(p_Vid->bitdepth_luma_qp_scale, p_Vid->bitdepth_chroma_qp_scale);
  int max_qp = 51 + max_qp_scale;
  InputParameters *p_Inp = p_Vid->p_Inp;

  p_Vid->AdaptRndWeight   = p_Inp->AdaptRndWFactor  [p_Vid->nal_reference_idc != 0][img_type];
  p_Vid->AdaptRndCrWeight = p_Inp->AdaptRndCrWFactor[p_Vid->nal_reference_idc != 0][img_type];

  if (img_type == I_SLICE )
  {
    for (qp = 0; qp < max_qp + 1; qp++)
    {
      k = p_Quant->qp_per_matrix [qp];
      qp_per = Q_BITS + k - OffsetBits;
      k = p_Inp->AdaptRoundingFixed ? 0 : qp;

      // Intra4x4 luma
      update_q_offset4x4(p_Quant->q_params_4x4[0][1][qp], p_Quant->OffsetList4x4[k][ 0], qp_per);
      // Intra4x4 chroma u
      update_q_offset4x4(p_Quant->q_params_4x4[1][1][qp], p_Quant->OffsetList4x4[k][ 1], qp_per);
      // Intra4x4 chroma v
      update_q_offset4x4(p_Quant->q_params_4x4[2][1][qp], p_Quant->OffsetList4x4[k][ 2], qp_per);
    }
  }
  else if (img_type == B_SLICE)
  {
    for (qp = 0; qp < max_qp + 1; qp++)
    {
      k = p_Quant->qp_per_matrix [qp];
      qp_per = Q_BITS + k - OffsetBits;
      k = p_Inp->AdaptRoundingFixed ? 0 : qp;

      // Inter4x4 luma
      update_q_offset4x4(p_Quant->q_params_4x4[0][0][qp], p_Quant->OffsetList4x4[k][12], qp_per);
      // Intra4x4 luma
      update_q_offset4x4(p_Quant->q_params_4x4[0][1][qp], p_Quant->OffsetList4x4[k][ 6], qp_per);
      // Inter4x4 chroma u
      update_q_offset4x4(p_Quant->q_params_4x4[1][0][qp], p_Quant->OffsetList4x4[k][13], qp_per);
      // Intra4x4 chroma u
      update_q_offset4x4(p_Quant->q_params_4x4[1][1][qp], p_Quant->OffsetList4x4[k][ 7], qp_per);
      // Inter4x4 chroma v
      update_q_offset4x4(p_Quant->q_params_4x4[2][0][qp], p_Quant->OffsetList4x4[k][14], qp_per);      
      // Intra4x4 chroma v
      update_q_offset4x4(p_Quant->q_params_4x4[2][1][qp], p_Quant->OffsetList4x4[k][ 8], qp_per);
    }
  }
  else
  {
    for (qp = 0; qp < max_qp + 1; qp++)
    {
      k = p_Quant->qp_per_matrix [qp];
      qp_per = Q_BITS + k - OffsetBits;
      k = p_Inp->AdaptRoundingFixed ? 0 : qp;

      // Inter4x4 luma
      update_q_offset4x4(p_Quant->q_params_4x4[0][0][qp], p_Quant->OffsetList4x4[k][ 9], qp_per);
      // Intra4x4 luma
      update_q_offset4x4(p_Quant->q_params_4x4[0][1][qp], p_Quant->OffsetList4x4[k][ 3], qp_per);
      // Inter4x4 chroma u
      update_q_offset4x4(p_Quant->q_params_4x4[1][0][qp], p_Quant->OffsetList4x4[k][10], qp_per);
      // Intra4x4 chroma u
      update_q_offset4x4(p_Quant->q_params_4x4[1][1][qp], p_Quant->OffsetList4x4[k][ 4], qp_per);
      // Inter4x4 chroma v
      update_q_offset4x4(p_Quant->q_params_4x4[2][0][qp], p_Quant->OffsetList4x4[k][11], qp_per);      
      // Intra4x4 chroma v
      update_q_offset4x4(p_Quant->q_params_4x4[2][1][qp], p_Quant->OffsetList4x4[k][ 5], qp_per);
    }
  }
}
【Codecs系列】量化死区dead zone的理解
优快云明星博主，认证博客专家，视频、Matlab领域优质创作者。
07-27 2161
DATE: 2020.7.26 文章目录1、参考2、量化死区3、H.264量化死区4、H.265量化死区 1、参考 H.264 Quantization HEVC量化死区 2、量化死区 在标量量化中，会将一定区间内的信号值量化为一个代表值，对于0附近对应的区间，就被称为死区，该区间内的信号会被量化为0。 一般的量化器，可用下面的公式来表示： 反量化可表示为： 量化步长△△决定了量化器的编码压缩率与图像精度。如果△△比较大，相应的编码长度较小，图像细节损失较多；如果△△比较小，相应的编码长度较大，图像损
一篇文章解析 H.264/AVC 视频编解码标准框架
最新发布
世界那么大，我想去看看～【偶尔更新，看世界去了😄】
05-07 562
一篇文章解析 H.264/AVC 视频编解码标准框架
H264 变换与量化
02-13
H264变换与量化的过程的详细说明，内容清晰简洁，十分好的资料
HEVC代码学习43：默认量化矩阵
慢慢积累
10-31 3780
量化矩阵的原理是对应不同位置的系数使用不同的量化系步长进行量化，人眼对高频不敏感，可以对低频分量进行小步长量化，对高频分量进行小步长量化，在保证主观质量的情况下，提高压缩效率。HEVC支持量化矩阵，但是默认不启用。HEVC的量化矩阵与TU大小相同，分为4x4，8x8，16x16，32x32 4种尺寸。 HEVC可以使用来ing中国量化矩阵 ...
一文搞懂H264量化原理以及计算过程
qq_42139383的博客
06-30 7658
1.概述 量化是使数据比特率下降的有效工具。量化过程的输入值动态范围很大，需要较多的比特才能表示一个数值，量化后的输出则只需要较小比特表示。 量化是不可逆过程，处理过程中有信息丢失，存在量化误差。 H.264采用标量量化技术，它将每个图像样点编码映射成较小的数值。一般标量量化器的原理为： FQ=round(y/QP)FQ=round(y/QP)FQ=round(y/QP) 其中，y 为输入样本点编码，QP 为量化步长，FQ 为 y 的量化值，round()为取整函数（其输出为与输入实数最近的整数） 在量化和
H264-DCT-Quanter.rar_H.264_H.264 quantization _dct_h264_x264
09-19
H264中的整数DCT变换编码及量化代码,并附有原文的DCT编码、量化的说明文档。本源码从X264及JM中抽取后整理得来，并用原文档中的示例数据进行了测试，与原文档结果完全一样，是学习H.264不可多得的参考资源.
【H.264】H.264详解（一）—— 一文看懂H.264协议
萧邯编程笔记
07-01 9575
H.264，是一种视频压缩编码标准 ，同时也是MPEG-4第10部分规范(ISO/IEC 14496-10)，MPEG-4 Part 10，⼜叫Advanced Video Codec（高级视频编码），因此H.264常常称为MPEG-4 AVC或直接叫AVC。所以在H.264的参数中可以看到 AVC == H264，而 HECV == H265。H.264已经成为高精度视频录制、压缩和发布的最常用格式之一。常见的写法H264，标准写法应该是H.264。
开源H.264 Video Encoder IP Core V2.0 介绍
OpenFPGA的博客
02-21 343
本文内容来自于该项目的官方网站：openasic.org项目官方网站：http://www.openasic.org/该项目介绍网页链接：http://www.openasic.org/topic/80/%E5%BC%80%E6%BA%90h-264-video-encoder-ip-core-v2-0-%E5%8F%91%E5%B8%83开源H.264 硬件视频编码器IP核H.264 Video...
H.264和H.265（HEVC）深度解析及对比
yinshipin007的博客
09-02 6678
H.265是ITU-TVCEG继H.264之后所制定的新的视频编码标准。H.265标准围绕着现有的视频编码标准H.264，保留原来的某些技术，同时对一些相关的技术加以改进。新技术使用先进的技术用以改善码流、编码质量、延时和算法复杂度之间的关系，达到最优化设置。具体的研究内容包括：提高压缩效率、提高鲁棒性和错误恢复能力、减少实时的时延、减少信道获取时间和随机接入时延、降低复杂度等。H264由于算法优化，可以低于1Mbps的速度实现标清数字图像传送；H265则可以实现利用1~2Mbps的传输速度传送720P（分
H264量化
workspace
11-29 2652
前言 残差矩阵经过整数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 1900
量化是视频编码中产生失真的根本原因，它同时影响着编码质量和比特率。 Quantize原理 Quantization parameter and step Quantization在编码中的应用 Quantization在编码中的实现 Quantization在编码中，不同系数采用的方案 Quantization在编码中，优化方案 Quantization在编码中，涉及的码流参数 Quantize原理 量化是指将信号的连续取值，映射为有限多个离散幅值的过程，实现信号多对一的映射。量.
H264-变换和量化
dongkun152的专栏
08-06 4479
H264-变换和量化 在早期的标准中，不同的处理步骤之间有明显的边界，对原始数据（或者残差）进行域变换，然后进行量化降低系数的精度，但是在H264中边界却不明显。为了消除浮点数DCT变换造成的误差累计，使用整数DCT变换，并且将放大系数移到量化阶段进行。 在DCT变换当中，存在有无理数系数。在不同精度的机器上的编码图像和解码图像之间，或者在同一个编码器的重建图像之间，会出现误差漂移和累计。h264通过下面的两个方法解决这个问题： 使用核变换，是整数DCT变换，只需要使用整数和定点数运算 使用最少的乘法优化
量化参数 quantization parameter以及HEVC中QP详解
热门推荐
liangjiubujiu的博客
06-04 2万+
1. 量化参数QP是量化步长Qstep的序号。对于亮度（Luma）编码而言，量化步长Qstep共有52个值，QP取值0~51，对于色度（Chroma）编码，Q的取值0~39。 Quantizer Parameter，量化参数，反映了空间细节压缩情况。值越小，量化越精细，图像质量越高，产生的码流也越长。如QP小，大部分的细节都会被保留；QP增大，一些细节丢失，码率降低，但图像失真加强和质量下降。QP...
HEVC量化死区
慢慢积累
11-25 2752
最近才接触到量化死区，来学习一下这个技术。
JPEG编码中的DCT与量化
SYSU_LBY的博客
03-16 4314
JPEG是最常用的有损图像压缩算法，而8×8的二维DCT（离散余弦变换）变换和量化又是该算法中的核心步骤。本文作业的例子，是针对一个8×8的数据块进行正反二维DCT变换、量化和反量化
第7章 量化
xiaofeilong321的专栏
10-16 3363
http://www.cnblogs.com/xkfz007/archive/2012/07/29/2614250.html 1. 量化Quantization 用更小的集合表示更大的集合的过程 对信号源的有限近似 有损过程 应用 A/D转换 压缩 量化方法 标量(Scalar)量化 矢量(Vector)量化 2. 量化的基本思想
H264量化参数QP
LIEY
05-29 1万+
编码流控策略 常见的x264编码器为例 CQ Constants Quantize：表示完全不控制码率，尽最大可能保证图像质量，对于质量要求高、不在乎带宽（例如本地存文件）、解码器支持码率剧烈波动的情况，显然 CQ 是不二之选。 CBR Constants Bits Rate, 静态比特率，表示编码器会尽量把输出码率控制为设定值，使用CBR编码时，比特率在流的进行过程中基本保持恒定并且接近目标比特率，始终处于由缓冲区大小确定的时间窗内。CBR编码的缺点在于编码内容的质量不稳定。因为内容的某些片段要比其他片段
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值