dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2024-11-20 04:18:26 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge "Add MSA optimized YUV to RGB upsampling functions"

Browse Source
This commit is contained in:
Parag Salasakar 2016-07-22 17:26:33 +00:00 committed by Gerrit Code Review
commit 7b87e8485b
8 changed files with 743 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Android.mk
View File

@ -70,6 +70,7 @@ dsp_dec_srcs := \
src/dsp/rescaler_sse2.c \
src/dsp/upsampling.c \
src/dsp/upsampling_mips_dsp_r2.c \
src/dsp/upsampling_msa.c \
src/dsp/upsampling_neon.$(NEON) \
src/dsp/upsampling_sse2.c \
src/dsp/yuv.c \

1
Makefile.vc
View File

@ -216,6 +216,7 @@ DSP_DEC_OBJS = \
$(DIROBJ)\dsp\rescaler_sse2.obj \
$(DIROBJ)\dsp\upsampling.obj \
$(DIROBJ)\dsp\upsampling_mips_dsp_r2.obj \
$(DIROBJ)\dsp\upsampling_msa.obj \
$(DIROBJ)\dsp\upsampling_neon.obj \
$(DIROBJ)\dsp\upsampling_sse2.obj \
$(DIROBJ)\dsp\yuv.obj \

1
build.gradle
View File

@ -140,6 +140,7 @@ model {
include "rescaler_sse2.c"
include "upsampling.c"
include "upsampling_mips_dsp_r2.c"
include "upsampling_msa.c"
include "upsampling_neon.$NEON"
include "upsampling_sse2.c"
include "yuv.c"

1
makefile.unix
View File

@ -159,6 +159,7 @@ DSP_DEC_OBJS = \
src/dsp/rescaler_sse2.o \
src/dsp/upsampling.o \
src/dsp/upsampling_mips_dsp_r2.o \
src/dsp/upsampling_msa.o \
src/dsp/upsampling_neon.o \
src/dsp/upsampling_sse2.o \
src/dsp/yuv.o \

1
src/dsp/Makefile.am
View File

@ -86,6 +86,7 @@ libwebpdspdecode_msa_la_SOURCES += dec_msa.c
libwebpdspdecode_msa_la_SOURCES += filters_msa.c
libwebpdspdecode_msa_la_SOURCES += lossless_msa.c
libwebpdspdecode_msa_la_SOURCES += rescaler_msa.c
libwebpdspdecode_neon_la_SOURCES += upsampling_msa.c
libwebpdspdecode_msa_la_SOURCES += msa_macro.h
libwebpdspdecode_msa_la_CPPFLAGS = $(libwebpdsp_msa_la_CPPFLAGS)
libwebpdspdecode_msa_la_CFLAGS = $(libwebpdsp_msa_la_CFLAGS)

54
src/dsp/msa_macro.h
View File

@ -28,6 +28,9 @@
#define SRAI_H(a, b) __msa_srai_h((v8i16)a, b)
#define SRAI_W(a, b) __msa_srai_w((v4i32)a, b)
#define SRLI_H(a, b) __msa_srli_h((v8i16)a, b)
#define SLLI_B(a, b) __msa_slli_b((v4i32)a, b)
#define ANDI_B(a, b) __msa_andi_b((v16u8)a, b)
#define ORI_B(a, b) __msa_ori_b((v16u8)a, b)
#else
#define ADDVI_H(a, b) (a + b)
#define ADDVI_W(a, b) (a + b)
@ -35,6 +38,9 @@
#define SRAI_H(a, b) (a >> b)
#define SRAI_W(a, b) (a >> b)
#define SRLI_H(a, b) (a << b)
#define SLLI_B(a, b) (a << b)
#define ANDI_B(a, b) (a & b)
#define ORI_B(a, b) (a | b)
#endif
#define LD_B(RTYPE, psrc) *((RTYPE*)(psrc))
@ -535,6 +541,23 @@
CLIP_SH2_0_255(in2, in3); \
} while (0)
/* Description : Clips all unsigned halfword elements of input vector
* between 0 & 255
* Arguments : Input - in
* Output - out_m
* Return Type - unsigned halfword
*/
#define CLIP_UH_0_255(in) do { \
const v8u16 max_m = (v8u16)__msa_ldi_h(255); \
in = __msa_maxi_u_h((v8u16) in, 0); \
in = __msa_min_u_h((v8u16) max_m, (v8u16) in); \
} while (0)
#define CLIP_UH2_0_255(in0, in1) do { \
CLIP_UH_0_255(in0); \
CLIP_UH_0_255(in1); \
} while (0)
/* Description : Clips all signed word elements of input vector
* between 0 & 255
* Arguments : Input/output - val
@ -1000,6 +1023,23 @@ static WEBP_INLINE uint32_t func_hadd_uh_u32(v8u16 in) {
#define PCKEV_W2_SW(...) PCKEV_W2(v4i32, __VA_ARGS__)
#define PCKEV_W2_UW(...) PCKEV_W2(v4u32, __VA_ARGS__)
/* Description : Pack odd halfword elements of vector pairs
* Arguments : Inputs - in0, in1, in2, in3
* Outputs - out0, out1
* Return Type - as per RTYPE
* Details : Odd halfword elements of 'in0' are copied to the left half of
* 'out0' & odd halfword elements of 'in1' are copied to the
* right half of 'out0'.
*/
#define PCKOD_H2(RTYPE, in0, in1, in2, in3, out0, out1) do { \
out0 = (RTYPE)__msa_pckod_h((v8i16)in0, (v8i16)in1); \
out1 = (RTYPE)__msa_pckod_h((v8i16)in2, (v8i16)in3); \
} while (0)
#define PCKOD_H2_UH(...) PCKOD_H2(v8u16, __VA_ARGS__)
#define PCKOD_H2_SH(...) PCKOD_H2(v8i16, __VA_ARGS__)
#define PCKOD_H2_SW(...) PCKOD_H2(v4i32, __VA_ARGS__)
#define PCKOD_H2_UW(...) PCKOD_H2(v4u32, __VA_ARGS__)
/* Description : Arithmetic immediate shift right all elements of word vector
* Arguments : Inputs - in0, in1, shift
* Outputs - in place operation
@ -1333,4 +1373,18 @@ static WEBP_INLINE uint32_t func_hadd_uh_u32(v8u16 in) {
ST4x4_UB(tmp0_m, tmp1_m, 0, 2, 0, 2, pdst, stride); \
} while (0)
/* Description : average with rounding (in0 + in1 + 1) / 2.
* Arguments : Inputs - in0, in1, in2, in3,
* Outputs - out0, out1
* Return Type - as per RTYPE
* Details : Each unsigned byte element from 'in0' vector is added with
* each unsigned byte element from 'in1' vector. Then the average
* with rounding is calculated and written to 'out0'
*/
#define AVER_UB2(RTYPE, in0, in1, in2, in3, out0, out1) do { \
out0 = (RTYPE)__msa_aver_u_b((v16u8)in0, (v16u8)in1); \
out1 = (RTYPE)__msa_aver_u_b((v16u8)in2, (v16u8)in3); \
} while (0)
#define AVER_UB2_UB(...) AVER_UB2(v16u8, __VA_ARGS__)
#endif /* WEBP_DSP_MSA_MACRO_H_ */

