/* -----------------------------------------------------------------------------

The copyright in this software is being made available under the Clear BSD

License, included below. No patent rights, trademark rights and/or 

other Intellectual Property Rights other than the copyrights concerning 

the Software are granted under this license.

The Clear BSD License

Copyright (c) 2018-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVdeC Authors.

All rights reserved.

Redistribution and use in source and binary forms, with or without modification,

are permitted (subject to the limitations in the disclaimer below) provided that

the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,

     this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright

     notice, this list of conditions and the following disclaimer in the

     documentation and/or other materials provided with the distribution.

     * Neither the name of the copyright holder nor the names of its

     contributors may be used to endorse or promote products derived from this

     software without specific prior written permission.

NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY

THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER

IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

------------------------------------------------------------------------------------------- */

/** \file     QuantX86.h

    \brief    SIMD for Quant/Dequant

*/

#include "CommonLib/CommonDef.h"

#include "CommonDefX86.h"

#include "CommonLib/Quant.h"

namespace vvdec

{

#if ENABLE_SIMD_OPT_QUANT

#ifdef TARGET_SIMD_X86

#if USE_AVX2 && !defined( _mm256_set_m128i )

#define VVCLIB_OWN_mm256_set_m128i

#define _mm256_set_m128i( v0, v1 ) _mm256_inserti128_si256( _mm256_castsi128_si256( v1 ), ( v0 ), 1 )

#endif

static constexpr unsigned short levmask[16] = {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0,0,0,0,0,0,0,0};

#if USE_AVX2

static constexpr unsigned short xlevmask[32] = {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

#endif

template< X86_VEXT vext>

static void DeQuantScalingCoreSIMD(const int maxX,const int restX,const int maxY,const int scaleQP,const int *piDequantCoef,const TCoeffSig*const piQCoef,const size_t piQCfStride,TCoeff   *const piCoef,const int rightShift,const int inputMaximum,const TCoeff transformMaximum)

{

  const int inputMinimum = -(inputMaximum+1);

  const TCoeff transformMinimum = -(transformMaximum+1);

  const int width = restX+maxX+1;

  __m128i vlevmask;

  if (maxX<7)

    vlevmask = _mm_loadu_si128( ( __m128i const * )&levmask[7-maxX] );

  else

    vlevmask = _mm_set_epi64x(0xffffffffffffffff,0xffffffffffffffff);

#if USE_AVX2

  __m256i xvlevmask;

  if (maxX<15)

    xvlevmask = _mm256_loadu_si256( ( __m256i const * )&xlevmask[15-maxX] );

  else

    xvlevmask = _mm256_set_epi64x(0xffffffffffffffff,0xffffffffffffffff,0xffffffffffffffff,0xffffffffffffffff);

#endif

  if (rightShift>0)

  {

    const Intermediate_Int iAdd = (Intermediate_Int) 1 << (rightShift - 1);

    __m128i v_max =  _mm_set1_epi16 ((short)inputMaximum);

    __m128i v_min =  _mm_set1_epi16 ((short)inputMinimum);

    __m128i v_Tmax =  _mm_set1_epi32 ((short)transformMaximum);

    __m128i v_Tmin =  _mm_set1_epi32 ((short)transformMinimum);

    __m128i v_scaleQP = _mm_set1_epi16 ((short)scaleQP);

    __m128i v_add = _mm_set1_epi32 (iAdd);

    __m128i v_rshift = _mm_set1_epi64x (rightShift);

    if (maxX<4)

    {

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = maxX  > 1 ? _mm_loadu_si64( ( const __m128i* ) &piQCoef[y * piQCfStride] )

                        : maxX == 1 ? _mm_setr_epi16( piQCoef[y * piQCfStride], piQCoef[y * piQCfStride + 1], 0, 0, 0, 0, 0, 0 )

                                    : _mm_setr_epi16( piQCoef[y * piQCfStride], 0, 0, 0, 0, 0, 0, 0 );

        __m128i v_scale = maxX  > 1 ? _mm_loadu_si128( ( const __m128i* ) &piDequantCoef[y * width] )

                                : maxX == 1 ? _mm_setr_epi32( piDequantCoef[y * width], piDequantCoef[y * width + 1], 0, 0 )

                                            : _mm_setr_epi32( piDequantCoef[y * width], 0, 0, 0 );

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scaleQP);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scaleQP);

        v_level = _mm_unpacklo_epi16(v_low,v_high);  

        v_level = _mm_mullo_epi32(v_level,v_scale);

        v_level =  _mm_add_epi32(v_level,v_add);

        v_level = _mm_sra_epi32(v_level,v_rshift);        

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

      }

    }

#if USE_AVX2

    else if (maxX<8)

