Ignore:
Timestamp:
11 Jul 2018, 15:19:49 (6 years ago)
Author:
tech
Message:

Merged HTM-16.2-dev@1412

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibCommon/TComInterpolationFilter.cpp

    r1405 r1413  
    44 * granted under this license.
    55 *
    6  * Copyright (c) 2010-2016, ITU/ISO/IEC
     6 * Copyright (c) 2010-2017, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4747#include "TComChromaFormat.h"
    4848
     49#if VECTOR_CODING__INTERPOLATION_FILTER && (RExt__HIGH_BIT_DEPTH_SUPPORT==0)
     50#include <emmintrin.h>
     51#endif
    4952
    5053//! \ingroup TLibCommon
     
    7578};
    7679
    77 #if NH_3D_ARP
     80#if VECTOR_CODING__INTERPOLATION_FILTER && (RExt__HIGH_BIT_DEPTH_SUPPORT==0)
     81inline __m128i simdInterpolateLuma4( Short const *src , Int srcStride , __m128i *mmCoeff , const __m128i & mmOffset , Int shift )
     82{
     83  __m128i sumHi = _mm_setzero_si128();
     84  __m128i sumLo = _mm_setzero_si128();
     85  for( Int n = 0 ; n < 8 ; n++ )
     86  {
     87    __m128i mmPix = _mm_loadl_epi64( ( __m128i* )src );
     88    __m128i hi = _mm_mulhi_epi16( mmPix , mmCoeff[n] );
     89    __m128i lo = _mm_mullo_epi16( mmPix , mmCoeff[n] );
     90    sumHi = _mm_add_epi32( sumHi , _mm_unpackhi_epi16( lo , hi ) );
     91    sumLo = _mm_add_epi32( sumLo , _mm_unpacklo_epi16( lo , hi ) );
     92    src += srcStride;
     93  }
     94  sumHi = _mm_srai_epi32( _mm_add_epi32( sumHi , mmOffset ) , shift );
     95  sumLo = _mm_srai_epi32( _mm_add_epi32( sumLo , mmOffset ) , shift );
     96  return( _mm_packs_epi32( sumLo , sumHi ) );
     97}
     98
     99inline __m128i simdInterpolateChroma4( Short const *src , Int srcStride , __m128i *mmCoeff , const __m128i & mmOffset , Int shift )
     100{
     101  __m128i sumHi = _mm_setzero_si128();
     102  __m128i sumLo = _mm_setzero_si128();
     103  for( Int n = 0 ; n < 4 ; n++ )
     104  {
     105    __m128i mmPix = _mm_loadl_epi64( ( __m128i* )src );
     106    __m128i hi = _mm_mulhi_epi16( mmPix , mmCoeff[n] );
     107    __m128i lo = _mm_mullo_epi16( mmPix , mmCoeff[n] );
     108    sumHi = _mm_add_epi32( sumHi , _mm_unpackhi_epi16( lo , hi ) );
     109    sumLo = _mm_add_epi32( sumLo , _mm_unpacklo_epi16( lo , hi ) );
     110    src += srcStride;
     111  }
     112  sumHi = _mm_srai_epi32( _mm_add_epi32( sumHi , mmOffset ) , shift );
     113  sumLo = _mm_srai_epi32( _mm_add_epi32( sumLo , mmOffset ) , shift );
     114  return( _mm_packs_epi32( sumLo , sumHi ) );
     115}
     116
     117inline __m128i simdInterpolateLuma8( Short const *src , Int srcStride , __m128i *mmCoeff , const __m128i & mmOffset , Int shift )
     118{
     119  __m128i sumHi = _mm_setzero_si128();
     120  __m128i sumLo = _mm_setzero_si128();
     121  for( Int n = 0 ; n < 8 ; n++ )
     122  {
     123    __m128i mmPix = _mm_loadu_si128( ( __m128i* )src );
     124    __m128i hi = _mm_mulhi_epi16( mmPix , mmCoeff[n] );
     125    __m128i lo = _mm_mullo_epi16( mmPix , mmCoeff[n] );
     126    sumHi = _mm_add_epi32( sumHi , _mm_unpackhi_epi16( lo , hi ) );
     127    sumLo = _mm_add_epi32( sumLo , _mm_unpacklo_epi16( lo , hi ) );
     128    src += srcStride;
     129  }
     130  sumHi = _mm_srai_epi32( _mm_add_epi32( sumHi , mmOffset ) , shift );
     131  sumLo = _mm_srai_epi32( _mm_add_epi32( sumLo , mmOffset ) , shift );
     132  return( _mm_packs_epi32( sumLo , sumHi ) );
     133}
     134
     135inline __m128i simdInterpolateLuma2P8( Short const *src , Int srcStride , __m128i *mmCoeff , const __m128i & mmOffset , Int shift )
     136{
     137  __m128i sumHi = _mm_setzero_si128();
     138  __m128i sumLo = _mm_setzero_si128();
     139  for( Int n = 0 ; n < 2 ; n++ )
     140  {
     141    __m128i mmPix = _mm_loadu_si128( ( __m128i* )src );
     142    __m128i hi = _mm_mulhi_epi16( mmPix , mmCoeff[n] );
     143    __m128i lo = _mm_mullo_epi16( mmPix , mmCoeff[n] );
     144    sumHi = _mm_add_epi32( sumHi , _mm_unpackhi_epi16( lo , hi ) );
     145    sumLo = _mm_add_epi32( sumLo , _mm_unpacklo_epi16( lo , hi ) );
     146    src += srcStride;
     147  }
     148  sumHi = _mm_srai_epi32( _mm_add_epi32( sumHi , mmOffset ) , shift );
     149  sumLo = _mm_srai_epi32( _mm_add_epi32( sumLo , mmOffset ) , shift );
     150  return( _mm_packs_epi32( sumLo , sumHi ) );
     151}
     152
     153inline __m128i simdInterpolateLuma2P4( Short const *src , Int srcStride , __m128i *mmCoeff , const __m128i & mmOffset , Int shift )
     154{
     155  __m128i sumHi = _mm_setzero_si128();
     156  __m128i sumLo = _mm_setzero_si128();
     157  for( Int n = 0 ; n < 2 ; n++ )
     158  {
     159    __m128i mmPix = _mm_loadl_epi64( ( __m128i* )src );
     160    __m128i hi = _mm_mulhi_epi16( mmPix , mmCoeff[n] );
     161    __m128i lo = _mm_mullo_epi16( mmPix , mmCoeff[n] );
     162    sumHi = _mm_add_epi32( sumHi , _mm_unpackhi_epi16( lo , hi ) );
     163    sumLo = _mm_add_epi32( sumLo , _mm_unpacklo_epi16( lo , hi ) );
     164    src += srcStride;
     165  }
     166  sumHi = _mm_srai_epi32( _mm_add_epi32( sumHi , mmOffset ) , shift );
     167  sumLo = _mm_srai_epi32( _mm_add_epi32( sumLo , mmOffset ) , shift );
     168  return( _mm_packs_epi32( sumLo , sumHi ) );
     169}
     170
     171inline __m128i simdClip3( __m128i mmMin , __m128i mmMax , __m128i mmPix )
     172{
     173  __m128i mmMask = _mm_cmpgt_epi16( mmPix , mmMin );
     174  mmPix = _mm_or_si128( _mm_and_si128( mmMask , mmPix ) , _mm_andnot_si128( mmMask , mmMin ) );
     175  mmMask = _mm_cmplt_epi16( mmPix , mmMax );
     176  mmPix = _mm_or_si128( _mm_and_si128( mmMask , mmPix ) , _mm_andnot_si128( mmMask , mmMax ) );
     177  return( mmPix );
     178}
     179#endif
     180
     181#if NH_3D
    78182const Short TComInterpolationFilter::m_lumaFilterARP[4][NTAPS_LUMA_ARP] =
    79183{
     
    240344  }
    241345
     346#if VECTOR_CODING__INTERPOLATION_FILTER && (RExt__HIGH_BIT_DEPTH_SUPPORT==0)
     347  if( bitDepth <= 10 )
     348  {
     349    if( N == 8 && !( width & 0x07 ) )
     350    {
     351      Short minVal = 0;
     352      __m128i mmOffset = _mm_set1_epi32( offset );
     353      __m128i mmCoeff[8];
     354      __m128i mmMin = _mm_set1_epi16( minVal );
     355      __m128i mmMax = _mm_set1_epi16( maxVal );
     356      for( Int n = 0 ; n < 8 ; n++ )
     357        mmCoeff[n] = _mm_set1_epi16( c[n] );
     358      for( row = 0 ; row < height ; row++ )
     359      {
     360        for( col = 0 ; col < width ; col += 8 )
     361        {
     362          __m128i mmFiltered = simdInterpolateLuma8( src + col , cStride , mmCoeff , mmOffset , shift );
     363          if( isLast )
     364          {
     365            mmFiltered = simdClip3( mmMin , mmMax , mmFiltered );
     366          }
     367          _mm_storeu_si128( ( __m128i * )( dst + col ) , mmFiltered );
     368        }
     369        src += srcStride;
     370        dst += dstStride;
     371      }
     372      return;
     373    }
     374    else if( N == 8 && !( width & 0x03 ) )
     375    {
     376      Short minVal = 0;
     377      __m128i mmOffset = _mm_set1_epi32( offset );
     378      __m128i mmCoeff[8];
     379      __m128i mmMin = _mm_set1_epi16( minVal );
     380      __m128i mmMax = _mm_set1_epi16( maxVal );
     381      for( Int n = 0 ; n < 8 ; n++ )
     382        mmCoeff[n] = _mm_set1_epi16( c[n] );
     383      for( row = 0 ; row < height ; row++ )
     384      {
     385        for( col = 0 ; col < width ; col += 4 )
     386        {
     387          __m128i mmFiltered = simdInterpolateLuma4( src + col , cStride , mmCoeff , mmOffset , shift );
     388          if( isLast )
     389          {
     390            mmFiltered = simdClip3( mmMin , mmMax , mmFiltered );
     391          }
     392          _mm_storel_epi64( ( __m128i * )( dst + col ) , mmFiltered );
     393        }
     394        src += srcStride;
     395        dst += dstStride;
     396      }
     397      return;
     398    }
     399    else if( N == 4 && !( width & 0x03 ) )
     400    {
     401      Short minVal = 0;
     402      __m128i mmOffset = _mm_set1_epi32( offset );
     403      __m128i mmCoeff[8];
     404      __m128i mmMin = _mm_set1_epi16( minVal );
     405      __m128i mmMax = _mm_set1_epi16( maxVal );
     406      for( Int n = 0 ; n < 4 ; n++ )
     407        mmCoeff[n] = _mm_set1_epi16( c[n] );
     408      for( row = 0 ; row < height ; row++ )
     409      {
     410        for( col = 0 ; col < width ; col += 4 )
     411        {
     412          __m128i mmFiltered = simdInterpolateChroma4( src + col , cStride , mmCoeff , mmOffset , shift );
     413          if( isLast )
     414          {
     415            mmFiltered = simdClip3( mmMin , mmMax , mmFiltered );
     416          }
     417          _mm_storel_epi64( ( __m128i * )( dst + col ) , mmFiltered );
     418        }
     419        src += srcStride;
     420        dst += dstStride;
     421      }
     422      return;
     423    }
     424    else if( N == 2 && !( width & 0x07 ) )
     425    {
     426      Short minVal = 0;
     427      __m128i mmOffset = _mm_set1_epi32( offset );
     428      __m128i mmCoeff[2];
     429      __m128i mmMin = _mm_set1_epi16( minVal );
     430      __m128i mmMax = _mm_set1_epi16( maxVal );
     431      for( Int n = 0 ; n < 2 ; n++ )
     432        mmCoeff[n] = _mm_set1_epi16( c[n] );
     433      for( row = 0 ; row < height ; row++ )
     434      {
     435        for( col = 0 ; col < width ; col += 8 )
     436        {
     437          __m128i mmFiltered = simdInterpolateLuma2P8( src + col , cStride , mmCoeff , mmOffset , shift );
     438          if( isLast )
     439          {
     440            mmFiltered = simdClip3( mmMin , mmMax , mmFiltered );
     441          }
     442          _mm_storeu_si128( ( __m128i * )( dst + col ) , mmFiltered );
     443        }
     444        src += srcStride;
     445        dst += dstStride;
     446      }
     447      return;
     448    }
     449    else if( N == 2 && !( width & 0x03 ) )
     450    {
     451      Short minVal = 0;
     452      __m128i mmOffset = _mm_set1_epi32( offset );
     453      __m128i mmCoeff[8];
     454      __m128i mmMin = _mm_set1_epi16( minVal );
     455      __m128i mmMax = _mm_set1_epi16( maxVal );
     456      for( Int n = 0 ; n < 2 ; n++ )
     457        mmCoeff[n] = _mm_set1_epi16( c[n] );
     458      for( row = 0 ; row < height ; row++ )
     459      {
     460        for( col = 0 ; col < width ; col += 4 )
     461        {
     462          __m128i mmFiltered = simdInterpolateLuma2P4( src + col , cStride , mmCoeff , mmOffset , shift );
     463          if( isLast )
     464          {
     465            mmFiltered = simdClip3( mmMin , mmMax , mmFiltered );
     466          }
     467          _mm_storel_epi64( ( __m128i * )( dst + col ) , mmFiltered );
     468        }
     469        src += srcStride;
     470        dst += dstStride;
     471      }
     472      return;
     473    }
     474  }
     475#endif
     476
    242477  for (row = 0; row < height; row++)
    243478  {
     
    360595 * \param  bitDepth   Bit depth
    361596 */
    362 #if NH_3D_ARP
     597#if NH_3D
    363598Void TComInterpolationFilter::filterHor(const ComponentID compID, Pel *src, Int srcStride, Pel *dst, Int dstStride, Int width, Int height, Int frac, Bool isLast, const ChromaFormat fmt, const Int bitDepth, Bool filterType )
    364599#else
     
    374609  {
    375610    assert(frac >= 0 && frac < LUMA_INTERPOLATION_FILTER_SUB_SAMPLE_POSITIONS);
    376 #if NH_3D_ARP
     611#if NH_3D
    377612    if(filterType)
    378613    {
     
    383618#endif
    384619    filterHor<NTAPS_LUMA>(bitDepth, src, srcStride, dst, dstStride, width, height, isLast, m_lumaFilter[frac]);
    385 #if NH_3D_ARP
     620#if NH_3D
    386621    }
    387622#endif
     
    392627    const UInt csx = getComponentScaleX(compID, fmt);
    393628    assert(frac >=0 && csx<2 && (frac<<(1-csx)) < CHROMA_INTERPOLATION_FILTER_SUB_SAMPLE_POSITIONS);
    394 #if NH_3D_ARP
     629#if NH_3D
    395630    if(filterType)
    396631    {
     
    401636#endif
    402637    filterHor<NTAPS_CHROMA>(bitDepth, src, srcStride, dst, dstStride, width, height, isLast, m_chromaFilter[frac<<(1-csx)]);
    403 #if NH_3D_ARP
     638#if NH_3D
    404639    }
    405640#endif
     
    424659 * \param  bitDepth   Bit depth
    425660 */
    426 #if NH_3D_ARP
     661#if NH_3D
    427662Void TComInterpolationFilter::filterVer(const ComponentID compID, Pel *src, Int srcStride, Pel *dst, Int dstStride, Int width, Int height, Int frac, Bool isFirst, Bool isLast, const ChromaFormat fmt, const Int bitDepth, Bool filterType )
    428663#else
     
    437672  {
    438673    assert(frac >= 0 && frac < LUMA_INTERPOLATION_FILTER_SUB_SAMPLE_POSITIONS);
    439 #if NH_3D_ARP
     674#if NH_3D
    440675    if(filterType)
    441676    {
     
    445680    {
    446681#endif
    447     filterVer<NTAPS_LUMA>(bitDepth, src, srcStride, dst, dstStride, width, height, isFirst, isLast, m_lumaFilter[frac]);
    448 #if NH_3D_ARP
     682      filterVer<NTAPS_LUMA>(bitDepth, src, srcStride, dst, dstStride, width, height, isFirst, isLast, m_lumaFilter[frac]);
     683#if NH_3D
    449684    }
    450685#endif
     
    455690    const UInt csy = getComponentScaleY(compID, fmt);
    456691    assert(frac >=0 && csy<2 && (frac<<(1-csy)) < CHROMA_INTERPOLATION_FILTER_SUB_SAMPLE_POSITIONS);
    457 #if NH_3D_ARP
     692#if NH_3D
    458693    if(filterType)
    459694    {
     
    463698    {
    464699#endif
    465     filterVer<NTAPS_CHROMA>(bitDepth, src, srcStride, dst, dstStride, width, height, isFirst, isLast, m_chromaFilter[frac<<(1-csy)]);
    466 #if NH_3D_ARP
    467     }
    468 #endif
    469     }
    470     }
     700      filterVer<NTAPS_CHROMA>(bitDepth, src, srcStride, dst, dstStride, width, height, isFirst, isLast, m_chromaFilter[frac<<(1-csy)]);
     701#if NH_3D
     702    }
     703#endif
     704  }
     705}
    471706//! \}
Note: See TracChangeset for help on using the changeset viewer.