adaptive_filter.c

JM 11.0 KTA 2.1 Source Code

  6,  7,  8,  8,  7,  6,
  0,  1,  2,  2,  1,  0  },
  {35, 29, 23, 17, 11,  5,
  29, 28, 22, 16, 10,  4,
  23, 22, 21, 15,  9,  3,         // o_pos
  17, 16, 15, 14,  8,  2,
  11, 10,  9,  8,  7,  1,
  5,  4,  3,  2,  1,  0  }
};
int FILTER_NEW_SUB_POS[15] = {       a_pos, b_pos, a_pos,
a_pos, e_pos, f_pos, e_pos,
b_pos, f_pos, j_pos, f_pos,
a_pos, e_pos, f_pos, e_pos };
//static int SymmetryPosition[15] = {1,1,0,0,1,1,0,0,0,1,0,0,0,0};

#ifdef E_DAIF
int numQBitsInt[SQR_FILTER_INT-1] = 
{
  12, 12, 12, 12, 12, 
  12, 11, 11, 11, 12, 
  12, 11, 10, 11, 12, 
  12, 11, 11, 11, 12,
  12, 12, 12, 12, 12, 
};

int DiffQFilterOffsetI[15], DiffQFilterOffsetF[15], DiffQFilterOffsetSign[15];
int DiffQFilterOffsetIntI, DiffQFilterOffsetIntF, DiffQFilterOffsetIntSign; 
int DiffQFilterCoeffInt[SQR_FILTER_INT]; 
int FilterFlagInt;
int FILTER_OFFSET_INT = 2; 
double FilterCoefInt[SQR_FILTER_INT];
#endif

int FILTER_SIZE = 6;
int FILTER_OFFSET;
int UseAllSubpelPositions;
int SubpelPositionsPattern;
int DiffQFilterCoef[15][SQR_FILTER];             // differences to be received
int FilterFlag[15];                              // Flags defining if Filter at the particular position calculated
int POS_EQUATION_NUMBER[15];                     // number of different coefficietns for each sub-pel position
int SymmetryPosition[15];
int NumberOfQBits;                               // number of bits used for quantization of
static double FilterCoef[15][SQR_FILTER];                // SQR(PEL)-1 X SQR(FILTER_SIZE) - Filter Coeffitients
short int FilterCoef_16bits[15][SQR_FILTER];             // AIF in integer representation
short int PredFilterCoef16bits[15][SQR_FILTER];          // AVC in integer representation
static int    QFilterCoef[15][SQR_FILTER];       // SQR(PEL)-1 X SQR(FILTER_SIZE) - quantized filter coefficients
//  static double LastFilterCoef[15][SQR_FILTER];  // filter used for previous frame
static double PredFilterCoef[15][SQR_FILTER];    // predicted filter coefficients
static int    QPredFilterCoef[15][SQR_FILTER];   // quantized predicted filter coefficients

