upsampling_msa.c - mozsearch

// Copyright 2016 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.

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

//

// MSA version of YUV to RGB upsampling functions.

//

// Author: Prashant Patil (prashant.patil@imgtec.com)

#include <string.h>

#include "src/dsp/dsp.h"

#if defined(WEBP_USE_MSA)

#include "src/dsp/msa_macro.h"

#include "src/dsp/yuv.h"

#ifdef FANCY_UPSAMPLING

#define ILVR_UW2(in, out0, out1) do {                            \

  const v8i16 t0 = (v8i16)__msa_ilvr_b((v16i8)zero, (v16i8)in);  \

  out0 = (v4u32)__msa_ilvr_h((v8i16)zero, t0);                   \

  out1 = (v4u32)__msa_ilvl_h((v8i16)zero, t0);                   \

} while (0)

#define ILVRL_UW4(in, out0, out1, out2, out3) do {  \

  v16u8 t0, t1;                                     \

  ILVRL_B2_UB(zero, in, t0, t1);                    \

  ILVRL_H2_UW(zero, t0, out0, out1);                \

  ILVRL_H2_UW(zero, t1, out2, out3);                \

} while (0)

#define MULTHI_16(in0, in1, in2, in3, cnst, out0, out1) do {   \

  const v4i32 const0 = (v4i32)__msa_fill_w(cnst * 256);        \

  v4u32 temp0, temp1, temp2, temp3;                            \

  MUL4(in0, const0, in1, const0, in2, const0, in3, const0,     \

       temp0, temp1, temp2, temp3);                            \

  PCKOD_H2_UH(temp1, temp0, temp3, temp2, out0, out1);         \

} while (0)

#define MULTHI_8(in0, in1, cnst, out0) do {                 \

  const v4i32 const0 = (v4i32)__msa_fill_w(cnst * 256);     \

  v4u32 temp0, temp1;                                       \

  MUL2(in0, const0, in1, const0, temp0, temp1);             \

  out0 = (v8u16)__msa_pckod_h((v8i16)temp1, (v8i16)temp0);  \

} while (0)

#define CALC_R16(y0, y1, v0, v1, dst) do {                \

  const v8i16 const_a = (v8i16)__msa_fill_h(14234);       \

  const v8i16 a0 = __msa_adds_s_h((v8i16)y0, (v8i16)v0);  \

  const v8i16 a1 = __msa_adds_s_h((v8i16)y1, (v8i16)v1);  \

  v8i16 b0 = __msa_subs_s_h(a0, const_a);                 \

  v8i16 b1 = __msa_subs_s_h(a1, const_a);                 \

  SRAI_H2_SH(b0, b1, 6);                                  \

  CLIP_SH2_0_255(b0, b1);                                 \

  dst = (v16u8)__msa_pckev_b((v16i8)b1, (v16i8)b0);       \

} while (0)

#define CALC_R8(y0, v0, dst) do {                         \

  const v8i16 const_a = (v8i16)__msa_fill_h(14234);       \

  const v8i16 a0 = __msa_adds_s_h((v8i16)y0, (v8i16)v0);  \

  v8i16 b0 = __msa_subs_s_h(a0, const_a);                 \

  b0 = SRAI_H(b0, 6);                                     \

  CLIP_SH_0_255(b0);                                      \

  dst = (v16u8)__msa_pckev_b((v16i8)b0, (v16i8)b0);       \

} while (0)

#define CALC_G16(y0, y1, u0, u1, v0, v1, dst) do {   \

  const v8i16 const_a = (v8i16)__msa_fill_h(8708);   \

  v8i16 a0 = __msa_subs_s_h((v8i16)y0, (v8i16)u0);   \

  v8i16 a1 = __msa_subs_s_h((v8i16)y1, (v8i16)u1);   \

  const v8i16 b0 = __msa_subs_s_h(a0, (v8i16)v0);    \

  const v8i16 b1 = __msa_subs_s_h(a1, (v8i16)v1);    \

  a0 = __msa_adds_s_h(b0, const_a);                  \

  a1 = __msa_adds_s_h(b1, const_a);                  \

  SRAI_H2_SH(a0, a1, 6);                             \

  CLIP_SH2_0_255(a0, a1);                            \

  dst = (v16u8)__msa_pckev_b((v16i8)a1, (v16i8)a0);  \

} while (0)