    {

      __m256i xv_add = _mm256_set1_epi32 (iAdd);

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

        __m256i v_scale = _mm256_loadu_si256( ( const __m256i* ) &piDequantCoef[y * width] );

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scaleQP);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scaleQP);

        __m256i xv_level = _mm256_set_m128i (_mm_unpackhi_epi16(v_low,v_high), _mm_unpacklo_epi16(v_low,v_high));

        xv_level = _mm256_mullo_epi32(xv_level,v_scale);

        xv_level =  _mm256_add_epi32(xv_level,xv_add);

        xv_level = _mm256_sra_epi32(xv_level,v_rshift);

        xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

        xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

        _mm256_storeu_si256(( __m256i * )(piCoef+y*width ), xv_level );

      }

    }

    else

    {

      __m256i xv_max =  _mm256_set1_epi16 ((short)inputMaximum);

      __m256i xv_min =  _mm256_set1_epi16 ((short)inputMinimum);

      __m256i xv_scaleQP = _mm256_set1_epi16 ((short)scaleQP);

      __m256i xv_add = _mm256_set1_epi32 (iAdd);

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      __m256i v_scale_l,v_scale_h;

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=16)

        {

          __m256i xv_level = _mm256_loadu_si256( ( __m256i const * )&piQCoef[x+ y * piQCfStride]  );

          v_scale_l = _mm256_loadu_si256( ( const __m256i* ) &piDequantCoef[y * width + x ]);

          v_scale_h = _mm256_loadu_si256( ( const __m256i* ) &piDequantCoef[y * width + x + 8 ]);

          xv_level = _mm256_and_si256(xv_level,xvlevmask);

          xv_level = _mm256_max_epi16 (xv_level, xv_min);

          xv_level = _mm256_min_epi16 (xv_level, xv_max);

          __m256i xv_low = _mm256_mullo_epi16(xv_level,xv_scaleQP);

          __m256i xv_high = _mm256_mulhi_epi16(xv_level,xv_scaleQP);

          xv_low = _mm256_permute4x64_epi64(xv_low,0xD8);

          xv_high = _mm256_permute4x64_epi64(xv_high,0xD8);

          xv_level = _mm256_unpacklo_epi16(xv_low,xv_high);

          xv_level = _mm256_mullo_epi32(xv_level,v_scale_l);

          xv_level =  _mm256_add_epi32(xv_level,xv_add);

          xv_level = _mm256_sra_epi32(xv_level,v_rshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+x+y*width ), xv_level );

          xv_level = _mm256_unpackhi_epi16(xv_low,xv_high);

          xv_level = _mm256_mullo_epi32(xv_level,v_scale_h);

          xv_level =  _mm256_add_epi32(xv_level,xv_add);

          xv_level = _mm256_sra_epi32(xv_level,v_rshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+8+x+y*width ), xv_level );

        }

      }

    }

#else

    else

    {        

      __m128i v_scale_l,v_scale_h;

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=8)

        {

          __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[x+ y * piQCfStride]  );

          v_scale_l = _mm_loadu_si128( ( const __m128i* ) &piDequantCoef[y * width+x] );

          v_level = _mm_and_si128(v_level,vlevmask);

          v_level = _mm_max_epi16 (v_level, v_min);

          v_level = _mm_min_epi16 (v_level, v_max);

          __m128i v_low = _mm_mullo_epi16(v_level,v_scaleQP);

          __m128i v_high = _mm_mulhi_epi16(v_level,v_scaleQP);

          v_level = _mm_unpacklo_epi16(v_low,v_high);

          v_level = _mm_mullo_epi32(v_level,v_scale_l);

          v_level =  _mm_add_epi32(v_level,v_add);

          v_level = _mm_sra_epi32(v_level,v_rshift);        

          v_level = _mm_max_epi32 (v_level, v_Tmin);

          v_level = _mm_min_epi32 (v_level, v_Tmax);

          _mm_storeu_si128(( __m128i * )(piCoef+y*width +x), v_level );

          if (maxX + 1 - x > 4)

          {

            v_scale_h = _mm_loadu_si128( ( const __m128i* ) &piDequantCoef[y * width+x+4] );

            v_level = _mm_unpackhi_epi16(v_low,v_high);

            v_level = _mm_mullo_epi32(v_level,v_scale_h);

            v_level =  _mm_add_epi32(v_level,v_add);

            v_level = _mm_sra_epi32(v_level,v_rshift);

            v_level = _mm_max_epi32 (v_level, v_Tmin);

            v_level = _mm_min_epi32 (v_level, v_Tmax);

            _mm_storeu_si128(( __m128i * )(piCoef+4+x+y*width ), v_level );

          }

        }

      }

    }

#endif

  }

  else  // rightshift <0

  {

    __m128i v_max =  _mm_set1_epi16 ((short)inputMaximum);

    __m128i v_min =  _mm_set1_epi16 ((short)inputMinimum);

    __m128i v_Tmax =  _mm_set1_epi32 ((short)transformMaximum);

    __m128i v_Tmin =  _mm_set1_epi32 ((short)transformMinimum);

    __m128i v_scaleQP = _mm_set1_epi16 ((short)scaleQP);

    __m128i v_lshift = _mm_set1_epi64x (-rightShift);

    if (maxX<4)

    {

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = maxX  > 1 ? _mm_loadu_si64( ( const __m128i* ) &piQCoef[y * piQCfStride] )

                        : maxX == 1 ? _mm_setr_epi16( piQCoef[y * piQCfStride], piQCoef[y * piQCfStride + 1], 0, 0, 0, 0, 0, 0 )

                                    : _mm_setr_epi16( piQCoef[y * piQCfStride], 0, 0, 0, 0, 0, 0, 0 );

        __m128i v_scale = maxX  > 1 ? _mm_loadu_si128( ( const __m128i* ) &piDequantCoef[y * width] )

                                : maxX == 1 ? _mm_setr_epi32( piDequantCoef[y * width], piDequantCoef[y * width + 1], 0, 0 )

                                            : _mm_setr_epi32( piDequantCoef[y * width], 0, 0, 0 );

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scaleQP);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scaleQP);

        v_level = _mm_unpacklo_epi16(v_low,v_high);

        v_level = _mm_mullo_epi32(v_level,v_scale);

        v_level = _mm_sll_epi32(v_level,v_lshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

      }

    }

