H.264 Quantization

最新推荐文章于 2021-07-19 10:21:06 发布
最新推荐文章于 2021-07-19 10:21:06 发布
阅读量984 收藏
点赞数
分类专栏： audio video codec

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);
    }
  }
}
samssm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
H264 变换与量化
02-13
H264变换与量化的过程的详细说明，内容清晰简洁，十分好的资料
一文搞懂H264量化原理以及计算过程
qq_42139383的博客
06-30 6132
1.概述 量化是使数据比特率下降的有效工具。量化过程的输入值动态范围很大，需要较多的比特才能表示一个数值，量化后的输出则只需要较小比特表示。 量化是不可逆过程，处理过程中有信息丢失，存在量化误差。 H.264采用标量量化技术，它将每个图像样点编码映射成较小的数值。一般标量量化器的原理为： FQ=round(y/QP)FQ=round(y/QP)FQ=round(y/QP) 其中，y 为输入样本点编码，QP 为量化步长，FQ 为 y 的量化值，round()为取整函数（其输出为与输入实数最近的整数） 在量化和
H264量化
workspace
11-29 2476
前言 残差矩阵经过整数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 1602
量化是视频编码中产生失真的根本原因，它同时影响着编码质量和比特率。 Quantize原理 Quantization parameter and step Quantization在编码中的应用 Quantization在编码中的实现 Quantization在编码中，不同系数采用的方案 Quantization在编码中，优化方案 Quantization在编码中，涉及的码流参数 Quantize原理 量化是指将信号的连续取值，映射为有限多个离散幅值的过程，实现信号多对一的映射。量.
H264-变换和量化
dongkun152的专栏
08-06 3577
H264-变换和量化 在早期的标准中，不同的处理步骤之间有明显的边界，对原始数据（或者残差）进行域变换，然后进行量化降低系数的精度，但是在H264中边界却不明显。为了消除浮点数DCT变换造成的误差累计，使用整数DCT变换，并且将放大系数移到量化阶段进行。 在DCT变换当中，存在有无理数系数。在不同精度的机器上的编码图像和解码图像之间，或者在同一个编码器的重建图像之间，会出现误差漂移和累计。h264通过下面的两个方法解决这个问题： 使用核变换，是整数DCT变换，只需要使用整数和定点数运算 使用最少的乘法优化
H264-DCT-Quanter.rar_H.264_H.264 quantization _dct_h264_x264
最新发布
09-19
H264中的整数DCT变换编码及量化代码,并附有原文的DCT编码、量化的说明文档。本源码从X264及JM中抽取后整理得来，并用原文档中的示例数据进行了测试，与原文档结果完全一样，是学习H.264不可多得的参考资源.
视频压缩标准H.264
02-10
H.264编码过程主要分为四个阶段：帧内预测（Intra Prediction）、帧间预测（Inter Prediction）、变换与量化（Transform and Quantization）、熵编码（Entropy Encoding）。 1. 帧内预测：对当前宏块进行预测，利用...
h.264和mpeg-4视频压缩--欧阳合译.pdf
12-10
### H.264与MPEG-4视频压缩技术解析 #### 一、H.264概述 H.264（也称为MPEG-4 AVC）是一种高效的视频编码标准，由ITU-T（国际电信联盟）的VCEG（视频编码专家组）和ISO/IEC（国际标准化组织/国际电工委员会）的...
H.264 High profile
06-30
### H.264 High Profile：深度解析与应用探索 #### 一、H.264/MPEG-4 Part 10标准概述 H.264/MPEG-4 Part 10是一种国际视频编码标准，它在压缩效率和错误鲁棒性方面相比之前的编码标准（如MPEG-2、H.263、MPEG-4 ...
论文研究-一种简化的HEVC率失真优化技术框架 .pdf
08-16
一种简化的HEVC率失真优化技术框架，万勤，章登勇，高效视频编码标准(HEVC)相比于之前的视频编码标准有明显的性能提高,但它是以计算的复杂度增加为代价。HEVC 编码采用率失真优化(RDO)技�
H.264/AVC 变换与量化的原理描述 white paper
08-02
H.264/AVC 变换与量化的原理描述 也就是white paper 行业知名咨询公司写的，英文
h.264仿真软件，模拟软件
01-04
H.264，全称为Advanced Video Coding（高级视频编码），是ITU-T的VCEG（视频编码专家组）和ISO/IEC的MPEG（活动图像编码专家组）联合开发的一套视频编码标准，也是目前广泛应用于高清视频传输、存储和播放的标准之一...
量化参数 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...
【Codecs系列】量化死区dead zone的理解
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
07-27 1694
DATE: 2020.7.26 文章目录1、参考2、量化死区3、H.264量化死区4、H.265量化死区 1、参考 H.264 Quantization HEVC量化死区 2、量化死区 在标量量化中，会将一定区间内的信号值量化为一个代表值，对于0附近对应的区间，就被称为死区，该区间内的信号会被量化为0。 一般的量化器，可用下面的公式来表示： 反量化可表示为： 量化步长△△决定了量化器的编码压缩率与图像精度。如果△△比较大，相应的编码长度较小，图像细节损失较多；如果△△比较小，相应的编码长度较大，图像损
HEVC代码学习43：默认量化矩阵
慢慢积累
10-31 3247
量化矩阵的原理是对应不同位置的系数使用不同的量化系步长进行量化，人眼对高频不敏感，可以对低频分量进行小步长量化，对高频分量进行小步长量化，在保证主观质量的情况下，提高压缩效率。HEVC支持量化矩阵，但是默认不启用。HEVC的量化矩阵与TU大小相同，分为4x4，8x8，16x16，32x32 4种尺寸。 HEVC可以使用来ing中国量化矩阵 ...
JPEG编码中的DCT与量化
SYSU_LBY的博客
03-16 4133
JPEG是最常用的有损图像压缩算法，而8×8的二维DCT（离散余弦变换）变换和量化又是该算法中的核心步骤。本文作业的例子，是针对一个8×8的数据块进行正反二维DCT变换、量化和反量化
HM编码器代码阅读(20)——与变换量化有关的其他知识
NB_vol_1的专栏
04-19 2643
其他和变换量化相关的函数（以后补充）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值