// Copyright 2010 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be found in the AUTHORS file in the root of the source tree.
// -----------------------------------------------------------------------------
//
// YUV->RGB conversion functions
//
// Author: Skal (pascal.massimino@gmail.com)

#include "src/dsp/yuv.h"

#include <assert.h>
#include <stdlib.h>
#include <string.h>

#include "src/dsp/cpu.h"
#include "src/dsp/dsp.h"
#include "src/webp/decode.h"
#include "src/webp/types.h"

// Uncomment to disable gamma-compression during RGB->U/V averaging
#define USE_GAMMA_COMPRESSION

// If defined, use table to compute x / alpha.
#define USE_INVERSE_ALPHA_TABLE

#ifdef USE_GAMMA_COMPRESSION
#include <math.h>
#endif

//-----------------------------------------------------------------------------
// Plain-C version

#define ROW_FUNC(FUNC_NAME, FUNC, XSTEP)                                     \
  static void FUNC_NAME(                                                     \
      const uint8_t* WEBP_RESTRICT y, const uint8_t* WEBP_RESTRICT u,        \
      const uint8_t* WEBP_RESTRICT v, uint8_t* WEBP_RESTRICT dst, int len) { \
    const uint8_t* const end = dst + (len & ~1) * (XSTEP);                   \
    while (dst != end) {                                                     \
      FUNC(y[0], u[0], v[0], dst);                                           \
      FUNC(y[1], u[0], v[0], dst + (XSTEP));                                 \
      y += 2;                                                                \
      ++u;                                                                   \
      ++v;                                                                   \
      dst += 2 * (XSTEP);                                                    \
    }                                                                        \
    if (len & 1) {                                                           \
      FUNC(y[0], u[0], v[0], dst);                                           \
    }                                                                        \
  }

// All variants implemented.
ROW_FUNC(YuvToRgbRow, VP8YuvToRgb, 3)
ROW_FUNC(YuvToBgrRow, VP8YuvToBgr, 3)
ROW_FUNC(YuvToRgbaRow, VP8YuvToRgba, 4)
ROW_FUNC(YuvToBgraRow, VP8YuvToBgra, 4)
ROW_FUNC(YuvToArgbRow, VP8YuvToArgb, 4)
ROW_FUNC(YuvToRgba4444Row, VP8YuvToRgba4444, 2)
ROW_FUNC(YuvToRgb565Row, VP8YuvToRgb565, 2)

#undef ROW_FUNC

// Main call for processing a plane with a WebPSamplerRowFunc function:
void WebPSamplerProcessPlane(const uint8_t* WEBP_RESTRICT y, int y_stride,
                             const uint8_t* WEBP_RESTRICT u,
                             const uint8_t* WEBP_RESTRICT v, int uv_stride,
                             uint8_t* WEBP_RESTRICT dst, int dst_stride,
                             int width, int height, WebPSamplerRowFunc func) {
  int j;
  for (j = 0; j < height; ++j) {
    func(y, u, v, dst, width);
    y += y_stride;
    if (j & 1) {
      u += uv_stride;
      v += uv_stride;
    }
    dst += dst_stride;
  }
}

//-----------------------------------------------------------------------------
// Main call

WebPSamplerRowFunc WebPSamplers[MODE_LAST];

extern VP8CPUInfo VP8GetCPUInfo;
extern void WebPInitSamplersSSE2(void);
extern void WebPInitSamplersSSE41(void);
extern void WebPInitSamplersMIPS32(void);
extern void WebPInitSamplersMIPSdspR2(void);

WEBP_DSP_INIT_FUNC(WebPInitSamplers) {
  WebPSamplers[MODE_RGB] = YuvToRgbRow;
  WebPSamplers[MODE_RGBA] = YuvToRgbaRow;
  WebPSamplers[MODE_BGR] = YuvToBgrRow;
  WebPSamplers[MODE_BGRA] = YuvToBgraRow;
  WebPSamplers[MODE_ARGB] = YuvToArgbRow;
  WebPSamplers[MODE_RGBA_4444] = YuvToRgba4444Row;
  WebPSamplers[MODE_RGB_565] = YuvToRgb565Row;
  WebPSamplers[MODE_rgbA] = YuvToRgbaRow;
  WebPSamplers[MODE_bgrA] = YuvToBgraRow;
  WebPSamplers[MODE_Argb] = YuvToArgbRow;
  WebPSamplers[MODE_rgbA_4444] = YuvToRgba4444Row;

  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPInitSamplersSSE2();
    }