#if USE_AVX2

    else if (maxX<8)

    {

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

        __m256i v_scale = _mm256_loadu_si256( ( const __m256i* ) &piDequantCoef[y * width] );

        v_level = _mm_and_si128(v_level,vlevmask);

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scaleQP);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scaleQP);

        __m256i xv_level = _mm256_set_m128i (_mm_unpackhi_epi16(v_low,v_high), _mm_unpacklo_epi16(v_low,v_high));

        xv_level = _mm256_mullo_epi32(xv_level,v_scale);

        xv_level = _mm256_sll_epi32(xv_level,v_lshift);

        xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

        xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

        _mm256_storeu_si256(( __m256i * )(piCoef+y*width ), xv_level );

      }

    }

    else

    {

      __m256i xv_max =  _mm256_set1_epi16 ((short)inputMaximum);

      __m256i xv_min =  _mm256_set1_epi16 ((short)inputMinimum);

      __m256i xv_scaleQP = _mm256_set1_epi16 ((short)scaleQP);

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      __m256i v_scale_l,v_scale_h;

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=16)

        {

          __m256i xv_level = _mm256_loadu_si256( ( __m256i const * )&piQCoef[x+ y * piQCfStride]  );

          v_scale_l = _mm256_loadu_si256( ( const __m256i* ) &piDequantCoef[y * width + x ]);

          v_scale_h = _mm256_loadu_si256( ( const __m256i* ) &piDequantCoef[y * width + x + 8 ]);

          xv_level = _mm256_and_si256(xv_level,xvlevmask);

          xv_level = _mm256_max_epi16 (xv_level, xv_min);

          xv_level = _mm256_min_epi16 (xv_level, xv_max);

          __m256i xv_low = _mm256_mullo_epi16(xv_level,xv_scaleQP);

          __m256i xv_high = _mm256_mulhi_epi16(xv_level,xv_scaleQP);

          xv_low = _mm256_permute4x64_epi64(xv_low,0xD8);

          xv_high = _mm256_permute4x64_epi64(xv_high,0xD8);

          xv_level = _mm256_unpacklo_epi16(xv_low,xv_high);

          xv_level = _mm256_mullo_epi32(xv_level,v_scale_l);

          xv_level = _mm256_sll_epi32(xv_level,v_lshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+x+y*width ), xv_level );

          xv_level = _mm256_unpackhi_epi16(xv_low,xv_high);

          xv_level = _mm256_mullo_epi32(xv_level,v_scale_h);

          xv_level = _mm256_sll_epi32(xv_level,v_lshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+8+x+y*width ), xv_level );

        }

      }

    }

#else

    else

    {

      __m128i v_scale_l,v_scale_h;

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=8)

        {

          __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[x+ y * piQCfStride]  );

          v_scale_l = _mm_loadu_si128( ( const __m128i* ) &piDequantCoef[y * width+x] );

          v_level = _mm_and_si128(v_level,vlevmask);

          v_level = _mm_max_epi16 (v_level, v_min);

          v_level = _mm_min_epi16 (v_level, v_max);

          __m128i v_low = _mm_mullo_epi16(v_level,v_scaleQP);

          __m128i v_high = _mm_mulhi_epi16(v_level,v_scaleQP);

          v_level = _mm_unpacklo_epi16(v_low,v_high);

          v_level = _mm_mullo_epi32(v_level,v_scale_l);

          v_level = _mm_sll_epi32(v_level,v_lshift);

          v_level = _mm_max_epi32 (v_level, v_Tmin);

          v_level = _mm_min_epi32 (v_level, v_Tmax);

          _mm_storeu_si128(( __m128i * )(piCoef+x+y*width ), v_level );

          if (maxX + 1 - x > 4)

          {

            v_scale_h = _mm_loadu_si128( ( const __m128i* ) &piDequantCoef[y * width+x+4] );

            v_level = _mm_unpackhi_epi16(v_low,v_high);

            v_level = _mm_mullo_epi32(v_level,v_scale_h);

            v_level = _mm_sll_epi32(v_level,v_lshift);

            v_level = _mm_max_epi32 (v_level, v_Tmin);

            v_level = _mm_min_epi32 (v_level, v_Tmax);

            _mm_storeu_si128(( __m128i * )(piCoef+4+x+y*width ), v_level );

          }

        }

      }

    }

#endif

  }

}

Unexecuted instantiation: Quant_sse41.cpp:void vvdec::DeQuantScalingCoreSIMD<(vvdec::x86_simd::X86_VEXT)1>(int, int, int, int, int const*, short const*, unsigned long, int*, int, int, int)

