adaptive_filter.c

JM 11.0 KTA 2.1 Source Code

#ifdef E_DAIF

// dequantize coefficients and offset
void DequantizeFilterCoefficientsExt(int QFCoef[SQR_FILTER], int numQBits, int QFOffsetI, int QFOffsetF, int QFOffsetSign, double FCoef[SQR_FILTER])
{
  double factor; 
  int j;
  double is = 0.0;
  int offsetFracCodeLen[] = 
  {
    5, 4, 4, 2, 2, 2, 2, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
  };
  int bitsForOffsetFrac; 

  factor = pow(2,numQBits-1);
  for(j=0; j < SQR_FILTER-1; j++)
  {
    if(QFCoef[j])
    {
      is = (double)(QFCoef[j])/factor;
    }
    else 
      is = 0.;
    FCoef[j]  = is;		// reconstructed (quantized) filter coefficients
  }

  // offset
  bitsForOffsetFrac = offsetFracCodeLen[QFOffsetI];
  factor = pow(2.,bitsForOffsetFrac);
  FCoef[j] = (double)QFOffsetI + (double)QFOffsetF/factor; 
  FCoef[j] = FCoef[j]*QFOffsetSign; 
}

#endif  // E_DAIF

/*!
************************************************************************
* \brief
*    quantize filter coefficients
*    input:
*        double FCoef[][] - filter coefficients to be quantized
*    output:
*        int QFCoef[][]   - quantized filter coefficients, 
*                             represented in step numbers
************************************************************************
*/
void QuantizeFilterCoefficients(double FCoef[SQR_FILTER], int QFCoef[SQR_FILTER])
{
  int number_of_steps = 2^(NumberOfQBits-1);  // 1 bit for sign, NumberOfQBits-1 for amplitude
  int sign;
  int j;
  for(j=0; j < SQR_FILTER; j++)
  {
    sign = FCoef[j] >= 0.0 ? 1:-1;
    QFCoef[j] = sign*(int)(fabs(FCoef[j])*number_of_steps + 0.5);  // step number
    FCoef[j] = (double)(QFCoef[j])/(double)number_of_steps; // reconstructed (quantized) filter coefficients
  }
}


/*!
************************************************************************
* \brief
*    extend the filter to 2D (FILTER_SIZE X FILTER_SIZE)
*
*    input:
*      sub_pos - sub-position
*    input output:
*      FCoef[][] - Filter to be extended at symmetric positions,
*                  using FILTER_NEW_SUB_POS
************************************************************************
*/
void ExtendFilterCoefficientsFloat(int sub_pos, double FCoef[15][SQR_FILTER])
{
  int i;
  int filter_type = img->AdaptiveFilterFlag;
#ifndef DIRECTIONAL_FILTER
  for(i = 0; i < SQR_FILTER; i++)
    FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
#else
  if(filter_type == FILTER_TYPE_2D_NS)
  {
    for(i = 0; i < SQR_FILTER; i++)
      FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
  }

#ifdef E_DAIF
  else if (filter_type == FILTER_TYPE_1D || filter_type == FILTER_TYPE_EDAIF)
#else
  else if (filter_type == FILTER_TYPE_1D)
#endif
  {
    int j;
    if (IsDiagonal1D[sub_pos]==1)
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = FILTER_SIZE-1-i;
        FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
      }
    }
    else if (IsDiagonal1D[sub_pos]==2)
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = FILTER_SIZE-1-i;
        //FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
        FCoef[sub_pos][i*FILTER_SIZE + j] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + j]];
      }
    }
    else if(IsDiagonal1D[sub_pos]==3)
    {
      if(sub_pos == j_pos)
      {
        for(i = 0; i < FILTER_SIZE; i++)
        {
          j = FILTER_SIZE-1-i;
          FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
          FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
        }
      }
      else 
      {
        for(i = 0; i < FILTER_SIZE; i++)
        {
          j = i;
          FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
          j = FILTER_SIZE-1-i;
          FCoef[sub_pos][i*FILTER_SIZE + j] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + j]];
        }
      }
    }
    else 
      for(i = 0; i < SQR_FILTER; i++)
        FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];

  }
  return;
#endif
}