#endif  // WEBP_HAVE_SSE2
#if defined(WEBP_HAVE_SSE41)
    if (VP8GetCPUInfo(kSSE4_1)) {
      WebPInitSamplersSSE41();
    }
#endif  // WEBP_HAVE_SSE41
#if defined(WEBP_USE_MIPS32)
    if (VP8GetCPUInfo(kMIPS32)) {
      WebPInitSamplersMIPS32();
    }
#endif  // WEBP_USE_MIPS32
#if defined(WEBP_USE_MIPS_DSP_R2)
    if (VP8GetCPUInfo(kMIPSdspR2)) {
      WebPInitSamplersMIPSdspR2();
    }
#endif  // WEBP_USE_MIPS_DSP_R2
  }
}

//-----------------------------------------------------------------------------
// ARGB -> YUV converters

static void ConvertARGBToY_C(const uint32_t* WEBP_RESTRICT argb,
                             uint8_t* WEBP_RESTRICT y, int width) {
  int i;
  for (i = 0; i < width; ++i) {
    const uint32_t p = argb[i];
    y[i] =
        VP8RGBToY((p >> 16) & 0xff, (p >> 8) & 0xff, (p >> 0) & 0xff, YUV_HALF);
  }
}

void WebPConvertARGBToUV_C(const uint32_t* WEBP_RESTRICT argb,
                           uint8_t* WEBP_RESTRICT u, uint8_t* WEBP_RESTRICT v,
                           int src_width, int do_store) {
  // No rounding. Last pixel is dealt with separately.
  const int uv_width = src_width >> 1;
  int i;
  for (i = 0; i < uv_width; ++i) {
    const uint32_t v0 = argb[2 * i + 0];
    const uint32_t v1 = argb[2 * i + 1];
    // VP8RGBToU/V expects four accumulated pixels. Hence we need to
    // scale r/g/b value by a factor 2. We just shift v0/v1 one bit less.
    const int r = ((v0 >> 15) & 0x1fe) + ((v1 >> 15) & 0x1fe);
    const int g = ((v0 >> 7) & 0x1fe) + ((v1 >> 7) & 0x1fe);
    const int b = ((v0 << 1) & 0x1fe) + ((v1 << 1) & 0x1fe);
    const int tmp_u = VP8RGBToU(r, g, b, YUV_HALF << 2);
    const int tmp_v = VP8RGBToV(r, g, b, YUV_HALF << 2);
    if (do_store) {
      u[i] = tmp_u;
      v[i] = tmp_v;
    } else {
      // Approximated average-of-four. But it's an acceptable diff.
      u[i] = (u[i] + tmp_u + 1) >> 1;
      v[i] = (v[i] + tmp_v + 1) >> 1;
    }
  }
  if (src_width & 1) {  // last pixel
    const uint32_t v0 = argb[2 * i + 0];
    const int r = (v0 >> 14) & 0x3fc;
    const int g = (v0 >> 6) & 0x3fc;
    const int b = (v0 << 2) & 0x3fc;
    const int tmp_u = VP8RGBToU(r, g, b, YUV_HALF << 2);
    const int tmp_v = VP8RGBToV(r, g, b, YUV_HALF << 2);
    if (do_store) {
      u[i] = tmp_u;
      v[i] = tmp_v;
    } else {
      u[i] = (u[i] + tmp_u + 1) >> 1;
      v[i] = (v[i] + tmp_v + 1) >> 1;
    }
  }
}

//-----------------------------------------------------------------------------

static void ConvertRGBToY_C(const uint8_t* WEBP_RESTRICT rgb,
                            uint8_t* WEBP_RESTRICT y, int width, int step) {
  int i;
  for (i = 0; i < width; ++i, rgb += step) {
    y[i] = VP8RGBToY(rgb[0], rgb[1], rgb[2], YUV_HALF);
  }
}

static void ConvertBGRToY_C(const uint8_t* WEBP_RESTRICT bgr,
                            uint8_t* WEBP_RESTRICT y, int width, int step) {
  int i;
  for (i = 0; i < width; ++i, bgr += step) {
    y[i] = VP8RGBToY(bgr[2], bgr[1], bgr[0], YUV_HALF);
  }
}