Unexecuted instantiation: Quant_avx2.cpp:void vvdec::DeQuantScalingCoreSIMD<(vvdec::x86_simd::X86_VEXT)4>(int, int, int, int, int const*, short const*, unsigned long, int*, int, int, int)

template< X86_VEXT vext>

static void DeQuantCoreSIMD(const int maxX,const int restX,const int maxY,const int scale,const TCoeffSig*const piQCoef,const size_t piQCfStride,TCoeff   *const piCoef,const int rightShift,const int inputMaximum,const TCoeff transformMaximum)

{

  const int inputMinimum = -(inputMaximum+1);

  const TCoeff transformMinimum = -(transformMaximum+1);

  const int width = restX+maxX+1;

  __m128i vlevmask;

  if (maxX<7)

    vlevmask = _mm_loadu_si128( ( __m128i const * )&levmask[7-maxX] );

  else

    vlevmask = _mm_set_epi64x(0xffffffffffffffff,0xffffffffffffffff);

#if USE_AVX2

  __m256i xvlevmask;

  if (maxX<15)

    xvlevmask = _mm256_loadu_si256( ( __m256i const * )&xlevmask[15-maxX] );

  else

    xvlevmask = _mm256_set_epi64x(0xffffffffffffffff,0xffffffffffffffff,0xffffffffffffffff,0xffffffffffffffff);

#endif

  if (rightShift>0)

  {

    const Intermediate_Int iAdd = (Intermediate_Int) 1 << (rightShift - 1);

    __m128i v_max =  _mm_set1_epi16 ((short)inputMaximum);

    __m128i v_min =  _mm_set1_epi16 ((short)inputMinimum);

    __m128i v_Tmax =  _mm_set1_epi32 ((short)transformMaximum);

    __m128i v_Tmin =  _mm_set1_epi32 ((short)transformMinimum);

    __m128i v_scale = _mm_set1_epi16 ((short)scale);

    __m128i v_add = _mm_set1_epi32 (iAdd);

    __m128i v_rshift = _mm_set1_epi64x (rightShift);

    if (maxX<4)

    {

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = maxX  > 1 ? _mm_loadu_si64( ( const __m128i* ) &piQCoef[y * piQCfStride] )

                        : maxX == 1 ? _mm_setr_epi16( piQCoef[y * piQCfStride], piQCoef[y * piQCfStride + 1], 0, 0, 0, 0, 0, 0 )

                                    : _mm_setr_epi16( piQCoef[y * piQCfStride], 0, 0, 0, 0, 0, 0, 0 );

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

        v_level = _mm_unpacklo_epi16(v_low,v_high);

        v_level =  _mm_add_epi32(v_level,v_add);

        v_level = _mm_sra_epi32(v_level,v_rshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

      }

    }

#if USE_AVX2

    else if (maxX<8)

    {

      __m256i xv_add = _mm256_set1_epi32 (iAdd);

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

        __m256i xv_level = _mm256_set_m128i (_mm_unpackhi_epi16(v_low,v_high), _mm_unpacklo_epi16(v_low,v_high));

        xv_level =  _mm256_add_epi32(xv_level,xv_add);

        xv_level = _mm256_sra_epi32(xv_level,v_rshift);

        xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

        xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

        _mm256_storeu_si256(( __m256i * )(piCoef+y*width ), xv_level );

      }

    }

    else

    {

      __m256i xv_max =  _mm256_set1_epi16 ((short)inputMaximum);

      __m256i xv_min =  _mm256_set1_epi16 ((short)inputMinimum);

      __m256i xv_scale = _mm256_set1_epi16 ((short)scale);

      __m256i xv_add = _mm256_set1_epi32 (iAdd);

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=16)

        {

          __m256i xv_level = _mm256_loadu_si256( ( __m256i const * )&piQCoef[x+ y * piQCfStride]  );

          xv_level = _mm256_and_si256(xv_level,xvlevmask);

          xv_level = _mm256_max_epi16 (xv_level, xv_min);

          xv_level = _mm256_min_epi16 (xv_level, xv_max);

          __m256i xv_low = _mm256_mullo_epi16(xv_level,xv_scale);

          __m256i xv_high = _mm256_mulhi_epi16(xv_level,xv_scale);

          xv_low = _mm256_permute4x64_epi64(xv_low,0xD8);

          xv_high = _mm256_permute4x64_epi64(xv_high,0xD8);

          xv_level = _mm256_unpacklo_epi16(xv_low,xv_high);

          xv_level =  _mm256_add_epi32(xv_level,xv_add);

          xv_level = _mm256_sra_epi32(xv_level,v_rshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+x+y*width ), xv_level );

          xv_level = _mm256_unpackhi_epi16(xv_low,xv_high);

          xv_level =  _mm256_add_epi32(xv_level,xv_add);

          xv_level = _mm256_sra_epi32(xv_level,v_rshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+8+x+y*width ), xv_level );

        }

      }

    }

#else