#ifdef DIRECTIONAL_FILTER
int IsDiagonal1D[15];
int nQBits[15] = {7,7,7,7,7,8,7,7,8,8,8,7,7,8,7};
void initFilterCustom(int filterID)
{
  memset(FilterFlag,0,15*sizeof(int));
  memset(DiffQFilterCoef, 0, SQR_FILTER*15*sizeof(int));
  memset(FilterCoef, 0, SQR_FILTER*15*sizeof(double));
  if (img->ImpType == IMP_INT16)
    FILTCOEF_BITS = 7;
  else 
    FILTCOEF_BITS = DEFAULT_QUANT;
  if (filterID==FILTER_TYPE_2D_NS)
  {
    memcpy(&STANDARD_2D_FILTER[0][0],&STANDARD_2D_FILTER_orig[0][0],sizeof(double)*15*SQR_FILTER);
    memcpy(&TwoDSymmetricPattern[0][0],&TwoDSymmetricPattern_orig[0][0],sizeof(int)*15*SQR_FILTER);

    memcpy(&IsDiagonal1D[0],&IsDiagonal1D_orig[0],sizeof(int)*15);
    memcpy(&POS_EQUATION_NUMBER[0],&POS_EQUATION_NUMBER_orig[0],sizeof(int)*15);
    memcpy(&FILTER_NEW_SUB_POS[0],&FILTER_NEW_SUB_POS_orig[0],sizeof(int)*15);

  }
#ifdef E_DAIF
  else if (filterID==FILTER_TYPE_1D || filterID == FILTER_TYPE_EDAIF)
#else
  else if (filterID==FILTER_TYPE_1D)
#endif
  {
    NumberOfQBits = FILTCOEF_BITS;
    memcpy(TwoDSymmetricPattern,TwoDSymmetricPattern_v4,sizeof(int)*15*SQR_FILTER);
    memcpy(IsDiagonal1D,IsDiagonal1D_v4,sizeof(int)*15);
    memcpy(POS_EQUATION_NUMBER,POS_EQUATION_NUMBER_v4,sizeof(int)*15);
    memcpy(FILTER_NEW_SUB_POS,FILTER_NEW_SUB_POS_v4,sizeof(int)*15);
    memcpy(&SymmetryPosition[0],&SymmetryPosition_v4[0],sizeof(int)*15);
    memcpy(&STANDARD_2D_FILTER[0][0],STANDARD_2D_FILTER_v4,sizeof(double)*15*SQR_FILTER);
  }
}
#endif
/*!
************************************************************************
* \brief
*    init adaptive filter structure
************************************************************************
*/
void InitAdaptiveFilter(void)
{
  FILTER_OFFSET = (FILTER_SIZE)/2-1;

  POS_EQUATION_NUMBER[a_pos] =  6;
  POS_EQUATION_NUMBER[b_pos] =  3;
  POS_EQUATION_NUMBER[c_pos] =  6;

  POS_EQUATION_NUMBER[d_pos] =  6;
  POS_EQUATION_NUMBER[e_pos] = 21;
  POS_EQUATION_NUMBER[f_pos] = 18;
  POS_EQUATION_NUMBER[g_pos] = 21;

  POS_EQUATION_NUMBER[h_pos] =  3;
  POS_EQUATION_NUMBER[i_pos] = 18;
  POS_EQUATION_NUMBER[j_pos] =  6;
  POS_EQUATION_NUMBER[k_pos] = 18;

  POS_EQUATION_NUMBER[l_pos] =  6;
  POS_EQUATION_NUMBER[m_pos] = 21;
  POS_EQUATION_NUMBER[n_pos] = 18;
  POS_EQUATION_NUMBER[o_pos] = 21;
}


/*!
************************************************************************
* \brief
*    free adaptive filter structure
************************************************************************
*/
void FreeAdaptiveFilter(void)
{
  ;
}

/*
************************************************************************
* \brief
*    reset adaptive filter structure
************************************************************************
*/
void ResetAdaptiveFilter(void)
{
  int sub_pel,i;

  for(sub_pel = 0; sub_pel < 15; sub_pel++)
    for(i = 0; i < SQR_FILTER; i++)
    {
      QPredFilterCoef[sub_pel][i] = 0;
      DiffQFilterCoef[sub_pel][i] = 0;
      QFilterCoef    [sub_pel][i] = 0;
      PredFilterCoef [sub_pel][i] = 0.0;
    }
    NumberOfQBits = DEFAULT_QUANT;
#ifdef DIRECTIONAL_FILTER
    if (img->ImpType==IMP_INT16)
      FILTCOEF_BITS = 7;
    else
      FILTCOEF_BITS = DEFAULT_QUANT;
#endif
}

/*
************************************************************************
* \brief
*    return if adaptive filter is used for current frame
************************************************************************
*/
int UseAdaptiveFilterForCurrentFrame(void)
{
  if( (img->type == P_SLICE || img->type == B_SLICE) && img->UseAdaptiveFilter)
    return 1;
  else
    return 0;
}

#ifdef E_DAIF

static void ZeroFilterOffsets()
{
  int sub_pos;

  for(sub_pos = 0; sub_pos < 15; sub_pos++)
  {
    FilterCoef[sub_pos][SQR_FILTER-1] = 0.;
  }
}
#endif

