// 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);                                           \

    }                                                                        \

  }

Unexecuted instantiation: yuv.c:YuvToRgbRow

Unexecuted instantiation: yuv.c:YuvToRgbaRow

Unexecuted instantiation: yuv.c:YuvToBgrRow

Unexecuted instantiation: yuv.c:YuvToBgraRow

Unexecuted instantiation: yuv.c:YuvToArgbRow

Unexecuted instantiation: yuv.c:YuvToRgba4444Row

Unexecuted instantiation: yuv.c:YuvToRgb565Row

// 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);

}