h.264 scanning process for transform coefficients

宏块在经过变换、量化后，得到大小为4x4或者8x8的矩阵，矩阵中的数据被称为transform coefficient levels。这些level在后面会被用于熵编码，因此我们需要把矩阵按照一定顺序进行扫描，得到数字序列。

扫描顺序在帧与场会有所不同

4x4块矩阵的扫描顺序如下

              

Zig-zag scan(Frame)                          Field scan

8x8块矩阵的扫描顺序如下

           

Zig-zag scan(Frame)                                  Field scan           

在实际的代码处理上（JM），对变换系数的扫描过程是包含在量化过程中的，因为对矩阵内的元素的量化也是逐个进行的，因此就可以按照对变换系数扫描的顺序取出矩阵内的元素进行量化，后续就能直接对这些transform coefficient level序列进行熵编码。

int quant_4x4_normal(Macroblock *currMB, int **tblock, struct quant_methods *q_method)

{

  VideoParameters *p_Vid = currMB->p_Vid;

  QuantParameters *p_Quant = p_Vid->p_Quant;

  Slice *currSlice = currMB->p_Slice;

  Boolean is_cavlc = (Boolean) (currSlice->symbol_mode == CAVLC);

  int   block_x = q_method->block_x;

  int  qp = q_method->qp;

  int*  ACL = &q_method->ACLevel[0];

  int*  ACR = &q_method->ACRun[0];

  LevelQuantParams **q_params_4x4 = q_method->q_params;

  const byte (*pos_scan)[2] = q_method->pos_scan;

  const byte *c_cost = q_method->c_cost;

  int *coeff_cost = q_method->coeff_cost;

  LevelQuantParams *q_params = NULL;

  int i,j, coeff_ctr;

  int *m7;

  int scaled_coeff;

  int   level, run = 0;

  int   nonzero = FALSE;

  int   qp_per = p_Quant->qp_per_matrix[qp];

  int   q_bits = Q_BITS + qp_per;

  const byte *p_scan = &pos_scan[0][0];

  // Quantization

  // 4x4 block matrix has 16 coefficients

  for (coeff_ctr = 0; coeff_ctr < 16; ++coeff_ctr)

  {

    //scanning positions (Zig-zag scan or Field scan)

    i = *p_scan++;  // horizontal position

    j = *p_scan++;  // vertical position

    //block_x,block_y here is the position of a block on a Macroblock with the unit of pixel

    m7 = &tblock[j][block_x + i];

    if (*m7 != 0)

    {

      q_params = &q_params_4x4[j][i];

      scaled_coeff = iabs (*m7) * q_params->ScaleComp;

      level = (scaled_coeff + q_params->OffsetComp) >> q_bits;

      if (level != 0)

      {

        if (is_cavlc)

          level = imin(level, CAVLC_LEVEL_LIMIT);

        *coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];

        level  = isignab(level, *m7);

        *m7     = rshift_rnd_sf(((level * q_params->InvScaleComp) << qp_per), 4);

        // inverse scale can be alternative performed as follows to ensure 16bit

        // arithmetic is satisfied.

        // *m7 = (qp_per<4) ? rshift_rnd_sf((level*q_params->InvScaleComp),4-qp_per) : (level*q_params->InvScaleComp)<<(qp_per-4);

        *ACL++ = level;

        *ACR++ = run;

        // reset zero level counter

        run    = 0;

        nonzero = TRUE;

      }

      else

      {

        *m7 = 0;

        ++run;

      }

    }

    else

    {

      ++run;

    }

  }

  *ACL = 0;

  return nonzero;

}