adaptive_quantization.c

JM 11.0 KTA 2.1 Source Code

  best_rd_pass = img->rd_pass;

  if( (input->UseAdaptiveQuantMatrix && img->type == I_SLICE && !idr_flag) || (FAQ_Skip_flag))
  {
    *mincost_flg = 1;
    return 0;
  }

  // set slice modeling quantization matrix
  img->slice_modeling_qm_param0 = VALUE_OF_QM_PARAM0;
  img->slice_modeling_qm_param1 = VALUE_OF_QM_PARAM1;
  SetAutoScalingListDataForMQM();
  // set macroblock quantization matrix
  SetAutoScalingListDataForIAQMS();

  ReGenerateParameterSets(active_pps->pic_parameter_set_id);
  active_pps  = PicParSet[PPSID_AQMS];
  // return default input parameter
  LoadInputParam(defInputParam);
  SetFastEncodingForIAQMS(defInputParam);

  img->write_macroblock = 0;
  {
    enc_picture = enc_frame_picture_aqms;
    frame_pic   = frame_pic_aqms;
  }

  // Final encode
  frame_picture(frame_pic_aqms, gdwAQMS_frame_num);
  *mincost_flg = ChooseBestPicture(rd_qp);

  // return default input parameter
  LoadInputParam(defInputParam);

  if(*mincost_flg==0)
    img->rd_pass = gdwAQMS_frame_num;
  else
    img->rd_pass = best_rd_pass;

  SkipRatio[(img->type)+(img->type==B_SLICE? (img->nal_reference_idc<<2) : 0)] = ((double)dwSkipMbCountForSlice[(img->type)+(img->type==B_SLICE? (img->nal_reference_idc<<2) : 0)]/(double)dwSkipEnableMbCountForSlice[(img->type)+(img->type==B_SLICE? (img->nal_reference_idc<<2) : 0)]*100.0);

#ifdef MV_COMPETITION // MVC bug fix by AT
  if(*mincost_flg && input->mv_competition)
    ReEncodeMVCompetition(img->rd_pass);
#endif

  return 0;
}

/*!
 ************************************************************************
 * \brief
 *    For generating the modeling quantization matrix
 *
 ************************************************************************
 */
void SetAutoScalingListDataForIAQMS()
{
  int ListIdx=0;
  int *GradientTab;
  int cGradientTab_HR[6][NUM_OF_IAQMS_MAT] ={{  0,  -8,256,255}, // P-slice
                                            {  0, 256,256,256}, // B-slice
                                            {  0,  -8,-16,255}, // I-slice
                                            {  0,   4, -4,  8},
                                            {  0,   4, -4,  8},
                                            {  0,   4, -4,  8}};
  int cGradientTab_BR[6][NUM_OF_IAQMS_MAT] ={{  0,256,256,256}, // P-slice
                                            {  0, 256,256,256}, // B-slice
                                            {  0,  -8,-16,255}, // I-slice
                                            {  0,   4, -4,  8},
                                            {  0,   4, -4,  8},
                                            {  0,   4, -4,  8}};

  for(ListIdx=0;ListIdx<NUM_OF_IAQMS_MAT;ListIdx++)
  {
    if(active_sps->profile_idc < FREXT_HP)
      GradientTab = cGradientTab_BR[img->type];
    else
      GradientTab = cGradientTab_HR[img->type];

    // 4x4 block
    CreateScalingList4x4ForIAQMS(GradientTab[ListIdx], ListIdx);
    // 8x8 block
    CreateScalingList8x8ForIAQMS(GradientTab[ListIdx], ListIdx);
  }
}
/*!
 ************************************************************************
 * \brief
 *    For generating the modeling quantization matrix at 4x4 block
 *
 ************************************************************************
 */
void CreateScalingList4x4ForIAQMS(int Gradient, int ListIdx)
{
  int i,j,r=0;
  int QM4[16];

  if(Gradient==255) // Flat base value minus 1
  {
    for(i=0;i<16;i++)
      for(j=0;j<6;j++)
        ScalingList4x4_IAQMS[ListIdx][j][i] = Clip3(1,255,(ScalingList4x4[j][i]-1));
  }
  else if(Gradient==256)  // Flat base value plus 1
  {
    for(i=0;i<16;i++)
      for(j=0;j<6;j++)
        ScalingList4x4_IAQMS[ListIdx][j][i] = Clip3(1,255,(ScalingList4x4[j][i]+1));
  }
  else  // slope matrix
  {
    for(j=0;j<4;j++)
      for(i=0;i<4;i++)
      {
        r=i+j;
        QM4[i+(j<<2)]=(((Gradient*r)+8)>>4);
      }

    for(i=0;i<16;i++)
      for(j=0;j<6;j++)
        ScalingList4x4_IAQMS[ListIdx][j][i] = Clip3(1,255,(QM4[i]+ScalingList4x4[j][i]));
  }
}