#define CALC_G8(y0, u0, v0, dst) do {                \

  const v8i16 const_a = (v8i16)__msa_fill_h(8708);   \

  v8i16 a0 = __msa_subs_s_h((v8i16)y0, (v8i16)u0);   \

  const v8i16 b0 = __msa_subs_s_h(a0, (v8i16)v0);    \

  a0 = __msa_adds_s_h(b0, const_a);                  \

  a0 = SRAI_H(a0, 6);                                \

  CLIP_SH_0_255(a0);                                 \

  dst = (v16u8)__msa_pckev_b((v16i8)a0, (v16i8)a0);  \

} while (0)

#define CALC_B16(y0, y1, u0, u1, dst) do {           \

  const v8u16 const_a = (v8u16)__msa_fill_h(17685);  \

  const v8u16 a0 = __msa_adds_u_h((v8u16)y0, u0);    \

  const v8u16 a1 = __msa_adds_u_h((v8u16)y1, u1);    \

  v8u16 b0 = __msa_subs_u_h(a0, const_a);            \

  v8u16 b1 = __msa_subs_u_h(a1, const_a);            \

  SRAI_H2_UH(b0, b1, 6);                             \

  CLIP_UH2_0_255(b0, b1);                            \

  dst = (v16u8)__msa_pckev_b((v16i8)b1, (v16i8)b0);  \

} while (0)

#define CALC_B8(y0, u0, dst) do {                    \

  const v8u16 const_a = (v8u16)__msa_fill_h(17685);  \

  const v8u16 a0 = __msa_adds_u_h((v8u16)y0, u0);    \

  v8u16 b0 = __msa_subs_u_h(a0, const_a);            \

  b0 = SRAI_H(b0, 6);                                \

  CLIP_UH_0_255(b0);                                 \

  dst = (v16u8)__msa_pckev_b((v16i8)b0, (v16i8)b0);  \

} while (0)

#define CALC_RGB16(y, u, v, R, G, B) do {    \

  const v16u8 zero = { 0 };                  \

  v8u16 y0, y1, u0, u1, v0, v1;              \

  v4u32 p0, p1, p2, p3;                      \

  const v16u8 in_y = LD_UB(y);               \

  const v16u8 in_u = LD_UB(u);               \

  const v16u8 in_v = LD_UB(v);               \

  ILVRL_UW4(in_y, p0, p1, p2, p3);           \

  MULTHI_16(p0, p1, p2, p3, 19077, y0, y1);  \

  ILVRL_UW4(in_v, p0, p1, p2, p3);           \

  MULTHI_16(p0, p1, p2, p3, 26149, v0, v1);  \

  CALC_R16(y0, y1, v0, v1, R);               \

  MULTHI_16(p0, p1, p2, p3, 13320, v0, v1);  \

  ILVRL_UW4(in_u, p0, p1, p2, p3);           \

  MULTHI_16(p0, p1, p2, p3, 6419, u0, u1);   \

  CALC_G16(y0, y1, u0, u1, v0, v1, G);       \

  MULTHI_16(p0, p1, p2, p3, 33050, u0, u1);  \

  CALC_B16(y0, y1, u0, u1, B);               \

} while (0)

#define CALC_RGB8(y, u, v, R, G, B) do {  \

  const v16u8 zero = { 0 };               \

  v8u16 y0, u0, v0;                       \

  v4u32 p0, p1;                           \

  const v16u8 in_y = LD_UB(y);            \

  const v16u8 in_u = LD_UB(u);            \

  const v16u8 in_v = LD_UB(v);            \

  ILVR_UW2(in_y, p0, p1);                 \

  MULTHI_8(p0, p1, 19077, y0);            \

  ILVR_UW2(in_v, p0, p1);                 \

  MULTHI_8(p0, p1, 26149, v0);            \

  CALC_R8(y0, v0, R);                     \

  MULTHI_8(p0, p1, 13320, v0);            \

  ILVR_UW2(in_u, p0, p1);                 \

  MULTHI_8(p0, p1, 6419, u0);             \

  CALC_G8(y0, u0, v0, G);                 \

  MULTHI_8(p0, p1, 33050, u0);            \

  CALC_B8(y0, u0, B);                     \

} while (0)