6
src/dsp/upsampling.c
View File

@ -215,6 +215,7 @@ WEBP_TSAN_IGNORE_FUNCTION void WebPInitYUV444Converters(void) {
extern void WebPInitUpsamplersSSE2(void);
extern void WebPInitUpsamplersNEON(void);
extern void WebPInitUpsamplersMIPSdspR2(void);
extern void WebPInitUpsamplersMSA(void);
static volatile VP8CPUInfo upsampling_last_cpuinfo_used2 =
(VP8CPUInfo)&upsampling_last_cpuinfo_used2;
@ -251,6 +252,11 @@ WEBP_TSAN_IGNORE_FUNCTION void WebPInitUpsamplers(void) {
if (VP8GetCPUInfo(kMIPSdspR2)) {
WebPInitUpsamplersMIPSdspR2();
}
#endif
#if defined(WEBP_USE_MSA)
if (VP8GetCPUInfo(kMSA)) {
WebPInitUpsamplersMSA();
}
#endif
}
#endif // FANCY_UPSAMPLING

678
src/dsp/upsampling_msa.c Normal file
View File

@ -0,0 +1,678 @@
// 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 "./dsp.h"
#if defined(WEBP_USE_MSA)
#include "./msa_macro.h"
#include "./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);
}
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);
#ifdef WEBP_SWAP_16BIT_CSP
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
#ifdef WEBP_SWAP_16BIT_CSP
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);
}
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;
}
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));
}
}
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(0xff);
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(0xff);
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));
}
}
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(0xff);
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) {
#ifdef WEBP_SWAP_16BIT_CSP
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));
#ifdef WEBP_SWAP_16BIT_CSP
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));
#ifdef WEBP_SWAP_16BIT_CSP
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) {
#ifdef WEBP_SWAP_16BIT_CSP
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));
#ifdef WEBP_SWAP_16BIT_CSP
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));
#ifdef WEBP_SWAP_16BIT_CSP
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));
}
}
#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(UpsampleRgbLinePair, YuvToRgb, 3)
UPSAMPLE_FUNC(UpsampleBgrLinePair, YuvToBgr, 3)
UPSAMPLE_FUNC(UpsampleRgbaLinePair, YuvToRgba, 4)
UPSAMPLE_FUNC(UpsampleBgraLinePair, YuvToBgra, 4)
UPSAMPLE_FUNC(UpsampleArgbLinePair, YuvToArgb, 4)
UPSAMPLE_FUNC(UpsampleRgba4444LinePair, YuvToRgba4444, 2)
UPSAMPLE_FUNC(UpsampleRgb565LinePair, YuvToRgb565, 2)
//------------------------------------------------------------------------------
// Entry point
extern WebPUpsampleLinePairFunc WebPUpsamplers[/* MODE_LAST */];
extern void WebPInitUpsamplersMSA(void);
WEBP_TSAN_IGNORE_FUNCTION void WebPInitUpsamplersMSA(void) {
WebPUpsamplers[MODE_RGB] = UpsampleRgbLinePair;
WebPUpsamplers[MODE_RGBA] = UpsampleRgbaLinePair;
WebPUpsamplers[MODE_BGR] = UpsampleBgrLinePair;
WebPUpsamplers[MODE_BGRA] = UpsampleBgraLinePair;
WebPUpsamplers[MODE_ARGB] = UpsampleArgbLinePair;
WebPUpsamplers[MODE_rgbA] = UpsampleRgbaLinePair;
WebPUpsamplers[MODE_bgrA] = UpsampleBgraLinePair;
WebPUpsamplers[MODE_Argb] = UpsampleArgbLinePair;
WebPUpsamplers[MODE_RGB_565] = UpsampleRgb565LinePair;
WebPUpsamplers[MODE_RGBA_4444] = UpsampleRgba4444LinePair;
WebPUpsamplers[MODE_rgbA_4444] = UpsampleRgba4444LinePair;
}
#endif // FANCY_UPSAMPLING
#endif // WEBP_USE_MSA
#if !(defined(FANCY_UPSAMPLING) && defined(WEBP_USE_MSA))
WEBP_DSP_INIT_STUB(WebPInitUpsamplersMSA)
#endif