/*

    else if (maxX<8)

    {

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

        v_level = _mm_and_si128(v_level,vlevmask);

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

        v_level = _mm_unpacklo_epi16(v_low,v_high);

        v_level =  _mm_add_epi32(v_level,v_add);

        v_level = _mm_sra_epi32(v_level,v_rshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

        v_level = _mm_unpackhi_epi16(v_low,v_high);

        v_level =  _mm_add_epi32(v_level,v_add);

        v_level = _mm_sra_epi32(v_level,v_rshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+4+y*width ), v_level );

      }

    }

*/

    else

    {

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=8)

        {

          __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[x+ y * piQCfStride]  );

          v_level = _mm_and_si128(v_level,vlevmask);

          v_level = _mm_max_epi16 (v_level, v_min);

          v_level = _mm_min_epi16 (v_level, v_max);

          __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

          __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

          v_level = _mm_unpacklo_epi16(v_low,v_high);

          v_level =  _mm_add_epi32(v_level,v_add);

          v_level = _mm_sra_epi32(v_level,v_rshift);

          v_level = _mm_max_epi32 (v_level, v_Tmin);

          v_level = _mm_min_epi32 (v_level, v_Tmax);

          _mm_storeu_si128(( __m128i * )(piCoef+x+y*width ), v_level );

          if( maxX + 1 - x <= 4 ) continue;

          v_level = _mm_unpackhi_epi16(v_low,v_high);

          v_level =  _mm_add_epi32(v_level,v_add);

          v_level = _mm_sra_epi32(v_level,v_rshift);

          v_level = _mm_max_epi32 (v_level, v_Tmin);

          v_level = _mm_min_epi32 (v_level, v_Tmax);

          _mm_storeu_si128(( __m128i * )(piCoef+4+x+y*width ), v_level );

        }

      }

    }

#endif

  }

  else  // rightshift <0

  {

    __m128i v_max =  _mm_set1_epi16 ((short)inputMaximum);

    __m128i v_min =  _mm_set1_epi16 ((short)inputMinimum);

    __m128i v_Tmax =  _mm_set1_epi32 ((short)transformMaximum);

    __m128i v_Tmin =  _mm_set1_epi32 ((short)transformMinimum);

    __m128i v_scale = _mm_set1_epi16 ((short)scale);

    __m128i v_lshift = _mm_set1_epi64x (-rightShift);

    if (maxX<4)

    {

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = maxX  > 1 ? _mm_loadu_si64( ( const __m128i* ) &piQCoef[y * piQCfStride] )

                        : maxX == 1 ? _mm_setr_epi16( piQCoef[y * piQCfStride], piQCoef[y * piQCfStride + 1], 0, 0, 0, 0, 0, 0 )

                                    : _mm_setr_epi16( piQCoef[y * piQCfStride], 0, 0, 0, 0, 0, 0, 0 );

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

        v_level = _mm_unpacklo_epi16(v_low,v_high);

        v_level = _mm_sll_epi32(v_level,v_lshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

      }

    }

#if USE_AVX2

    else if (maxX<8)

    {

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

        v_level = _mm_and_si128(v_level,vlevmask);

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

        __m256i xv_level = _mm256_set_m128i (_mm_unpackhi_epi16(v_low,v_high), _mm_unpacklo_epi16(v_low,v_high));

        xv_level = _mm256_sll_epi32(xv_level,v_lshift);

        xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

        xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

        _mm256_storeu_si256(( __m256i * )(piCoef+y*width ), xv_level );

      }

    }

    else

    {

      __m256i xv_max =  _mm256_set1_epi16 ((short)inputMaximum);

      __m256i xv_min =  _mm256_set1_epi16 ((short)inputMinimum);

      __m256i xv_scale = _mm256_set1_epi16 ((short)scale);

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=16)

        {

          __m256i xv_level = _mm256_loadu_si256( ( __m256i const * )&piQCoef[x+ y * piQCfStride]  );

          xv_level = _mm256_and_si256(xv_level,xvlevmask);

          xv_level = _mm256_max_epi16 (xv_level, xv_min);

          xv_level = _mm256_min_epi16 (xv_level, xv_max);

          __m256i xv_low = _mm256_mullo_epi16(xv_level,xv_scale);

          __m256i xv_high = _mm256_mulhi_epi16(xv_level,xv_scale);

          xv_low = _mm256_permute4x64_epi64(xv_low,0xD8);

          xv_high = _mm256_permute4x64_epi64(xv_high,0xD8);

          xv_level = _mm256_unpacklo_epi16(xv_low,xv_high);

          xv_level = _mm256_sll_epi32(xv_level,v_lshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+x+y*width ), xv_level );

          xv_level = _mm256_unpackhi_epi16(xv_low,xv_high);

          xv_level = _mm256_sll_epi32(xv_level,v_lshift);

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

          _mm256_storeu_si256(( __m256i * )(piCoef+8+x+y*width ), xv_level );

        }

      }

    }

#else

