Add unit tests for InterPrediction xFpBiDirOptFlow

We have both x86 and Arm implementations of this kernel, so add some
simple unit tests to ensure that the behaviour matches between them.

This requires us to extract the C fallback implementation for
xFpBiDirOptFlow to its own function and wire it up as the default
function pointer. As part of this we also need to move xRightShiftMSB to
be a non-member function so it is callable from the new fallback
implementation.

Similar to other unit tests, we add a new `enableOpt` parameter to the
`InterPredInterpolation::init` function to allow us to construct both a
reference and optimized object to compare against in the test.

Author: georges-arm

source/Lib/CommonLib/InterPrediction.cpp

@@ -154,7 +154,10 @@ void gradFilterCore(const Pel* pSrc, int srcStride, int width, int height, int g
   }
 }
 
-void calcBDOFSumsCore(const Pel* srcY0Tmp, const Pel* srcY1Tmp, Pel* gradX0, Pel* gradX1, Pel* gradY0, Pel* gradY1, int xu, int yu, const int src0Stride, const int src1Stride, const int widthG, const int bitDepth, int* sumAbsGX, int* sumAbsGY, int* sumDIX, int* sumDIY, int* sumSignGY_GX)
+void calcBDOFSumsCore( const Pel* srcY0Tmp, const Pel* srcY1Tmp, const Pel* gradX0, const Pel* gradX1,
+                       const Pel* gradY0, const Pel* gradY1, int xu, int yu, const int src0Stride, const int src1Stride,
+                       const int widthG, const int bitDepth, int* sumAbsGX, int* sumAbsGY, int* sumDIX, int* sumDIY,
+                       int* sumSignGY_GX )
 {
   int shift4 = 4;
   int shift5 = 1;
@@ -596,6 +599,67 @@ void InterPrediction::xSubPuMC(CodingUnit& cu, PelUnitBuf& predBuf, const RefPic
   cu.affine = isAffine;
 }
 
+static inline int xRightShiftMSB( int numer, int denom )
+{
+  return numer >> floorLog2( denom );
+}
+
+void xFpBiDirOptFlowCore( const Pel* srcY0, const Pel* srcY1, const Pel* gradX0, const Pel* gradX1, const Pel* gradY0,
+                          const Pel* gradY1, const int width, const int height, Pel* dstY, const ptrdiff_t dstStride,
+                          const int shiftNum, const int offset, const int limit, const ClpRng& clpRng,
+                          const int bitDepth )
+{
+  int xUnit = width >> 2;
+  int yUnit = height >> 2;
+  int widthG = width + 2 * BDOF_EXTEND_SIZE;
+
+  int offsetPos = widthG * BDOF_EXTEND_SIZE + BDOF_EXTEND_SIZE;
+  int stridePredMC = widthG + 2;
+
+  const int src0Stride = stridePredMC;
+  const int src1Stride = stridePredMC;
+
+  const Pel* srcY0Temp = srcY0;
+  const Pel* srcY1Temp = srcY1;
+
+  for( int yu = 0; yu < yUnit; yu++ )
+  {
+    for( int xu = 0; xu < xUnit; xu++ )
+    {
+      int tmpx = 0, tmpy = 0;
+      int sumAbsGX = 0, sumAbsGY = 0, sumDIX = 0, sumDIY = 0;
+      int sumSignGY_GX = 0;
+
+      const Pel* pGradX0Tmp = gradX0 + ( xu << 2 ) + ( yu << 2 ) * widthG;
+      const Pel* pGradX1Tmp = gradX1 + ( xu << 2 ) + ( yu << 2 ) * widthG;
+      const Pel* pGradY0Tmp = gradY0 + ( xu << 2 ) + ( yu << 2 ) * widthG;
+      const Pel* pGradY1Tmp = gradY1 + ( xu << 2 ) + ( yu << 2 ) * widthG;
+      const Pel* SrcY1Tmp = srcY1 + ( xu << 2 ) + ( yu << 2 ) * src1Stride;
+      const Pel* SrcY0Tmp = srcY0 + ( xu << 2 ) + ( yu << 2 ) * src0Stride;
+
+      calcBDOFSumsCore( SrcY0Tmp, SrcY1Tmp, pGradX0Tmp, pGradX1Tmp, pGradY0Tmp, pGradY1Tmp, xu, yu, src0Stride,
+                        src1Stride, widthG, bitDepth, &sumAbsGX, &sumAbsGY, &sumDIX, &sumDIY, &sumSignGY_GX );
+      tmpx = ( sumAbsGX == 0 ? 0 : xRightShiftMSB( 4 * sumDIX, sumAbsGX ) );
+      tmpx = Clip3( -limit, limit, tmpx );
+
+      const int tmpData = sumSignGY_GX * tmpx >> 1;
+      tmpy = ( sumAbsGY == 0 ? 0 : xRightShiftMSB( ( 4 * sumDIY - tmpData ), sumAbsGY ) );
+      tmpy = Clip3( -limit, limit, tmpy );
+
+      srcY0Temp = srcY0 + ( stridePredMC + 1 ) + ( ( yu * src0Stride + xu ) << 2 );
+      srcY1Temp = srcY1 + ( stridePredMC + 1 ) + ( ( yu * src0Stride + xu ) << 2 );
+      pGradX0Tmp = gradX0 + offsetPos + ( ( yu * widthG + xu ) << 2 );
+      pGradX1Tmp = gradX1 + offsetPos + ( ( yu * widthG + xu ) << 2 );
+      pGradY0Tmp = gradY0 + offsetPos + ( ( yu * widthG + xu ) << 2 );
+      pGradY1Tmp = gradY1 + offsetPos + ( ( yu * widthG + xu ) << 2 );
+
+      Pel* dstY0 = dstY + ( ( yu * dstStride + xu ) << 2 );
+      addBDOFAvgCore( srcY0Temp, src0Stride, srcY1Temp, src1Stride, dstY0, dstStride, pGradX0Tmp, pGradX1Tmp,
+                      pGradY0Tmp, pGradY1Tmp, widthG, ( 1 << 2 ), ( 1 << 2 ), tmpx, tmpy, shiftNum, offset, clpRng );
+    } // xu
+  } // yu
+}
+
 InterPredInterpolation::InterPredInterpolation()
   : m_storedMv(nullptr)
   , m_skipPROF(false)
@@ -639,7 +703,7 @@ void InterPredInterpolation::destroy()
   }
 }
 