/*!
************************************************************************
* \brief
*    extend the filter to 2D (FILTER_SIZE X FILTER_SIZE)
*
*    input:
*      sub_pos - sub-position
*     input output:
*       FCoef[][] - Filter to be extended at symmetric positions,
*                     using FILTER_NEW_SUB_POS
************************************************************************
*/
void ExtendFilterCoefficientsInt(int sub_pos, int FCoef[15][SQR_FILTER])
{
  int i;
  int filter_type = img->AdaptiveFilterFlag;
#ifndef DIRECTIONAL_FILTER
  for(i = 0; i < SQR_FILTER; i++)
    FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
#else
  if(filter_type == FILTER_TYPE_2D_NS)
  {
    for(i = 0; i < SQR_FILTER; i++)
      FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
  }
#ifdef E_DAIF
  else if (filter_type == FILTER_TYPE_1D || filter_type == FILTER_TYPE_EDAIF )
#else
  else if (filter_type == FILTER_TYPE_1D)
#endif
  {
    int j;
    if (IsDiagonal1D[sub_pos]==1)
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = FILTER_SIZE-1-i;
        FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
      }
    }
    //else if ((sub_pos == g_pos)||(sub_pos == m_pos))
    else if (IsDiagonal1D[sub_pos]==2)
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = FILTER_SIZE-1-i;
        //FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
        FCoef[sub_pos][i*FILTER_SIZE + j] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + j]];
      }
    }
    else if(IsDiagonal1D[sub_pos]==3)
    {
      if(sub_pos == j_pos)
      {
        for(i = 0; i < FILTER_SIZE; i++)
        {
          j = FILTER_SIZE-1-i;
          FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
          FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
        }
      }
      else 
      {
        for(i = 0; i < FILTER_SIZE; i++)
        {
          j = i;
          FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
          j = FILTER_SIZE-1-i;
          FCoef[sub_pos][i*FILTER_SIZE + j] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + j]];
        }
      }
    }
    else 
      for(i = 0; i < SQR_FILTER; i++)
        FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
  }
  return;
#endif
}
/*!
************************************************************************
* \brief
*    extend the filter DAIF with respect to symmeties.
*
*    input:
*      sub_pos - sub-position
*     input output:
*       FCoef[][] - Filter to be extended at symmetric positions,
*                     using FILTER_NEW_SUB_POS
************************************************************************
*/
void ExtendFilterCoefficientsShort(int sub_pos, short FCoef[15][SQR_FILTER])
{
  int i;
  int filter_type = img->AdaptiveFilterFlag;
#ifndef DIRECTIONAL_FILTER
  for(i = 0; i < SQR_FILTER; i++)
    FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
#else
  if(filter_type == FILTER_TYPE_2D_NS)
  {
    for(i = 0; i < SQR_FILTER; i++)
      FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
  }
  else if (filter_type == FILTER_TYPE_1D)
  {
    int j;
    if (IsDiagonal1D[sub_pos]==1)
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = FILTER_SIZE-1-i;
        FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
      }
    }
    else if (IsDiagonal1D[sub_pos]==2)
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = FILTER_SIZE-1-i;
        FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
      }
    }
    else if(IsDiagonal1D[sub_pos]==3)
    {
      if(sub_pos == j_pos)
      {
        for(i = 0; i < FILTER_SIZE; i++)
        {
          j = FILTER_SIZE-1-i;
          FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
          FCoef[sub_pos][i*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + i]];
        }
      }
      else 
      {
        for(i = 0; i < FILTER_SIZE; i++)
        {
          j = i;
          FCoef[sub_pos][j*FILTER_SIZE + i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][j*FILTER_SIZE + i]];
          j = FILTER_SIZE-1-i;
          FCoef[sub_pos][i*FILTER_SIZE + j] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i*FILTER_SIZE + j]];
        }
      }
    }
    else 
      for(i = 0; i < SQR_FILTER; i++)
        FCoef[sub_pos][i] = FCoef[FILTER_NEW_SUB_POS[sub_pos]][TwoDSymmetricPattern[sub_pos][i]];
  }
  return;
#endif
}

#ifdef EIGHTH_PEL
void GetBlockWith2DAIF_eighth_pel( int             ref_idx,
                                  StorablePicture **list,
                                  int             x_pos,
                                  int             y_pos,
                                  int             mvx,
                                  int             mvy,
                                  int             img_width,
                                  int             img_height,
                                  int             block[BLOCK_SIZE][BLOCK_SIZE])
{
  int block2[BLOCK_SIZE][BLOCK_SIZE]; 
  int block3[BLOCK_SIZE][BLOCK_SIZE]; 
  int block4[BLOCK_SIZE][BLOCK_SIZE]; 
  int dmvx = (mvx%8+8)%8;
  int dmvy = (mvy%8+8)%8;


  if(!(dmvx&1) && !(dmvy&1))                                                              //              1/4-pel
    GetBlockWith2DAIF_quarter_pel(ref_idx, list, x_pos, y_pos, mvx/2, mvy/2, img_width,img_height, block);
  else                                                                                                                            //              1/$
  {
    if(dmvx&1 && !(dmvy&1))                                                         //              horizontal 1/8 and vertical 1/4
    {
      GetBlockWith2DAIF_quarter_pel(ref_idx, list, x_pos, y_pos, (mvx+1)/2, mvy/2, img_width,img_height, block);
      GetBlockWith2DAIF_quarter_pel(ref_idx, list, x_pos, y_pos, (mvx-1)/2, mvy/2, img_width,img_height, block2);
      average_block(block, block2);