/*!
************************************************************************
* \brief
*    Predict and calculate filter coefficients
************************************************************************
*/
void CalculateFilterCoefficients(void)
{
  int i,j, sub_pel;

  // at first predict b and h position using inter prediction, b and h are already quantized in last frame
  if(img->AdaptiveFilterFlag)
  {
    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
    if(FilterFlag[e_pos])
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        for(j = 0; j < FILTER_SIZE; j++)
        {
          PredFilterCoef[e_pos][FILTER_SIZE*i+j] =
            FilterCoef[d_pos][FILTER_SIZE*i+FILTER_OFFSET]*FilterCoef[a_pos][FILTER_SIZE*FILTER_OFFSET+j];
        }
      }
      DequantizeFilterCoefficients(DiffQFilterCoef[e_pos], FilterCoef[e_pos]);
      for(i = 0; i < SQR_FILTER; i++)
      {
        FilterCoef[e_pos][i] += PredFilterCoef[e_pos][i];
      }
    }
    else
    {
      for(i=0; i < SQR_FILTER; i++)
        FilterCoef[e_pos][i] = STANDARD_2D_FILTER[e_pos][i];
    }
    ExtendFilterCoefficientsFloat(g_pos,FilterCoef);
    ExtendFilterCoefficientsFloat(m_pos,FilterCoef);
    ExtendFilterCoefficientsFloat(o_pos,FilterCoef);

    //predict f_pos:
    if(FilterFlag[f_pos])
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        for(j = 0; j < FILTER_SIZE; j++)
        {
          PredFilterCoef[f_pos][FILTER_SIZE*i+j] =
            FilterCoef[d_pos][FILTER_SIZE*i+FILTER_OFFSET]*FilterCoef[b_pos][FILTER_SIZE*FILTER_OFFSET+j];
        }
      }
      DequantizeFilterCoefficients(DiffQFilterCoef[f_pos], FilterCoef[f_pos]);
      for(i = 0; i < SQR_FILTER; i++)
      {
        FilterCoef[f_pos][i] += PredFilterCoef[f_pos][i];
      }
    }
    else
    {
      for(i=0; i < SQR_FILTER; i++)
        FilterCoef[f_pos][i] = STANDARD_2D_FILTER[f_pos][i];
    }
    ExtendFilterCoefficientsFloat(i_pos,FilterCoef);
    ExtendFilterCoefficientsFloat(k_pos,FilterCoef);
    ExtendFilterCoefficientsFloat(n_pos,FilterCoef);

    //predict j_pos:
    if(FilterFlag[j_pos])
    {
      for(i = 0; i < FILTER_SIZE; i++)
      {
        for(j = 0; j < FILTER_SIZE; j++)
        {
          PredFilterCoef[j_pos][FILTER_SIZE*i+j] =
            FilterCoef[h_pos][FILTER_SIZE*i+FILTER_OFFSET]*FilterCoef[b_pos][FILTER_SIZE*FILTER_OFFSET+j];
        }
      }
      DequantizeFilterCoefficients(DiffQFilterCoef[j_pos], FilterCoef[j_pos]);
      for(i = 0; i < SQR_FILTER; i++)
      {
        FilterCoef[j_pos][i] += PredFilterCoef[j_pos][i];
      }
    }
    else
    {
      for(i=0; i < SQR_FILTER; i++)
        FilterCoef[j_pos][i] = STANDARD_2D_FILTER[j_pos][i];
    }
  }
  else
    for(sub_pel = 0; sub_pel < 15; sub_pel++)
      for(i = 0; i < SQR_FILTER; i++)
        FilterCoef[sub_pel][i] = STANDARD_2D_FILTER[sub_pel][i];
  //  PrintFilterCoefInt(DiffQFilterCoef);
  //  PrintFilterCoefFloat(PredFilterCoef);
  //  PrintFilterCoefFloat(FilterCoef);

#ifdef E_DAIF
  ZeroFilterOffsets();
#endif
}