q_offsets.c

H.264视频编解码的标准测试模型

  {
    cnt = 0;
    if (0 > (MapIdx = CheckOffsetParameterName (items[i + cnt], &type)))
    {
      snprintf (errortext, ET_SIZE,
        " Parsing error in config file: Parameter Name '%s' not recognized.",
        items[i + cnt]);
      error (errortext, 300);
    }
    cnt++;
    if (strcmp ("=", items[i + cnt]))
    {
      snprintf (errortext, ET_SIZE,
        " Parsing error in config file: '=' expected as the second token in each item.");
      error (errortext, 300);
    }
    cnt++;

    if (!type) //4x4 Matrix
    {
      range = 16;
      OffsetList = OffsetList4x4input[MapIdx];
      offset4x4_check[MapIdx] = 1; //to indicate matrix found in cfg file
    }
    else //8x8 matrix
    {
      range = 64;
      OffsetList = OffsetList8x8input[MapIdx];
      offset8x8_check[MapIdx] = 1; //to indicate matrix found in cfg file
    }

    for (j = 0; j < range; j++)
    {
      if (1 != sscanf (items[i + cnt + j], "%d", &IntContent))
      {
        snprintf (errortext, ET_SIZE,
          " Parsing error: Expected numerical value for Parameter of %s, found '%s'.",
          items[i], items[i + cnt + j]);
        error (errortext, 300);
      }

      OffsetList[j] = (short) IntContent; //save value in matrix
    }
    cnt += j;
    printf (".");
  }
}


/*!
 ***********************************************************************
 * \brief
 *    Initialise Q offset matrix values.
 ***********************************************************************
 */
void Init_QOffsetMatrix ()
{
  char *content;

  allocate_QOffsets ();

  if (input->OffsetMatrixPresentFlag)
  {
    printf ("Parsing Quantization Offset Matrix file %s ",
      input->QOffsetMatrixFile);
    content = GetConfigFileContent (input->QOffsetMatrixFile, 0);
    if (content != '\0')
      ParseQOffsetMatrix (content, strlen (content));
    else
    {
      printf
        ("\nError: %s\nProceeding with default values for all matrices.",
        errortext);
      input->OffsetMatrixPresentFlag = 0;
    }   

    printf ("\n");

    free (content);
  }
  //! Now set up all offset params. This process could be reused if we wish to re-init offsets
  InitOffsetParam ();
}

/*!
 ************************************************************************
 * \brief
 *    Intit quantization offset params 
 *
 * \par Input:
 *    none
 *
 * \par Output:
 *    none
 ************************************************************************
 */
void InitOffsetParam ()
{
  int i, j, k, temp;
  
  if (input->OffsetMatrixPresentFlag)
  {
    for (j = 0; j < 4; j++)
    {
      for (i = 0; i < 4; i++)
      {
        temp = (i << 2) + j;
        for (k = 0; k < 15; k++)
        {          
          OffsetList4x4[k][temp] = OffsetList4x4input[k][temp];
        }
      }
    }
    for (j = 0; j < 8; j++)
    {
      for (i = 0; i < 8; i++)
      {           
        temp = (i << 3) + j;
        for (k = 0; k < 5; k++)
          OffsetList8x8[k][temp] = OffsetList8x8input[k][temp];
      }
    }
  }
  else
  {        
    for (j = 0; j < 4; j++)
    {
      for (i = 0; i < 4; i++)
      {
        temp = (i << 2) + j;
        
        for (k = 0; k < 3; k++)
          OffsetList4x4[k][temp] = Offset_intra_default_intra[temp];
        for (k = 3; k < 9; k++)
          OffsetList4x4[k][temp] = Offset_intra_default_inter[temp];
        for (k = 9; k < 15; k++)
          OffsetList4x4[k][temp] = Offset_inter_default[temp];
      }
    }     
    for (j = 0; j < 8; j++)
    {
      for (i = 0; i < 8; i++)
      {
        temp = (i << 3) + j;
        OffsetList8x8[0][temp]  = Offset8_intra_default_intra[temp];           
        OffsetList8x8[1][temp]  = Offset8_intra_default_inter[temp];
        OffsetList8x8[2][temp]  = Offset8_intra_default_inter[temp];
        OffsetList8x8[3][temp] = Offset8_inter_default[temp];
        OffsetList8x8[4][temp] = Offset8_inter_default[temp];
      }
    }
  }
}


/*!
 ************************************************************************
 * \brief
 *    Calculation of the quantization offset params at the frame level
 *
 * \par Input:
 *    none
 *
 * \par Output:
 *    none
 ************************************************************************
 */