-void InterPredInterpolation::init()
+void InterPredInterpolation::init( bool enableOpt )
 {
   for( uint32_t c = 0; c < MAX_NUM_COMP; c++ )
   {
@@ -672,18 +736,21 @@ void InterPredInterpolation::init()
 
   m_if.initInterpolationFilter( true );
 
+  xFpBiDirOptFlow = xFpBiDirOptFlowCore;
   xFpBDOFGradFilter = gradFilterCore;
   xFpProfGradFilter = gradFilterCore<false>;
   xFpApplyPROF      = applyPROFCore;
   xFpPadDmvr        = padDmvrCore;
 
+  if( enableOpt )
+  {
 #if ENABLE_SIMD_OPT_BDOF && defined( TARGET_SIMD_X86 )
-  initInterPredictionX86();
+    initInterPredictionX86();
 #endif
-
 #if ENABLE_SIMD_OPT_BDOF && defined( TARGET_SIMD_ARM )
-  initInterPredictionARM();
+    initInterPredictionARM();
 #endif
+  }
 
   if (m_storedMv == nullptr)
   {
@@ -841,11 +908,6 @@ void InterPredInterpolation::xPredInterBlk( const ComponentID compID, const Codi
   }
 }
 
-int InterPredInterpolation::xRightShiftMSB( int numer, int denom )
-{
-  return ( numer >> floorLog2( denom ) );
-}
-
 void InterPredInterpolation::xApplyBDOF( PelBuf& yuvDst, const ClpRng& clpRng )
 {
   const int     bitDepth  = clpRng.bd;
@@ -854,7 +916,6 @@ void InterPredInterpolation::xApplyBDOF( PelBuf& yuvDst, const ClpRng& clpRng )
   const int     width     = yuvDst.width;
   int           heightG   = height + 2 * BDOF_EXTEND_SIZE;
   int           widthG    = width + 2 * BDOF_EXTEND_SIZE;
-  int           offsetPos = widthG*BDOF_EXTEND_SIZE + BDOF_EXTEND_SIZE;
 
   Pel*          gradX0 = m_gradX0;
   Pel*          gradX1 = m_gradX1;
@@ -864,13 +925,9 @@ void InterPredInterpolation::xApplyBDOF( PelBuf& yuvDst, const ClpRng& clpRng )
   int           stridePredMC = widthG + 2;
   const Pel*    srcY0 = m_filteredBlockTmp[2][COMP_Y] + stridePredMC + 1;
   const Pel*    srcY1 = m_filteredBlockTmp[3][COMP_Y] + stridePredMC + 1;
-  const int     src0Stride = stridePredMC;
-  const int     src1Stride = stridePredMC;
 
   Pel*          dstY = yuvDst.buf;
-  const int     dstStride = yuvDst.stride;
-  const Pel*    srcY0Temp = srcY0;
-  const Pel*    srcY1Temp = srcY1;
+  const int dstStride = yuvDst.stride;
 
   for (int refList = 0; refList < NUM_REF_PIC_LIST_01; refList++)
   {
@@ -896,53 +953,8 @@ void InterPredInterpolation::xApplyBDOF( PelBuf& yuvDst, const ClpRng& clpRng )
   const int   offset = (1 << (shiftNum - 1)) + 2 * IF_INTERNAL_OFFS;
   const int   limit = (1 << 4) - 1;
 
-  if( xFpBiDirOptFlow )
-  {
-    xFpBiDirOptFlow( srcY0, srcY1, gradX0, gradX1, gradY0, gradY1, width, height, dstY, dstStride, shiftNum, offset, limit, clpRng, bitDepth );
-    return;
-  }
-
-  int xUnit = (width >> 2);
-  int yUnit = (height >> 2);
-
-  Pel* dstY0 = dstY;
-  gradX0 = m_gradX0; gradX1 = m_gradX1;
-  gradY0 = m_gradY0; gradY1 = m_gradY1;
-
-  for (int yu = 0; yu < yUnit; yu++)
-  {
-    for (int xu = 0; xu < xUnit; xu++)
-    {
-      int tmpx = 0, tmpy = 0;
-      int sumAbsGX = 0, sumAbsGY = 0, sumDIX = 0, sumDIY = 0;
-      int sumSignGY_GX = 0;
-
-      Pel* pGradX0Tmp = m_gradX0 + (xu << 2) + (yu << 2) * widthG;
-      Pel* pGradX1Tmp = m_gradX1 + (xu << 2) + (yu << 2) * widthG;
-      Pel* pGradY0Tmp = m_gradY0 + (xu << 2) + (yu << 2) * widthG;
-      Pel* pGradY1Tmp = m_gradY1 + (xu << 2) + (yu << 2) * widthG;
-      const Pel* SrcY1Tmp = srcY1 + (xu << 2) + (yu << 2) * src1Stride;
-      const Pel* SrcY0Tmp = srcY0 + (xu << 2) + (yu << 2) * src0Stride;
-
-      calcBDOFSumsCore(SrcY0Tmp, SrcY1Tmp, pGradX0Tmp, pGradX1Tmp, pGradY0Tmp, pGradY1Tmp, xu, yu, src0Stride, src1Stride, widthG, bitDepth, &sumAbsGX, &sumAbsGY, &sumDIX, &sumDIY, &sumSignGY_GX);
-      tmpx = (sumAbsGX == 0 ? 0 : xRightShiftMSB(4 * sumDIX, sumAbsGX));
-      tmpx = Clip3(-limit, limit, tmpx);
-
-      const int tmpData = sumSignGY_GX * tmpx >> 1;
-      tmpy = (sumAbsGY == 0 ? 0 : xRightShiftMSB((4 * sumDIY - tmpData), sumAbsGY));
-      tmpy = Clip3(-limit, limit, tmpy);
-
-      srcY0Temp = srcY0 + (stridePredMC + 1) + ((yu*src0Stride + xu) << 2);
-      srcY1Temp = srcY1 + (stridePredMC + 1) + ((yu*src0Stride + xu) << 2);
-      gradX0 = m_gradX0 + offsetPos + ((yu*widthG + xu) << 2);
-      gradX1 = m_gradX1 + offsetPos + ((yu*widthG + xu) << 2);
-      gradY0 = m_gradY0 + offsetPos + ((yu*widthG + xu) << 2);
-      gradY1 = m_gradY1 + offsetPos + ((yu*widthG + xu) << 2);
-
-      dstY0 = dstY + ((yu*dstStride + xu) << 2);
-      addBDOFAvgCore(srcY0Temp, src0Stride, srcY1Temp, src1Stride, dstY0, dstStride, gradX0, gradX1, gradY0, gradY1, widthG, (1 << 2), (1 << 2), tmpx, tmpy, shiftNum, offset, clpRng);
-    }  // xu
-  }  // yu
+  xFpBiDirOptFlow( srcY0, srcY1, gradX0, gradX1, gradY0, gradY1, width, height, dstY, dstStride, shiftNum, offset,
+                   limit, clpRng, bitDepth );
 }
 
 void InterPredInterpolation::xWeightedAverage( const CodingUnit& cu, const CPelUnitBuf& pcYuvSrc0, const CPelUnitBuf& pcYuvSrc1, PelUnitBuf& pcYuvDst, const bool bdofApplied, PelUnitBuf *yuvPredTmp )

source/Lib/CommonLib/InterPrediction.h

@@ -89,14 +89,16 @@ class InterPredInterpolation
   Pel*                 m_filteredBlockTmp     [LUMA_INTERPOLATION_FILTER_SUB_SAMPLE_POSITIONS_SIGNAL][MAX_NUM_COMP];
   int                  m_ifpLines;
 
-  int  xRightShiftMSB         ( int numer, int denom );
   void xApplyBDOF             ( PelBuf& yuvDst, const ClpRng& clpRng );
+
+public:
   void(*xFpBiDirOptFlow)      ( const Pel* srcY0, const Pel* srcY1, const Pel* gradX0, const Pel* gradX1, const Pel* gradY0, const Pel* gradY1, const int width, const int height, Pel* dstY, const ptrdiff_t dstStride, const int shiftNum, const int  offset, const int  limit, const ClpRng& clpRng, const int bitDepth ) = nullptr;
   void(*xFpBDOFGradFilter)    ( const Pel* pSrc, int srcStride, int width, int height, int gradStride, Pel* gradX, Pel* gradY, const int bitDepth );
   void(*xFpProfGradFilter)    ( const Pel* pSrc, int srcStride, int width, int height, int gradStride, Pel* gradX, Pel* gradY, const int bitDepth );
   void(*xFpApplyPROF)         ( Pel* dst, int dstStride, const Pel* src, int srcStride, int width, int height, const Pel* gradX, const Pel* gradY, int gradStride, const int* dMvX, const int* dMvY, int dMvStride, const bool& bi, int shiftNum, Pel offset, const ClpRng& clpRng );
   void(*xFpPadDmvr)           ( const Pel* src, const int srcStride, Pel* dst, const int dstStride, int width, int height, int padSize );
 
+protected:
 #if ENABLE_SIMD_OPT_BDOF && defined( TARGET_SIMD_X86 )
   void initInterPredictionX86();
   template <X86_VEXT vext>
@@ -109,7 +111,6 @@ class InterPredInterpolation
   void _initInterPredictionARM();
 #endif
 
-protected:
   void xWeightedAverage       ( const CodingUnit& cu, const CPelUnitBuf& pcYuvSrc0, const CPelUnitBuf& pcYuvSrc1, PelUnitBuf& pcYuvDst, const bool bdofApplied, PelUnitBuf *yuvPredTmp = NULL );
   void xPredAffineBlk         ( const ComponentID compID, const CodingUnit& cu, const Picture* refPic, const Mv* _mv, PelUnitBuf& dstPic, const bool bi, const ClpRng& clpRng, const RefPicList refPicList = REF_PIC_LIST_X);
   void xPredInterBlk( const ComponentID compID, const CodingUnit& cu, const Picture* refPic, const Mv& _mv, PelUnitBuf& dstPic, const bool bi, const ClpRng& clpRng
@@ -126,8 +127,8 @@ class InterPredInterpolation
 public:
   InterPredInterpolation();
   virtual ~InterPredInterpolation();
-  void    destroy         ();
-  void    init            ();
+  void destroy();
+  void init( bool enableOpt = true );
 
   void    weightedGeoBlk  ( const ClpRngs &clpRngs, CodingUnit& cu, const uint8_t splitDir, int32_t channel,
                             PelUnitBuf &predDst, PelUnitBuf &predSrc0, PelUnitBuf &predSrc1);

test/vvenc_unit_test/vvenc_unit_test.cpp

@@ -52,6 +52,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <stdio.h>
 #include <time.h>
 
+#include "CommonLib/InterPrediction.h"
 #include "CommonLib/MCTF.h"
 #include "CommonLib/TrQuant_EMT.h"
 #include "CommonLib/TypeDef.h"
@@ -71,8 +72,9 @@ static inline bool compare_value( const std::string& context, const T ref, const
   return opt == ref;
 }
 
-static inline bool compare_values_2d( const std::string& context, const TCoeff* ref, const TCoeff* opt, unsigned rows,
-                               unsigned cols, unsigned stride = 0 )
+template<typename T>
+static inline bool compare_values_2d( const std::string& context, const T* ref, const T* opt, unsigned rows,
+                                      unsigned cols, unsigned stride = 0 )
 {
   stride = stride != 0 ? stride : cols;
 
@@ -360,6 +362,98 @@ static bool test_MCTF()
 }
 #endif
 
+#if ENABLE_SIMD_OPT_BDOF
+template<typename G>
+static bool check_one_biDirOptFlow( InterPredInterpolation* ref, InterPredInterpolation* opt, int width, int height,
+                                    ptrdiff_t dstStride, int shift, int offset, int limit, ClpRng clpRng, int bitDepth,
+                                    G input_generator )
+{
+  CHECK( width % 8, "Width must be a multiple of eight" );
+  CHECK( height % 8, "Height must be a multiple of eight" );
+
+  std::ostringstream sstm;
+  sstm << "biDirOptFlow width=" << width << " height=" << height << " shift=" << shift << " offset=" << offset
+       << " limit=" << limit;
+
+  int srcStride = width + 2 * BDOF_EXTEND_SIZE + 2;
+  int gradStride = width + 2;
+
+  std::vector<Pel> srcY0( srcStride * ( height + 2 ) );
+  std::vector<Pel> srcY1( srcStride * ( height + 2 ) );
+  std::vector<Pel> gradX0( gradStride * ( height + 2 ) );
+  std::vector<Pel> gradX1( gradStride * ( height + 2 ) );
+  std::vector<Pel> gradY0( gradStride * ( height + 2 ) );
+  std::vector<Pel> gradY1( gradStride * ( height + 2 ) );
+  std::vector<Pel> dstYref( dstStride * height );
+  std::vector<Pel> dstYopt( dstStride * height );
+
+  // Initialize source buffers.
+  std::generate( srcY0.begin(), srcY0.end(), input_generator );
+  std::generate( srcY1.begin(), srcY1.end(), input_generator );
+  std::generate( gradX0.begin(), gradX0.end(), input_generator );
+  std::generate( gradX1.begin(), gradX1.end(), input_generator );
+  std::generate( gradY0.begin(), gradY0.end(), input_generator );
+  std::generate( gradY1.begin(), gradY1.end(), input_generator );
+
+  ref->xFpBiDirOptFlow( srcY0.data(), srcY1.data(), gradX0.data(), gradX1.data(), gradY0.data(), gradY1.data(), width,
+                        height, dstYref.data(), dstStride, shift, offset, limit, clpRng, bitDepth );
+  opt->xFpBiDirOptFlow( srcY0.data(), srcY1.data(), gradX0.data(), gradX1.data(), gradY0.data(), gradY1.data(), width,
+                        height, dstYopt.data(), dstStride, shift, offset, limit, clpRng, bitDepth );
+  return compare_values_2d( sstm.str(), dstYref.data(), dstYopt.data(), height, dstStride );
+}
+
+static bool check_biDirOptFlow( InterPredInterpolation* ref, InterPredInterpolation* opt, unsigned num_cases, int width,
+                                int height )
+{
+  printf( "Testing InterPred::xFpBiDirOptFlow w=%d h=%d\n", width, height );
+  InputGenerator<Pel> g{ 10 };
+  DimensionGenerator rng;
+
+  for( unsigned i = 0; i < num_cases; ++i )
+  {
+    // Width is either 8 or 16.
+    // DstStride is a multiple of eight in the range width to 128 inclusive.
+    unsigned dstStride = rng.get( width, 128, 8 );
+
+    for( int bitDepth = 8; bitDepth <= 10; bitDepth += 2 )
+    {
+      const unsigned shift = IF_INTERNAL_PREC + 1 - bitDepth;
+      const int offset = ( 1 << ( shift - 1 ) ) + 2 * IF_INTERNAL_OFFS;
+      const int limit = ( 1 << 4 ) - 1;
+      ClpRng clpRng{ bitDepth };
+
+      if( !check_one_biDirOptFlow( ref, opt, width, height, dstStride, shift, offset, limit, clpRng, bitDepth, g ) )
+      {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool test_InterPred()
+{
+  InterPredInterpolation ref;
+  InterPredInterpolation opt;
+
+  ref.init( /*enableOpt=*/false );
+  opt.init( /*enableOpt=*/true );
+
+  unsigned num_cases = NUM_CASES;
+  bool passed = true;
+
+  for( unsigned width = 8; width <= 16; width += 8 )
+  {
+    for( unsigned height = 8; height <= 16; height += 8 )
+    {
+      passed = check_biDirOptFlow( &ref, &opt, num_cases, width, height ) && passed;
+    }
+  }
+  return passed;
+}
+#endif
+
 int main( int argc, char** argv )
 {
   unsigned seed = ( unsigned ) time( NULL );
@@ -370,10 +464,12 @@ int main( int argc, char** argv )
 #if ENABLE_SIMD_TRAFO
   passed = test_TCoeffOps() && passed;
 #endif
-
 #if ENABLE_SIMD_OPT_MCTF
   passed = test_MCTF() && passed;
 #endif
+#if ENABLE_SIMD_OPT_BDOF
+  passed = test_InterPred() && passed;
+#endif
 
   if( !passed )
   {