void WebPConvertRGBA32ToUV_C(const uint16_t* WEBP_RESTRICT rgb,
                             uint8_t* WEBP_RESTRICT u, uint8_t* WEBP_RESTRICT v,
                             int width) {
  int i;
  for (i = 0; i < width; i += 1, rgb += 4) {
    const int r = rgb[0], g = rgb[1], b = rgb[2];
    u[i] = VP8RGBToU(r, g, b, YUV_HALF << 2);
    v[i] = VP8RGBToV(r, g, b, YUV_HALF << 2);
  }
}

//------------------------------------------------------------------------------
// Code for gamma correction

#if defined(USE_GAMMA_COMPRESSION)

// Gamma correction compensates loss of resolution during chroma subsampling.
#define GAMMA_FIX 12     // fixed-point precision for linear values
#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
#define GAMMA_TAB_SIZE (1 << (GAMMA_FIX - GAMMA_TAB_FIX))
static const double kGamma = 0.80;
static const int kGammaScale = ((1 << GAMMA_FIX) - 1);
static const int kGammaTabScale = (1 << GAMMA_TAB_FIX);
static const int kGammaTabRounder = (1 << GAMMA_TAB_FIX >> 1);

static int kLinearToGammaTab[GAMMA_TAB_SIZE + 1];
static uint16_t kGammaToLinearTab[256];
static volatile int kGammaTablesOk = 0;
extern VP8CPUInfo VP8GetCPUInfo;

WEBP_DSP_INIT_FUNC(WebPInitGammaTables) {
  if (!kGammaTablesOk) {
    int v;
    const double scale = (double)(1 << GAMMA_TAB_FIX) / kGammaScale;
    const double norm = 1. / 255.;
    for (v = 0; v <= 255; ++v) {
      kGammaToLinearTab[v] =
          (uint16_t)(pow(norm * v, kGamma) * kGammaScale + .5);
    }
    for (v = 0; v <= GAMMA_TAB_SIZE; ++v) {
      kLinearToGammaTab[v] = (int)(255. * pow(scale * v, 1. / kGamma) + .5);
    }
    kGammaTablesOk = 1;
  }
}

static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) {
  return kGammaToLinearTab[v];
}

static WEBP_INLINE int Interpolate(int v) {
  const int tab_pos = v >> (GAMMA_TAB_FIX + 2);   // integer part
  const int x = v & ((kGammaTabScale << 2) - 1);  // fractional part
  const int v0 = kLinearToGammaTab[tab_pos];
  const int v1 = kLinearToGammaTab[tab_pos + 1];
  const int y = v1 * x + v0 * ((kGammaTabScale << 2) - x);  // interpolate
  assert(tab_pos + 1 < GAMMA_TAB_SIZE + 1);
  return y;
}

// Convert a linear value 'v' to YUV_FIX+2 fixed-point precision
// U/V value, suitable for RGBToU/V calls.
static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
  const int y = Interpolate(base_value << shift);  // final uplifted value
  return (y + kGammaTabRounder) >> GAMMA_TAB_FIX;  // descale
}

#else

void WebPInitGammaTables(void) {}
static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) { return v; }
static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
  return (int)(base_value << shift);
}

#endif  // USE_GAMMA_COMPRESSION

#define SUM4(ptr, step)                                                  \
  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
                    GammaToLinear((ptr)[rgb_stride]) +                   \
                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
                0)

#define SUM2(ptr) \
  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)

//------------------------------------------------------------------------------
// "Fast" regular RGB->YUV

#define SUM4(ptr, step)                                                  \
  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
                    GammaToLinear((ptr)[rgb_stride]) +                   \
                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
                0)

#define SUM2(ptr) \
  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)

#define SUM2ALPHA(ptr) ((ptr)[0] + (ptr)[rgb_stride])
#define SUM4ALPHA(ptr) (SUM2ALPHA(ptr) + SUM2ALPHA((ptr) + 4))

#if defined(USE_INVERSE_ALPHA_TABLE)

