adaptive_filter.c

JM 11.0 KTA 2.1 Source Code

#ifdef DIRECTIONAL_FILTER
/*!
************************************************************************
* \brief
*    Predict and calculate filter coefficients
************************************************************************
*/
void CalculateFilterCoefficients1DAIF(void)
{
  int i,j;
  int multplier;
  double abs_value; 
  int signFC;

  // at first predict b and h position using inter prediction, b and h are already quantized in last frame
  if(img->AdaptiveFilterFlag)
  {
    if (img->ImpType == IMP_FLOAT32)
    {
      if(FilterFlag[b_pos])
      {
        for(i=0; i < SQR_FILTER; i++)
        {
          PredFilterCoef[b_pos][i] = STANDARD_2D_FILTER[b_pos][i];
          PredFilterCoef[h_pos][i] = STANDARD_2D_FILTER[h_pos][i];
        }
        DequantizeFilterCoefficients(DiffQFilterCoef[b_pos], FilterCoef[b_pos]);
        // add differences to predicted values
        for(i=FILTER_SIZE*FILTER_OFFSET; i < FILTER_SIZE*(FILTER_OFFSET+1); i++)
        {
          FilterCoef[b_pos][i] += PredFilterCoef[b_pos][i];
        }
      }
      else
      {
        for(i=0; i < SQR_FILTER; i++)
          FilterCoef[b_pos][i] = STANDARD_2D_FILTER[b_pos][i];
      }
      ExtendFilterCoefficientsFloat(h_pos,FilterCoef);

      // predict a_pos:
      if(FilterFlag[a_pos])
      {
        for(i=0; i < SQR_FILTER; i++)
        {
          PredFilterCoef[a_pos][i] = STANDARD_2D_FILTER[a_pos][i];
        }
        DequantizeFilterCoefficients(DiffQFilterCoef[a_pos], FilterCoef[a_pos]);
        // add differences to predicted values
        for(i=FILTER_SIZE*FILTER_OFFSET; i < FILTER_SIZE*(FILTER_OFFSET+1); i++)
        {
          FilterCoef[a_pos][i] += PredFilterCoef[a_pos][i];
        }
      }
      else
      {
        for(i=0; i < SQR_FILTER; i++)
          FilterCoef[a_pos][i] = STANDARD_2D_FILTER[a_pos][i];
      }
      ExtendFilterCoefficientsFloat(c_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(d_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(l_pos,FilterCoef);
      //predict e_pos
      for(i=0; i < SQR_FILTER; i++)
      {
        PredFilterCoef[e_pos][i] = STANDARD_2D_FILTER[e_pos][i];
        PredFilterCoef[f_pos][i] = STANDARD_2D_FILTER[f_pos][i];
        PredFilterCoef[j_pos][i] = STANDARD_2D_FILTER[j_pos][i];
      }
      DequantizeFilterCoefficients(DiffQFilterCoef[e_pos], FilterCoef[e_pos]);
      DequantizeFilterCoefficients(DiffQFilterCoef[f_pos], FilterCoef[f_pos]);
      DequantizeFilterCoefficients(DiffQFilterCoef[j_pos], FilterCoef[j_pos]);
      for(i = 0; i < SQR_FILTER; i++)
      {
        FilterCoef[e_pos][i] += PredFilterCoef[e_pos][i];
        FilterCoef[f_pos][i] += PredFilterCoef[f_pos][i];
        FilterCoef[j_pos][i] += PredFilterCoef[j_pos][i];
      }
      ExtendFilterCoefficientsFloat(g_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(i_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(k_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(m_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(n_pos,FilterCoef);
      ExtendFilterCoefficientsFloat(o_pos,FilterCoef);
    }
    else
    {
      multplier = 1<<FILTCOEF_BITS;
      for(j = 0; j < 15; j++)
      {
        multplier = 1<<nQBits[j];
        for(i = 0; i < SQR_FILTER; i++)
        {
          if (STANDARD_2D_FILTER[j][i]>=0) signFC = 1; else signFC = -1;
          abs_value = STANDARD_2D_FILTER[j][i]*multplier;
          abs_value = fabs(abs_value) + 0.5;
          // define a integer representation of the FC.
          PredFilterCoef16bits[j][i] = (short int)abs_value*signFC;
          FilterCoef_16bits[j][i] = PredFilterCoef16bits[j][i] + DiffQFilterCoef[j][i];
          FilterCoef[j][i]= (double)FilterCoef_16bits[j][i]/(double)multplier;
        }
      }
      ExtendFilterCoefficientsShort(h_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(c_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(d_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(l_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(g_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(i_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(k_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(m_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(n_pos,FilterCoef_16bits);
      ExtendFilterCoefficientsShort(o_pos,FilterCoef_16bits);

    }
  }


}
#endif

#ifdef E_DAIF

void CalculateFilterCoefficientsInt(void)
{
  int i, j; 
  int filterHalfLen = (FILTER_SIZE_INT/2)+1; 
  double filterIntFixed[] = 
  {
    41./2048.,  -72./2048.,  61./2048., 0., 0.,   
    -51./2048.,  -68./2048., 246./2048., 0., 0., 
    -20./2048.,  420./2048.,1229./2048., 0., 0.,
    0.,          0.,         0., 0., 0., 
    0.,          0.,         0., 0., 0., 
  };
  double predFilter[SQR_FILTER_INT]; 
  int factor;
  double is; 
  int numQBits;

  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; 

  // predict top-left quadrant from fixed filter and quantize
  for(i = 0; i < filterHalfLen; i++)
  {
    for(j = 0; j < filterHalfLen; j++)
    {
      numQBits = numQBitsInt[i*FILTER_SIZE_INT+j]-1; // 1-bit for sign
      factor = (1<<numQBits); 
      predFilter[i*FILTER_SIZE_INT+j] = filterIntFixed[i*FILTER_SIZE_INT+j];
      is = (double)(DiffQFilterCoeffInt[i*FILTER_SIZE_INT+j])/(double)factor;
      FilterCoefInt[i*FILTER_SIZE_INT+j] = predFilter[i*FILTER_SIZE_INT+j]+is; 
    }
  }

  // predict top-right quadrant from top-left quadrant and quantize
  for(i = 0; i < filterHalfLen; i++)
  {
    for(j = filterHalfLen; j < FILTER_SIZE_INT; j++)
    {
      numQBits = numQBitsInt[i*FILTER_SIZE_INT+j]-1; // 1-bit for sign
      factor = (1<<numQBits); 
      predFilter[i*FILTER_SIZE_INT+j] = FilterCoefInt[i*FILTER_SIZE_INT+(FILTER_SIZE_INT-1-j)];
      is = (double)(DiffQFilterCoeffInt[i*FILTER_SIZE_INT+j])/(double)factor;
      FilterCoefInt[i*FILTER_SIZE_INT+j] = predFilter[i*FILTER_SIZE_INT+j]+is; 
    }
  }

  // predict bottom half from top half and quantize
  for(i = filterHalfLen; i < FILTER_SIZE_INT; i++)
  {
    for(j = 0; j < FILTER_SIZE_INT; j++)
    {
      numQBits = numQBitsInt[i*FILTER_SIZE_INT+j]-1; // 1-bit for sign
      factor = (1<<numQBits); 
      predFilter[i*FILTER_SIZE_INT+j] = FilterCoefInt[(FILTER_SIZE_INT-1-i)*FILTER_SIZE_INT+j];
      is = (double)(DiffQFilterCoeffInt[i*FILTER_SIZE_INT+j])/(double)factor;
      FilterCoefInt[i*FILTER_SIZE_INT+j] = predFilter[i*FILTER_SIZE_INT+j]+is; 
    }
  }

  // full-pel filter offset
  bitsForOffsetFrac = offsetFracCodeLen[DiffQFilterOffsetIntI];
  factor = 1<<bitsForOffsetFrac;
  FilterCoefInt[SQR_FILTER_INT-1] = (double)DiffQFilterOffsetIntI + (double)DiffQFilterOffsetIntF/(double)factor; 
  FilterCoefInt[SQR_FILTER_INT-1] = FilterCoefInt[SQR_FILTER_INT-1] *DiffQFilterOffsetIntSign; 
}

void CalculateFilterCoefficients_EDAIF(void)
{
  int i;
  int sub_pos;
  int FILTCOEF_BITS = NumberOfQBits;

  if(img->AdaptiveFilterFlag)
  {
    memset(&FilterCoef[0][0], 0, sizeof(double)*15*SQR_FILTER);
    if (img->ImpType == IMP_FLOAT32)
    {
      for(sub_pos=0; sub_pos < 15; sub_pos++)
      {
        if (!FilterFlag[sub_pos])
        {
          memcpy(&FilterCoef[sub_pos][0],&STANDARD_2D_FILTER_orig[sub_pos][0],sizeof(double)*SQR_FILTER);
        }
        else if((SymmetryPosition[sub_pos]))
        {
          DequantizeFilterCoefficientsExt(DiffQFilterCoef[sub_pos], FILTCOEF_BITS, 
            DiffQFilterOffsetI[sub_pos], DiffQFilterOffsetF[sub_pos], DiffQFilterOffsetSign[sub_pos], 
            FilterCoef[sub_pos]);
          for(i=0; i < SQR_FILTER; i++)
          {
            FilterCoef[sub_pos][i] += STANDARD_2D_FILTER[sub_pos][i];
          }
        }
      }
      if(FilterFlag[c_pos])
        ExtendFilterCoefficientsFloat(c_pos,FilterCoef);
      if(FilterFlag[d_pos])
        ExtendFilterCoefficientsFloat(d_pos,FilterCoef);
      if(FilterFlag[g_pos])
        ExtendFilterCoefficientsFloat(g_pos,FilterCoef);
      if(FilterFlag[h_pos])
        ExtendFilterCoefficientsFloat(h_pos,FilterCoef);
      if(FilterFlag[i_pos])
        ExtendFilterCoefficientsFloat(i_pos,FilterCoef);
      if(FilterFlag[k_pos])
        ExtendFilterCoefficientsFloat(k_pos,FilterCoef);
      if(FilterFlag[l_pos])
        ExtendFilterCoefficientsFloat(l_pos,FilterCoef);
      if(FilterFlag[m_pos])
        ExtendFilterCoefficientsFloat(m_pos,FilterCoef);
      if(FilterFlag[n_pos])
        ExtendFilterCoefficientsFloat(n_pos,FilterCoef);
      if(FilterFlag[o_pos])
        ExtendFilterCoefficientsFloat(o_pos,FilterCoef);
      // offset 
      for(sub_pos=0; sub_pos < 15; sub_pos++)
      {
        if(!(SymmetryPosition[sub_pos]))
          FilterCoef[sub_pos][SQR_FILTER-1] = FilterCoef[FILTER_NEW_SUB_POS[sub_pos]][SQR_FILTER-1];
      }
    }
    else
    {
      printf("ERROR: Current implementation of DAIF supports only IMP_FLOAT32\n");
    }

    if(FilterFlagInt)
      CalculateFilterCoefficientsInt(); 
    else 
    {
      for(i=0; i < SQR_FILTER_INT; i++)
        FilterCoefInt[i] = 0.;
      FilterCoefInt[12] = 1.0; 
    }
  }
}
#endif  // E_DAIF

// separable aif (BEGIN)
/*!
************************************************************************
* \brief
*    Predict and calculate filter coefficients for separable filter
************************************************************************
*/
void CalculateFilterCoefficientsSep(void)
{
  int i,sub_pel;
  if(img->AdaptiveFilterFlag)
  {
    for(sub_pel = a_pos; sub_pel <= o_pos; sub_pel++)
    {
      if(FilterFlag[sub_pel])
      {
        DequantizeFilterCoefficients(DiffQFilterCoef[sub_pel], FilterCoef[sub_pel]);
        // add differences to predicted values
        for(i=0; i < FILTER_SIZE; i++)
        {
          FilterCoef[sub_pel][i] += STANDARD_2D_FILTER_SEP[sub_pel][i];
        }
      }
      else
      {
        for(i=0; i < FILTER_SIZE; i++)
          FilterCoef[sub_pel][i] = STANDARD_2D_FILTER_SEP[sub_pel][i];
      }
    }
  }
  else
    for(sub_pel = a_pos; sub_pel <= o_pos; sub_pel++)
      for(i = 0; i < FILTER_SIZE; i++)
        FilterCoef[sub_pel][i] = STANDARD_2D_FILTER_SEP[sub_pel][i];
}
// separable aif (END)
/*!
************************************************************************
* \brief
*   inverse quantization of filter coefficients
*    input:
*        int QFCoef[][] - filter coefficients to be dequantized
*    output:
*        int FCoef[][]   - double filter coefficients
************************************************************************
*/
void DequantizeFilterCoefficients(int QFCoef[SQR_FILTER], double FCoef[SQR_FILTER])
{
  double number_of_steps = pow(2,NumberOfQBits-1);  // 1 bit for sign, NumberOfQBits-1 for amplitude
  int j;
  double is = 0.0;
  for(j=0; j < SQR_FILTER; j++)
  {
    is = (double)(QFCoef[j]);
    is = is/(double)number_of_steps;
    FCoef[j]  = is;  // reconstructed (quantized) filter coefficients
  }
}