/*!
 ************************************************************************
 * \brief
 *    For generating the modeling quantization matrix at 8x8 block
 *
 ************************************************************************
 */
void CreateScalingList8x8ForIAQMS(int Gradient, int ListIdx)
{
  int i,j,r=0;
  int QM8[64];

  if(Gradient==255) // Flat base value minus 1
  {
    for(i=0;i<64;i++)
      for(j=0;j<2;j++)
        ScalingList8x8_IAQMS[ListIdx][j][i] = Clip3(1,255,(ScalingList8x8[j][i]-1));
  }
  else if(Gradient==256)  // Flat base value plus 1
  {
    for(i=0;i<64;i++)
      for(j=0;j<2;j++)
        ScalingList8x8_IAQMS[ListIdx][j][i] = Clip3(1,255,(ScalingList8x8[j][i]+1));
  }
  else  // slope matrix
  {
    for(j=0;j<8;j++)
      for(i=0;i<8;i++)
      {
        r=i+j;
        QM8[i+(j<<3)]=(((Gradient*r)+16)>>5);
      }

    for(i=0;i<64;i++)
      for(j=0;j<2;j++)
        ScalingList8x8_IAQMS[ListIdx][j][i] = Clip3(1,255,(QM8[i]+ScalingList8x8[j][i]));
  }
}

/*!
************************************************************************
* \brief
*    For generating the modeling quantization matrix at slice level
*
************************************************************************
*/
void SetAutoScalingListDataForMQM()
{
  int pA = 0, pB = 0;
  
  pA = ((img->slice_modeling_qm_param0)-32);
  pB = (img->slice_modeling_qm_param1);
  
  // 4x4 block
  CreateScalingList4x4ForMQM(pA, pB);
  // 8x8 block
  CreateScalingList8x8ForMQM(pA, pB);
}
/*!
************************************************************************
* \brief
*    For generating the modeling quantization matrix at 4x4 block
*
************************************************************************
*/
void CreateScalingList4x4ForMQM(int pA, int pB)
{
  int i,j,r=0;
  unsigned int QM4[16];
  
  // 4x4 Matrix
  for(j=0;j<4;j++)
  {
    for(i=0;i<4;i++)
    {
      r=i+j;
      QM4[i+(j<<2)]=Clip3(1,255,(((pA*r)+8)>>4) + pB);
    }
  }
  
  for(i=0;i<16;i++)
    for(j=0;j<6;j++)
      ScalingList4x4[j][i] = Clip3(1,255,QM4[i]);
}
/*!
************************************************************************
* \brief
*    For generating the modeling quantization matrix at 8x8 block
*
************************************************************************
*/
void CreateScalingList8x8ForMQM(int pA, int pB)
{
  int i,j,r=0;
  unsigned int QM8[64];
  
  // 8x8 Matrix
  for(j=0;j<8;j++)
  {
    for(i=0;i<8;i++)
    {
      r=i+j;
      QM8[i+(j<<3)]=Clip3(1,255,( ((pA*r+16)>>5 ) + pB) );
    }
  }
  
  for(i=0;i<64;i++)
    for(j=0;j<2;j++)
      ScalingList8x8[j][i] = Clip3(1,255,QM8[i]);
}

/*!
 ***********************************************************************
 * \brief
 *   storing the input parameters (for speed up)
 ***********************************************************************
 */
void SetFastEncodingForIAQMS(sDefaultInputParam_t *defInputParam)
{
  // for fast encoding
  input->SelectiveIntraEnable = 1;
  input->EarlySkipEnable = 1;
  input->FMEnable = 3;

  if(img->type!=I_SLICE)
  {
    input->ChromaIntraDisable     = 1;
  }
}
/*
 ***********************************************************************
 * \brief
 *   initialize scaling lists 
 ***********************************************************************
 */
void InitScalingList()
{
  int i, j;
  for(j=0;j<6;j++)
    for(i=0;i<16;i++)
      ScalingList4x4[j][i] = 16;

  for(j=0;j<2;j++)
    for(i=0;i<64;i++)
      ScalingList8x8[j][i] = 16;
}

/*
 ***********************************************************************
 * \brief
 *   set mode availability
 ***********************************************************************
 */
void SetModeAvalability(RD_PARAMS *enc_mb)
{
  int i;

  if(final_mb_encoding == 1)
  {
    if(saved_best_mode<=P8x8)
    {
      for(i=P8x8+1; i<MAXMODE; i++)
        enc_mb->valid[i] = 0;
    }
  }
}

#endif