static const int kAlphaFix = 19;
// Following table is (1 << kAlphaFix) / a. The (v * kInvAlpha[a]) >> kAlphaFix
// formula is then equal to v / a in most (99.6%) cases. Note that this table
// and constant are adjusted very tightly to fit 32b arithmetic.
// In particular, they use the fact that the operands for 'v / a' are actually
// derived as v = (a0.p0 + a1.p1 + a2.p2 + a3.p3) and a = a0 + a1 + a2 + a3
// with ai in [0..255] and pi in [0..1<<GAMMA_FIX). The constraint to avoid
// overflow is: GAMMA_FIX + kAlphaFix <= 31.
static const uint32_t kInvAlpha[4 * 0xff + 1] = {
    0, /* alpha = 0 */
    524288, 262144, 174762, 131072, 104857, 87381, 74898, 65536, 58254, 52428,
    47662,  43690,  40329,  37449,  34952,  32768, 30840, 29127, 27594, 26214,
    24966,  23831,  22795,  21845,  20971,  20164, 19418, 18724, 18078, 17476,
    16912,  16384,  15887,  15420,  14979,  14563, 14169, 13797, 13443, 13107,
    12787,  12483,  12192,  11915,  11650,  11397, 11155, 10922, 10699, 10485,
    10280,  10082,  9892,   9709,   9532,   9362,  9198,  9039,  8886,  8738,
    8594,   8456,   8322,   8192,   8065,   7943,  7825,  7710,  7598,  7489,
    7384,   7281,   7182,   7084,   6990,   6898,  6808,  6721,  6636,  6553,
    6472,   6393,   6316,   6241,   6168,   6096,  6026,  5957,  5890,  5825,
    5761,   5698,   5637,   5577,   5518,   5461,  5405,  5349,  5295,  5242,
    5190,   5140,   5090,   5041,   4993,   4946,  4899,  4854,  4809,  4766,
    4723,   4681,   4639,   4599,   4559,   4519,  4481,  4443,  4405,  4369,
    4332,   4297,   4262,   4228,   4194,   4161,  4128,  4096,  4064,  4032,
    4002,   3971,   3942,   3912,   3883,   3855,  3826,  3799,  3771,  3744,
    3718,   3692,   3666,   3640,   3615,   3591,  3566,  3542,  3518,  3495,
    3472,   3449,   3426,   3404,   3382,   3360,  3339,  3318,  3297,  3276,
    3256,   3236,   3216,   3196,   3177,   3158,  3139,  3120,  3102,  3084,
    3066,   3048,   3030,   3013,   2995,   2978,  2962,  2945,  2928,  2912,
    2896,   2880,   2864,   2849,   2833,   2818,  2803,  2788,  2774,  2759,
    2744,   2730,   2716,   2702,   2688,   2674,  2661,  2647,  2634,  2621,
    2608,   2595,   2582,   2570,   2557,   2545,  2532,  2520,  2508,  2496,
    2484,   2473,   2461,   2449,   2438,   2427,  2416,  2404,  2394,  2383,
    2372,   2361,   2351,   2340,   2330,   2319,  2309,  2299,  2289,  2279,
    2269,   2259,   2250,   2240,   2231,   2221,  2212,  2202,  2193,  2184,
    2175,   2166,   2157,   2148,   2139,   2131,  2122,  2114,  2105,  2097,
    2088,   2080,   2072,   2064,   2056,   2048,  2040,  2032,  2024,  2016,
    2008,   2001,   1993,   1985,   1978,   1971,  1963,  1956,  1949,  1941,
    1934,   1927,   1920,   1913,   1906,   1899,  1892,  1885,  1879,  1872,
    1865,   1859,   1852,   1846,   1839,   1833,  1826,  1820,  1814,  1807,
    1801,   1795,   1789,   1783,   1777,   1771,  1765,  1759,  1753,  1747,
    1741,   1736,   1730,   1724,   1718,   1713,  1707,  1702,  1696,  1691,
    1685,   1680,   1675,   1669,   1664,   1659,  1653,  1648,  1643,  1638,
    1633,   1628,   1623,   1618,   1613,   1608,  1603,  1598,  1593,  1588,
    1583,   1579,   1574,   1569,   1565,   1560,  1555,  1551,  1546,  1542,
    1537,   1533,   1528,   1524,   1519,   1515,  1510,  1506,  1502,  1497,
    1493,   1489,   1485,   1481,   1476,   1472,  1468,  1464,  1460,  1456,
    1452,   1448,   1444,   1440,   1436,   1432,  1428,  1424,  1420,  1416,
    1413,   1409,   1405,   1401,   1398,   1394,  1390,  1387,  1383,  1379,
    1376,   1372,   1368,   1365,   1361,   1358,  1354,  1351,  1347,  1344,
    1340,   1337,   1334,   1330,   1327,   1323,  1320,  1317,  1314,  1310,
    1307,   1304,   1300,   1297,   1294,   1291,  1288,  1285,  1281,  1278,
    1275,   1272,   1269,   1266,   1263,   1260,  1257,  1254,  1251,  1248,
    1245,   1242,   1239,   1236,   1233,   1230,  1227,  1224,  1222,  1219,
    1216,   1213,   1210,   1208,   1205,   1202,  1199,  1197,  1194,  1191,
    1188,   1186,   1183,   1180,   1178,   1175,  1172,  1170,  1167,  1165,
    1162,   1159,   1157,   1154,   1152,   1149,  1147,  1144,  1142,  1139,
    1137,   1134,   1132,   1129,   1127,   1125,  1122,  1120,  1117,  1115,
    1113,   1110,   1108,   1106,   1103,   1101,  1099,  1096,  1094,  1092,
    1089,   1087,   1085,   1083,   1081,   1078,  1076,  1074,  1072,  1069,
    1067,   1065,   1063,   1061,   1059,   1057,  1054,  1052,  1050,  1048,
    1046,   1044,   1042,   1040,   1038,   1036,  1034,  1032,  1030,  1028,
    1026,   1024,   1022,   1020,   1018,   1016,  1014,  1012,  1010,  1008,
    1006,   1004,   1002,   1000,   998,    996,   994,   992,   991,   989,
    987,    985,    983,    981,    979,    978,   976,   974,   972,   970,
    969,    967,    965,    963,    961,    960,   958,   956,   954,   953,
    951,    949,    948,    946,    944,    942,   941,   939,   937,   936,
    934,    932,    931,    929,    927,    926,   924,   923,   921,   919,
    918,    916,    914,    913,    911,    910,   908,   907,   905,   903,
    902,    900,    899,    897,    896,    894,   893,   891,   890,   888,
    887,    885,    884,    882,    881,    879,   878,   876,   875,   873,
    872,    870,    869,    868,    866,    865,   863,   862,   860,   859,
    858,    856,    855,    853,    852,    851,   849,   848,   846,   845,
    844,    842,    841,    840,    838,    837,   836,   834,   833,   832,
    830,    829,    828,    826,    825,    824,   823,   821,   820,   819,
    817,    816,    815,    814,    812,    811,   810,   809,   807,   806,
    805,    804,    802,    801,    800,    799,   798,   796,   795,   794,
    793,    791,    790,    789,    788,    787,   786,   784,   783,   782,
    781,    780,    779,    777,    776,    775,   774,   773,   772,   771,
    769,    768,    767,    766,    765,    764,   763,   762,   760,   759,
    758,    757,    756,    755,    754,    753,   752,   751,   750,   748,
    747,    746,    745,    744,    743,    742,   741,   740,   739,   738,
    737,    736,    735,    734,    733,    732,   731,   730,   729,   728,
    727,    726,    725,    724,    723,    722,   721,   720,   719,   718,
    717,    716,    715,    714,    713,    712,   711,   710,   709,   708,
    707,    706,    705,    704,    703,    702,   701,   700,   699,   699,
    698,    697,    696,    695,    694,    693,   692,   691,   690,   689,
    688,    688,    687,    686,    685,    684,   683,   682,   681,   680,
    680,    679,    678,    677,    676,    675,   674,   673,   673,   672,
    671,    670,    669,    668,    667,    667,   666,   665,   664,   663,
    662,    661,    661,    660,    659,    658,   657,   657,   656,   655,
    654,    653,    652,    652,    651,    650,   649,   648,   648,   647,
    646,    645,    644,    644,    643,    642,   641,   640,   640,   639,
    638,    637,    637,    636,    635,    634,   633,   633,   632,   631,
    630,    630,    629,    628,    627,    627,   626,   625,   624,   624,
    623,    622,    621,    621,    620,    619,   618,   618,   617,   616,
    616,    615,    614,    613,    613,    612,   611,   611,   610,   609,
    608,    608,    607,    606,    606,    605,   604,   604,   603,   602,
    601,    601,    600,    599,    599,    598,   597,   597,   596,   595,
    595,    594,    593,    593,    592,    591,   591,   590,   589,   589,
    588,    587,    587,    586,    585,    585,   584,   583,   583,   582,
    581,    581,    580,    579,    579,    578,   578,   577,   576,   576,
    575,    574,    574,    573,    572,    572,   571,   571,   570,   569,
    569,    568,    568,    567,    566,    566,   565,   564,   564,   563,
    563,    562,    561,    561,    560,    560,   559,   558,   558,   557,
    557,    556,    555,    555,    554,    554,   553,   553,   552,   551,
    551,    550,    550,    549,    548,    548,   547,   547,   546,   546,
    545,    544,    544,    543,    543,    542,   542,   541,   541,   540,
    539,    539,    538,    538,    537,    537,   536,   536,   535,   534,
    534,    533,    533,    532,    532,    531,   531,   530,   530,   529,
    529,    528,    527,    527,    526,    526,   525,   525,   524,   524,
    523,    523,    522,    522,    521,    521,   520,   520,   519,   519,
    518,    518,    517,    517,    516,    516,   515,   515,   514,   514};

