/*!
 * \copy
 *     Copyright (c)  2013, Cisco Systems
 *     All rights reserved.
 *
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted 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.
 *
 *     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.
 *
 */


#include "ls_defines.h"
#include "encode_mb_aux.h"
#include "cpu_core.h"
namespace WelsEnc {

ALIGNED_DECLARE (const int16_t, g_kiQuantInterFF[58][8], 16) = {
  /* 0*/ {   0,   1,   0,   1,   1,   1,   1,   1 },
  /* 1*/ {   0,   1,   0,   1,   1,   1,   1,   1 },
  /* 2*/ {   1,   1,   1,   1,   1,   1,   1,   1 },
  /* 3*/ {   1,   1,   1,   1,   1,   1,   1,   1 },
  /* 4*/ {   1,   1,   1,   1,   1,   2,   1,   2 },
  /* 5*/ {   1,   1,   1,   1,   1,   2,   1,   2 },
  /* 6*/ {   1,   1,   1,   1,   1,   2,   1,   2 },
  /* 7*/ {   1,   1,   1,   1,   1,   2,   1,   2 },
  /* 8*/ {   1,   2,   1,   2,   2,   3,   2,   3 },
  /* 9*/ {   1,   2,   1,   2,   2,   3,   2,   3 },
  /*10*/ {   1,   2,   1,   2,   2,   3,   2,   3 },
  /*11*/ {   1,   2,   1,   2,   2,   4,   2,   4 },
  /*12*/ {   2,   3,   2,   3,   3,   4,   3,   4 },
  /*13*/ {   2,   3,   2,   3,   3,   5,   3,   5 },
  /*14*/ {   2,   3,   2,   3,   3,   5,   3,   5 },
  /*15*/ {   2,   4,   2,   4,   4,   6,   4,   6 },
  /*16*/ {   3,   4,   3,   4,   4,   7,   4,   7 },
  /*17*/ {   3,   5,   3,   5,   5,   8,   5,   8 },
  /*18*/ {   3,   5,   3,   5,   5,   8,   5,   8 },
  /*19*/ {   4,   6,   4,   6,   6,   9,   6,   9 },
  /*20*/ {   4,   7,   4,   7,   7,  10,   7,  10 },
  /*21*/ {   5,   8,   5,   8,   8,  12,   8,  12 },
  /*22*/ {   5,   8,   5,   8,   8,  13,   8,  13 },
  /*23*/ {   6,  10,   6,  10,  10,  15,  10,  15 },
  /*24*/ {   7,  11,   7,  11,  11,  17,  11,  17 },
  /*25*/ {   7,  12,   7,  12,  12,  19,  12,  19 },
  /*26*/ {   9,  13,   9,  13,  13,  21,  13,  21 },
  /*27*/ {   9,  15,   9,  15,  15,  24,  15,  24 },
  /*28*/ {  11,  17,  11,  17,  17,  26,  17,  26 },
  /*29*/ {  12,  19,  12,  19,  19,  30,  19,  30 },
  /*30*/ {  13,  22,  13,  22,  22,  33,  22,  33 },
  /*31*/ {  15,  23,  15,  23,  23,  38,  23,  38 },
  /*32*/ {  17,  27,  17,  27,  27,  42,  27,  42 },
  /*33*/ {  19,  30,  19,  30,  30,  48,  30,  48 },
  /*34*/ {  21,  33,  21,  33,  33,  52,  33,  52 },
  /*35*/ {  24,  38,  24,  38,  38,  60,  38,  60 },
  /*36*/ {  27,  43,  27,  43,  43,  67,  43,  67 },
  /*37*/ {  29,  47,  29,  47,  47,  75,  47,  75 },
  /*38*/ {  35,  53,  35,  53,  53,  83,  53,  83 },
  /*39*/ {  37,  60,  37,  60,  60,  96,  60,  96 },
  /*40*/ {  43,  67,  43,  67,  67, 104,  67, 104 },
  /*41*/ {  48,  77,  48,  77,  77, 121,  77, 121 },
  /*42*/ {  53,  87,  53,  87,  87, 133,  87, 133 },
  /*43*/ {  59,  93,  59,  93,  93, 150,  93, 150 },
  /*44*/ {  69, 107,  69, 107, 107, 167, 107, 167 },
  /*45*/ {  75, 120,  75, 120, 120, 192, 120, 192 },
  /*46*/ {  85, 133,  85, 133, 133, 208, 133, 208 },
  /*47*/ {  96, 153,  96, 153, 153, 242, 153, 242 },
  /*48*/ { 107, 173, 107, 173, 173, 267, 173, 267 },
  /*49*/ { 117, 187, 117, 187, 187, 300, 187, 300 },
  /*50*/ { 139, 213, 139, 213, 213, 333, 213, 333 },
  /*51*/ { 149, 240, 149, 240, 240, 383, 240, 383 },
  /* from here below is only for intra */
  /*46*/ { 171, 267, 171, 267, 267, 417, 267, 417 },
  /*47*/ { 192, 307, 192, 307, 307, 483, 307, 483 },
  /*48*/ { 213, 347, 213, 347, 347, 533, 347, 533 },
  /*49*/ { 235, 373, 235, 373, 373, 600, 373, 600 },
  /*50*/ { 277, 427, 277, 427, 427, 667, 427, 667 },
  /*51*/ { 299, 480, 299, 480, 480, 767, 480, 767 },
};



ALIGNED_DECLARE (const int16_t, g_kiQuantMF[52][8], 16) = {
  /* 0*/        {26214, 16132, 26214, 16132, 16132, 10486, 16132, 10486 },
  /* 1*/        {23832, 14980, 23832, 14980, 14980,  9320, 14980,  9320 },
  /* 2*/        {20164, 13108, 20164, 13108, 13108,  8388, 13108,  8388 },
  /* 3*/        {18724, 11650, 18724, 11650, 11650,  7294, 11650,  7294 },
  /* 4*/        {16384, 10486, 16384, 10486, 10486,  6710, 10486,  6710 },
  /* 5*/        {14564,  9118, 14564,  9118,  9118,  5786,  9118,  5786 },
  /* 6*/        {13107,  8066, 13107,  8066,  8066,  5243,  8066,  5243 },
  /* 7*/        {11916,  7490, 11916,  7490,  7490,  4660,  7490,  4660 },
  /* 8*/        {10082,  6554, 10082,  6554,  6554,  4194,  6554,  4194 },
  /* 9*/        { 9362,  5825,  9362,  5825,  5825,  3647,  5825,  3647 },
  /*10*/        { 8192,  5243,  8192,  5243,  5243,  3355,  5243,  3355 },
  /*11*/        { 7282,  4559,  7282,  4559,  4559,  2893,  4559,  2893 },
  /*12*/        { 6554,  4033,  6554,  4033,  4033,  2622,  4033,  2622 },
  /*13*/        { 5958,  3745,  5958,  3745,  3745,  2330,  3745,  2330 },
  /*14*/        { 5041,  3277,  5041,  3277,  3277,  2097,  3277,  2097 },
  /*15*/        { 4681,  2913,  4681,  2913,  2913,  1824,  2913,  1824 },
  /*16*/        { 4096,  2622,  4096,  2622,  2622,  1678,  2622,  1678 },
  /*17*/        { 3641,  2280,  3641,  2280,  2280,  1447,  2280,  1447 },
  /*18*/        { 3277,  2017,  3277,  2017,  2017,  1311,  2017,  1311 },
  /*19*/        { 2979,  1873,  2979,  1873,  1873,  1165,  1873,  1165 },
  /*20*/        { 2521,  1639,  2521,  1639,  1639,  1049,  1639,  1049 },
  /*21*/        { 2341,  1456,  2341,  1456,  1456,   912,  1456,   912 },
  /*22*/        { 2048,  1311,  2048,  1311,  1311,   839,  1311,   839 },
  /*23*/        { 1821,  1140,  1821,  1140,  1140,   723,  1140,   723 },
  /*24*/        { 1638,  1008,  1638,  1008,  1008,   655,  1008,   655 },
  /*25*/        { 1490,   936,  1490,   936,   936,   583,   936,   583 },
  /*26*/        { 1260,   819,  1260,   819,   819,   524,   819,   524 },
  /*27*/        { 1170,   728,  1170,   728,   728,   456,   728,   456 },
  /*28*/        { 1024,   655,  1024,   655,   655,   419,   655,   419 },
  /*29*/        {  910,   570,   910,   570,   570,   362,   570,   362 },
  /*30*/        {  819,   504,   819,   504,   504,   328,   504,   328 },
  /*31*/        {  745,   468,   745,   468,   468,   291,   468,   291 },
  /*32*/        {  630,   410,   630,   410,   410,   262,   410,   262 },
  /*33*/        {  585,   364,   585,   364,   364,   228,   364,   228 },
  /*34*/        {  512,   328,   512,   328,   328,   210,   328,   210 },
  /*35*/        {  455,   285,   455,   285,   285,   181,   285,   181 },
  /*36*/        {  410,   252,   410,   252,   252,   164,   252,   164 },
  /*37*/        {  372,   234,   372,   234,   234,   146,   234,   146 },
  /*38*/        {  315,   205,   315,   205,   205,   131,   205,   131 },
  /*39*/        {  293,   182,   293,   182,   182,   114,   182,   114 },
  /*40*/        {  256,   164,   256,   164,   164,   105,   164,   105 },
  /*41*/        {  228,   142,   228,   142,   142,    90,   142,    90 },
  /*42*/        {  205,   126,   205,   126,   126,    82,   126,    82 },
  /*43*/        {  186,   117,   186,   117,   117,    73,   117,    73 },
  /*44*/        {  158,   102,   158,   102,   102,    66,   102,    66 },
  /*45*/        {  146,    91,   146,    91,    91,    57,    91,    57 },
  /*46*/        {  128,    82,   128,    82,    82,    52,    82,    52 },
  /*47*/        {  114,    71,   114,    71,    71,    45,    71,    45 },
  /*48*/        {  102,    63,   102,    63,    63,    41,    63,    41 },
  /*49*/        {   93,    59,    93,    59,    59,    36,    59,    36 },
  /*50*/        {   79,    51,    79,    51,    51,    33,    51,    33 },
  /*51*/        {   73,    46,    73,    46,    46,    28,    46,    28 }
};

/****************************************************************************
 * HDM and Quant functions
 ****************************************************************************/
#define WELS_ABS_LC(a) ((iSign ^ (int32_t)(a)) - iSign)
#define NEW_QUANT(pDct, iFF, iMF) (((iFF)+ WELS_ABS_LC(pDct))*(iMF)) >>16
#define WELS_NEW_QUANT(pDct,iFF,iMF) WELS_ABS_LC(NEW_QUANT(pDct, iFF, iMF))
void WelsQuant4x4_c (int16_t* pDct, const int16_t* pFF,  const int16_t* pMF) {
  int32_t i, j, iSign;
  for (i = 0; i < 16; i += 4) {
    j = i & 0x07;
    iSign = WELS_SIGN (pDct[i]);
    pDct[i] = WELS_NEW_QUANT (pDct[i], pFF[j], pMF[j]);
    iSign = WELS_SIGN (pDct[i + 1]);
    pDct[i + 1] = WELS_NEW_QUANT (pDct[i + 1], pFF[j + 1], pMF[j + 1]);
    iSign = WELS_SIGN (pDct[i + 2]);
    pDct[i + 2] = WELS_NEW_QUANT (pDct[i + 2], pFF[j + 2], pMF[j + 2]);
    iSign = WELS_SIGN (pDct[i + 3]);
    pDct[i + 3] = WELS_NEW_QUANT (pDct[i + 3], pFF[j + 3], pMF[j + 3]);
  }
}

void WelsQuant4x4Dc_c (int16_t* pDct, int16_t iFF,  int16_t iMF) {
  int32_t i, iSign;
  for (i = 0; i < 16; i += 4) {
    iSign = WELS_SIGN (pDct[i]);
    pDct[i] = WELS_NEW_QUANT (pDct[i], iFF, iMF);
    iSign = WELS_SIGN (pDct[i + 1]);
    pDct[i + 1] = WELS_NEW_QUANT (pDct[i + 1], iFF, iMF);
    iSign = WELS_SIGN (pDct[i + 2]);
    pDct[i + 2] = WELS_NEW_QUANT (pDct[i + 2], iFF, iMF);
    iSign = WELS_SIGN (pDct[i + 3]);
    pDct[i + 3] = WELS_NEW_QUANT (pDct[i + 3], iFF, iMF);
  }
}

void WelsQuantFour4x4_c (int16_t* pDct, const int16_t* pFF, const int16_t* pMF) {
  int32_t i, j, iSign;

  for (i = 0; i < 64; i += 4) {
    j = i & 0x07;
    iSign = WELS_SIGN (pDct[i]);
    pDct[i] = WELS_NEW_QUANT (pDct[i], pFF[j], pMF[j]);
    iSign = WELS_SIGN (pDct[i + 1]);
    pDct[i + 1] = WELS_NEW_QUANT (pDct[i + 1], pFF[j + 1], pMF[j + 1]);
    iSign = WELS_SIGN (pDct[i + 2]);
    pDct[i + 2] = WELS_NEW_QUANT (pDct[i + 2], pFF[j + 2], pMF[j + 2]);
    iSign = WELS_SIGN (pDct[i + 3]);
    pDct[i + 3] = WELS_NEW_QUANT (pDct[i + 3], pFF[j + 3], pMF[j + 3]);
  }
}

void WelsQuantFour4x4Max_c (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax) {
  int32_t i, j, k, iSign;
  int16_t iMaxAbs;
  for (k = 0; k < 4; k++) {
    iMaxAbs = 0;
    for (i = 0; i < 16; i++) {
      j = i & 0x07;
      iSign = WELS_SIGN (pDct[i]);
      pDct[i] = NEW_QUANT (pDct[i], pFF[j], pMF[j]);
      if (iMaxAbs < pDct[i]) iMaxAbs = pDct[i];
      pDct[i] = WELS_ABS_LC (pDct[i]);
    }
    pDct += 16;
    pMax[k] = iMaxAbs;
  }
}

int32_t WelsHadamardQuant2x2Skip_c (int16_t* pRs, int16_t iFF,  int16_t iMF) {
  int16_t pDct[4], s[4];
  int16_t iThreshold = ((1 << 16) - 1) / iMF - iFF;

  s[0] = pRs[0]  + pRs[32];
  s[1] = pRs[0]  - pRs[32];
  s[2] = pRs[16] + pRs[48];
  s[3] = pRs[16] - pRs[48];

  pDct[0] = s[0] + s[2];
  pDct[1] = s[0] - s[2];
  pDct[2] = s[1] + s[3];
  pDct[3] = s[1] - s[3];

  return ((WELS_ABS (pDct[0]) > iThreshold) || (WELS_ABS (pDct[1]) > iThreshold) || (WELS_ABS (pDct[2]) > iThreshold)
          || (WELS_ABS (pDct[3]) > iThreshold));
}

int32_t WelsHadamardQuant2x2_c (int16_t* pRs, const int16_t iFF, int16_t iMF, int16_t* pDct, int16_t* pBlock) {
  int16_t s[4];
  int32_t iSign, i, iDcNzc = 0;

  s[0] = pRs[0]  + pRs[32];
  s[1] = pRs[0]  - pRs[32];
  s[2] = pRs[16] + pRs[48];
  s[3] = pRs[16] - pRs[48];

  pRs[0] = 0;
  pRs[16] = 0;
  pRs[32] = 0;
  pRs[48] = 0;

  pDct[0] = s[0] + s[2];
  pDct[1] = s[0] - s[2];
  pDct[2] = s[1] + s[3];
  pDct[3] = s[1] - s[3];

  iSign = WELS_SIGN (pDct[0]);
  pDct[0] = WELS_NEW_QUANT (pDct[0], iFF, iMF);
  iSign = WELS_SIGN (pDct[1]);
  pDct[1] = WELS_NEW_QUANT (pDct[1], iFF, iMF);
  iSign = WELS_SIGN (pDct[2]);
  pDct[2] = WELS_NEW_QUANT (pDct[2], iFF, iMF);
  iSign = WELS_SIGN (pDct[3]);
  pDct[3] = WELS_NEW_QUANT (pDct[3], iFF, iMF);

  ST64 (pBlock, LD64 (pDct));

  for (i = 0; i < 4; i++)
    iDcNzc += (pBlock[i] != 0);
  return iDcNzc;
}

/* dc value pick up and hdm_4x4 */
void WelsHadamardT4Dc_c (int16_t* pLumaDc, int16_t* pDct) {
  int32_t p[16], s[4];
  int32_t i, iIdx;

  for (i = 0 ; i < 16 ; i += 4) {
    iIdx = ((i & 0x08) << 4) + ((i & 0x04) << 3);
    s[0] = pDct[iIdx ]     + pDct[iIdx + 80];
    s[3] = pDct[iIdx ]     - pDct[iIdx + 80];
    s[1] = pDct[iIdx + 16] + pDct[iIdx + 64];
    s[2] = pDct[iIdx + 16] - pDct[iIdx + 64];

    p[i  ]   = s[0] + s[1];
    p[i + 2] = s[0] - s[1];
    p[i + 1] = s[3] + s[2];
    p[i + 3] = s[3] - s[2];
  }

  for (i = 0 ; i < 4 ; i ++) {
    s[0] = p[i ]    + p[i + 12];
    s[3] = p[i ]    - p[i + 12];
    s[1] = p[i + 4] + p[i + 8];
    s[2] = p[i + 4] - p[i + 8];

    pLumaDc[i  ]    = WELS_CLIP3 ((s[0] + s[1] + 1) >> 1, -32768, 32767);
    pLumaDc[i + 8 ] = WELS_CLIP3 ((s[0] - s[1] + 1) >> 1, -32768, 32767);
    pLumaDc[i + 4 ] = WELS_CLIP3 ((s[3] + s[2] + 1) >> 1, -32768, 32767);
    pLumaDc[i + 12] = WELS_CLIP3 ((s[3] - s[2] + 1) >> 1, -32768, 32767);
  }
}

/****************************************************************************
 * DCT functions
 ****************************************************************************/
void WelsDctT4_c (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2) {
  int16_t i, pData[16], s[4];
  for (i = 0 ; i < 16 ; i += 4) {
    const int32_t kiI1 = 1 + i;
    const int32_t kiI2 = 2 + i;
    const int32_t kiI3 = 3 + i;

    pData[i ] = pPixel1[0] - pPixel2[0];
    pData[kiI1] = pPixel1[1] - pPixel2[1];
    pData[kiI2] = pPixel1[2] - pPixel2[2];
    pData[kiI3] = pPixel1[3] - pPixel2[3];

    pPixel1 += iStride1;
    pPixel2 += iStride2;

    /*horizontal transform */
    s[0] = pData[i] + pData[kiI3];
    s[3] = pData[i] - pData[kiI3];
    s[1] = pData[kiI1] + pData[kiI2];
    s[2] = pData[kiI1] - pData[kiI2];

    pDct[i ]   = s[0] + s[1];
    pDct[kiI2] = s[0] - s[1];
    pDct[kiI1] = (s[3] * (1 << 1)) + s[2];
    pDct[kiI3] = s[3] - (s[2] * (1 << 1));
  }

  /* vertical transform */
  for (i = 0 ; i < 4 ; i ++) {
    const int32_t kiI4  = 4 + i;
    const int32_t kiI8  = 8 + i;
    const int32_t kiI12 = 12 + i;

    s[0] = pDct[i ] + pDct[kiI12];
    s[3] = pDct[i ] - pDct[kiI12];
    s[1] = pDct[kiI4] + pDct[kiI8 ];
    s[2] = pDct[kiI4] - pDct[kiI8 ];

    pDct[i  ]   = s[0] + s[1];
    pDct[kiI8 ] = s[0] - s[1];
    pDct[kiI4 ] = (s[3] * (1 << 1)) + s[2];
    pDct[kiI12] = s[3] - (s[2] * (1 << 1));
  }
}

void WelsDctFourT4_c (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2) {
  int32_t stride_1 = iStride1 << 2;
  int32_t stride_2 = iStride2 << 2;

  WelsDctT4_c (pDct,      &pPixel1[0],            iStride1, &pPixel2[0],            iStride2);
  WelsDctT4_c (pDct + 16, &pPixel1[4],            iStride1, &pPixel2[4],            iStride2);
  WelsDctT4_c (pDct + 32, &pPixel1[stride_1    ], iStride1, &pPixel2[stride_2    ], iStride2);
  WelsDctT4_c (pDct + 48, &pPixel1[stride_1 + 4], iStride1, &pPixel2[stride_2 + 4], iStride2);
}

/****************************************************************************
 * Scan and Score functions
 ****************************************************************************/
void WelsScan4x4DcAc_c (int16_t* pLevel, int16_t* pDct) {
  ST32 (pLevel, LD32 (pDct));
  pLevel[2] = pDct[4];
  pLevel[3] = pDct[8];
  pLevel[4] = pDct[5];
  ST32 (pLevel + 5, LD32 (pDct + 2));
  pLevel[7] = pDct[6];
  pLevel[8] = pDct[9];
  ST32 (pLevel + 9, LD32 (pDct + 12));
  pLevel[11] = pDct[10];
  pLevel[12] = pDct[7];
  pLevel[13] = pDct[11];
  ST32 (pLevel + 14, LD32 (pDct + 14));
}

void WelsScan4x4Ac_c (int16_t* pLevel, int16_t* pDct) {
  pLevel[0]  = pDct[1];
  pLevel[1]  = pDct[4];
  pLevel[2]  = pDct[8];
  pLevel[3]  = pDct[5];
  ST32 (&pLevel[4], LD32 (&pDct[2]));
  pLevel[6]  = pDct[6];
  pLevel[7]  = pDct[9];
  ST32 (&pLevel[8], LD32 (&pDct[12]));
  pLevel[10] = pDct[10];
  pLevel[11] = pDct[7];
  pLevel[12] = pDct[11];
  ST32 (&pLevel[13], LD32 (&pDct[14]));
  pLevel[15] = 0;
}

void WelsScan4x4Dc (int16_t* pLevel, int16_t* pDct) {
  ST32 (pLevel, LD32 (pDct));
  pLevel[2] = pDct[4];
  pLevel[3] = pDct[8];
  pLevel[4] = pDct[5];
  ST32 (pLevel + 5, LD32 (pDct + 2));
  pLevel[7] = pDct[6];
  pLevel[8] = pDct[9];
  ST32 (pLevel + 9, LD32 (pDct + 12));
  pLevel[11] = pDct[10];
  pLevel[12] = pDct[7];
  pLevel[13] = pDct[11];
  ST32 (pLevel + 14, LD32 (pDct + 14));
}

//refer to JVT-O079
int32_t WelsCalculateSingleCtr4x4_c (int16_t* pDct) {
  static const int32_t kiTRunTable[16] = { 3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

  int32_t iSingleCtr = 0;
  int32_t iIdx = 15;
  int32_t iRun;

  while (iIdx >= 0 && pDct[iIdx] == 0)      --iIdx;

  while (iIdx >= 0) {
    -- iIdx;
    iRun = iIdx;
    while (iIdx >= 0 && pDct[iIdx] == 0)  --iIdx;
    iRun -= iIdx;
    iSingleCtr += kiTRunTable[iRun];
  }
  return iSingleCtr;
}

int32_t WelsGetNoneZeroCount_c (int16_t* pLevel) {
  int32_t iCnt = 0;
  int32_t iIdx = 0;

  while (iIdx < 16) {
    iCnt += (pLevel[  iIdx] == 0);
    iCnt += (pLevel[1 + iIdx] == 0);
    iCnt += (pLevel[2 + iIdx] == 0);
    iCnt += (pLevel[3 + iIdx] == 0);

    iIdx += 4;
  }
  return (16 - iCnt);
}

#ifdef HAVE_NEON
int32_t WelsHadamardQuant2x2Skip_neon (int16_t* pRes, int16_t iFF,  int16_t iMF) {
  int16_t iThreshold = ((1 << 16) - 1) / iMF - iFF;
  return WelsHadamardQuant2x2SkipKernel_neon (pRes, iThreshold);
}
#endif
#ifdef HAVE_NEON_AARCH64
int32_t WelsHadamardQuant2x2Skip_AArch64_neon (int16_t* pRes, int16_t iFF,  int16_t iMF) {
  int16_t iThreshold = ((1 << 16) - 1) / iMF - iFF;
  return WelsHadamardQuant2x2SkipKernel_AArch64_neon (pRes, iThreshold);
}
#endif
void WelsInitEncodingFuncs (SWelsFuncPtrList* pFuncList, uint32_t  uiCpuFlag) {
  pFuncList->pfCopy8x8Aligned           = WelsCopy8x8_c;
  pFuncList->pfCopy16x16Aligned         =
  pFuncList->pfCopy16x16NotAligned      = WelsCopy16x16_c;
  pFuncList->pfCopy16x8NotAligned       = WelsCopy16x8_c;
  pFuncList->pfCopy8x16Aligned          = WelsCopy8x16_c;
  pFuncList->pfCopy4x4           = WelsCopy4x4_c;
  pFuncList->pfCopy8x4           = WelsCopy8x4_c;
  pFuncList->pfCopy4x8           = WelsCopy4x8_c;
  pFuncList->pfQuantizationHadamard2x2          = WelsHadamardQuant2x2_c;
  pFuncList->pfQuantizationHadamard2x2Skip      = WelsHadamardQuant2x2Skip_c;
  pFuncList->pfTransformHadamard4x4Dc           = WelsHadamardT4Dc_c;

  pFuncList->pfDctT4                    = WelsDctT4_c;
  pFuncList->pfDctFourT4                = WelsDctFourT4_c;

  pFuncList->pfScan4x4                  = WelsScan4x4DcAc_c;
  pFuncList->pfScan4x4Ac                = WelsScan4x4Ac_c;
  pFuncList->pfCalculateSingleCtr4x4    = WelsCalculateSingleCtr4x4_c;

  pFuncList->pfGetNoneZeroCount         = WelsGetNoneZeroCount_c;

  pFuncList->pfQuantization4x4          = WelsQuant4x4_c;
  pFuncList->pfQuantizationDc4x4        = WelsQuant4x4Dc_c;
  pFuncList->pfQuantizationFour4x4      = WelsQuantFour4x4_c;
  pFuncList->pfQuantizationFour4x4Max   = WelsQuantFour4x4Max_c;

#if defined(X86_ASM)
  if (uiCpuFlag & WELS_CPU_MMXEXT) {

    pFuncList->pfQuantizationHadamard2x2        = WelsHadamardQuant2x2_mmx;
    pFuncList->pfQuantizationHadamard2x2Skip    = WelsHadamardQuant2x2Skip_mmx;

    pFuncList->pfDctT4                  = WelsDctT4_mmx;

    pFuncList->pfCopy8x8Aligned         = WelsCopy8x8_mmx;
    pFuncList->pfCopy8x16Aligned        = WelsCopy8x16_mmx;
  }
  if (uiCpuFlag & WELS_CPU_SSE2) {
    pFuncList->pfGetNoneZeroCount       = WelsGetNoneZeroCount_sse2;
    pFuncList->pfTransformHadamard4x4Dc = WelsHadamardT4Dc_sse2;

    pFuncList->pfQuantization4x4        = WelsQuant4x4_sse2;
    pFuncList->pfQuantizationDc4x4      = WelsQuant4x4Dc_sse2;
    pFuncList->pfQuantizationFour4x4    = WelsQuantFour4x4_sse2;
    pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_sse2;

    pFuncList->pfCopy16x16Aligned       = WelsCopy16x16_sse2;
    pFuncList->pfCopy16x16NotAligned    = WelsCopy16x16NotAligned_sse2;
    pFuncList->pfCopy16x8NotAligned     = WelsCopy16x8NotAligned_sse2;

    pFuncList->pfScan4x4                = WelsScan4x4DcAc_sse2;
    pFuncList->pfScan4x4Ac              = WelsScan4x4Ac_sse2;
    pFuncList->pfCalculateSingleCtr4x4  = WelsCalculateSingleCtr4x4_sse2;

    pFuncList->pfDctT4                  = WelsDctT4_sse2;
    pFuncList->pfDctFourT4              = WelsDctFourT4_sse2;
  }
//#ifndef MACOS
  if (uiCpuFlag & WELS_CPU_SSSE3) {
    pFuncList->pfScan4x4                = WelsScan4x4DcAc_ssse3;
  }
  if (uiCpuFlag & WELS_CPU_SSE42) {
    pFuncList->pfGetNoneZeroCount       = WelsGetNoneZeroCount_sse42;
  }
#if defined(HAVE_AVX2)
  if (uiCpuFlag & WELS_CPU_AVX2) {
    pFuncList->pfDctT4                  = WelsDctT4_avx2;
    pFuncList->pfDctFourT4              = WelsDctFourT4_avx2;

    pFuncList->pfQuantization4x4        = WelsQuant4x4_avx2;
    pFuncList->pfQuantizationDc4x4      = WelsQuant4x4Dc_avx2;
    pFuncList->pfQuantizationFour4x4    = WelsQuantFour4x4_avx2;
    pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_avx2;
  }
#endif
//#endif//MACOS

#endif//X86_ASM

#if defined(HAVE_NEON)
  if (uiCpuFlag & WELS_CPU_NEON) {
    pFuncList->pfQuantizationHadamard2x2        = WelsHadamardQuant2x2_neon;
    pFuncList->pfQuantizationHadamard2x2Skip    = WelsHadamardQuant2x2Skip_neon;
    pFuncList->pfDctT4                          = WelsDctT4_neon;
    pFuncList->pfCopy8x8Aligned                 = WelsCopy8x8_neon;
    pFuncList->pfCopy8x16Aligned                = WelsCopy8x16_neon;

    pFuncList->pfGetNoneZeroCount       = WelsGetNoneZeroCount_neon;
    pFuncList->pfTransformHadamard4x4Dc = WelsHadamardT4Dc_neon;

    pFuncList->pfQuantization4x4        = WelsQuant4x4_neon;
    pFuncList->pfQuantizationDc4x4      = WelsQuant4x4Dc_neon;
    pFuncList->pfQuantizationFour4x4    = WelsQuantFour4x4_neon;
    pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_neon;

    pFuncList->pfCopy16x16Aligned       = WelsCopy16x16_neon;
    pFuncList->pfCopy16x16NotAligned    = WelsCopy16x16NotAligned_neon;
    pFuncList->pfCopy16x8NotAligned     = WelsCopy16x8NotAligned_neon;
    pFuncList->pfDctFourT4              = WelsDctFourT4_neon;
  }
#endif

#if defined(HAVE_NEON_AARCH64)
  if (uiCpuFlag & WELS_CPU_NEON) {
    pFuncList->pfQuantizationHadamard2x2        = WelsHadamardQuant2x2_AArch64_neon;
    pFuncList->pfQuantizationHadamard2x2Skip    = WelsHadamardQuant2x2Skip_AArch64_neon;
    pFuncList->pfDctT4                          = WelsDctT4_AArch64_neon;
    pFuncList->pfCopy8x8Aligned                 = WelsCopy8x8_AArch64_neon;
    pFuncList->pfCopy8x16Aligned                = WelsCopy8x16_AArch64_neon;

    pFuncList->pfGetNoneZeroCount       = WelsGetNoneZeroCount_AArch64_neon;
    pFuncList->pfTransformHadamard4x4Dc = WelsHadamardT4Dc_AArch64_neon;

    pFuncList->pfQuantization4x4        = WelsQuant4x4_AArch64_neon;
    pFuncList->pfQuantizationDc4x4      = WelsQuant4x4Dc_AArch64_neon;
    pFuncList->pfQuantizationFour4x4    = WelsQuantFour4x4_AArch64_neon;
    pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_AArch64_neon;

    pFuncList->pfCopy16x16Aligned       = WelsCopy16x16_AArch64_neon;
    pFuncList->pfCopy16x16NotAligned    = WelsCopy16x16NotAligned_AArch64_neon;
    pFuncList->pfCopy16x8NotAligned     = WelsCopy16x8NotAligned_AArch64_neon;
    pFuncList->pfDctFourT4              = WelsDctFourT4_AArch64_neon;
  }
#endif

#if defined(HAVE_MMI)
  if (uiCpuFlag & WELS_CPU_MMI) {
    pFuncList->pfCopy8x8Aligned         = WelsCopy8x8_mmi;
    pFuncList->pfCopy8x16Aligned        = WelsCopy8x16_mmi;

    pFuncList->pfGetNoneZeroCount       = WelsGetNoneZeroCount_mmi;
    pFuncList->pfTransformHadamard4x4Dc = WelsHadamardT4Dc_mmi;

    pFuncList->pfQuantization4x4        = WelsQuant4x4_mmi;
    pFuncList->pfQuantizationDc4x4      = WelsQuant4x4Dc_mmi;
    pFuncList->pfQuantizationFour4x4    = WelsQuantFour4x4_mmi;
    pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_mmi;

    pFuncList->pfCopy16x16Aligned       = WelsCopy16x16_mmi;
    pFuncList->pfCopy16x16NotAligned    = WelsCopy16x16NotAligned_mmi;
    pFuncList->pfCopy16x8NotAligned     = WelsCopy16x8NotAligned_mmi;

    pFuncList->pfScan4x4                = WelsScan4x4DcAc_mmi;
    pFuncList->pfScan4x4Ac              = WelsScan4x4Ac_mmi;
    pFuncList->pfCalculateSingleCtr4x4  = WelsCalculateSingleCtr4x4_mmi;

    pFuncList->pfDctT4                  = WelsDctT4_mmi;
    pFuncList->pfDctFourT4              = WelsDctFourT4_mmi;
  }
#endif//HAVE_MMI

#if defined(HAVE_MSA)
  if (uiCpuFlag & WELS_CPU_MSA) {
    pFuncList->pfCopy8x8Aligned         = WelsCopy8x8_msa;
    pFuncList->pfCopy8x16Aligned        = WelsCopy8x16_msa;

    pFuncList->pfCopy16x16Aligned       =
    pFuncList->pfCopy16x16NotAligned    = WelsCopy16x16_msa;
    pFuncList->pfCopy16x8NotAligned     = WelsCopy16x8_msa;
  }
#endif

#if defined(HAVE_LSX)
  if (uiCpuFlag & WELS_CPU_LSX) {
    pFuncList->pfCopy8x8Aligned         = WelsCopy8x8_lsx;
    pFuncList->pfCopy16x16Aligned       = WelsCopy16x16_lsx;
    pFuncList->pfCopy16x16NotAligned    = WelsCopy16x16NotAligned_lsx;
    pFuncList->pfQuantizationFour4x4    = WelsQuantFour4x4_lsx;
    pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_lsx;
  }
#endif
#if defined(HAVE_LASX)
  if (uiCpuFlag & WELS_CPU_LASX) {
    pFuncList->pfDctT4                  = WelsDctT4_lasx;
    pFuncList->pfDctFourT4              = WelsDctFourT4_lasx;
}
#endif
}
}