#define STORE16_3(a0, a1, a2, dst) do {                          \

  const v16u8 mask0 = { 0, 1, 16, 2, 3, 17, 4, 5, 18, 6, 7, 19,  \

                        8, 9, 20, 10 };                          \

  const v16u8 mask1 = { 0, 21, 1, 2, 22, 3, 4, 23, 5, 6, 24, 7,  \

                        8, 25, 9, 10 };                          \

  const v16u8 mask2 = { 26, 0, 1, 27, 2, 3, 28, 4, 5, 29, 6, 7,  \

                        30, 8, 9, 31 };                          \

  v16u8 out0, out1, out2, tmp0, tmp1, tmp2;                      \

  ILVRL_B2_UB(a1, a0, tmp0, tmp1);                               \

  out0 = VSHF_UB(tmp0, a2, mask0);                               \

  tmp2 = SLDI_UB(tmp1, tmp0, 11);                                \

  out1 = VSHF_UB(tmp2, a2, mask1);                               \

  tmp2 = SLDI_UB(tmp1, tmp1, 6);                                 \

  out2 = VSHF_UB(tmp2, a2, mask2);                               \

  ST_UB(out0, dst +  0);                                         \

  ST_UB(out1, dst + 16);                                         \

  ST_UB(out2, dst + 32);                                         \

} while (0)

#define STORE8_3(a0, a1, a2, dst) do {                             \

  int64_t out_m;                                                   \

  const v16u8 mask0 = { 0, 1, 16, 2, 3, 17, 4, 5, 18, 6, 7, 19,    \

                        8, 9, 20, 10 };                            \

  const v16u8 mask1 = { 11, 21, 12, 13, 22, 14, 15, 23,            \

                        255, 255, 255, 255, 255, 255, 255, 255 };  \

  const v16u8 tmp0 = (v16u8)__msa_ilvr_b((v16i8)a1, (v16i8)a0);    \

  v16u8 out0, out1;                                                \

  VSHF_B2_UB(tmp0, a2, tmp0, a2, mask0, mask1, out0, out1);        \

  ST_UB(out0, dst);                                                \

  out_m = __msa_copy_s_d((v2i64)out1, 0);                          \

  SD(out_m, dst + 16);                                             \

} while (0)

#define STORE16_4(a0, a1, a2, a3, dst) do {  \

  v16u8 tmp0, tmp1, tmp2, tmp3;              \

  v16u8 out0, out1, out2, out3;              \

  ILVRL_B2_UB(a1, a0, tmp0, tmp1);           \

  ILVRL_B2_UB(a3, a2, tmp2, tmp3);           \

  ILVRL_H2_UB(tmp2, tmp0, out0, out1);       \

  ILVRL_H2_UB(tmp3, tmp1, out2, out3);       \

  ST_UB(out0, dst +  0);                     \

  ST_UB(out1, dst + 16);                     \

  ST_UB(out2, dst + 32);                     \

  ST_UB(out3, dst + 48);                     \

} while (0)

#define STORE8_4(a0, a1, a2, a3, dst) do {  \

  v16u8 tmp0, tmp1, tmp2, tmp3;             \

  ILVR_B2_UB(a1, a0, a3, a2, tmp0, tmp1);   \

  ILVRL_H2_UB(tmp1, tmp0, tmp2, tmp3);      \

  ST_UB(tmp2, dst +  0);                    \

  ST_UB(tmp3, dst + 16);                    \

} while (0)

#define STORE2_16(a0, a1, dst) do {  \

  v16u8 out0, out1;                  \

  ILVRL_B2_UB(a1, a0, out0, out1);   \

  ST_UB(out0, dst +  0);             \

  ST_UB(out1, dst + 16);             \

} while (0)

#define STORE2_8(a0, a1, dst) do {                               \

  const v16u8 out0 = (v16u8)__msa_ilvr_b((v16i8)a1, (v16i8)a0);  \

  ST_UB(out0, dst);                                              \

} while (0)