// Note that LinearToGamma() expects the values to be premultiplied by 4,
// so we incorporate this factor 4 inside the DIVIDE_BY_ALPHA macro directly.
#define DIVIDE_BY_ALPHA(sum, a) (((sum) * kInvAlpha[(a)]) >> (kAlphaFix - 2))

#else

#define DIVIDE_BY_ALPHA(sum, a) (4 * (sum) / (a))

#endif  // USE_INVERSE_ALPHA_TABLE

static WEBP_INLINE int LinearToGammaWeighted(const uint8_t* src,
                                             const uint8_t* a_ptr,
                                             uint32_t total_a, int step,
                                             int rgb_stride) {
  const uint32_t sum =
      a_ptr[0] * GammaToLinear(src[0]) +
      a_ptr[step] * GammaToLinear(src[step]) +
      a_ptr[rgb_stride] * GammaToLinear(src[rgb_stride]) +
      a_ptr[rgb_stride + step] * GammaToLinear(src[rgb_stride + step]);
  assert(total_a > 0 && total_a <= 4 * 0xff);
#if defined(USE_INVERSE_ALPHA_TABLE)
  assert((uint64_t)sum * kInvAlpha[total_a] < ((uint64_t)1 << 32));
#endif
  return LinearToGamma(DIVIDE_BY_ALPHA(sum, total_a), 0);
}