void CalculateOffsetParam ()
{
  int i, j, k, temp;
  int qp_per;
  int img_type = (img->type == SI_SLICE ? I_SLICE : (img->type == SP_SLICE ? P_SLICE : img->type));
  
  int max_qp_per_luma = (51 + img->bitdepth_luma_qp_scale - MIN_QP)/6 + 1;
  int max_qp_per_cr = (51 + img->bitdepth_chroma_qp_scale - MIN_QP)/6 + 1;
  
  AdaptRndWeight = input->AdaptRndWFactor[img->nal_reference_idc!=0][img_type];
  for (k = 0; k < max(max_qp_per_luma,max_qp_per_cr); k++)
  {
    qp_per = Q_BITS + k - OffsetBits;
    for (j = 0; j < 4; j++)
    {
      for (i = 0; i < 4; i++)
      {
        temp = (i << 2) + j;
        if (img_type == I_SLICE)
        {
          LevelOffset4x4Luma[1][k][j][i] =
            (int) OffsetList4x4[0][temp] << qp_per;
          LevelOffset4x4Chroma[0][1][k][j][i] =
            (int) OffsetList4x4[1][temp] << qp_per;
          LevelOffset4x4Chroma[1][1][k][j][i] =
            (int) OffsetList4x4[2][temp] << qp_per;
        }
        else if (img_type == B_SLICE)
        {
          LevelOffset4x4Luma[1][k][j][i] =
            (int) OffsetList4x4[6][temp] << qp_per;
          LevelOffset4x4Chroma[0][1][k][j][i] =
            (int) OffsetList4x4[7][temp] << qp_per;
          LevelOffset4x4Chroma[1][1][k][j][i] =
            (int) OffsetList4x4[8][temp] << qp_per;
        }
        else
        {
          LevelOffset4x4Luma[1][k][j][i] =
            (int) OffsetList4x4[3][temp] << qp_per;
          LevelOffset4x4Chroma[0][1][k][j][i] =
            (int) OffsetList4x4[4][temp] << qp_per;
          LevelOffset4x4Chroma[1][1][k][j][i] =
            (int) OffsetList4x4[5][temp] << qp_per;
        }
        
        if (img_type == B_SLICE)
        {
          LevelOffset4x4Luma[0][k][j][i] =
            (int) OffsetList4x4[12][temp] << qp_per;
          LevelOffset4x4Chroma[0][0][k][j][i] =
            (int) OffsetList4x4[13][temp] << qp_per;
          LevelOffset4x4Chroma[1][0][k][j][i] =
            (int) OffsetList4x4[14][temp] << qp_per;
        }
        else
        {
          LevelOffset4x4Luma[0][k][j][i] =
            (int) OffsetList4x4[9][temp] << qp_per;
          LevelOffset4x4Chroma[0][0][k][j][i] =
            (int) OffsetList4x4[10][temp] << qp_per;
          LevelOffset4x4Chroma[1][0][k][j][i] =
            (int) OffsetList4x4[11][temp] << qp_per;
        }
      }
    }
  }
}
 
 /*!
 ************************************************************************
 * \brief
 *    Calculate the quantisation offset parameters
 *
 ************************************************************************
 */
void CalculateOffset8Param ()
{
  int i, j, k, temp;
  int q_bits;
  
  int max_qp_per_luma = (51 + img->bitdepth_luma_qp_scale - MIN_QP)/6 + 1;
  int max_qp_per_cr = (51 + img->bitdepth_chroma_qp_scale - MIN_QP)/6 + 1;

  for (k = 0; k < max(max_qp_per_luma,max_qp_per_cr); k++)
  {
    q_bits = Q_BITS_8 + k - OffsetBits;
    for (j = 0; j < 8; j++)
    {
      for (i = 0; i < 8; i++)
      {           
        temp = (i << 3) + j;
        if (img->type == I_SLICE)
          LevelOffset8x8Luma[1][k][j][i] =
          (int) OffsetList8x8[0][temp] << q_bits;
        else if (img->type == B_SLICE)
          LevelOffset8x8Luma[1][k][j][i] =
          (int) OffsetList8x8[2][temp] << q_bits;
        else
          LevelOffset8x8Luma[1][k][j][i] =
          (int) OffsetList8x8[1][temp] << q_bits;

        if (img->type == B_SLICE)
          LevelOffset8x8Luma[0][k][j][i] =
          (int) OffsetList8x8[4][temp] << q_bits;
        else
          LevelOffset8x8Luma[0][k][j][i] =
          (int) OffsetList8x8[3][temp] << q_bits;
      }
    }
  }
}