/*

    else if (maxX<8)

    {

      for( int y = 0; y <= maxY; y++)

      {

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

        v_level = _mm_and_si128(v_level,vlevmask);

        v_level = _mm_max_epi16 (v_level, v_min);

        v_level = _mm_min_epi16 (v_level, v_max);

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

        v_level = _mm_unpacklo_epi16(v_low,v_high);

        v_level = _mm_sll_epi32(v_level,v_lshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

        v_level = _mm_unpackhi_epi16(v_low,v_high);

        v_level = _mm_sll_epi32(v_level,v_lshift);

        v_level = _mm_max_epi32 (v_level, v_Tmin);

        v_level = _mm_min_epi32 (v_level, v_Tmax);

        _mm_storeu_si128(( __m128i * )(piCoef+4+y*width ), v_level );

      }

    }

*/

    else

    {

      for( int y = 0; y <= maxY; y++)

      {

        for( int x = 0; x <= maxX; x+=8)

        {

          __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[x+ y * piQCfStride]  );

          v_level = _mm_and_si128(v_level,vlevmask);

          v_level = _mm_max_epi16 (v_level, v_min);

          v_level = _mm_min_epi16 (v_level, v_max);

          __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

          __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

          v_level = _mm_unpacklo_epi16(v_low,v_high);

          v_level = _mm_sll_epi32(v_level,v_lshift);

          v_level = _mm_max_epi32 (v_level, v_Tmin);

          v_level = _mm_min_epi32 (v_level, v_Tmax);

          _mm_storeu_si128(( __m128i * )(piCoef+x+y*width ), v_level );

          if( maxX + 1 - x <= 4 ) continue;

          v_level = _mm_unpackhi_epi16(v_low,v_high);

          v_level = _mm_sll_epi32(v_level,v_lshift);

          v_level = _mm_max_epi32 (v_level, v_Tmin);

          v_level = _mm_min_epi32 (v_level, v_Tmax);

          _mm_storeu_si128(( __m128i * )(piCoef+4+x+y*width ), v_level );

        }

      }

    }

#endif

  }

}

Unexecuted instantiation: Quant_sse41.cpp:void vvdec::DeQuantCoreSIMD<(vvdec::x86_simd::X86_VEXT)1>(int, int, int, int, short const*, unsigned long, int*, int, int, int)

Quant_avx2.cpp:void vvdec::DeQuantCoreSIMD<(vvdec::x86_simd::X86_VEXT)4>(int, int, int, int, short const*, unsigned long, int*, int, int, int)

Line

Count

Source

386

26.4k