void WebPAccumulateRGBA(const uint8_t* const r_ptr, const uint8_t* const g_ptr,
                        const uint8_t* const b_ptr, const uint8_t* const a_ptr,
                        int rgb_stride, uint16_t* dst, int width) {
  int i, j;
  // we loop over 2x2 blocks and produce one R/G/B/A value for each.
  for (i = 0, j = 0; i < (width >> 1); i += 1, j += 2 * 4, dst += 4) {
    const uint32_t a = SUM4ALPHA(a_ptr + j);
    int r, g, b;
    if (a == 4 * 0xff || a == 0) {
      r = SUM4(r_ptr + j, 4);
      g = SUM4(g_ptr + j, 4);
      b = SUM4(b_ptr + j, 4);
    } else {
      r = LinearToGammaWeighted(r_ptr + j, a_ptr + j, a, 4, rgb_stride);
      g = LinearToGammaWeighted(g_ptr + j, a_ptr + j, a, 4, rgb_stride);
      b = LinearToGammaWeighted(b_ptr + j, a_ptr + j, a, 4, rgb_stride);
    }
    dst[0] = r;
    dst[1] = g;
    dst[2] = b;
    dst[3] = a;
  }
  if (width & 1) {
    const uint32_t a = 2u * SUM2ALPHA(a_ptr + j);
    int r, g, b;
    if (a == 4 * 0xff || a == 0) {
      r = SUM2(r_ptr + j);
      g = SUM2(g_ptr + j);
      b = SUM2(b_ptr + j);
    } else {
      r = LinearToGammaWeighted(r_ptr + j, a_ptr + j, a, 0, rgb_stride);
      g = LinearToGammaWeighted(g_ptr + j, a_ptr + j, a, 0, rgb_stride);
      b = LinearToGammaWeighted(b_ptr + j, a_ptr + j, a, 0, rgb_stride);
    }
    dst[0] = r;
    dst[1] = g;
    dst[2] = b;
    dst[3] = a;
  }
}