#define CALC_RGBA4444(y, u, v, out0, out1, N, dst) do {  \

  CALC_RGB##N(y, u, v, R, G, B);                         \

  tmp0 = ANDI_B(R, 0xf0);                                \

  tmp1 = SRAI_B(G, 4);                                   \

  RG = tmp0 | tmp1;                                      \

  tmp0 = ANDI_B(B, 0xf0);                                \

  BA = ORI_B(tmp0, 0x0f);                                \

  STORE2_##N(out0, out1, dst);                           \

} while (0)

#define CALC_RGB565(y, u, v, out0, out1, N, dst) do {  \

  CALC_RGB##N(y, u, v, R, G, B);                       \

  tmp0 = ANDI_B(R, 0xf8);                              \

  tmp1 = SRAI_B(G, 5);                                 \

  RG = tmp0 | tmp1;                                    \

  tmp0 = SLLI_B(G, 3);                                 \

  tmp1 = ANDI_B(tmp0, 0xe0);                           \

  tmp0 = SRAI_B(B, 3);                                 \

  GB = tmp0 | tmp1;                                    \

  STORE2_##N(out0, out1, dst);                         \

} while (0)

static WEBP_INLINE int Clip8(int v) {

  return v < 0 ? 0 : v > 255 ? 255 : v;

static void YuvToRgb(int y, int u, int v, uint8_t* const rgb) {

  const int y1 = MultHi(y, 19077);

  const int r1 = y1 + MultHi(v, 26149) - 14234;

  const int g1 = y1 - MultHi(u, 6419) - MultHi(v, 13320) + 8708;

  const int b1 = y1 + MultHi(u, 33050) - 17685;

  rgb[0] = Clip8(r1 >> 6);

  rgb[1] = Clip8(g1 >> 6);

  rgb[2] = Clip8(b1 >> 6);

static void YuvToBgr(int y, int u, int v, uint8_t* const bgr) {

  const int y1 = MultHi(y, 19077);

  const int r1 = y1 + MultHi(v, 26149) - 14234;

  const int g1 = y1 - MultHi(u, 6419) - MultHi(v, 13320) + 8708;

  const int b1 = y1 + MultHi(u, 33050) - 17685;

  bgr[0] = Clip8(b1 >> 6);

  bgr[1] = Clip8(g1 >> 6);

  bgr[2] = Clip8(r1 >> 6);

#if !defined(WEBP_REDUCE_CSP)

static void YuvToRgb565(int y, int u, int v, uint8_t* const rgb) {

  const int y1 = MultHi(y, 19077);

  const int r1 = y1 + MultHi(v, 26149) - 14234;

  const int g1 = y1 - MultHi(u, 6419) - MultHi(v, 13320) + 8708;

  const int b1 = y1 + MultHi(u, 33050) - 17685;

  const int r = Clip8(r1 >> 6);

  const int g = Clip8(g1 >> 6);

  const int b = Clip8(b1 >> 6);

  const int rg = (r & 0xf8) | (g >> 5);

  const int gb = ((g << 3) & 0xe0) | (b >> 3);

#if (WEBP_SWAP_16BIT_CSP == 1)

  rgb[0] = gb;

  rgb[1] = rg;

#else

  rgb[0] = rg;

  rgb[1] = gb;

#endif

static void YuvToRgba4444(int y, int u, int v, uint8_t* const argb) {

  const int y1 = MultHi(y, 19077);

  const int r1 = y1 + MultHi(v, 26149) - 14234;

  const int g1 = y1 - MultHi(u, 6419) - MultHi(v, 13320) + 8708;

  const int b1 = y1 + MultHi(u, 33050) - 17685;

  const int r = Clip8(r1 >> 6);

  const int g = Clip8(g1 >> 6);

  const int b = Clip8(b1 >> 6);

  const int rg = (r & 0xf0) | (g >> 4);

  const int ba = (b & 0xf0) | 0x0f;     // overwrite the lower 4 bits

#if (WEBP_SWAP_16BIT_CSP == 1)

  argb[0] = ba;

  argb[1] = rg;

#else

  argb[0] = rg;

  argb[1] = ba;

#endif

static void YuvToArgb(uint8_t y, uint8_t u, uint8_t v, uint8_t* const argb) {

  argb[0] = 0xff;

  YuvToRgb(y, u, v, argb + 1);

#endif  // WEBP_REDUCE_CSP

static void YuvToBgra(uint8_t y, uint8_t u, uint8_t v, uint8_t* const bgra) {

  YuvToBgr(y, u, v, bgra);

  bgra[3] = 0xff;

static void YuvToRgba(uint8_t y, uint8_t u, uint8_t v, uint8_t* const rgba) {

  YuvToRgb(y, u, v, rgba);

  rgba[3] = 0xff;

#if !defined(WEBP_REDUCE_CSP)

static void YuvToRgbLine(const uint8_t* y, const uint8_t* u,

                         const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B;

  while (length >= 16) {

    CALC_RGB16(y, u, v, R, G, B);

    STORE16_3(R, G, B, dst);

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 3;

    length -= 16;

  if (length > 8) {

    uint8_t temp[3 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB16(temp, u, v, R, G, B);

    STORE16_3(R, G, B, temp);

    memcpy(dst, temp, length * 3 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[3 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB8(temp, u, v, R, G, B);

    STORE8_3(R, G, B, temp);

    memcpy(dst, temp, length * 3 * sizeof(*dst));

static void YuvToBgrLine(const uint8_t* y, const uint8_t* u,

                         const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B;

  while (length >= 16) {

    CALC_RGB16(y, u, v, R, G, B);

    STORE16_3(B, G, R, dst);

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 3;

    length -= 16;

  if (length > 8) {

    uint8_t temp[3 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB16(temp, u, v, R, G, B);

    STORE16_3(B, G, R, temp);

    memcpy(dst, temp, length * 3 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[3 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB8(temp, u, v, R, G, B);

    STORE8_3(B, G, R, temp);

    memcpy(dst, temp, length * 3 * sizeof(*dst));

#endif  // WEBP_REDUCE_CSP

static void YuvToRgbaLine(const uint8_t* y, const uint8_t* u,

                          const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B;

  const v16u8 A = (v16u8)__msa_ldi_b(ALPHAVAL);

  while (length >= 16) {

    CALC_RGB16(y, u, v, R, G, B);

    STORE16_4(R, G, B, A, dst);

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 4;

    length -= 16;

  if (length > 8) {

    uint8_t temp[4 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB16(&temp[0], u, v, R, G, B);

    STORE16_4(R, G, B, A, temp);

    memcpy(dst, temp, length * 4 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[4 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB8(temp, u, v, R, G, B);

    STORE8_4(R, G, B, A, temp);

    memcpy(dst, temp, length * 4 * sizeof(*dst));

static void YuvToBgraLine(const uint8_t* y, const uint8_t* u,

                          const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B;

  const v16u8 A = (v16u8)__msa_ldi_b(ALPHAVAL);

  while (length >= 16) {

    CALC_RGB16(y, u, v, R, G, B);

    STORE16_4(B, G, R, A, dst);

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 4;

    length -= 16;

  if (length > 8) {

    uint8_t temp[4 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB16(temp, u, v, R, G, B);

    STORE16_4(B, G, R, A, temp);

    memcpy(dst, temp, length * 4 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[4 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB8(temp, u, v, R, G, B);

    STORE8_4(B, G, R, A, temp);

    memcpy(dst, temp, length * 4 * sizeof(*dst));

#if !defined(WEBP_REDUCE_CSP)

static void YuvToArgbLine(const uint8_t* y, const uint8_t* u,

                          const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B;

  const v16u8 A = (v16u8)__msa_ldi_b(ALPHAVAL);

  while (length >= 16) {

    CALC_RGB16(y, u, v, R, G, B);

    STORE16_4(A, R, G, B, dst);

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 4;

    length -= 16;

  if (length > 8) {

    uint8_t temp[4 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB16(temp, u, v, R, G, B);

    STORE16_4(A, R, G, B, temp);

    memcpy(dst, temp, length * 4 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[4 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

    CALC_RGB8(temp, u, v, R, G, B);

    STORE8_4(A, R, G, B, temp);

    memcpy(dst, temp, length * 4 * sizeof(*dst));

static void YuvToRgba4444Line(const uint8_t* y, const uint8_t* u,

                              const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B, RG, BA, tmp0, tmp1;

  while (length >= 16) {

#if (WEBP_SWAP_16BIT_CSP == 1)

    CALC_RGBA4444(y, u, v, BA, RG, 16, dst);

#else

    CALC_RGBA4444(y, u, v, RG, BA, 16, dst);

#endif

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 2;

    length -= 16;

  if (length > 8) {

    uint8_t temp[2 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

#if (WEBP_SWAP_16BIT_CSP == 1)

    CALC_RGBA4444(temp, u, v, BA, RG, 16, temp);

#else

    CALC_RGBA4444(temp, u, v, RG, BA, 16, temp);

#endif

    memcpy(dst, temp, length * 2 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[2 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

#if (WEBP_SWAP_16BIT_CSP == 1)

    CALC_RGBA4444(temp, u, v, BA, RG, 8, temp);

#else

    CALC_RGBA4444(temp, u, v, RG, BA, 8, temp);

#endif

    memcpy(dst, temp, length * 2 * sizeof(*dst));

static void YuvToRgb565Line(const uint8_t* y, const uint8_t* u,

                            const uint8_t* v, uint8_t* dst, int length) {

  v16u8 R, G, B, RG, GB, tmp0, tmp1;

  while (length >= 16) {

#if (WEBP_SWAP_16BIT_CSP == 1)

    CALC_RGB565(y, u, v, GB, RG, 16, dst);

#else

    CALC_RGB565(y, u, v, RG, GB, 16, dst);

#endif

    y      += 16;

    u      += 16;

    v      += 16;

    dst    += 16 * 2;

    length -= 16;

  if (length > 8) {

    uint8_t temp[2 * 16] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

#if (WEBP_SWAP_16BIT_CSP == 1)

    CALC_RGB565(temp, u, v, GB, RG, 16, temp);

#else

    CALC_RGB565(temp, u, v, RG, GB, 16, temp);

#endif

    memcpy(dst, temp, length * 2 * sizeof(*dst));

  } else if (length > 0) {

    uint8_t temp[2 * 8] = { 0 };

    memcpy(temp, y, length * sizeof(*temp));

#if (WEBP_SWAP_16BIT_CSP == 1)

    CALC_RGB565(temp, u, v, GB, RG, 8, temp);

#else

    CALC_RGB565(temp, u, v, RG, GB, 8, temp);

#endif

    memcpy(dst, temp, length * 2 * sizeof(*dst));

#endif  // WEBP_REDUCE_CSP

#define UPSAMPLE_32PIXELS(a, b, c, d) do {    \

  v16u8 s = __msa_aver_u_b(a, d);             \

  v16u8 t = __msa_aver_u_b(b, c);             \

  const v16u8 st = s ^ t;                     \

  v16u8 ad = a ^ d;                           \

  v16u8 bc = b ^ c;                           \

  v16u8 t0 = ad | bc;                         \

  v16u8 t1 = t0 | st;                         \

  v16u8 t2 = ANDI_B(t1, 1);                   \

  v16u8 t3 = __msa_aver_u_b(s, t);            \

  const v16u8 k = t3 - t2;                    \

  v16u8 diag1, diag2;                         \

  AVER_UB2_UB(t, k, s, k, t0, t1);            \

  bc = bc & st;                               \

  ad = ad & st;                               \

  t = t ^ k;                                  \

  s = s ^ k;                                  \

  t2 = bc | t;                                \

  t3 = ad | s;                                \

  t2 = ANDI_B(t2, 1);                         \

  t3 = ANDI_B(t3, 1);                         \

  SUB2(t0, t2, t1, t3, diag1, diag2);         \

  AVER_UB2_UB(a, diag1, b, diag2, t0, t1);    \

  ILVRL_B2_UB(t1, t0, a, b);                  \

  if (pbot_y != NULL) {                       \

    AVER_UB2_UB(c, diag2, d, diag1, t0, t1);  \

    ILVRL_B2_UB(t1, t0, c, d);                \

  }                                           \

} while (0)

#define UPSAMPLE_FUNC(FUNC_NAME, FUNC, XSTEP)                            \

static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bot_y,        \

                      const uint8_t* top_u, const uint8_t* top_v,        \

                      const uint8_t* cur_u, const uint8_t* cur_v,        \

                      uint8_t* top_dst, uint8_t* bot_dst, int len)       \

{                                                                        \

  int size = (len - 1) >> 1;                                             \

  uint8_t temp_u[64];                                                    \

  uint8_t temp_v[64];                                                    \

  const uint32_t tl_uv = ((top_u[0]) | ((top_v[0]) << 16));              \

  const uint32_t l_uv = ((cur_u[0]) | ((cur_v[0]) << 16));               \

  const uint32_t uv0 = (3 * tl_uv + l_uv + 0x00020002u) >> 2;            \

  const uint8_t* ptop_y = &top_y[1];                                     \

  uint8_t* ptop_dst = top_dst + XSTEP;                                   \

  const uint8_t* pbot_y = &bot_y[1];                                     \

  uint8_t* pbot_dst = bot_dst + XSTEP;                                   \

  FUNC(top_y[0], uv0 & 0xff, (uv0 >> 16), top_dst);                      \

  if (bot_y != NULL) {                                                   \

    const uint32_t uv1 = (3 * l_uv + tl_uv + 0x00020002u) >> 2;          \

    FUNC(bot_y[0], uv1 & 0xff, (uv1 >> 16), bot_dst);                    \

  }                                                                      \

  while (size >= 16) {                                                   \

    v16u8 tu0, tu1, tv0, tv1, cu0, cu1, cv0, cv1;                        \

    LD_UB2(top_u, 1, tu0, tu1);                                          \

    LD_UB2(cur_u, 1, cu0, cu1);                                          \

    LD_UB2(top_v, 1, tv0, tv1);                                          \

    LD_UB2(cur_v, 1, cv0, cv1);                                          \

    UPSAMPLE_32PIXELS(tu0, tu1, cu0, cu1);                               \

    UPSAMPLE_32PIXELS(tv0, tv1, cv0, cv1);                               \

    ST_UB4(tu0, tu1, cu0, cu1, &temp_u[0], 16);                          \

    ST_UB4(tv0, tv1, cv0, cv1, &temp_v[0], 16);                          \

    FUNC##Line(ptop_y, &temp_u[ 0], &temp_v[0], ptop_dst, 32);           \

    if (bot_y != NULL) {                                                 \

      FUNC##Line(pbot_y, &temp_u[32], &temp_v[32], pbot_dst, 32);        \

    }                                                                    \

    ptop_y   += 32;                                                      \

    pbot_y   += 32;                                                      \

    ptop_dst += XSTEP * 32;                                              \

    pbot_dst += XSTEP * 32;                                              \

    top_u    += 16;                                                      \

    top_v    += 16;                                                      \

    cur_u    += 16;                                                      \

    cur_v    += 16;                                                      \

    size     -= 16;                                                      \

  }                                                                      \

  if (size > 0) {                                                        \

    v16u8 tu0, tu1, tv0, tv1, cu0, cu1, cv0, cv1;                        \

    memcpy(&temp_u[ 0], top_u, 17 * sizeof(uint8_t));                    \

    memcpy(&temp_u[32], cur_u, 17 * sizeof(uint8_t));                    \

    memcpy(&temp_v[ 0], top_v, 17 * sizeof(uint8_t));                    \

    memcpy(&temp_v[32], cur_v, 17 * sizeof(uint8_t));                    \

    LD_UB2(&temp_u[ 0], 1, tu0, tu1);                                    \

    LD_UB2(&temp_u[32], 1, cu0, cu1);                                    \

    LD_UB2(&temp_v[ 0], 1, tv0, tv1);                                    \

    LD_UB2(&temp_v[32], 1, cv0, cv1);                                    \

    UPSAMPLE_32PIXELS(tu0, tu1, cu0, cu1);                               \

    UPSAMPLE_32PIXELS(tv0, tv1, cv0, cv1);                               \

    ST_UB4(tu0, tu1, cu0, cu1, &temp_u[0], 16);                          \

    ST_UB4(tv0, tv1, cv0, cv1, &temp_v[0], 16);                          \

    FUNC##Line(ptop_y, &temp_u[ 0], &temp_v[0], ptop_dst, size * 2);     \

    if (bot_y != NULL) {                                                 \

      FUNC##Line(pbot_y, &temp_u[32], &temp_v[32], pbot_dst, size * 2);  \

    }                                                                    \

    top_u += size;                                                       \

    top_v += size;                                                       \

    cur_u += size;                                                       \

    cur_v += size;                                                       \

  }                                                                      \

  if (!(len & 1)) {                                                      \

    const uint32_t t0 = ((top_u[0]) | ((top_v[0]) << 16));               \

    const uint32_t c0  = ((cur_u[0]) | ((cur_v[0]) << 16));              \

    const uint32_t tmp0 = (3 * t0 + c0 + 0x00020002u) >> 2;              \

    FUNC(top_y[len - 1], tmp0 & 0xff, (tmp0 >> 16),                      \

                top_dst + (len - 1) * XSTEP);                            \

    if (bot_y != NULL) {                                                 \

      const uint32_t tmp1 = (3 * c0 + t0 + 0x00020002u) >> 2;            \

      FUNC(bot_y[len - 1], tmp1 & 0xff, (tmp1 >> 16),                    \

           bot_dst + (len - 1) * XSTEP);                                 \

    }                                                                    \

  }                                                                      \

UPSAMPLE_FUNC(UpsampleRgbaLinePair,     YuvToRgba,     4)

UPSAMPLE_FUNC(UpsampleBgraLinePair,     YuvToBgra,     4)

#if !defined(WEBP_REDUCE_CSP)

UPSAMPLE_FUNC(UpsampleRgbLinePair,      YuvToRgb,      3)

UPSAMPLE_FUNC(UpsampleBgrLinePair,      YuvToBgr,      3)

UPSAMPLE_FUNC(UpsampleArgbLinePair,     YuvToArgb,     4)

UPSAMPLE_FUNC(UpsampleRgba4444LinePair, YuvToRgba4444, 2)

UPSAMPLE_FUNC(UpsampleRgb565LinePair,   YuvToRgb565,   2)

#endif   // WEBP_REDUCE_CSP

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

// Entry point

extern WebPUpsampleLinePairFunc WebPUpsamplers[/* MODE_LAST */];

extern void WebPInitUpsamplersMSA(void);

WEBP_TSAN_IGNORE_FUNCTION void WebPInitUpsamplersMSA(void) {

  WebPUpsamplers[MODE_RGBA]      = UpsampleRgbaLinePair;

  WebPUpsamplers[MODE_BGRA]      = UpsampleBgraLinePair;

  WebPUpsamplers[MODE_rgbA]      = UpsampleRgbaLinePair;

  WebPUpsamplers[MODE_bgrA]      = UpsampleBgraLinePair;

#if !defined(WEBP_REDUCE_CSP)

  WebPUpsamplers[MODE_RGB]       = UpsampleRgbLinePair;

  WebPUpsamplers[MODE_BGR]       = UpsampleBgrLinePair;

  WebPUpsamplers[MODE_ARGB]      = UpsampleArgbLinePair;

  WebPUpsamplers[MODE_Argb]      = UpsampleArgbLinePair;

  WebPUpsamplers[MODE_RGB_565]   = UpsampleRgb565LinePair;

  WebPUpsamplers[MODE_RGBA_4444] = UpsampleRgba4444LinePair;

  WebPUpsamplers[MODE_rgbA_4444] = UpsampleRgba4444LinePair;

#endif   // WEBP_REDUCE_CSP

#endif  // FANCY_UPSAMPLING

#endif  // WEBP_USE_MSA

#if !(defined(FANCY_UPSAMPLING) && defined(WEBP_USE_MSA))

WEBP_DSP_INIT_STUB(WebPInitUpsamplersMSA)

#endif

Source code

Revision control

Copy as Markdown

Other Tools