{

387

26.4k

  const int inputMinimum = -(inputMaximum+1);

388

26.4k

  const TCoeff transformMinimum = -(transformMaximum+1);

389

26.4k

  const int width = restX+maxX+1;

390

26.4k

  __m128i vlevmask;

391

26.4k

  if (maxX<7)

392

21.0k

    vlevmask = _mm_loadu_si128( ( __m128i const * )&levmask[7-maxX] );

393

5.35k

  else

394

5.35k

    vlevmask = _mm_set_epi64x(0xffffffffffffffff,0xffffffffffffffff);

395

396

26.4k

#if USE_AVX2

397

26.4k

  __m256i xvlevmask;

398

26.4k

  if (maxX<15)

399

25.9k

    xvlevmask = _mm256_loadu_si256( ( __m256i const * )&xlevmask[15-maxX] );

400

528

  else

401

528

    xvlevmask = _mm256_set_epi64x(0xffffffffffffffff,0xffffffffffffffff,0xffffffffffffffff,0xffffffffffffffff);

402

403

26.4k

#endif

404

405

26.4k

  if (rightShift>0)

406

3.93k

  {

407

3.93k

    const Intermediate_Int iAdd = (Intermediate_Int) 1 << (rightShift - 1);

408

409

3.93k

    __m128i v_max =  _mm_set1_epi16 ((short)inputMaximum);

410

3.93k

    __m128i v_min =  _mm_set1_epi16 ((short)inputMinimum);

411

3.93k

    __m128i v_Tmax =  _mm_set1_epi32 ((short)transformMaximum);

412

3.93k

    __m128i v_Tmin =  _mm_set1_epi32 ((short)transformMinimum);

413

3.93k

    __m128i v_scale = _mm_set1_epi16 ((short)scale);

414

3.93k

    __m128i v_add = _mm_set1_epi32 (iAdd);

415

3.93k

    __m128i v_rshift = _mm_set1_epi64x (rightShift);

416

417

3.93k

    if (maxX<4)

418

2.96k

    {

419

9.63k

      for( int y = 0; y <= maxY; y++)

420

6.66k

      {

421

6.66k

        __m128i v_level = maxX  > 1 ? _mm_loadu_si64( ( const __m128i* ) &piQCoef[y * piQCfStride] )

422

6.66k

                        : maxX == 1 ? _mm_setr_epi16( piQCoef[y * piQCfStride], piQCoef[y * piQCfStride + 1], 0, 0, 0, 0, 0, 0 )

423

2.18k

                                    : _mm_setr_epi16( piQCoef[y * piQCfStride], 0, 0, 0, 0, 0, 0, 0 );

424

425

6.66k

        v_level = _mm_max_epi16 (v_level, v_min);

426

6.66k

        v_level = _mm_min_epi16 (v_level, v_max);

427

6.66k

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

428

6.66k

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

429

430

6.66k

        v_level = _mm_unpacklo_epi16(v_low,v_high);

431

6.66k

        v_level =  _mm_add_epi32(v_level,v_add);

432

6.66k

        v_level = _mm_sra_epi32(v_level,v_rshift);

433

434

6.66k

        v_level = _mm_max_epi32 (v_level, v_Tmin);

435

6.66k

        v_level = _mm_min_epi32 (v_level, v_Tmax);

436

6.66k

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

437

6.66k

      }

438

2.96k

    }

439

970

#if USE_AVX2

440

970

    else if (maxX<8)

441

648

    {

442

648

      __m256i xv_add = _mm256_set1_epi32 (iAdd);

443

648

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

444

648

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

445

446

4.38k

      for( int y = 0; y <= maxY; y++)

447

3.74k

      {

448

3.74k

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

449

3.74k

        v_level = _mm_max_epi16 (v_level, v_min);

450

3.74k

        v_level = _mm_min_epi16 (v_level, v_max);

451

3.74k

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

452

3.74k

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

453

454

3.74k

        __m256i xv_level = _mm256_set_m128i (_mm_unpackhi_epi16(v_low,v_high), _mm_unpacklo_epi16(v_low,v_high));

455

456

3.74k

        xv_level =  _mm256_add_epi32(xv_level,xv_add);

457

3.74k

        xv_level = _mm256_sra_epi32(xv_level,v_rshift);

458

459

3.74k

        xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

460

3.74k

        xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

461

462

3.74k

        _mm256_storeu_si256(( __m256i * )(piCoef+y*width ), xv_level );

463

3.74k

      }

464

648

    }

465

322

    else

466

322

    {

467

322

      __m256i xv_max =  _mm256_set1_epi16 ((short)inputMaximum);

468

322

      __m256i xv_min =  _mm256_set1_epi16 ((short)inputMinimum);

469

322

      __m256i xv_scale = _mm256_set1_epi16 ((short)scale);

470

322

      __m256i xv_add = _mm256_set1_epi32 (iAdd);

471

322

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

472

322

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

473

474

3.81k

      for( int y = 0; y <= maxY; y++)

475

3.49k

      {

476

7.72k

        for( int x = 0; x <= maxX; x+=16)

477

4.22k

        {

478

4.22k

          __m256i xv_level = _mm256_loadu_si256( ( __m256i const * )&piQCoef[x+ y * piQCfStride]  );

479

4.22k

          xv_level = _mm256_and_si256(xv_level,xvlevmask);

480

4.22k

          xv_level = _mm256_max_epi16 (xv_level, xv_min);

481

4.22k

          xv_level = _mm256_min_epi16 (xv_level, xv_max);

482

4.22k

          __m256i xv_low = _mm256_mullo_epi16(xv_level,xv_scale);

483

4.22k

          __m256i xv_high = _mm256_mulhi_epi16(xv_level,xv_scale);

484

485

4.22k

          xv_low = _mm256_permute4x64_epi64(xv_low,0xD8);

486

4.22k

          xv_high = _mm256_permute4x64_epi64(xv_high,0xD8);

487

488

489

4.22k

          xv_level = _mm256_unpacklo_epi16(xv_low,xv_high);

490

4.22k

          xv_level =  _mm256_add_epi32(xv_level,xv_add);

491

4.22k

          xv_level = _mm256_sra_epi32(xv_level,v_rshift);

492

493

4.22k

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

494

4.22k

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

495

496

4.22k

          _mm256_storeu_si256(( __m256i * )(piCoef+x+y*width ), xv_level );

497

4.22k

          xv_level = _mm256_unpackhi_epi16(xv_low,xv_high);

498

4.22k

          xv_level =  _mm256_add_epi32(xv_level,xv_add);

499

4.22k

          xv_level = _mm256_sra_epi32(xv_level,v_rshift);

500

501

4.22k

          xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

502

4.22k

          xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

503

504

4.22k

          _mm256_storeu_si256(( __m256i * )(piCoef+8+x+y*width ), xv_level );

505

4.22k

        }

506

3.49k

      }

507

508

322

    }

509

510

#else

511

/*

512

    else if (maxX<8)

513

    {

514

      for( int y = 0; y <= maxY; y++)

515

      {

516

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

517

        v_level = _mm_and_si128(v_level,vlevmask);

518

        v_level = _mm_max_epi16 (v_level, v_min);

519

        v_level = _mm_min_epi16 (v_level, v_max);

520

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

521

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

522

523

        v_level = _mm_unpacklo_epi16(v_low,v_high);

524

        v_level =  _mm_add_epi32(v_level,v_add);

525

        v_level = _mm_sra_epi32(v_level,v_rshift);

526

527

        v_level = _mm_max_epi32 (v_level, v_Tmin);

528

        v_level = _mm_min_epi32 (v_level, v_Tmax);

529

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

530

531

        v_level = _mm_unpackhi_epi16(v_low,v_high);

532

        v_level =  _mm_add_epi32(v_level,v_add);

533

        v_level = _mm_sra_epi32(v_level,v_rshift);

534

535

        v_level = _mm_max_epi32 (v_level, v_Tmin);

536

        v_level = _mm_min_epi32 (v_level, v_Tmax);

537

        _mm_storeu_si128(( __m128i * )(piCoef+4+y*width ), v_level );

538

      }

539

    }

540

*/

541

    else

542

    {

543

      for( int y = 0; y <= maxY; y++)

544

      {

545

        for( int x = 0; x <= maxX; x+=8)

546

        {

547

          __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[x+ y * piQCfStride]  );

548

          v_level = _mm_and_si128(v_level,vlevmask);

549

          v_level = _mm_max_epi16 (v_level, v_min);

550

          v_level = _mm_min_epi16 (v_level, v_max);

551

          __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

552

          __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

553

554

          v_level = _mm_unpacklo_epi16(v_low,v_high);

555

          v_level =  _mm_add_epi32(v_level,v_add);

556

          v_level = _mm_sra_epi32(v_level,v_rshift);

557

558

          v_level = _mm_max_epi32 (v_level, v_Tmin);

559

          v_level = _mm_min_epi32 (v_level, v_Tmax);

560

          _mm_storeu_si128(( __m128i * )(piCoef+x+y*width ), v_level );

561

562

          if( maxX + 1 - x <= 4 ) continue;

563

564

          v_level = _mm_unpackhi_epi16(v_low,v_high);

565

          v_level =  _mm_add_epi32(v_level,v_add);

566

          v_level = _mm_sra_epi32(v_level,v_rshift);

567

568

          v_level = _mm_max_epi32 (v_level, v_Tmin);

569

          v_level = _mm_min_epi32 (v_level, v_Tmax);

570

          _mm_storeu_si128(( __m128i * )(piCoef+4+x+y*width ), v_level );

571

        }

572

      }

573

    }

574

#endif

575

3.93k

  }