void WebPAccumulateRGB(const uint8_t* const r_ptr, const uint8_t* const g_ptr,
                       const uint8_t* const b_ptr, int step, int rgb_stride,
                       uint16_t* dst, int width) {
  int i, j;
  for (i = 0, j = 0; i < (width >> 1); i += 1, j += 2 * step, dst += 4) {
    dst[0] = SUM4(r_ptr + j, step);
    dst[1] = SUM4(g_ptr + j, step);
    dst[2] = SUM4(b_ptr + j, step);
    // MemorySanitizer may raise false positives with data that passes through
    // RGBA32PackedToPlanar_16b_SSE41() due to incorrect modeling of shuffles.
    // See https://crbug.com/webp/573.
#ifdef WEBP_MSAN
    dst[3] = 0;
#endif
  }
  if (width & 1) {
    dst[0] = SUM2(r_ptr + j);
    dst[1] = SUM2(g_ptr + j);
    dst[2] = SUM2(b_ptr + j);
#ifdef WEBP_MSAN
    dst[3] = 0;
#endif
  }
}

static void ImportYUVAFromRGBA_C(const uint8_t* r_ptr, const uint8_t* g_ptr,
                                 const uint8_t* b_ptr, const uint8_t* a_ptr,
                                 int step,        // bytes per pixel
                                 int rgb_stride,  // bytes per scanline
                                 int has_alpha, int width, int height,
                                 uint16_t* tmp_rgb, int y_stride, int uv_stride,
                                 int a_stride, uint8_t* dst_y, uint8_t* dst_u,
                                 uint8_t* dst_v, uint8_t* dst_a) {
  int y;
  const int is_rgb = (r_ptr < b_ptr);  // otherwise it's bgr
  const int uv_width = (width + 1) >> 1;

  has_alpha &= dst_a != NULL;
  if (has_alpha) {
#if defined(USE_GAMMA_COMPRESSION) && defined(USE_INVERSE_ALPHA_TABLE)
    assert(kAlphaFix + GAMMA_FIX <= 31);
#endif
  }

  WebPInitGammaTables();

  // Downsample Y/U/V planes, two rows at a time
  for (y = 0; y < (height >> 1); ++y) {
    int rows_have_alpha = has_alpha;
    if (is_rgb) {
      WebPConvertRGBToY(r_ptr, dst_y, width, step);
      WebPConvertRGBToY(r_ptr + rgb_stride, dst_y + y_stride, width, step);
    } else {
      WebPConvertBGRToY(b_ptr, dst_y, width, step);
      WebPConvertBGRToY(b_ptr + rgb_stride, dst_y + y_stride, width, step);
    }
    dst_y += 2 * y_stride;
    if (has_alpha) {
      rows_have_alpha &=
          !WebPExtractAlpha(a_ptr, rgb_stride, width, 2, dst_a, a_stride);
      dst_a += 2 * a_stride;
    } else if (dst_a != NULL) {
      int i;
      for (i = 0; i < 2; ++i, dst_a += a_stride) {
        memset(dst_a, 0xff, width);
      }
    }

    // Collect averaged R/G/B(/A)
    if (!rows_have_alpha) {
      WebPAccumulateRGB(r_ptr, g_ptr, b_ptr, step, rgb_stride, tmp_rgb, width);
    } else {
      WebPAccumulateRGBA(r_ptr, g_ptr, b_ptr, a_ptr, rgb_stride, tmp_rgb,
                         width);
    }
    // Convert to U/V
    WebPConvertRGBA32ToUV(tmp_rgb, dst_u, dst_v, uv_width);
    dst_u += uv_stride;
    dst_v += uv_stride;
    r_ptr += 2 * rgb_stride;
    b_ptr += 2 * rgb_stride;
    g_ptr += 2 * rgb_stride;
    if (has_alpha) a_ptr += 2 * rgb_stride;
  }
}

static void ImportYUVAFromRGBALastLine_C(
    const uint8_t* r_ptr, const uint8_t* g_ptr, const uint8_t* b_ptr,
    const uint8_t* a_ptr,
    int step,  // bytes per pixel
    int has_alpha, int width, uint16_t* tmp_rgb, uint8_t* dst_y, uint8_t* dst_u,
    uint8_t* dst_v, uint8_t* dst_a) {
  const int is_rgb = (r_ptr < b_ptr);  // otherwise it's bgr
  const int uv_width = (width + 1) >> 1;
  int row_has_alpha = has_alpha && dst_a != NULL;

  if (is_rgb) {
    WebPConvertRGBToY(r_ptr, dst_y, width, step);
  } else {
    WebPConvertBGRToY(b_ptr, dst_y, width, step);
  }
  if (row_has_alpha) {
    row_has_alpha &= !WebPExtractAlpha(a_ptr, 0, width, 1, dst_a, 0);
  } else if (dst_a != NULL) {
    memset(dst_a, 0xff, width);
  }

  // Collect averaged R/G/B(/A)
  if (!row_has_alpha) {
    // Collect averaged R/G/B
    WebPAccumulateRGB(r_ptr, g_ptr, b_ptr, step, /*rgb_stride=*/0, tmp_rgb,
                      width);
  } else {
    WebPAccumulateRGBA(r_ptr, g_ptr, b_ptr, a_ptr, /*rgb_stride=*/0, tmp_rgb,
                       width);
  }
  WebPConvertRGBA32ToUV(tmp_rgb, dst_u, dst_v, uv_width);
}