576

22.4k

  else  // rightshift <0

577

22.4k

  {

578

579

22.4k

    __m128i v_max =  _mm_set1_epi16 ((short)inputMaximum);

580

22.4k

    __m128i v_min =  _mm_set1_epi16 ((short)inputMinimum);

581

22.4k

    __m128i v_Tmax =  _mm_set1_epi32 ((short)transformMaximum);

582

22.4k

    __m128i v_Tmin =  _mm_set1_epi32 ((short)transformMinimum);

583

22.4k

    __m128i v_scale = _mm_set1_epi16 ((short)scale);

584

22.4k

    __m128i v_lshift = _mm_set1_epi64x (-rightShift);

585

586

22.4k

    if (maxX<4)

587

18.1k

    {

588

104k

      for( int y = 0; y <= maxY; y++)

589

86.0k

      {

590

86.0k

        __m128i v_level = maxX  > 1 ? _mm_loadu_si64( ( const __m128i* ) &piQCoef[y * piQCfStride] )

591

86.0k

                        : maxX == 1 ? _mm_setr_epi16( piQCoef[y * piQCfStride], piQCoef[y * piQCfStride + 1], 0, 0, 0, 0, 0, 0 )

592

5.91k

                                    : _mm_setr_epi16( piQCoef[y * piQCfStride], 0, 0, 0, 0, 0, 0, 0 );

593

594

86.0k

        v_level = _mm_max_epi16 (v_level, v_min);

595

86.0k

        v_level = _mm_min_epi16 (v_level, v_max);

596

86.0k

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

597

86.0k

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

598

599

86.0k

        v_level = _mm_unpacklo_epi16(v_low,v_high);

600

86.0k

        v_level = _mm_sll_epi32(v_level,v_lshift);

601

602

86.0k

        v_level = _mm_max_epi32 (v_level, v_Tmin);

603

86.0k

        v_level = _mm_min_epi32 (v_level, v_Tmax);

604

86.0k

        _mm_storeu_si128(( __m128i * )(piCoef+y*width ), v_level );

605

606

86.0k

      }

607

18.1k

    }

608

4.39k

#if USE_AVX2

609

4.39k

    else if (maxX<8)

610

3.74k

    {

611

3.74k

      __m256i xv_Tmax =  _mm256_set1_epi32 ((short)transformMaximum);

612

3.74k

      __m256i xv_Tmin =  _mm256_set1_epi32 ((short)transformMinimum);

613

614

29.9k

      for( int y = 0; y <= maxY; y++)

615

26.2k

      {

616

26.2k

        __m128i v_level = _mm_loadu_si128( ( __m128i const * )&piQCoef[y * piQCfStride]  );

617

26.2k

        v_level = _mm_and_si128(v_level,vlevmask);

618

26.2k

        v_level = _mm_max_epi16 (v_level, v_min);

619

26.2k

        v_level = _mm_min_epi16 (v_level, v_max);

620

26.2k

        __m128i v_low = _mm_mullo_epi16(v_level,v_scale);

621

26.2k

        __m128i v_high = _mm_mulhi_epi16(v_level,v_scale);

622

623

26.2k

        __m256i xv_level = _mm256_set_m128i (_mm_unpackhi_epi16(v_low,v_high), _mm_unpacklo_epi16(v_low,v_high));

624

625

26.2k

        xv_level = _mm256_sll_epi32(xv_level,v_lshift);

626

627

26.2k

        xv_level = _mm256_max_epi32 (xv_level, xv_Tmin);

628

26.2k

        xv_level = _mm256_min_epi32 (xv_level, xv_Tmax);

629

630

26.2k

        _mm256_storeu_si256(( __m256i * )(piCoef+y*width ), xv_level );

631

26.2k