//-----------------------------------------------------------------------------

void (*WebPConvertRGBToY)(const uint8_t* WEBP_RESTRICT rgb,
                          uint8_t* WEBP_RESTRICT y, int width, int step);
void (*WebPConvertBGRToY)(const uint8_t* WEBP_RESTRICT bgr,
                          uint8_t* WEBP_RESTRICT y, int width, int step);
void (*WebPConvertRGBA32ToUV)(const uint16_t* WEBP_RESTRICT rgb,
                              uint8_t* WEBP_RESTRICT u,
                              uint8_t* WEBP_RESTRICT v, int width);

void (*WebPImportYUVAFromRGBA)(const uint8_t* r_ptr, const uint8_t* g_ptr,
                               const uint8_t* b_ptr, const uint8_t* a_ptr,
                               int step,        // bytes per pixel
                               int rgb_stride,  // bytes per scanline
                               int has_alpha, int width, int height,
                               uint16_t* tmp_rgb, int y_stride, int uv_stride,
                               int a_stride, uint8_t* dst_y, uint8_t* dst_u,
                               uint8_t* dst_v, uint8_t* dst_a);
void (*WebPImportYUVAFromRGBALastLine)(
    const uint8_t* r_ptr, const uint8_t* g_ptr, const uint8_t* b_ptr,
    const uint8_t* a_ptr,
    int step,  // bytes per pixel
    int has_alpha, int width, uint16_t* tmp_rgb, uint8_t* dst_y, uint8_t* dst_u,
    uint8_t* dst_v, uint8_t* dst_a);

void (*WebPConvertARGBToY)(const uint32_t* WEBP_RESTRICT argb,
                           uint8_t* WEBP_RESTRICT y, int width);
void (*WebPConvertARGBToUV)(const uint32_t* WEBP_RESTRICT argb,
                            uint8_t* WEBP_RESTRICT u, uint8_t* WEBP_RESTRICT v,
                            int src_width, int do_store);

extern void WebPInitConvertARGBToYUVSSE2(void);
extern void WebPInitConvertARGBToYUVSSE41(void);
extern void WebPInitConvertARGBToYUVNEON(void);

WEBP_DSP_INIT_FUNC(WebPInitConvertARGBToYUV) {
  WebPConvertARGBToY = ConvertARGBToY_C;
  WebPConvertARGBToUV = WebPConvertARGBToUV_C;

  WebPConvertRGBToY = ConvertRGBToY_C;
  WebPConvertBGRToY = ConvertBGRToY_C;

  WebPConvertRGBA32ToUV = WebPConvertRGBA32ToUV_C;

  WebPImportYUVAFromRGBA = ImportYUVAFromRGBA_C;
  WebPImportYUVAFromRGBALastLine = ImportYUVAFromRGBALastLine_C;

  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPInitConvertARGBToYUVSSE2();
    }
#endif  // WEBP_HAVE_SSE2
#if defined(WEBP_HAVE_SSE41)
    if (VP8GetCPUInfo(kSSE4_1)) {
      WebPInitConvertARGBToYUVSSE41();
    }
#endif  // WEBP_HAVE_SSE41
  }

#if defined(WEBP_HAVE_NEON)
  if (WEBP_NEON_OMIT_C_CODE ||
      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
    WebPInitConvertARGBToYUVNEON();
  }
#endif  // WEBP_HAVE_NEON

  assert(WebPConvertARGBToY != NULL);
  assert(WebPConvertARGBToUV != NULL);
  assert(WebPConvertRGBToY != NULL);
  assert(WebPConvertBGRToY != NULL);
  assert(WebPConvertRGBA32ToUV != NULL);
}