mirror of
https://chromium.googlesource.com/libyuv/libyuv
synced 2025-12-06 16:56:55 +08:00
Deprecate MIPS and MSA support.
- Remove *_msa.cc source files - Update build files - Update header references, planar ifdefs for row functions - Update documentation on supported platforms Bug: 434383432 Change-Id: I072d6aac4956f0ed668e64614ac8557612171f76
This commit is contained in:
Frank Barchard
parent
613393324f
commit
61867c0b15
@ -34,7 +34,6 @@ cc_library {
|
||||
"source/compare.cc",
|
||||
"source/compare_common.cc",
|
||||
"source/compare_gcc.cc",
|
||||
"source/compare_msa.cc",
|
||||
"source/compare_neon.cc",
|
||||
"source/compare_neon64.cc",
|
||||
"source/convert.cc",
|
||||
@ -53,13 +52,11 @@ cc_library {
|
||||
"source/rotate_argb.cc",
|
||||
"source/rotate_common.cc",
|
||||
"source/rotate_gcc.cc",
|
||||
"source/rotate_msa.cc",
|
||||
"source/rotate_neon.cc",
|
||||
"source/rotate_neon64.cc",
|
||||
"source/row_any.cc",
|
||||
"source/row_common.cc",
|
||||
"source/row_gcc.cc",
|
||||
"source/row_msa.cc",
|
||||
"source/row_neon.cc",
|
||||
"source/row_neon64.cc",
|
||||
"source/row_rvv.cc",
|
||||
@ -68,7 +65,6 @@ cc_library {
|
||||
"source/scale_argb.cc",
|
||||
"source/scale_common.cc",
|
||||
"source/scale_gcc.cc",
|
||||
"source/scale_msa.cc",
|
||||
"source/scale_neon.cc",
|
||||
"source/scale_neon64.cc",
|
||||
"source/scale_rgb.cc",
|
||||
|
||||
@ -9,7 +9,6 @@ LOCAL_SRC_FILES := \
|
||||
source/compare.cc \
|
||||
source/compare_common.cc \
|
||||
source/compare_gcc.cc \
|
||||
source/compare_msa.cc \
|
||||
source/compare_neon.cc \
|
||||
source/compare_neon64.cc \
|
||||
source/compare_win.cc \
|
||||
@ -26,14 +25,12 @@ LOCAL_SRC_FILES := \
|
||||
source/rotate_argb.cc \
|
||||
source/rotate_common.cc \
|
||||
source/rotate_gcc.cc \
|
||||
source/rotate_msa.cc \
|
||||
source/rotate_neon.cc \
|
||||
source/rotate_neon64.cc \
|
||||
source/rotate_win.cc \
|
||||
source/row_any.cc \
|
||||
source/row_common.cc \
|
||||
source/row_gcc.cc \
|
||||
source/row_msa.cc \
|
||||
source/row_neon.cc \
|
||||
source/row_neon64.cc \
|
||||
source/row_win.cc \
|
||||
@ -42,7 +39,6 @@ LOCAL_SRC_FILES := \
|
||||
source/scale_argb.cc \
|
||||
source/scale_common.cc \
|
||||
source/scale_gcc.cc \
|
||||
source/scale_msa.cc \
|
||||
source/scale_neon.cc \
|
||||
source/scale_neon64.cc \
|
||||
source/scale_rgb.cc \
|
||||
|
||||
25
BUILD.gn
25
BUILD.gn
@ -23,7 +23,7 @@ declare_args() {
|
||||
config("libyuv_config") {
|
||||
include_dirs = [ "include" ]
|
||||
if (is_android) {
|
||||
if (target_cpu == "arm" || target_cpu == "x86" || target_cpu == "mipsel") {
|
||||
if (target_cpu == "arm" || target_cpu == "x86") {
|
||||
ldflags = [ "-Wl,--dynamic-linker,/system/bin/linker" ]
|
||||
} else {
|
||||
ldflags = [ "-Wl,--dynamic-linker,/system/bin/linker64" ]
|
||||
@ -92,10 +92,6 @@ group("libyuv") {
|
||||
deps += [ ":libyuv_sme" ]
|
||||
}
|
||||
|
||||
if (libyuv_use_msa) {
|
||||
deps += [ ":libyuv_msa" ]
|
||||
}
|
||||
|
||||
if (libyuv_use_lsx) {
|
||||
deps += [ ":libyuv_lsx" ]
|
||||
}
|
||||
@ -127,7 +123,6 @@ static_library("libyuv_internal") {
|
||||
"include/libyuv/convert_from_argb.h",
|
||||
"include/libyuv/cpu_id.h",
|
||||
"include/libyuv/loongson_intrinsics.h",
|
||||
"include/libyuv/macros_msa.h",
|
||||
"include/libyuv/mjpeg_decoder.h",
|
||||
"include/libyuv/planar_functions.h",
|
||||
"include/libyuv/rotate.h",
|
||||
@ -255,6 +250,7 @@ if (libyuv_use_sve) {
|
||||
|
||||
# The -march arguments below are incompatible with libc++ modules.
|
||||
use_libcxx_modules = false
|
||||
|
||||
# SVE2 is an Armv9-A feature.
|
||||
cflags = [ "-march=armv9-a+i8mm+sve2" ]
|
||||
}
|
||||
@ -274,27 +270,12 @@ if (libyuv_use_sme) {
|
||||
|
||||
# The -march arguments below are incompatible with libc++ modules.
|
||||
use_libcxx_modules = false
|
||||
|
||||
# SME is an Armv9-A feature.
|
||||
cflags = [ "-march=armv9-a+i8mm+sme" ]
|
||||
}
|
||||
}
|
||||
|
||||
if (libyuv_use_msa) {
|
||||
static_library("libyuv_msa") {
|
||||
sources = [
|
||||
# MSA Source Files
|
||||
"source/compare_msa.cc",
|
||||
"source/rotate_msa.cc",
|
||||
"source/row_msa.cc",
|
||||
"source/scale_msa.cc",
|
||||
]
|
||||
|
||||
deps = [ ":libyuv_internal" ]
|
||||
|
||||
public_configs = [ ":libyuv_config" ]
|
||||
}
|
||||
}
|
||||
|
||||
if (libyuv_use_lsx) {
|
||||
static_library("libyuv_lsx") {
|
||||
sources = [
|
||||
|
||||
@ -23,7 +23,6 @@ set ( ly_common_source_files
|
||||
${ly_src_dir}/compare.cc
|
||||
${ly_src_dir}/compare_common.cc
|
||||
${ly_src_dir}/compare_gcc.cc
|
||||
${ly_src_dir}/compare_msa.cc
|
||||
${ly_src_dir}/compare_win.cc
|
||||
${ly_src_dir}/convert_argb.cc
|
||||
${ly_src_dir}/convert.cc
|
||||
@ -42,14 +41,12 @@ set ( ly_common_source_files
|
||||
${ly_src_dir}/rotate_common.cc
|
||||
${ly_src_dir}/rotate_gcc.cc
|
||||
${ly_src_dir}/rotate_lsx.cc
|
||||
${ly_src_dir}/rotate_msa.cc
|
||||
${ly_src_dir}/rotate_win.cc
|
||||
${ly_src_dir}/row_any.cc
|
||||
${ly_src_dir}/row_common.cc
|
||||
${ly_src_dir}/row_gcc.cc
|
||||
${ly_src_dir}/row_lasx.cc
|
||||
${ly_src_dir}/row_lsx.cc
|
||||
${ly_src_dir}/row_msa.cc
|
||||
${ly_src_dir}/row_rvv.cc
|
||||
${ly_src_dir}/row_win.cc
|
||||
${ly_src_dir}/scale_any.cc
|
||||
@ -58,7 +55,6 @@ set ( ly_common_source_files
|
||||
${ly_src_dir}/scale_common.cc
|
||||
${ly_src_dir}/scale_gcc.cc
|
||||
${ly_src_dir}/scale_lsx.cc
|
||||
${ly_src_dir}/scale_msa.cc
|
||||
${ly_src_dir}/scale_rgb.cc
|
||||
${ly_src_dir}/scale_rvv.cc
|
||||
${ly_src_dir}/scale_uv.cc
|
||||
|
||||
7
DEPS
7
DEPS
@ -1532,13 +1532,6 @@ hooks = [
|
||||
'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
|
||||
'--arch=x86'],
|
||||
},
|
||||
{
|
||||
'name': 'sysroot_mips',
|
||||
'pattern': '.',
|
||||
'condition': 'checkout_linux and checkout_mips',
|
||||
'action': ['python3', 'src/build/linux/sysroot_scripts/install-sysroot.py',
|
||||
'--arch=mips'],
|
||||
},
|
||||
{
|
||||
'name': 'sysroot_x64',
|
||||
'pattern': '.',
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
Name: libyuv
|
||||
URL: https://chromium.googlesource.com/libyuv/libyuv/
|
||||
Version: 1920
|
||||
Version: 1921
|
||||
License: BSD-3-Clause
|
||||
License File: LICENSE
|
||||
Shipped: yes
|
||||
|
||||
@ -157,12 +157,6 @@ ia32
|
||||
GYP_DEFINES="OS=android target_arch=ia32 android_full_debug=1" GYP_CROSSCOMPILE=1 ./gyp_libyuv
|
||||
ninja -j7 -C out/Debug yuv_unittest_apk
|
||||
|
||||
mipsel
|
||||
|
||||
GYP_DEFINES="OS=android target_arch=mipsel" GYP_CROSSCOMPILE=1 ./gyp_libyuv
|
||||
ninja -j7 -C out/Debug yuv_unittest_apk
|
||||
ninja -j7 -C out/Release yuv_unittest_apk
|
||||
|
||||
arm32 disassembly:
|
||||
|
||||
llvm-objdump -d out/Release/obj/source/libyuv.row_neon.o
|
||||
@ -195,16 +189,6 @@ Running test with C code:
|
||||
gn gen out/Official "--args=is_debug=false is_official_build=true is_chrome_branded=true"
|
||||
ninja -C out/Official
|
||||
|
||||
#### Building mips with GN
|
||||
|
||||
mipsel
|
||||
gn gen out/Default "--args=is_debug=false target_cpu=\"mipsel\" target_os = \"android\" mips_arch_variant = \"r6\" mips_use_msa = true is_component_build = true is_clang = false"
|
||||
ninja -C out/Default
|
||||
|
||||
mips64el
|
||||
gn gen out/Default "--args=is_debug=false target_cpu=\"mips64el\" target_os = \"android\" mips_arch_variant = \"r6\" mips_use_msa = true is_component_build = true is_clang = false"
|
||||
ninja -C out/Default
|
||||
|
||||
### Linux
|
||||
|
||||
GYP_DEFINES="target_arch=x64" ./gyp_libyuv
|
||||
|
||||
@ -43,10 +43,6 @@ By default the cpu is detected and the most advanced form of SIMD is used. But
|
||||
LIBYUV_DISABLE_SVE2
|
||||
LIBYUV_DISABLE_SME
|
||||
|
||||
## MIPS CPUs
|
||||
|
||||
LIBYUV_DISABLE_MSA
|
||||
|
||||
## LOONGARCH CPUs
|
||||
|
||||
LIBYUV_DISABLE_LSX
|
||||
|
||||
@ -130,13 +130,6 @@ ia32
|
||||
ninja -v -C out/Debug libyuv_unittest
|
||||
ninja -v -C out/Release libyuv_unittest
|
||||
|
||||
mips
|
||||
|
||||
gn gen out/Release "--args=is_debug=false target_os=\"android\" target_cpu=\"mips64el\" mips_arch_variant=\"r6\" mips_use_msa=true is_component_build=true"
|
||||
gn gen out/Debug "--args=is_debug=true target_os=\"android\" target_cpu=\"mips64el\" mips_arch_variant=\"r6\" mips_use_msa=true is_component_build=true"
|
||||
ninja -v -C out/Debug libyuv_unittest
|
||||
ninja -v -C out/Release libyuv_unittest
|
||||
|
||||
arm disassembly:
|
||||
|
||||
llvm-objdump -d ./out/Release/obj/libyuv/row_common.o >row_common.txt
|
||||
@ -176,13 +169,6 @@ Running test with C code:
|
||||
ninja -v -C out/Debug libyuv_unittest
|
||||
ninja -v -C out/Release libyuv_unittest
|
||||
|
||||
### MIPS Linux
|
||||
|
||||
gn gen out/Release "--args=is_debug=false target_os=\"linux\" target_cpu=\"mips64el\" mips_arch_variant=\"loongson3\" is_component_build=false use_sysroot=false use_gold=false"
|
||||
gn gen out/Debug "--args=is_debug=true target_os=\"linux\" target_cpu=\"mips64el\" mips_arch_variant=\"loongson3\" is_component_build=false use_sysroot=false use_gold=false"
|
||||
ninja -v -C out/Debug libyuv_unittest
|
||||
ninja -v -C out/Release libyuv_unittest
|
||||
|
||||
## Building the Library with make
|
||||
|
||||
### Linux
|
||||
|
||||
@ -65,11 +65,6 @@ extern "C" {
|
||||
#define HAS_SUMSQUAREERROR_NEON_DOTPROD
|
||||
#endif
|
||||
|
||||
#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
|
||||
#define HAS_HAMMINGDISTANCE_MSA
|
||||
#define HAS_SUMSQUAREERROR_MSA
|
||||
#endif
|
||||
|
||||
uint32_t HammingDistance_C(const uint8_t* src_a,
|
||||
const uint8_t* src_b,
|
||||
int count);
|
||||
@ -88,9 +83,6 @@ uint32_t HammingDistance_NEON(const uint8_t* src_a,
|
||||
uint32_t HammingDistance_NEON_DotProd(const uint8_t* src_a,
|
||||
const uint8_t* src_b,
|
||||
int count);
|
||||
uint32_t HammingDistance_MSA(const uint8_t* src_a,
|
||||
const uint8_t* src_b,
|
||||
int count);
|
||||
uint32_t SumSquareError_C(const uint8_t* src_a,
|
||||
const uint8_t* src_b,
|
||||
int count);
|
||||
@ -106,9 +98,6 @@ uint32_t SumSquareError_NEON(const uint8_t* src_a,
|
||||
uint32_t SumSquareError_NEON_DotProd(const uint8_t* src_a,
|
||||
const uint8_t* src_b,
|
||||
int count);
|
||||
uint32_t SumSquareError_MSA(const uint8_t* src_a,
|
||||
const uint8_t* src_b,
|
||||
int count);
|
||||
|
||||
uint32_t HashDjb2_C(const uint8_t* src, int count, uint32_t seed);
|
||||
uint32_t HashDjb2_SSE41(const uint8_t* src, int count, uint32_t seed);
|
||||
|
||||
@ -1,244 +0,0 @@
|
||||
/*
|
||||
* Copyright 2016 The LibYuv Project Authors. All rights reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE 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.
|
||||
*/
|
||||
|
||||
#ifndef INCLUDE_LIBYUV_MACROS_MSA_H_
|
||||
#define INCLUDE_LIBYUV_MACROS_MSA_H_
|
||||
|
||||
#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
|
||||
#include <msa.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#if (__mips_isa_rev >= 6)
|
||||
#define LW(psrc) \
|
||||
({ \
|
||||
const uint8_t* psrc_lw_m = (const uint8_t*)(psrc); \
|
||||
uint32_t val_m; \
|
||||
asm("lw %[val_m], %[psrc_lw_m] \n" \
|
||||
: [val_m] "=r"(val_m) \
|
||||
: [psrc_lw_m] "m"(*psrc_lw_m)); \
|
||||
val_m; \
|
||||
})
|
||||
|
||||
#if (__mips == 64)
|
||||
#define LD(psrc) \
|
||||
({ \
|
||||
const uint8_t* psrc_ld_m = (const uint8_t*)(psrc); \
|
||||
uint64_t val_m = 0; \
|
||||
asm("ld %[val_m], %[psrc_ld_m] \n" \
|
||||
: [val_m] "=r"(val_m) \
|
||||
: [psrc_ld_m] "m"(*psrc_ld_m)); \
|
||||
val_m; \
|
||||
})
|
||||
#else // !(__mips == 64)
|
||||
#define LD(psrc) \
|
||||
({ \
|
||||
const uint8_t* psrc_ld_m = (const uint8_t*)(psrc); \
|
||||
uint32_t val0_m, val1_m; \
|
||||
uint64_t val_m = 0; \
|
||||
val0_m = LW(psrc_ld_m); \
|
||||
val1_m = LW(psrc_ld_m + 4); \
|
||||
val_m = (uint64_t)(val1_m); /* NOLINT */ \
|
||||
val_m = (uint64_t)((val_m << 32) & 0xFFFFFFFF00000000); /* NOLINT */ \
|
||||
val_m = (uint64_t)(val_m | (uint64_t)val0_m); /* NOLINT */ \
|
||||
val_m; \
|
||||
})
|
||||
#endif // (__mips == 64)
|
||||
|
||||
#define SW(val, pdst) \
|
||||
({ \
|
||||
uint8_t* pdst_sw_m = (uint8_t*)(pdst); /* NOLINT */ \
|
||||
uint32_t val_m = (val); \
|
||||
asm("sw %[val_m], %[pdst_sw_m] \n" \
|
||||
: [pdst_sw_m] "=m"(*pdst_sw_m) \
|
||||
: [val_m] "r"(val_m)); \
|
||||
})
|
||||
|
||||
#if (__mips == 64)
|
||||
#define SD(val, pdst) \
|
||||
({ \
|
||||
uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */ \
|
||||
uint64_t val_m = (val); \
|
||||
asm("sd %[val_m], %[pdst_sd_m] \n" \
|
||||
: [pdst_sd_m] "=m"(*pdst_sd_m) \
|
||||
: [val_m] "r"(val_m)); \
|
||||
})
|
||||
#else // !(__mips == 64)
|
||||
#define SD(val, pdst) \
|
||||
({ \
|
||||
uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */ \
|
||||
uint32_t val0_m, val1_m; \
|
||||
val0_m = (uint32_t)((val)&0x00000000FFFFFFFF); \
|
||||
val1_m = (uint32_t)(((val) >> 32) & 0x00000000FFFFFFFF); \
|
||||
SW(val0_m, pdst_sd_m); \
|
||||
SW(val1_m, pdst_sd_m + 4); \
|
||||
})
|
||||
#endif // !(__mips == 64)
|
||||
#else // !(__mips_isa_rev >= 6)
|
||||
#define LW(psrc) \
|
||||
({ \
|
||||
uint8_t* psrc_lw_m = (uint8_t*)(psrc); \
|
||||
uint32_t val_lw_m; \
|
||||
\
|
||||
asm("lwr %[val_lw_m], 0(%[psrc_lw_m]) \n\t" \
|
||||
"lwl %[val_lw_m], 3(%[psrc_lw_m]) \n\t" \
|
||||
\
|
||||
: [val_lw_m] "=&r"(val_lw_m) \
|
||||
: [psrc_lw_m] "r"(psrc_lw_m)); \
|
||||
\
|
||||
val_lw_m; \
|
||||
})
|
||||
|
||||
#if (__mips == 64)
|
||||
#define LD(psrc) \
|
||||
({ \
|
||||
uint8_t* psrc_ld_m = (uint8_t*)(psrc); \
|
||||
uint64_t val_ld_m = 0; \
|
||||
\
|
||||
asm("ldr %[val_ld_m], 0(%[psrc_ld_m]) \n\t" \
|
||||
"ldl %[val_ld_m], 7(%[psrc_ld_m]) \n\t" \
|
||||
\
|
||||
: [val_ld_m] "=&r"(val_ld_m) \
|
||||
: [psrc_ld_m] "r"(psrc_ld_m)); \
|
||||
\
|
||||
val_ld_m; \
|
||||
})
|
||||
#else // !(__mips == 64)
|
||||
#define LD(psrc) \
|
||||
({ \
|
||||
const uint8_t* psrc_ld_m = (const uint8_t*)(psrc); \
|
||||
uint32_t val0_m, val1_m; \
|
||||
uint64_t val_m = 0; \
|
||||
val0_m = LW(psrc_ld_m); \
|
||||
val1_m = LW(psrc_ld_m + 4); \
|
||||
val_m = (uint64_t)(val1_m); /* NOLINT */ \
|
||||
val_m = (uint64_t)((val_m << 32) & 0xFFFFFFFF00000000); /* NOLINT */ \
|
||||
val_m = (uint64_t)(val_m | (uint64_t)val0_m); /* NOLINT */ \
|
||||
val_m; \
|
||||
})
|
||||
#endif // (__mips == 64)
|
||||
|
||||
#define SW(val, pdst) \
|
||||
({ \
|
||||
uint8_t* pdst_sw_m = (uint8_t*)(pdst); /* NOLINT */ \
|
||||
uint32_t val_m = (val); \
|
||||
asm("usw %[val_m], %[pdst_sw_m] \n" \
|
||||
: [pdst_sw_m] "=m"(*pdst_sw_m) \
|
||||
: [val_m] "r"(val_m)); \
|
||||
})
|
||||
|
||||
#define SD(val, pdst) \
|
||||
({ \
|
||||
uint8_t* pdst_sd_m = (uint8_t*)(pdst); /* NOLINT */ \
|
||||
uint32_t val0_m, val1_m; \
|
||||
val0_m = (uint32_t)((val)&0x00000000FFFFFFFF); \
|
||||
val1_m = (uint32_t)(((val) >> 32) & 0x00000000FFFFFFFF); \
|
||||
SW(val0_m, pdst_sd_m); \
|
||||
SW(val1_m, pdst_sd_m + 4); \
|
||||
})
|
||||
#endif // (__mips_isa_rev >= 6)
|
||||
|
||||
// TODO(fbarchard): Consider removing __VAR_ARGS versions.
|
||||
#define LD_B(RTYPE, psrc) *((RTYPE*)(psrc)) /* NOLINT */
|
||||
#define LD_UB(...) LD_B(const v16u8, __VA_ARGS__)
|
||||
|
||||
#define LD_H(RTYPE, psrc) *((RTYPE*)(psrc)) /* NOLINT */
|
||||
#define LD_UH(...) LD_H(const v8u16, __VA_ARGS__)
|
||||
|
||||
#define ST_B(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in) /* NOLINT */
|
||||
#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
|
||||
|
||||
#define ST_H(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in) /* NOLINT */
|
||||
#define ST_UH(...) ST_H(v8u16, __VA_ARGS__)
|
||||
|
||||
/* Description : Load two vectors with 16 'byte' sized elements
|
||||
Arguments : Inputs - psrc, stride
|
||||
Outputs - out0, out1
|
||||
Return Type - as per RTYPE
|
||||
Details : Load 16 byte elements in 'out0' from (psrc)
|
||||
Load 16 byte elements in 'out1' from (psrc + stride)
|
||||
*/
|
||||
#define LD_B2(RTYPE, psrc, stride, out0, out1) \
|
||||
{ \
|
||||
out0 = LD_B(RTYPE, (psrc)); \
|
||||
out1 = LD_B(RTYPE, (psrc) + stride); \
|
||||
}
|
||||
#define LD_UB2(...) LD_B2(const v16u8, __VA_ARGS__)
|
||||
|
||||
#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3) \
|
||||
{ \
|
||||
LD_B2(RTYPE, (psrc), stride, out0, out1); \
|
||||
LD_B2(RTYPE, (psrc) + 2 * stride, stride, out2, out3); \
|
||||
}
|
||||
#define LD_UB4(...) LD_B4(const v16u8, __VA_ARGS__)
|
||||
|
||||
/* Description : Store two vectors with stride each having 16 'byte' sized
|
||||
elements
|
||||
Arguments : Inputs - in0, in1, pdst, stride
|
||||
Details : Store 16 byte elements from 'in0' to (pdst)
|
||||
Store 16 byte elements from 'in1' to (pdst + stride)
|
||||
*/
|
||||
#define ST_B2(RTYPE, in0, in1, pdst, stride) \
|
||||
{ \
|
||||
ST_B(RTYPE, in0, (pdst)); \
|
||||
ST_B(RTYPE, in1, (pdst) + stride); \
|
||||
}
|
||||
#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
|
||||
|
||||
#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride) \
|
||||
{ \
|
||||
ST_B2(RTYPE, in0, in1, (pdst), stride); \
|
||||
ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride); \
|
||||
}
|
||||
#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
|
||||
|
||||
/* Description : Store vectors of 8 halfword elements with stride
|
||||
Arguments : Inputs - in0, in1, pdst, stride
|
||||
Details : Store 8 halfword elements from 'in0' to (pdst)
|
||||
Store 8 halfword elements from 'in1' to (pdst + stride)
|
||||
*/
|
||||
#define ST_H2(RTYPE, in0, in1, pdst, stride) \
|
||||
{ \
|
||||
ST_H(RTYPE, in0, (pdst)); \
|
||||
ST_H(RTYPE, in1, (pdst) + stride); \
|
||||
}
|
||||
#define ST_UH2(...) ST_H2(v8u16, __VA_ARGS__)
|
||||
|
||||
// TODO(fbarchard): Consider using __msa_vshf_b and __msa_ilvr_b directly.
|
||||
/* Description : Shuffle byte vector elements as per mask vector
|
||||
Arguments : Inputs - in0, in1, in2, in3, mask0, mask1
|
||||
Outputs - out0, out1
|
||||
Return Type - as per RTYPE
|
||||
Details : Byte elements from 'in0' & 'in1' are copied selectively to
|
||||
'out0' as per control vector 'mask0'
|
||||
*/
|
||||
#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1) \
|
||||
{ \
|
||||
out0 = (RTYPE)__msa_vshf_b((v16i8)mask0, (v16i8)in1, (v16i8)in0); \
|
||||
out1 = (RTYPE)__msa_vshf_b((v16i8)mask1, (v16i8)in3, (v16i8)in2); \
|
||||
}
|
||||
#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
|
||||
|
||||
/* Description : Interleave both left and right half of input vectors
|
||||
Arguments : Inputs - in0, in1
|
||||
Outputs - out0, out1
|
||||
Return Type - as per RTYPE
|
||||
Details : Right half of byte elements from 'in0' and 'in1' are
|
||||
interleaved and written to 'out0'
|
||||
*/
|
||||
#define ILVRL_B2(RTYPE, in0, in1, out0, out1) \
|
||||
{ \
|
||||
out0 = (RTYPE)__msa_ilvr_b((v16i8)in0, (v16i8)in1); \
|
||||
out1 = (RTYPE)__msa_ilvl_b((v16i8)in0, (v16i8)in1); \
|
||||
}
|
||||
#define ILVRL_B2_UB(...) ILVRL_B2(v16u8, __VA_ARGS__)
|
||||
|
||||
#endif /* !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa) */
|
||||
|
||||
#endif // INCLUDE_LIBYUV_MACROS_MSA_H_
|
||||
@ -60,11 +60,6 @@ extern "C" {
|
||||
#define HAS_TRANSPOSEUVWXH_SME
|
||||
#endif
|
||||
|
||||
#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
|
||||
#define HAS_TRANSPOSEWX16_MSA
|
||||
#define HAS_TRANSPOSEUVWX16_MSA
|
||||
#endif
|
||||
|
||||
#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
|
||||
#define HAS_TRANSPOSEWX16_LSX
|
||||
#define HAS_TRANSPOSEUVWX16_LSX
|
||||
@ -113,11 +108,6 @@ void TransposeWx8_Fast_SSSE3(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
int dst_stride,
|
||||
int width);
|
||||
void TransposeWx16_MSA(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_stride,
|
||||
int width);
|
||||
void TransposeWx16_LSX(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst,
|
||||
@ -144,11 +134,6 @@ void TransposeWx8_Fast_Any_SSSE3(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
int dst_stride,
|
||||
int width);
|
||||
void TransposeWx16_Any_MSA(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_stride,
|
||||
int width);
|
||||
void TransposeWx16_Any_LSX(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst,
|
||||
@ -200,13 +185,6 @@ void TransposeUVWxH_SME(const uint8_t* src,
|
||||
int dst_stride_b,
|
||||
int width,
|
||||
int height);
|
||||
void TransposeUVWx16_MSA(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst_a,
|
||||
int dst_stride_a,
|
||||
uint8_t* dst_b,
|
||||
int dst_stride_b,
|
||||
int width);
|
||||
void TransposeUVWx16_LSX(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst_a,
|
||||
@ -229,13 +207,6 @@ void TransposeUVWx8_Any_NEON(const uint8_t* src,
|
||||
uint8_t* dst_b,
|
||||
int dst_stride_b,
|
||||
int width);
|
||||
void TransposeUVWx16_Any_MSA(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst_a,
|
||||
int dst_stride_a,
|
||||
uint8_t* dst_b,
|
||||
int dst_stride_b,
|
||||
int width);
|
||||
void TransposeUVWx16_Any_LSX(const uint8_t* src,
|
||||
int src_stride,
|
||||
uint8_t* dst_a,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -136,19 +136,6 @@ extern "C" {
|
||||
#define HAS_SCALEUVROWDOWN2_SME
|
||||
#endif
|
||||
|
||||
#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
|
||||
#define HAS_SCALEADDROW_MSA
|
||||
#define HAS_SCALEARGBCOLS_MSA
|
||||
#define HAS_SCALEARGBFILTERCOLS_MSA
|
||||
#define HAS_SCALEARGBROWDOWN2_MSA
|
||||
#define HAS_SCALEARGBROWDOWNEVEN_MSA
|
||||
#define HAS_SCALEFILTERCOLS_MSA
|
||||
#define HAS_SCALEROWDOWN2_MSA
|
||||
#define HAS_SCALEROWDOWN34_MSA
|
||||
#define HAS_SCALEROWDOWN38_MSA
|
||||
#define HAS_SCALEROWDOWN4_MSA
|
||||
#endif
|
||||
|
||||
#if !defined(LIBYUV_DISABLE_LSX) && defined(__loongarch_sx)
|
||||
#define HAS_SCALEARGBROWDOWN2_LSX
|
||||
#define HAS_SCALEARGBROWDOWNEVEN_LSX
|
||||
@ -269,17 +256,12 @@ enum FilterMode ScaleFilterReduce(int src_width,
|
||||
// Divide num by div and return as 16.16 fixed point result.
|
||||
int FixedDiv_C(int num, int div);
|
||||
int FixedDiv_X86(int num, int div);
|
||||
int FixedDiv_MIPS(int num, int div);
|
||||
// Divide num - 1 by div - 1 and return as 16.16 fixed point result.
|
||||
int FixedDiv1_C(int num, int div);
|
||||
int FixedDiv1_X86(int num, int div);
|
||||
int FixedDiv1_MIPS(int num, int div);
|
||||
#ifdef HAS_FIXEDDIV_X86
|
||||
#define FixedDiv FixedDiv_X86
|
||||
#define FixedDiv1 FixedDiv1_X86
|
||||
#elif defined HAS_FIXEDDIV_MIPS
|
||||
#define FixedDiv FixedDiv_MIPS
|
||||
#define FixedDiv1 FixedDiv1_MIPS
|
||||
#else
|
||||
#define FixedDiv FixedDiv_C
|
||||
#define FixedDiv1 FixedDiv1_C
|
||||
@ -935,26 +917,6 @@ void ScaleARGBCols_Any_NEON(uint8_t* dst_ptr,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleARGBFilterCols_MSA(uint8_t* dst_argb,
|
||||
const uint8_t* src_argb,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleARGBCols_MSA(uint8_t* dst_argb,
|
||||
const uint8_t* src_argb,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleARGBFilterCols_Any_MSA(uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleARGBCols_Any_MSA(uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleARGBFilterCols_RVV(uint8_t* dst_argb,
|
||||
const uint8_t* src_argb,
|
||||
int dst_width,
|
||||
@ -1010,18 +972,6 @@ void ScaleARGBRowDown2Box_RVV(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2_MSA(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2Linear_MSA(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2Box_MSA(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2_LSX(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_argb,
|
||||
@ -1058,18 +1008,6 @@ void ScaleARGBRowDown2Box_Any_NEON(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDown2_Any_LSX(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
@ -1102,16 +1040,6 @@ void ScaleARGBRowDownEvenBox_NEON(const uint8_t* src_argb,
|
||||
int src_stepx,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDownEven_MSA(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
int32_t src_stepx,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDownEvenBox_MSA(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
int src_stepx,
|
||||
uint8_t* dst_argb,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDownEven_LSX(const uint8_t* src_argb,
|
||||
ptrdiff_t src_stride,
|
||||
int32_t src_stepx,
|
||||
@ -1152,16 +1080,6 @@ void ScaleARGBRowDownEvenBox_Any_NEON(const uint8_t* src_ptr,
|
||||
int src_stepx,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDownEven_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int32_t src_stepx,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDownEvenBox_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int src_stepx,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleARGBRowDownEven_Any_LSX(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int32_t src_stepx,
|
||||
@ -1214,18 +1132,6 @@ void ScaleUVRowDown2Box_SME(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_uv,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2Linear_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_uv,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_uv,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2_RVV(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_uv,
|
||||
@ -1266,18 +1172,6 @@ void ScaleUVRowDown2Box_Any_NEON(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleUVRowDown2Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleUVRowDownEven_SSSE3(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int src_stepx,
|
||||
@ -1308,16 +1202,6 @@ void ScaleUVRowDownEven_RVV(const uint8_t* src_ptr,
|
||||
int32_t src_stepx,
|
||||
uint8_t* dst_uv,
|
||||
int dst_width);
|
||||
void ScaleUVRowDownEven_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int32_t src_stepx,
|
||||
uint8_t* dst_uv,
|
||||
int dst_width);
|
||||
void ScaleUVRowDownEvenBox_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int src_stepx,
|
||||
uint8_t* dst_uv,
|
||||
int dst_width);
|
||||
void ScaleUVRowDownEven_Any_SSSE3(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int src_stepx,
|
||||
@ -1338,16 +1222,6 @@ void ScaleUVRowDownEvenBox_Any_NEON(const uint8_t* src_ptr,
|
||||
int src_stepx,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleUVRowDownEven_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int32_t src_stepx,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleUVRowDownEvenBox_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
int src_stepx,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
|
||||
void ScaleUVRowUp2_Linear_SSSE3(const uint8_t* src_ptr,
|
||||
uint8_t* dst_ptr,
|
||||
@ -1664,110 +1538,6 @@ void ScaleFilterCols_Any_NEON(uint8_t* dst_ptr,
|
||||
int x,
|
||||
int dx);
|
||||
|
||||
void ScaleRowDown2_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown2Linear_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown2Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown4_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown4Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown38_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown38_2_Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown38_3_Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleAddRow_MSA(const uint8_t* src_ptr, uint16_t* dst_ptr, int src_width);
|
||||
void ScaleFilterCols_MSA(uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleRowDown34_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
int dst_width);
|
||||
void ScaleRowDown34_0_Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* d,
|
||||
int dst_width);
|
||||
void ScaleRowDown34_1_Box_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* d,
|
||||
int dst_width);
|
||||
|
||||
void ScaleRowDown2_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown2Linear_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown2Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown4_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown4Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown38_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown38_2_Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown38_3_Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleAddRow_Any_MSA(const uint8_t* src_ptr,
|
||||
uint16_t* dst_ptr,
|
||||
int src_width);
|
||||
void ScaleFilterCols_Any_MSA(uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr,
|
||||
int dst_width,
|
||||
int x,
|
||||
int dx);
|
||||
void ScaleRowDown34_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown34_0_Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
void ScaleRowDown34_1_Box_Any_MSA(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst_ptr,
|
||||
int dst_width);
|
||||
|
||||
void ScaleRowDown2_LSX(const uint8_t* src_ptr,
|
||||
ptrdiff_t src_stride,
|
||||
uint8_t* dst,
|
||||
|
||||
12
libyuv.gyp
12
libyuv.gyp
@ -26,20 +26,13 @@
|
||||
'clang%': 0,
|
||||
# Link-Time Optimizations.
|
||||
'use_lto%': 0,
|
||||
'mips_msa%': 0, # Default to msa off.
|
||||
'build_neon': 0,
|
||||
'build_msa': 0,
|
||||
'conditions': [
|
||||
['(target_arch == "armv7" or target_arch == "armv7s" or \
|
||||
(target_arch == "arm" and arm_version >= 7) or target_arch == "arm64")\
|
||||
and (arm_neon == 1 or arm_neon_optional == 1)', {
|
||||
'build_neon': 1,
|
||||
}],
|
||||
['(target_arch == "mipsel" or target_arch == "mips64el")\
|
||||
and (mips_msa == 1)',
|
||||
{
|
||||
'build_msa': 1,
|
||||
}],
|
||||
],
|
||||
},
|
||||
|
||||
@ -87,11 +80,6 @@
|
||||
}],
|
||||
],
|
||||
}],
|
||||
['build_msa != 0', {
|
||||
'defines': [
|
||||
'LIBYUV_MSA',
|
||||
],
|
||||
}],
|
||||
['OS != "ios" and libyuv_disable_jpeg != 1', {
|
||||
'defines': [
|
||||
'HAVE_JPEG'
|
||||
|
||||
@ -21,7 +21,6 @@
|
||||
'include/libyuv/cpu_id.h',
|
||||
'include/libyuv/cpu_support.h',
|
||||
'include/libyuv/loongson_intrinsics.h',
|
||||
'include/libyuv/macros_msa.h',
|
||||
'include/libyuv/mjpeg_decoder.h',
|
||||
'include/libyuv/planar_functions.h',
|
||||
'include/libyuv/rotate.h',
|
||||
@ -40,7 +39,6 @@
|
||||
'source/compare.cc',
|
||||
'source/compare_common.cc',
|
||||
'source/compare_gcc.cc',
|
||||
'source/compare_msa.cc',
|
||||
'source/compare_neon.cc',
|
||||
'source/compare_neon64.cc',
|
||||
'source/compare_win.cc',
|
||||
@ -61,14 +59,12 @@
|
||||
'source/rotate_common.cc',
|
||||
'source/rotate_gcc.cc',
|
||||
'source/rotate_lsx.cc',
|
||||
'source/rotate_msa.cc',
|
||||
'source/rotate_neon.cc',
|
||||
'source/rotate_neon64.cc',
|
||||
'source/rotate_win.cc',
|
||||
'source/row_any.cc',
|
||||
'source/row_common.cc',
|
||||
'source/row_gcc.cc',
|
||||
'source/row_msa.cc',
|
||||
'source/row_lasx.cc',
|
||||
'source/row_lsx.cc',
|
||||
'source/row_neon.cc',
|
||||
@ -80,7 +76,6 @@
|
||||
'source/scale_common.cc',
|
||||
'source/scale_gcc.cc',
|
||||
'source/scale_lsx.cc',
|
||||
'source/scale_msa.cc',
|
||||
'source/scale_neon.cc',
|
||||
'source/scale_neon64.cc',
|
||||
'source/scale_rgb.cc',
|
||||
|
||||
4
linux.mk
4
linux.mk
@ -13,7 +13,6 @@ LOCAL_OBJ_FILES := \
|
||||
source/compare.o \
|
||||
source/compare_common.o \
|
||||
source/compare_gcc.o \
|
||||
source/compare_msa.o \
|
||||
source/compare_neon.o \
|
||||
source/compare_neon64.o \
|
||||
source/compare_win.o \
|
||||
@ -34,7 +33,6 @@ LOCAL_OBJ_FILES := \
|
||||
source/rotate_common.o \
|
||||
source/rotate_gcc.o \
|
||||
source/rotate_lsx.o \
|
||||
source/rotate_msa.o \
|
||||
source/rotate_neon.o \
|
||||
source/rotate_neon64.o \
|
||||
source/rotate_win.o \
|
||||
@ -43,7 +41,6 @@ LOCAL_OBJ_FILES := \
|
||||
source/row_gcc.o \
|
||||
source/row_lasx.o \
|
||||
source/row_lsx.o \
|
||||
source/row_msa.o \
|
||||
source/row_neon.o \
|
||||
source/row_neon64.o \
|
||||
source/row_rvv.o \
|
||||
@ -54,7 +51,6 @@ LOCAL_OBJ_FILES := \
|
||||
source/scale_common.o \
|
||||
source/scale_gcc.o \
|
||||
source/scale_lsx.o \
|
||||
source/scale_msa.o \
|
||||
source/scale_neon.o \
|
||||
source/scale_neon64.o \
|
||||
source/scale_rgb.o \
|
||||
|
||||
@ -159,11 +159,6 @@ uint64_t ComputeHammingDistance(const uint8_t* src_a,
|
||||
HammingDistance = HammingDistance_AVX2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_HAMMINGDISTANCE_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
HammingDistance = HammingDistance_MSA;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef _OPENMP
|
||||
#pragma omp parallel for reduction(+ : diff)
|
||||
@ -221,11 +216,6 @@ uint64_t ComputeSumSquareError(const uint8_t* src_a,
|
||||
SumSquareError = SumSquareError_AVX2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SUMSQUAREERROR_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SumSquareError = SumSquareError_MSA;
|
||||
}
|
||||
#endif
|
||||
#ifdef _OPENMP
|
||||
#pragma omp parallel for reduction(+ : sse)
|
||||
#endif
|
||||
|
||||
@ -748,14 +748,6 @@ int I010ToNV12(const uint16_t* src_y,
|
||||
MergeUVRow = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow = MergeUVRow_Any_LSX;
|
||||
@ -1196,14 +1188,6 @@ int I422ToNV21(const uint8_t* src_y,
|
||||
MergeUVRow = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow = MergeUVRow_Any_LSX;
|
||||
@ -1246,14 +1230,6 @@ int I422ToNV21(const uint8_t* src_y,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -1724,16 +1700,6 @@ int YUY2ToI420(const uint8_t* src_yuy2,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_MSA;
|
||||
YUY2ToUVRow = YUY2ToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
YUY2ToYRow = YUY2ToYRow_MSA;
|
||||
YUY2ToUVRow = YUY2ToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_LSX) && defined(HAS_YUY2TOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_LSX;
|
||||
@ -1825,16 +1791,6 @@ int UYVYToI420(const uint8_t* src_uyvy,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
UYVYToYRow = UYVYToYRow_Any_MSA;
|
||||
UYVYToUVRow = UYVYToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
UYVYToYRow = UYVYToYRow_MSA;
|
||||
UYVYToUVRow = UYVYToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
UYVYToYRow = UYVYToYRow_Any_LSX;
|
||||
@ -2143,18 +2099,6 @@ int ARGBToI420(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -2337,18 +2281,6 @@ int ARGBToI420Alpha(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -2385,12 +2317,6 @@ int ARGBToI420Alpha(const uint8_t* src_argb,
|
||||
: ARGBExtractAlphaRow_Any_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBEXTRACTALPHAROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_MSA
|
||||
: ARGBExtractAlphaRow_Any_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBEXTRACTALPHAROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_LSX
|
||||
@ -2532,18 +2458,6 @@ int BGRAToI420(const uint8_t* src_bgra,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_BGRATOYROW_MSA) && defined(HAS_BGRATOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
BGRAToYRow = BGRAToYRow_Any_MSA;
|
||||
BGRAToUVRow = BGRAToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
BGRAToYRow = BGRAToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
BGRAToUVRow = BGRAToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_BGRATOYROW_LSX) && defined(HAS_BGRATOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
BGRAToYRow = BGRAToYRow_Any_LSX;
|
||||
@ -2691,16 +2605,6 @@ int ABGRToI420(const uint8_t* src_abgr,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ABGRToYRow = ABGRToYRow_Any_MSA;
|
||||
ABGRToUVRow = ABGRToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ABGRToYRow = ABGRToYRow_MSA;
|
||||
ABGRToUVRow = ABGRToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYROW_LSX) && defined(HAS_ABGRTOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ABGRToYRow = ABGRToYRow_Any_LSX;
|
||||
@ -2832,16 +2736,6 @@ int RGBAToI420(const uint8_t* src_rgba,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGBATOYROW_MSA) && defined(HAS_RGBATOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGBAToYRow = RGBAToYRow_Any_MSA;
|
||||
RGBAToUVRow = RGBAToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGBAToYRow = RGBAToYRow_MSA;
|
||||
RGBAToUVRow = RGBAToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGBATOYROW_LSX) && defined(HAS_RGBATOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGBAToYRow = RGBAToYRow_Any_LSX;
|
||||
@ -2883,8 +2777,8 @@ int RGBAToI420(const uint8_t* src_rgba,
|
||||
}
|
||||
|
||||
// Enabled if 1 pass is available
|
||||
#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_MSA) || \
|
||||
defined(HAS_RGB24TOYROW_LSX) || defined(HAS_RGB24TOYROW_RVV))
|
||||
#if (defined(HAS_RGB24TOYROW_NEON) || defined(HAS_RGB24TOYROW_LSX) || \
|
||||
defined(HAS_RGB24TOYROW_RVV))
|
||||
#define HAS_RGB24TOYROW
|
||||
#endif
|
||||
|
||||
@ -2939,16 +2833,6 @@ int RGB24ToI420(const uint8_t* src_rgb24,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOYROW_MSA) && defined(HAS_RGB24TOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGB24ToUVRow = RGB24ToUVRow_Any_MSA;
|
||||
RGB24ToYRow = RGB24ToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGB24ToYRow = RGB24ToYRow_MSA;
|
||||
RGB24ToUVRow = RGB24ToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOYROW_LSX) && defined(HAS_RGB24TOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGB24ToUVRow = RGB24ToUVRow_Any_LSX;
|
||||
@ -3065,8 +2949,7 @@ int RGB24ToI420(const uint8_t* src_rgb24,
|
||||
#undef HAS_RGB24TOYROW
|
||||
|
||||
// Enabled if 1 pass is available
|
||||
#if defined(HAS_RGB24TOYJROW_NEON) || defined(HAS_RGB24TOYJROW_MSA) || \
|
||||
defined(HAS_RGB24TOYJROW_RVV)
|
||||
#if defined(HAS_RGB24TOYJROW_NEON) || defined(HAS_RGB24TOYJROW_RVV)
|
||||
#define HAS_RGB24TOYJROW
|
||||
#endif
|
||||
|
||||
@ -3121,16 +3004,6 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOYJROW_MSA) && defined(HAS_RGB24TOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGB24ToUVJRow = RGB24ToUVJRow_Any_MSA;
|
||||
RGB24ToYJRow = RGB24ToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGB24ToYJRow = RGB24ToYJRow_MSA;
|
||||
RGB24ToUVJRow = RGB24ToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGB24ToYJRow = RGB24ToYJRow_Any_LSX;
|
||||
@ -3243,8 +3116,8 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
|
||||
#undef HAS_RGB24TOYJROW
|
||||
|
||||
// Enabled if 1 pass is available
|
||||
#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_MSA) || \
|
||||
defined(HAS_RAWTOYROW_LSX) || defined(HAS_RAWTOYROW_RVV))
|
||||
#if (defined(HAS_RAWTOYROW_NEON) || defined(HAS_RAWTOYROW_LSX) || \
|
||||
defined(HAS_RAWTOYROW_RVV))
|
||||
#define HAS_RAWTOYROW
|
||||
#endif
|
||||
|
||||
@ -3298,16 +3171,6 @@ int RAWToI420(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYROW_MSA) && defined(HAS_RAWTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToUVRow = RAWToUVRow_Any_MSA;
|
||||
RAWToYRow = RAWToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToYRow = RAWToYRow_MSA;
|
||||
RAWToUVRow = RAWToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYROW_LSX) && defined(HAS_RAWTOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToUVRow = RAWToUVRow_Any_LSX;
|
||||
@ -3432,8 +3295,7 @@ int RAWToI420(const uint8_t* src_raw,
|
||||
#undef HAS_RAWTOYROW
|
||||
|
||||
// Enabled if 1 pass is available
|
||||
#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_MSA) || \
|
||||
defined(HAS_RAWTOYJROW_RVV)
|
||||
#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_RVV)
|
||||
#define HAS_RAWTOYJROW
|
||||
#endif
|
||||
|
||||
@ -3488,16 +3350,6 @@ int RAWToJ420(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYJROW_MSA) && defined(HAS_RAWTOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToUVJRow = RAWToUVJRow_Any_MSA;
|
||||
RAWToYJRow = RAWToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToYJRow = RAWToYJRow_MSA;
|
||||
RAWToUVJRow = RAWToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYJROW_LSX) && defined(HAS_RAWTOUVJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToUVJRow = RAWToUVJRow_Any_LSX;
|
||||
@ -3683,14 +3535,6 @@ int RAWToI444(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUV444ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToUV444Row = ARGBToUV444Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToUV444Row = ARGBToUV444Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUV444ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToUV444Row = ARGBToUV444Row_Any_LSX;
|
||||
@ -3739,14 +3583,6 @@ int RAWToI444(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -3798,14 +3634,6 @@ int RAWToI444(const uint8_t* src_raw,
|
||||
RAWToARGBRow = RAWToARGBRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToARGBRow = RAWToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToARGBRow = RAWToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToARGBRow = RAWToARGBRow_Any_LSX;
|
||||
@ -3910,14 +3738,6 @@ int RAWToJ444(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUVJ444ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToUVJ444Row = ARGBToUVJ444Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToUVJ444Row = ARGBToUVJ444Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUVJ444ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToUVJ444Row = ARGBToUVJ444Row_Any_LSX;
|
||||
@ -3966,14 +3786,6 @@ int RAWToJ444(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYJRow = ARGBToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_LSX;
|
||||
@ -4025,14 +3837,6 @@ int RAWToJ444(const uint8_t* src_raw,
|
||||
RAWToARGBRow = RAWToARGBRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToARGBRow = RAWToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToARGBRow = RAWToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToARGBRow = RAWToARGBRow_Any_LSX;
|
||||
@ -4089,8 +3893,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
|
||||
int width,
|
||||
int height) {
|
||||
int y;
|
||||
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
|
||||
defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
|
||||
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
|
||||
defined(HAS_RGB565TOYROW_LASX))
|
||||
void (*RGB565ToUVRow)(const uint8_t* src_rgb565, int src_stride_rgb565,
|
||||
uint8_t* dst_u, uint8_t* dst_v, int width) =
|
||||
RGB565ToUVRow_C;
|
||||
@ -4134,16 +3938,6 @@ int RGB565ToI420(const uint8_t* src_rgb565,
|
||||
}
|
||||
#endif
|
||||
// MSA version does direct RGB565 to YUV.
|
||||
#if defined(HAS_RGB565TOYROW_MSA) && defined(HAS_RGB565TOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGB565ToUVRow = RGB565ToUVRow_Any_MSA;
|
||||
RGB565ToYRow = RGB565ToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGB565ToYRow = RGB565ToYRow_MSA;
|
||||
RGB565ToUVRow = RGB565ToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB565TOYROW_LSX) && defined(HAS_RGB565TOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGB565ToUVRow = RGB565ToUVRow_Any_LSX;
|
||||
@ -4214,8 +4008,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
|
||||
}
|
||||
#endif
|
||||
{
|
||||
#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
|
||||
defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
|
||||
#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
|
||||
defined(HAS_RGB565TOYROW_LASX))
|
||||
// Allocate 2 rows of ARGB.
|
||||
const int row_size = (width * 4 + 31) & ~31;
|
||||
align_buffer_64(row, row_size * 2);
|
||||
@ -4223,8 +4017,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
|
||||
return 1;
|
||||
#endif
|
||||
for (y = 0; y < height - 1; y += 2) {
|
||||
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
|
||||
defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
|
||||
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
|
||||
defined(HAS_RGB565TOYROW_LASX))
|
||||
RGB565ToUVRow(src_rgb565, src_stride_rgb565, dst_u, dst_v, width);
|
||||
RGB565ToYRow(src_rgb565, dst_y, width);
|
||||
RGB565ToYRow(src_rgb565 + src_stride_rgb565, dst_y + dst_stride_y, width);
|
||||
@ -4241,8 +4035,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
|
||||
dst_v += dst_stride_v;
|
||||
}
|
||||
if (height & 1) {
|
||||
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
|
||||
defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
|
||||
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
|
||||
defined(HAS_RGB565TOYROW_LASX))
|
||||
RGB565ToUVRow(src_rgb565, 0, dst_u, dst_v, width);
|
||||
RGB565ToYRow(src_rgb565, dst_y, width);
|
||||
#else
|
||||
@ -4251,8 +4045,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
|
||||
ARGBToYRow(row, dst_y, width);
|
||||
#endif
|
||||
}
|
||||
#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
|
||||
defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
|
||||
#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_LSX) || \
|
||||
defined(HAS_RGB565TOYROW_LASX))
|
||||
free_aligned_buffer_64(row);
|
||||
#endif
|
||||
}
|
||||
@ -4272,8 +4066,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
|
||||
int width,
|
||||
int height) {
|
||||
int y;
|
||||
#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
|
||||
defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
|
||||
#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
|
||||
defined(HAS_ARGB1555TOYROW_LASX))
|
||||
void (*ARGB1555ToUVRow)(const uint8_t* src_argb1555, int src_stride_argb1555,
|
||||
uint8_t* dst_u, uint8_t* dst_v, int width) =
|
||||
ARGB1555ToUVRow_C;
|
||||
@ -4318,16 +4112,6 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
|
||||
#endif
|
||||
|
||||
// MSA version does direct ARGB1555 to YUV.
|
||||
#if defined(HAS_ARGB1555TOYROW_MSA) && defined(HAS_ARGB1555TOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGB1555ToUVRow = ARGB1555ToUVRow_Any_MSA;
|
||||
ARGB1555ToYRow = ARGB1555ToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGB1555ToYRow = ARGB1555ToYRow_MSA;
|
||||
ARGB1555ToUVRow = ARGB1555ToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB1555TOYROW_LSX) && defined(HAS_ARGB1555TOUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGB1555ToUVRow = ARGB1555ToUVRow_Any_LSX;
|
||||
@ -4399,8 +4183,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
|
||||
}
|
||||
#endif
|
||||
{
|
||||
#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
|
||||
defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
|
||||
#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
|
||||
defined(HAS_ARGB1555TOYROW_LASX))
|
||||
// Allocate 2 rows of ARGB.
|
||||
const int row_size = (width * 4 + 31) & ~31;
|
||||
align_buffer_64(row, row_size * 2);
|
||||
@ -4409,8 +4193,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
|
||||
#endif
|
||||
|
||||
for (y = 0; y < height - 1; y += 2) {
|
||||
#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
|
||||
defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
|
||||
#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
|
||||
defined(HAS_ARGB1555TOYROW_LASX))
|
||||
ARGB1555ToUVRow(src_argb1555, src_stride_argb1555, dst_u, dst_v, width);
|
||||
ARGB1555ToYRow(src_argb1555, dst_y, width);
|
||||
ARGB1555ToYRow(src_argb1555 + src_stride_argb1555, dst_y + dst_stride_y,
|
||||
@ -4429,8 +4213,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
|
||||
dst_v += dst_stride_v;
|
||||
}
|
||||
if (height & 1) {
|
||||
#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
|
||||
defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
|
||||
#if (defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
|
||||
defined(HAS_ARGB1555TOYROW_LASX))
|
||||
ARGB1555ToUVRow(src_argb1555, 0, dst_u, dst_v, width);
|
||||
ARGB1555ToYRow(src_argb1555, dst_y, width);
|
||||
#else
|
||||
@ -4439,8 +4223,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
|
||||
ARGBToYRow(row, dst_y, width);
|
||||
#endif
|
||||
}
|
||||
#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
|
||||
defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
|
||||
#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_LSX) || \
|
||||
defined(HAS_ARGB1555TOYROW_LASX))
|
||||
free_aligned_buffer_64(row);
|
||||
#endif
|
||||
}
|
||||
@ -4519,14 +4303,6 @@ int ARGB4444ToI420(const uint8_t* src_argb4444,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB4444TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB4444TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LSX;
|
||||
@ -4575,18 +4351,6 @@ int ARGB4444ToI420(const uint8_t* src_argb4444,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -4710,14 +4474,6 @@ int RGB24ToJ400(const uint8_t* src_rgb24,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGB24ToYJRow = RGB24ToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGB24ToYJRow = RGB24ToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGB24ToYJRow = RGB24ToYJRow_Any_LSX;
|
||||
@ -4799,14 +4555,6 @@ int RAWToJ400(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToYJRow = RAWToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToYJRow = RAWToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToYJRow = RAWToYJRow_Any_LSX;
|
||||
|
||||
@ -119,14 +119,6 @@ int I420ToARGBMatrix(const uint8_t* src_y,
|
||||
I422ToARGBRow = I422ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToARGBRow = I422ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_LSX;
|
||||
@ -383,14 +375,6 @@ int I422ToARGBMatrix(const uint8_t* src_y,
|
||||
I422ToARGBRow = I422ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToARGBRow = I422ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_LSX;
|
||||
@ -636,14 +620,6 @@ int I444ToARGBMatrix(const uint8_t* src_y,
|
||||
I444ToARGBRow = I444ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444ToARGBRow = I444ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444ToARGBRow = I444ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I444ToARGBRow = I444ToARGBRow_Any_LSX;
|
||||
@ -881,14 +857,6 @@ int I444ToRGB24Matrix(const uint8_t* src_y,
|
||||
I444ToRGB24Row = I444ToRGB24Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TORGB24ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444ToRGB24Row = I444ToRGB24Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444ToRGB24Row = I444ToRGB24Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TORGB24ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I444ToRGB24Row = I444ToRGB24Row_Any_LSX;
|
||||
@ -2298,14 +2266,6 @@ int I420AlphaToARGBMatrix(const uint8_t* src_y,
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422ALPHATOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422ALPHATOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_Any_LSX;
|
||||
@ -2351,14 +2311,6 @@ int I420AlphaToARGBMatrix(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -2467,14 +2419,6 @@ int I422AlphaToARGBMatrix(const uint8_t* src_y,
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422ALPHATOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422ALPHATOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422AlphaToARGBRow = I422AlphaToARGBRow_Any_LSX;
|
||||
@ -2520,14 +2464,6 @@ int I422AlphaToARGBMatrix(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -2634,14 +2570,6 @@ int I444AlphaToARGBMatrix(const uint8_t* src_y,
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444ALPHATOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444ALPHATOARGBROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_RVV;
|
||||
@ -2671,14 +2599,6 @@ int I444AlphaToARGBMatrix(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -2938,14 +2858,6 @@ int I010AlphaToARGBMatrix(const uint16_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -3078,14 +2990,6 @@ int I210AlphaToARGBMatrix(const uint16_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -3216,14 +3120,6 @@ int I410AlphaToARGBMatrix(const uint16_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -3324,14 +3220,6 @@ int I400ToARGBMatrix(const uint8_t* src_y,
|
||||
I400ToARGBRow = I400ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I400TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I400ToARGBRow = I400ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
I400ToARGBRow = I400ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I400TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I400ToARGBRow = I400ToARGBRow_Any_LSX;
|
||||
@ -3416,14 +3304,6 @@ int J400ToARGB(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_J400TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
J400ToARGBRow = J400ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
J400ToARGBRow = J400ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_J400TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
J400ToARGBRow = J400ToARGBRow_Any_LSX;
|
||||
@ -3771,14 +3651,6 @@ int RGB24ToARGB(const uint8_t* src_rgb24,
|
||||
RGB24ToARGBRow = RGB24ToARGBRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGB24ToARGBRow = RGB24ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGB24ToARGBRow = RGB24ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB24TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGB24ToARGBRow = RGB24ToARGBRow_Any_LSX;
|
||||
@ -3864,14 +3736,6 @@ int RAWToARGB(const uint8_t* src_raw,
|
||||
RAWToARGBRow = RAWToARGBRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToARGBRow = RAWToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToARGBRow = RAWToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToARGBRow = RAWToARGBRow_Any_LSX;
|
||||
@ -4013,14 +3877,6 @@ int RGB565ToARGB(const uint8_t* src_rgb565,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB565TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGB565ToARGBRow = RGB565ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGB565ToARGBRow = RGB565ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGB565TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGB565ToARGBRow = RGB565ToARGBRow_Any_LSX;
|
||||
@ -4101,14 +3957,6 @@ int ARGB1555ToARGB(const uint8_t* src_argb1555,
|
||||
ARGB1555ToARGBRow = ARGB1555ToARGBRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB1555TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGB1555ToARGBRow = ARGB1555ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB1555TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGB1555ToARGBRow = ARGB1555ToARGBRow_Any_LSX;
|
||||
@ -4184,14 +4032,6 @@ int ARGB4444ToARGB(const uint8_t* src_argb4444,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB4444TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGB4444ToARGBRow = ARGB4444ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGB4444TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGB4444ToARGBRow = ARGB4444ToARGBRow_Any_LSX;
|
||||
@ -4500,14 +4340,6 @@ int NV12ToARGBMatrix(const uint8_t* src_y,
|
||||
NV12ToARGBRow = NV12ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_NV12TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
NV12ToARGBRow = NV12ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
NV12ToARGBRow = NV12ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_NV12TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
NV12ToARGBRow = NV12ToARGBRow_Any_LSX;
|
||||
@ -4600,14 +4432,6 @@ int NV21ToARGBMatrix(const uint8_t* src_y,
|
||||
NV21ToARGBRow = NV21ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_NV21TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
NV21ToARGBRow = NV21ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
NV21ToARGBRow = NV21ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_NV21TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
NV21ToARGBRow = NV21ToARGBRow_Any_LSX;
|
||||
@ -5028,14 +4852,6 @@ int YUY2ToARGBMatrix(const uint8_t* src_yuy2,
|
||||
YUY2ToARGBRow = YUY2ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
YUY2ToARGBRow = YUY2ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
YUY2ToARGBRow = YUY2ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
YUY2ToARGBRow = YUY2ToARGBRow_Any_LSX;
|
||||
@ -5126,14 +4942,6 @@ int UYVYToARGBMatrix(const uint8_t* src_uyvy,
|
||||
UYVYToARGBRow = UYVYToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
UYVYToARGBRow = UYVYToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
UYVYToARGBRow = UYVYToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
UYVYToARGBRow = UYVYToARGBRow_Any_LSX;
|
||||
@ -5343,14 +5151,6 @@ int I422ToRGBAMatrix(const uint8_t* src_y,
|
||||
I422ToRGBARow = I422ToRGBARow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGBAROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToRGBARow = I422ToRGBARow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToRGBARow = I422ToRGBARow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGBAROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToRGBARow = I422ToRGBARow_Any_LSX;
|
||||
@ -5468,14 +5268,6 @@ int NV12ToRGB565Matrix(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_NV12TORGB565ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
NV12ToRGB565Row = NV12ToRGB565Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
NV12ToRGB565Row = NV12ToRGB565Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_NV12TORGB565ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
NV12ToRGB565Row = NV12ToRGB565Row_Any_LSX;
|
||||
@ -5581,14 +5373,6 @@ int I420ToRGBAMatrix(const uint8_t* src_y,
|
||||
I422ToRGBARow = I422ToRGBARow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGBAROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToRGBARow = I422ToRGBARow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToRGBARow = I422ToRGBARow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGBAROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToRGBARow = I422ToRGBARow_Any_LSX;
|
||||
@ -5721,14 +5505,6 @@ int I420ToRGB24Matrix(const uint8_t* src_y,
|
||||
I422ToRGB24Row = I422ToRGB24Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB24ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToRGB24Row = I422ToRGB24Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
I422ToRGB24Row = I422ToRGB24Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB24ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToRGB24Row = I422ToRGB24Row_Any_LSX;
|
||||
@ -5933,14 +5709,6 @@ int I422ToRGB24Matrix(const uint8_t* src_y,
|
||||
I422ToRGB24Row = I422ToRGB24Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB24ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToRGB24Row = I422ToRGB24Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
I422ToRGB24Row = I422ToRGB24Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB24ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToRGB24Row = I422ToRGB24Row_Any_LSX;
|
||||
@ -6070,14 +5838,6 @@ int I420ToARGB1555(const uint8_t* src_y,
|
||||
I422ToARGB1555Row = I422ToARGB1555Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGB1555ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToARGB1555Row = I422ToARGB1555Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToARGB1555Row = I422ToARGB1555Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGB1555ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToARGB1555Row = I422ToARGB1555Row_Any_LSX;
|
||||
@ -6169,14 +5929,6 @@ int I420ToARGB4444(const uint8_t* src_y,
|
||||
I422ToARGB4444Row = I422ToARGB4444Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGB4444ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToARGB4444Row = I422ToARGB4444Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToARGB4444Row = I422ToARGB4444Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGB4444ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToARGB4444Row = I422ToARGB4444Row_Any_LSX;
|
||||
@ -6269,14 +6021,6 @@ int I420ToRGB565Matrix(const uint8_t* src_y,
|
||||
I422ToRGB565Row = I422ToRGB565Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB565ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToRGB565Row = I422ToRGB565Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToRGB565Row = I422ToRGB565Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB565ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToRGB565Row = I422ToRGB565Row_Any_LSX;
|
||||
@ -6419,14 +6163,6 @@ int I422ToRGB565Matrix(const uint8_t* src_y,
|
||||
I422ToRGB565Row = I422ToRGB565Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB565ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToRGB565Row = I422ToRGB565Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToRGB565Row = I422ToRGB565Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TORGB565ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToRGB565Row = I422ToRGB565Row_Any_LSX;
|
||||
@ -6552,14 +6288,6 @@ int I420ToRGB565Dither(const uint8_t* src_y,
|
||||
I422ToARGBRow = I422ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I422ToARGBRow = I422ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_LSX;
|
||||
@ -6610,14 +6338,6 @@ int I420ToRGB565Dither(const uint8_t* src_y,
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565DITHERROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_LSX;
|
||||
@ -6866,14 +6586,6 @@ static int I420ToARGBMatrixBilinear(const uint8_t* src_y,
|
||||
I444ToARGBRow = I444ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444ToARGBRow = I444ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444ToARGBRow = I444ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TOARGBROW_LASX)
|
||||
if (TestCpuFlag(kCpuHasLASX)) {
|
||||
I444ToARGBRow = I444ToARGBRow_Any_LASX;
|
||||
@ -7023,14 +6735,6 @@ static int I422ToARGBMatrixLinear(const uint8_t* src_y,
|
||||
I444ToARGBRow = I444ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444ToARGBRow = I444ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444ToARGBRow = I444ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TOARGBROW_LASX)
|
||||
if (TestCpuFlag(kCpuHasLASX)) {
|
||||
I444ToARGBRow = I444ToARGBRow_Any_LASX;
|
||||
@ -7157,14 +6861,6 @@ static int I420ToRGB24MatrixBilinear(const uint8_t* src_y,
|
||||
I444ToRGB24Row = I444ToRGB24Row_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TORGB24ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444ToRGB24Row = I444ToRGB24Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444ToRGB24Row = I444ToRGB24Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444TORGB24ROW_LASX)
|
||||
if (TestCpuFlag(kCpuHasLASX)) {
|
||||
I444ToRGB24Row = I444ToRGB24Row_Any_LASX;
|
||||
@ -7779,14 +7475,6 @@ static int I420AlphaToARGBMatrixBilinear(
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444ALPHATOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444ALPHATOARGBROW_LASX)
|
||||
if (TestCpuFlag(kCpuHasLASX)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_Any_LASX;
|
||||
@ -7824,14 +7512,6 @@ static int I420AlphaToARGBMatrixBilinear(
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -8015,14 +7695,6 @@ static int I422AlphaToARGBMatrixLinear(const uint8_t* src_y,
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444ALPHATOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I444ALPHATOARGBROW_LASX)
|
||||
if (TestCpuFlag(kCpuHasLASX)) {
|
||||
I444AlphaToARGBRow = I444AlphaToARGBRow_Any_LASX;
|
||||
@ -8060,14 +7732,6 @@ static int I422AlphaToARGBMatrixLinear(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -8240,14 +7904,6 @@ static int I010AlphaToARGBMatrixBilinear(
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
@ -8442,14 +8098,6 @@ static int I210AlphaToARGBMatrixLinear(const uint16_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_RVV;
|
||||
|
||||
@ -445,14 +445,6 @@ int I420ToYUY2(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOYUY2ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToYUY2Row = I422ToYUY2Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
I422ToYUY2Row = I422ToYUY2Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOYUY2ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToYUY2Row = I422ToYUY2Row_Any_LSX;
|
||||
@ -540,14 +532,6 @@ int I422ToUYVY(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOUYVYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOUYVYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_Any_LSX;
|
||||
@ -623,14 +607,6 @@ int I420ToUYVY(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOUYVYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOUYVYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_Any_LSX;
|
||||
|
||||
@ -84,14 +84,6 @@ int ARGBToI444(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUV444ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToUV444Row = ARGBToUV444Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToUV444Row = ARGBToUV444Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUV444ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToUV444Row = ARGBToUV444Row_Any_LSX;
|
||||
@ -140,14 +132,6 @@ int ARGBToI444(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -295,18 +279,6 @@ int ARGBToI422(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -459,18 +431,6 @@ int ARGBToNV12(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -531,14 +491,6 @@ int ARGBToNV12(const uint8_t* src_argb,
|
||||
MergeUVRow_ = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow_ = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_LSX;
|
||||
@ -686,18 +638,6 @@ int ARGBToNV21(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -768,14 +708,6 @@ int ARGBToNV21(const uint8_t* src_argb,
|
||||
MergeUVRow_ = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow_ = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_LSX;
|
||||
@ -922,18 +854,6 @@ int ABGRToNV12(const uint8_t* src_abgr,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ABGRToYRow = ABGRToYRow_Any_MSA;
|
||||
ABGRToUVRow = ABGRToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ABGRToYRow = ABGRToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ABGRToUVRow = ABGRToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ABGRToYRow = ABGRToYRow_Any_LSX;
|
||||
@ -992,14 +912,6 @@ int ABGRToNV12(const uint8_t* src_abgr,
|
||||
MergeUVRow_ = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow_ = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_LSX;
|
||||
@ -1147,18 +1059,6 @@ int ABGRToNV21(const uint8_t* src_abgr,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ABGRToYRow = ABGRToYRow_Any_MSA;
|
||||
ABGRToUVRow = ABGRToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ABGRToYRow = ABGRToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ABGRToUVRow = ABGRToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ABGRToYRow = ABGRToYRow_Any_LSX;
|
||||
@ -1217,14 +1117,6 @@ int ABGRToNV21(const uint8_t* src_abgr,
|
||||
MergeUVRow_ = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow_ = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_LSX;
|
||||
@ -1377,18 +1269,6 @@ int ARGBToYUY2(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -1446,14 +1326,6 @@ int ARGBToYUY2(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOYUY2ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToYUY2Row = I422ToYUY2Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
I422ToYUY2Row = I422ToYUY2Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOYUY2ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToYUY2Row = I422ToYUY2Row_Any_LSX;
|
||||
@ -1605,18 +1477,6 @@ int ARGBToUYVY(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA) && defined(HAS_ARGBTOUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
ARGBToUVRow = ARGBToUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVRow = ARGBToUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -1674,14 +1534,6 @@ int ARGBToUYVY(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOUYVYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOUYVYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToUYVYRow = I422ToUYVYRow_Any_LSX;
|
||||
@ -1777,14 +1629,6 @@ int ARGBToI400(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYRow = ARGBToYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYRow = ARGBToYRow_Any_LSX;
|
||||
@ -1935,14 +1779,6 @@ int ARGBToRGB24(const uint8_t* src_argb,
|
||||
ARGBToRGB24Row = ARGBToRGB24Row_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB24ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToRGB24Row = ARGBToRGB24Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToRGB24Row = ARGBToRGB24Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB24ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToRGB24Row = ARGBToRGB24Row_Any_LSX;
|
||||
@ -2027,14 +1863,6 @@ int ARGBToRAW(const uint8_t* src_argb,
|
||||
ARGBToRAWRow = ARGBToRAWRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORAWROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToRAWRow = ARGBToRAWRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToRAWRow = ARGBToRAWRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORAWROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToRAWRow = ARGBToRAWRow_Any_LSX;
|
||||
@ -2123,14 +1951,6 @@ int ARGBToRGB565Dither(const uint8_t* src_argb,
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565DITHERROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToRGB565DitherRow = ARGBToRGB565DitherRow_Any_LSX;
|
||||
@ -2213,14 +2033,6 @@ int ARGBToRGB565(const uint8_t* src_argb,
|
||||
ARGBToRGB565Row = ARGBToRGB565Row_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToRGB565Row = ARGBToRGB565Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBToRGB565Row = ARGBToRGB565Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToRGB565Row = ARGBToRGB565Row_Any_LSX;
|
||||
@ -2296,14 +2108,6 @@ int ARGBToARGB1555(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOARGB1555ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToARGB1555Row = ARGBToARGB1555Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBToARGB1555Row = ARGBToARGB1555Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOARGB1555ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToARGB1555Row = ARGBToARGB1555Row_Any_LSX;
|
||||
@ -2378,14 +2182,6 @@ int ARGBToARGB4444(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOARGB4444ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToARGB4444Row = ARGBToARGB4444Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBToARGB4444Row = ARGBToARGB4444Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOARGB4444ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToARGB4444Row = ARGBToARGB4444Row_Any_LSX;
|
||||
@ -2589,14 +2385,6 @@ int ARGBToJ444(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUVJ444ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToUVJ444Row = ARGBToUVJ444Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToUVJ444Row = ARGBToUVJ444Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOUVJ444ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToUVJ444Row = ARGBToUVJ444Row_Any_LSX;
|
||||
@ -2645,14 +2433,6 @@ int ARGBToJ444(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYJRow = ARGBToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_LSX;
|
||||
@ -2793,18 +2573,6 @@ int ARGBToJ420(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_MSA) && defined(HAS_ARGBTOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_MSA;
|
||||
ARGBToUVJRow = ARGBToUVJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYJRow = ARGBToYJRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVJRow = ARGBToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_LSX) && defined(HAS_ARGBTOUVJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_LSX;
|
||||
@ -2961,18 +2729,6 @@ int ARGBToJ422(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_MSA) && defined(HAS_ARGBTOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_MSA;
|
||||
ARGBToUVJRow = ARGBToUVJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYJRow = ARGBToYJRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ARGBToUVJRow = ARGBToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_LSX) && defined(HAS_ARGBTOUVJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_LSX;
|
||||
@ -3067,14 +2823,6 @@ int ARGBToJ400(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYJRow = ARGBToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV)) {
|
||||
ARGBToYJRow = ARGBToYJRow_RVV;
|
||||
@ -3146,14 +2894,6 @@ int RGBAToJ400(const uint8_t* src_rgba,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGBATOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RGBAToYJRow = RGBAToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RGBAToYJRow = RGBAToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RGBATOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RGBAToYJRow = RGBAToYJRow_Any_LSX;
|
||||
@ -3291,16 +3031,6 @@ int ABGRToJ420(const uint8_t* src_abgr,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYJROW_MSA) && defined(HAS_ABGRTOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ABGRToYJRow = ABGRToYJRow_Any_MSA;
|
||||
ABGRToUVJRow = ABGRToUVJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ABGRToYJRow = ABGRToYJRow_MSA;
|
||||
ABGRToUVJRow = ABGRToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ABGRToYJRow = ABGRToYJRow_Any_LSX;
|
||||
@ -3453,18 +3183,6 @@ int ABGRToJ422(const uint8_t* src_abgr,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYJROW_MSA) && defined(HAS_ABGRTOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ABGRToYJRow = ABGRToYJRow_Any_MSA;
|
||||
ABGRToUVJRow = ABGRToUVJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ABGRToYJRow = ABGRToYJRow_MSA;
|
||||
}
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
ABGRToUVJRow = ABGRToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ABGRToYJRow = ABGRToYJRow_Any_LSX;
|
||||
@ -3555,14 +3273,6 @@ int ABGRToJ400(const uint8_t* src_abgr,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ABGRToYJRow = ABGRToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ABGRToYJRow = ABGRToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ABGRTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ABGRToYJRow = ABGRToYJRow_Any_LSX;
|
||||
@ -3722,8 +3432,7 @@ int ARGBToAB64(const uint8_t* src_argb,
|
||||
}
|
||||
|
||||
// Enabled if 1 pass is available
|
||||
#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_MSA) || \
|
||||
defined(HAS_RAWTOYJROW_RVV)
|
||||
#if defined(HAS_RAWTOYJROW_NEON) || defined(HAS_RAWTOYJROW_RVV)
|
||||
#define HAS_RAWTOYJROW
|
||||
#endif
|
||||
|
||||
@ -3779,16 +3488,6 @@ int RAWToJNV21(const uint8_t* src_raw,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYJROW_MSA) && defined(HAS_RAWTOUVJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToUVJRow = RAWToUVJRow_Any_MSA;
|
||||
RAWToYJRow = RAWToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToYJRow = RAWToYJRow_MSA;
|
||||
RAWToUVJRow = RAWToUVJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToYJRow = RAWToYJRow_Any_LSX;
|
||||
@ -3900,14 +3599,6 @@ int RAWToJNV21(const uint8_t* src_raw,
|
||||
MergeUVRow_ = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(halfwidth, 16)) {
|
||||
MergeUVRow_ = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow_ = MergeUVRow_Any_LSX;
|
||||
|
||||
@ -631,14 +631,6 @@ void SplitUVPlane(const uint8_t* src_uv,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SPLITUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SplitUVRow = SplitUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
SplitUVRow = SplitUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SPLITUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
SplitUVRow = SplitUVRow_Any_LSX;
|
||||
@ -727,14 +719,6 @@ void MergeUVPlane(const uint8_t* src_u,
|
||||
MergeUVRow = MergeUVRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MergeUVRow = MergeUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
MergeUVRow = MergeUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MERGEUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MergeUVRow = MergeUVRow_Any_LSX;
|
||||
@ -2251,16 +2235,6 @@ int YUY2ToI422(const uint8_t* src_yuy2,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUV422ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_MSA;
|
||||
YUY2ToUV422Row = YUY2ToUV422Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
YUY2ToYRow = YUY2ToYRow_MSA;
|
||||
YUY2ToUV422Row = YUY2ToUV422Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_LSX) && defined(HAS_YUY2TOUV422ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_LSX;
|
||||
@ -2357,16 +2331,6 @@ int UYVYToI422(const uint8_t* src_uyvy,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOYROW_MSA) && defined(HAS_UYVYTOUV422ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
UYVYToYRow = UYVYToYRow_Any_MSA;
|
||||
UYVYToUV422Row = UYVYToUV422Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
UYVYToYRow = UYVYToYRow_MSA;
|
||||
UYVYToUV422Row = UYVYToUV422Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOYROW_LSX) && defined(HAS_UYVYTOUV422ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
UYVYToYRow = UYVYToYRow_Any_LSX;
|
||||
@ -2449,14 +2413,6 @@ int YUY2ToY(const uint8_t* src_yuy2,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
YUY2ToYRow = YUY2ToYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
for (y = 0; y < height; ++y) {
|
||||
YUY2ToYRow(src_yuy2, dst_y, width);
|
||||
@ -2516,14 +2472,6 @@ int UYVYToY(const uint8_t* src_uyvy,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
UYVYToYRow = UYVYToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
UYVYToYRow = UYVYToYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_UYVYTOYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
UYVYToYRow = UYVYToYRow_Any_LSX;
|
||||
@ -2582,14 +2530,6 @@ void MirrorPlane(const uint8_t* src_y,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MirrorRow = MirrorRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 64)) {
|
||||
MirrorRow = MirrorRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MirrorRow = MirrorRow_Any_LSX;
|
||||
@ -2656,14 +2596,6 @@ void MirrorUVPlane(const uint8_t* src_uv,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MirrorUVRow = MirrorUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
MirrorUVRow = MirrorUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MirrorUVRow = MirrorUVRow_Any_LSX;
|
||||
@ -2836,14 +2768,6 @@ int ARGBMirror(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBMIRRORROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBMirrorRow = ARGBMirrorRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBMirrorRow = ARGBMirrorRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBMIRRORROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBMirrorRow = ARGBMirrorRow_Any_LSX;
|
||||
@ -2955,11 +2879,6 @@ int ARGBBlend(const uint8_t* src_argb0,
|
||||
ARGBBlendRow = ARGBBlendRow_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBBLENDROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBBlendRow = ARGBBlendRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBBLENDROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBBlendRow = ARGBBlendRow_LSX;
|
||||
@ -3241,14 +3160,6 @@ int ARGBMultiply(const uint8_t* src_argb0,
|
||||
ARGBMultiplyRow = ARGBMultiplyRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBMULTIPLYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBMultiplyRow = ARGBMultiplyRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 4)) {
|
||||
ARGBMultiplyRow = ARGBMultiplyRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBMULTIPLYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBMultiplyRow = ARGBMultiplyRow_Any_LSX;
|
||||
@ -3334,14 +3245,6 @@ int ARGBAdd(const uint8_t* src_argb0,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBADDROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAddRow = ARGBAddRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAddRow = ARGBAddRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBADDROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBAddRow = ARGBAddRow_Any_LSX;
|
||||
@ -3422,14 +3325,6 @@ int ARGBSubtract(const uint8_t* src_argb0,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSUBTRACTROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBSubtractRow = ARGBSubtractRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBSubtractRow = ARGBSubtractRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSUBTRACTROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBSubtractRow = ARGBSubtractRow_Any_LSX;
|
||||
@ -3504,14 +3399,6 @@ int RAWToRGB24(const uint8_t* src_raw,
|
||||
RAWToRGB24Row = RAWToRGB24Row_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTORGB24ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
RAWToRGB24Row = RAWToRGB24Row_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
RAWToRGB24Row = RAWToRGB24Row_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_RAWTORGB24ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
RAWToRGB24Row = RAWToRGB24Row_Any_LSX;
|
||||
@ -3579,11 +3466,6 @@ void SetPlane(uint8_t* dst_y,
|
||||
SetRow = SetRow_ERMS;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SETROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 16)) {
|
||||
SetRow = SetRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SETROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
SetRow = SetRow_Any_LSX;
|
||||
@ -3674,14 +3556,6 @@ int ARGBRect(uint8_t* dst_argb,
|
||||
ARGBSetRow = ARGBSetRow_X86;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSETROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBSetRow = ARGBSetRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 4)) {
|
||||
ARGBSetRow = ARGBSetRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSETROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBSetRow = ARGBSetRow_Any_LSX;
|
||||
@ -3760,14 +3634,6 @@ int ARGBAttenuate(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBATTENUATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBAttenuateRow = ARGBAttenuateRow_Any_LSX;
|
||||
@ -3889,11 +3755,6 @@ int ARGBGrayTo(const uint8_t* src_argb,
|
||||
ARGBGrayRow = ARGBGrayRow_NEON_DotProd;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBGRAYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
|
||||
ARGBGrayRow = ARGBGrayRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBGRAYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
|
||||
ARGBGrayRow = ARGBGrayRow_LSX;
|
||||
@ -3949,11 +3810,6 @@ int ARGBGray(uint8_t* dst_argb,
|
||||
ARGBGrayRow = ARGBGrayRow_NEON_DotProd;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBGRAYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
|
||||
ARGBGrayRow = ARGBGrayRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBGRAYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
|
||||
ARGBGrayRow = ARGBGrayRow_LSX;
|
||||
@ -4007,11 +3863,6 @@ int ARGBSepia(uint8_t* dst_argb,
|
||||
ARGBSepiaRow = ARGBSepiaRow_NEON_DotProd;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSEPIAROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
|
||||
ARGBSepiaRow = ARGBSepiaRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSEPIAROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
|
||||
ARGBSepiaRow = ARGBSepiaRow_LSX;
|
||||
@ -4073,11 +3924,6 @@ int ARGBColorMatrix(const uint8_t* src_argb,
|
||||
ARGBColorMatrixRow = ARGBColorMatrixRow_NEON_I8MM;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBCOLORMATRIXROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
|
||||
ARGBColorMatrixRow = ARGBColorMatrixRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBCOLORMATRIXROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
|
||||
ARGBColorMatrixRow = ARGBColorMatrixRow_LSX;
|
||||
@ -4243,11 +4089,6 @@ int ARGBQuantize(uint8_t* dst_argb,
|
||||
ARGBQuantizeRow = ARGBQuantizeRow_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBQUANTIZEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 8)) {
|
||||
ARGBQuantizeRow = ARGBQuantizeRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBQUANTIZEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 8)) {
|
||||
ARGBQuantizeRow = ARGBQuantizeRow_LSX;
|
||||
@ -4442,11 +4283,6 @@ int ARGBShade(const uint8_t* src_argb,
|
||||
ARGBShadeRow = ARGBShadeRow_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSHADEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 4)) {
|
||||
ARGBShadeRow = ARGBShadeRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSHADEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 4)) {
|
||||
ARGBShadeRow = ARGBShadeRow_LSX;
|
||||
@ -4525,14 +4361,6 @@ int InterpolatePlane(const uint8_t* src0,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -4615,14 +4443,6 @@ int InterpolatePlane_16(const uint16_t* src0,
|
||||
InterpolateRow_16 = InterpolateRow_16_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_16_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow_16 = InterpolateRow_16_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
InterpolateRow_16 = InterpolateRow_16_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_16_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow_16 = InterpolateRow_16_Any_LSX;
|
||||
@ -4748,14 +4568,6 @@ int ARGBShuffle(const uint8_t* src_bgra,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSHUFFLEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBShuffleRow = ARGBShuffleRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
ARGBShuffleRow = ARGBShuffleRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBSHUFFLEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBShuffleRow = ARGBShuffleRow_Any_LSX;
|
||||
@ -4973,14 +4785,6 @@ static int ARGBSobelize(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBToYJRow = ARGBToYJRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBTOYJROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBToYJRow = ARGBToYJRow_Any_LSX;
|
||||
@ -5013,11 +4817,6 @@ static int ARGBSobelize(const uint8_t* src_argb,
|
||||
SobelYRow = SobelYRow_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SobelYRow = SobelYRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELXROW_SSE2)
|
||||
if (TestCpuFlag(kCpuHasSSE2)) {
|
||||
SobelXRow = SobelXRow_SSE2;
|
||||
@ -5027,11 +4826,6 @@ static int ARGBSobelize(const uint8_t* src_argb,
|
||||
if (TestCpuFlag(kCpuHasNEON)) {
|
||||
SobelXRow = SobelXRow_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELXROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SobelXRow = SobelXRow_MSA;
|
||||
}
|
||||
#endif
|
||||
{
|
||||
// 3 rows with edges before/after.
|
||||
@ -5109,14 +4903,6 @@ int ARGBSobel(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SobelRow = SobelRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
SobelRow = SobelRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
SobelRow = SobelRow_Any_LSX;
|
||||
@ -5155,14 +4941,6 @@ int ARGBSobelToPlane(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELTOPLANEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SobelToPlaneRow = SobelToPlaneRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
SobelToPlaneRow = SobelToPlaneRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELTOPLANEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
SobelToPlaneRow = SobelToPlaneRow_Any_LSX;
|
||||
@ -5202,14 +4980,6 @@ int ARGBSobelXY(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELXYROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SobelXYRow = SobelXYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
SobelXYRow = SobelXYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SOBELXYROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
SobelXYRow = SobelXYRow_Any_LSX;
|
||||
@ -5345,14 +5115,6 @@ int HalfFloatPlane(const uint16_t* src_y,
|
||||
HalfFloatRow = scale == 1.0f ? HalfFloat1Row_SVE2 : HalfFloatRow_SVE2;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_HALFFLOATROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
HalfFloatRow = HalfFloatRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
HalfFloatRow = HalfFloatRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_HALFFLOATROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
HalfFloatRow = HalfFloatRow_Any_LSX;
|
||||
@ -5527,12 +5289,6 @@ int ARGBExtractAlpha(const uint8_t* src_argb,
|
||||
: ARGBExtractAlphaRow_Any_NEON;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBEXTRACTALPHAROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_MSA
|
||||
: ARGBExtractAlphaRow_Any_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBEXTRACTALPHAROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBExtractAlphaRow = IS_ALIGNED(width, 16) ? ARGBExtractAlphaRow_LSX
|
||||
@ -5657,14 +5413,6 @@ int YUY2ToNV12(const uint8_t* src_yuy2,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_MSA) && defined(HAS_YUY2TOUV422ROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
YUY2ToYRow = YUY2ToYRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOYROW_LSX) && defined(HAS_YUY2TOUV422ROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
YUY2ToYRow = YUY2ToYRow_Any_LSX;
|
||||
@ -5773,14 +5521,6 @@ int UYVYToNV12(const uint8_t* src_uyvy,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SPLITUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
SplitUVRow = SplitUVRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
SplitUVRow = SplitUVRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SPLITUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
SplitUVRow = SplitUVRow_Any_LSX;
|
||||
@ -5824,14 +5564,6 @@ int UYVYToNV12(const uint8_t* src_uyvy,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
|
||||
@ -35,8 +35,7 @@ void TransposePlane(const uint8_t* src,
|
||||
void (*TransposeWxH)(const uint8_t* src, int src_stride, uint8_t* dst,
|
||||
int dst_stride, int width, int height) = NULL;
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEWX16_MSA) || defined(HAS_TRANSPOSEWX16_LSX) || \
|
||||
defined(HAS_TRANSPOSEWX16_NEON)
|
||||
#if defined(HAS_TRANSPOSEWX16_LSX) || defined(HAS_TRANSPOSEWX16_NEON)
|
||||
void (*TransposeWx16)(const uint8_t* src, int src_stride, uint8_t* dst,
|
||||
int dst_stride, int width) = TransposeWx16_C;
|
||||
#else
|
||||
@ -81,14 +80,6 @@ void TransposePlane(const uint8_t* src,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEWX16_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
TransposeWx16 = TransposeWx16_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
TransposeWx16 = TransposeWx16_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEWX16_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
TransposeWx16 = TransposeWx16_Any_LSX;
|
||||
@ -104,8 +95,7 @@ void TransposePlane(const uint8_t* src,
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEWX16_MSA) || defined(HAS_TRANSPOSEWX16_LSX) || \
|
||||
defined(HAS_TRANSPOSEWX16_NEON)
|
||||
#if defined(HAS_TRANSPOSEWX16_LSX) || defined(HAS_TRANSPOSEWX16_NEON)
|
||||
// Work across the source in 16x16 tiles
|
||||
while (i >= 16) {
|
||||
TransposeWx16(src, src_stride, dst, dst_stride, width);
|
||||
@ -200,14 +190,6 @@ void RotatePlane180(const uint8_t* src,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
MirrorRow = MirrorRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 64)) {
|
||||
MirrorRow = MirrorRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
MirrorRow = MirrorRow_Any_LSX;
|
||||
@ -288,11 +270,7 @@ void SplitTransposeUV(const uint8_t* src,
|
||||
int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
|
||||
int width, int height) = TransposeUVWxH_C;
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEUVWX16_MSA)
|
||||
void (*TransposeUVWx16)(const uint8_t* src, int src_stride, uint8_t* dst_a,
|
||||
int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
|
||||
int width) = TransposeUVWx16_C;
|
||||
#elif defined(HAS_TRANSPOSEUVWX16_LSX)
|
||||
#if defined(HAS_TRANSPOSEUVWX16_LSX)
|
||||
void (*TransposeUVWx16)(const uint8_t* src, int src_stride, uint8_t* dst_a,
|
||||
int dst_stride_a, uint8_t* dst_b, int dst_stride_b,
|
||||
int width) = TransposeUVWx16_C;
|
||||
@ -302,21 +280,14 @@ void SplitTransposeUV(const uint8_t* src,
|
||||
int width) = TransposeUVWx8_C;
|
||||
#endif
|
||||
|
||||
#if defined(HAS_TRANSPOSEUVWX16_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
TransposeUVWx16 = TransposeUVWx16_Any_MSA;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
TransposeUVWx16 = TransposeUVWx16_MSA;
|
||||
}
|
||||
}
|
||||
#elif defined(HAS_TRANSPOSEUVWX16_LSX)
|
||||
#if defined(HAS_TRANSPOSEUVWX16_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
TransposeUVWx16 = TransposeUVWx16_Any_LSX;
|
||||
if (IS_ALIGNED(width, 8)) {
|
||||
TransposeUVWx16 = TransposeUVWx16_LSX;
|
||||
}
|
||||
}
|
||||
#else
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEUVWX8_NEON)
|
||||
if (TestCpuFlag(kCpuHasNEON)) {
|
||||
TransposeUVWx8 = TransposeUVWx8_Any_NEON;
|
||||
@ -338,7 +309,6 @@ void SplitTransposeUV(const uint8_t* src,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif /* defined(HAS_TRANSPOSEUVWX16_MSA) */
|
||||
|
||||
#if defined(HAS_TRANSPOSEUVWXH_SME)
|
||||
if (TestCpuFlag(kCpuHasSME)) {
|
||||
@ -347,17 +317,7 @@ void SplitTransposeUV(const uint8_t* src,
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_TRANSPOSEUVWX16_MSA)
|
||||
// Work through the source in 8x8 tiles.
|
||||
while (i >= 16) {
|
||||
TransposeUVWx16(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
|
||||
width);
|
||||
src += 16 * src_stride; // Go down 16 rows.
|
||||
dst_a += 16; // Move over 8 columns.
|
||||
dst_b += 16; // Move over 8 columns.
|
||||
i -= 16;
|
||||
}
|
||||
#elif defined(HAS_TRANSPOSEUVWX16_LSX)
|
||||
#if defined(HAS_TRANSPOSEUVWX16_LSX)
|
||||
// Work through the source in 8x8 tiles.
|
||||
while (i >= 16) {
|
||||
TransposeUVWx16(src, src_stride, dst_a, dst_stride_a, dst_b, dst_stride_b,
|
||||
@ -442,11 +402,6 @@ void SplitRotateUV180(const uint8_t* src,
|
||||
MirrorSplitUVRow = MirrorSplitUVRow_SSSE3;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORSPLITUVROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && IS_ALIGNED(width, 32)) {
|
||||
MirrorSplitUVRow = MirrorSplitUVRow_MSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_MIRRORSPLITUVROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && IS_ALIGNED(width, 32)) {
|
||||
MirrorSplitUVRow = MirrorSplitUVRow_LSX;
|
||||
|
||||
@ -53,14 +53,6 @@ static int ARGBTranspose(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBROWDOWNEVEN_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_MSA;
|
||||
if (IS_ALIGNED(height, 4)) { // Width of dest.
|
||||
ScaleARGBRowDownEven = ScaleARGBRowDownEven_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBROWDOWNEVEN_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBRowDownEven = ScaleARGBRowDownEven_Any_LSX;
|
||||
@ -155,14 +147,6 @@ static int ARGBRotate180(const uint8_t* src_argb,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBMIRRORROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ARGBMirrorRow = ARGBMirrorRow_Any_MSA;
|
||||
if (IS_ALIGNED(width, 16)) {
|
||||
ARGBMirrorRow = ARGBMirrorRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_ARGBMIRRORROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ARGBMirrorRow = ARGBMirrorRow_Any_LSX;
|
||||
|
||||
@ -1074,14 +1074,6 @@ ANY11(ARGBToARGB1555Row_Any_NEON, ARGBToARGB1555Row_NEON, 0, 4, 2, 7)
|
||||
ANY11(ARGBToARGB4444Row_Any_NEON, ARGBToARGB4444Row_NEON, 0, 4, 2, 7)
|
||||
ANY11(J400ToARGBRow_Any_NEON, J400ToARGBRow_NEON, 0, 1, 4, 7)
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB24ROW_MSA)
|
||||
ANY11(ARGBToRGB24Row_Any_MSA, ARGBToRGB24Row_MSA, 0, 4, 3, 15)
|
||||
ANY11(ARGBToRAWRow_Any_MSA, ARGBToRAWRow_MSA, 0, 4, 3, 15)
|
||||
ANY11(ARGBToRGB565Row_Any_MSA, ARGBToRGB565Row_MSA, 0, 4, 2, 7)
|
||||
ANY11(ARGBToARGB1555Row_Any_MSA, ARGBToARGB1555Row_MSA, 0, 4, 2, 7)
|
||||
ANY11(ARGBToARGB4444Row_Any_MSA, ARGBToARGB4444Row_MSA, 0, 4, 2, 7)
|
||||
ANY11(J400ToARGBRow_Any_MSA, J400ToARGBRow_MSA, 0, 1, 4, 15)
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB24ROW_LSX)
|
||||
ANY11(ARGBToRGB24Row_Any_LSX, ARGBToRGB24Row_LSX, 0, 4, 3, 15)
|
||||
ANY11(ARGBToRAWRow_Any_LSX, ARGBToRAWRow_LSX, 0, 4, 3, 15)
|
||||
@ -1102,9 +1094,6 @@ ANY11(J400ToARGBRow_Any_LSX, J400ToARGBRow_LSX, 0, 1, 4, 15)
|
||||
#if defined(HAS_RAWTORGB24ROW_NEON)
|
||||
ANY11(RAWToRGB24Row_Any_NEON, RAWToRGB24Row_NEON, 0, 3, 3, 7)
|
||||
#endif
|
||||
#if defined(HAS_RAWTORGB24ROW_MSA)
|
||||
ANY11(RAWToRGB24Row_Any_MSA, RAWToRGB24Row_MSA, 0, 3, 3, 15)
|
||||
#endif
|
||||
#if defined(HAS_RAWTORGB24ROW_LSX)
|
||||
ANY11(RAWToRGB24Row_Any_LSX, RAWToRGB24Row_LSX, 0, 3, 3, 15)
|
||||
#endif
|
||||
@ -1552,14 +1541,6 @@ ANY11P(I400ToARGBRow_Any_NEON,
|
||||
4,
|
||||
7)
|
||||
#endif
|
||||
#if defined(HAS_I400TOARGBROW_MSA)
|
||||
ANY11P(I400ToARGBRow_Any_MSA,
|
||||
I400ToARGBRow_MSA,
|
||||
const struct YuvConstants*,
|
||||
1,
|
||||
4,
|
||||
15)
|
||||
#endif
|
||||
#if defined(HAS_I400TOARGBROW_LSX)
|
||||
ANY11P(I400ToARGBRow_Any_LSX,
|
||||
I400ToARGBRow_LSX,
|
||||
@ -1593,14 +1574,6 @@ ANY11P(ARGBToRGB565DitherRow_Any_NEON,
|
||||
2,
|
||||
7)
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565DITHERROW_MSA)
|
||||
ANY11P(ARGBToRGB565DitherRow_Any_MSA,
|
||||
ARGBToRGB565DitherRow_MSA,
|
||||
const uint32_t,
|
||||
4,
|
||||
2,
|
||||
7)
|
||||
#endif
|
||||
#if defined(HAS_ARGBTORGB565DITHERROW_LSX)
|
||||
ANY11P(ARGBToRGB565DitherRow_Any_LSX,
|
||||
ARGBToRGB565DitherRow_LSX,
|
||||
@ -1926,10 +1899,6 @@ ANY11C(UYVYToARGBRow_Any_AVX2, UYVYToARGBRow_AVX2, 1, 4, 4, 31)
|
||||
ANY11C(YUY2ToARGBRow_Any_NEON, YUY2ToARGBRow_NEON, 1, 4, 4, 7)
|
||||
ANY11C(UYVYToARGBRow_Any_NEON, UYVYToARGBRow_NEON, 1, 4, 4, 7)
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOARGBROW_MSA)
|
||||
ANY11C(YUY2ToARGBRow_Any_MSA, YUY2ToARGBRow_MSA, 1, 4, 4, 7)
|
||||
ANY11C(UYVYToARGBRow_Any_MSA, UYVYToARGBRow_MSA, 1, 4, 4, 7)
|
||||
#endif
|
||||
#if defined(HAS_YUY2TOARGBROW_LSX)
|
||||
ANY11C(YUY2ToARGBRow_Any_LSX, YUY2ToARGBRow_LSX, 1, 4, 4, 7)
|
||||
ANY11C(UYVYToARGBRow_Any_LSX, UYVYToARGBRow_LSX, 1, 4, 4, 7)
|
||||
|
||||
@ -112,21 +112,6 @@ static void ScalePlaneDown2(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEROWDOWN2_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleRowDown2 =
|
||||
filtering == kFilterNone
|
||||
? ScaleRowDown2_Any_MSA
|
||||
: (filtering == kFilterLinear ? ScaleRowDown2Linear_Any_MSA
|
||||
: ScaleRowDown2Box_Any_MSA);
|
||||
if (IS_ALIGNED(dst_width, 32)) {
|
||||
ScaleRowDown2 = filtering == kFilterNone ? ScaleRowDown2_MSA
|
||||
: (filtering == kFilterLinear
|
||||
? ScaleRowDown2Linear_MSA
|
||||
: ScaleRowDown2Box_MSA);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEROWDOWN2_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleRowDown2 =
|
||||
@ -317,15 +302,6 @@ static void ScalePlaneDown4(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEROWDOWN4_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleRowDown4 =
|
||||
filtering ? ScaleRowDown4Box_Any_MSA : ScaleRowDown4_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 16)) {
|
||||
ScaleRowDown4 = filtering ? ScaleRowDown4Box_MSA : ScaleRowDown4_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEROWDOWN4_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleRowDown4 =
|
||||
@ -694,26 +670,6 @@ static void ScalePlaneDown38(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEROWDOWN38_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
if (!filtering) {
|
||||
ScaleRowDown38_3 = ScaleRowDown38_Any_MSA;
|
||||
ScaleRowDown38_2 = ScaleRowDown38_Any_MSA;
|
||||
} else {
|
||||
ScaleRowDown38_3 = ScaleRowDown38_3_Box_Any_MSA;
|
||||
ScaleRowDown38_2 = ScaleRowDown38_2_Box_Any_MSA;
|
||||
}
|
||||
if (dst_width % 12 == 0) {
|
||||
if (!filtering) {
|
||||
ScaleRowDown38_3 = ScaleRowDown38_MSA;
|
||||
ScaleRowDown38_2 = ScaleRowDown38_MSA;
|
||||
} else {
|
||||
ScaleRowDown38_3 = ScaleRowDown38_3_Box_MSA;
|
||||
ScaleRowDown38_2 = ScaleRowDown38_2_Box_MSA;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEROWDOWN38_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
if (!filtering) {
|
||||
@ -1015,14 +971,6 @@ static int ScalePlaneBox(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEADDROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleAddRow = ScaleAddRow_Any_MSA;
|
||||
if (IS_ALIGNED(src_width, 16)) {
|
||||
ScaleAddRow = ScaleAddRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEADDROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleAddRow = ScaleAddRow_Any_LSX;
|
||||
@ -1178,14 +1126,6 @@ static int ScalePlaneBilinearDown(int src_width,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(src_width, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -1213,14 +1153,6 @@ static int ScalePlaneBilinearDown(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEFILTERCOLS_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA) && src_width < 32768) {
|
||||
ScaleFilterCols = ScaleFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 16)) {
|
||||
ScaleFilterCols = ScaleFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEFILTERCOLS_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX) && src_width < 32768) {
|
||||
ScaleFilterCols = ScaleFilterCols_Any_LSX;
|
||||
@ -1430,14 +1362,6 @@ static int ScalePlaneBilinearUp(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEFILTERCOLS_MSA)
|
||||
if (filtering && TestCpuFlag(kCpuHasMSA) && src_width < 32768) {
|
||||
ScaleFilterCols = ScaleFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 16)) {
|
||||
ScaleFilterCols = ScaleFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEFILTERCOLS_LSX)
|
||||
if (filtering && TestCpuFlag(kCpuHasLSX) && src_width < 32768) {
|
||||
ScaleFilterCols = ScaleFilterCols_Any_LSX;
|
||||
|
||||
@ -107,22 +107,6 @@ static void ScaleARGBDown2(int src_width,
|
||||
: ScaleARGBRowDown2Box_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBROWDOWN2_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBRowDown2 =
|
||||
filtering == kFilterNone
|
||||
? ScaleARGBRowDown2_Any_MSA
|
||||
: (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_MSA
|
||||
: ScaleARGBRowDown2Box_Any_MSA);
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleARGBRowDown2 =
|
||||
filtering == kFilterNone
|
||||
? ScaleARGBRowDown2_MSA
|
||||
: (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_MSA
|
||||
: ScaleARGBRowDown2Box_MSA);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBROWDOWN2_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBRowDown2 =
|
||||
@ -282,16 +266,6 @@ static void ScaleARGBDownEven(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBROWDOWNEVEN_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_MSA
|
||||
: ScaleARGBRowDownEven_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleARGBRowDownEven =
|
||||
filtering ? ScaleARGBRowDownEvenBox_MSA : ScaleARGBRowDownEven_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBROWDOWNEVEN_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_LSX
|
||||
@ -386,14 +360,6 @@ static int ScaleARGBBilinearDown(int src_width,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(clip_src_width, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -420,14 +386,6 @@ static int ScaleARGBBilinearDown(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBFILTERCOLS_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
|
||||
@ -525,14 +483,6 @@ static int ScaleARGBBilinearUp(int src_width,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -563,14 +513,6 @@ static int ScaleARGBBilinearUp(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
|
||||
if (filtering && TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBFILTERCOLS_LSX)
|
||||
if (filtering && TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
|
||||
@ -597,14 +539,6 @@ static int ScaleARGBBilinearUp(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBCOLS_MSA)
|
||||
if (!filtering && TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBFilterCols = ScaleARGBCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleARGBFilterCols = ScaleARGBCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBCOLS_LSX)
|
||||
if (!filtering && TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBFilterCols = ScaleARGBCols_Any_LSX;
|
||||
@ -747,14 +681,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
|
||||
I422ToARGBRow = I422ToARGBRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_MSA;
|
||||
if (IS_ALIGNED(src_width, 8)) {
|
||||
I422ToARGBRow = I422ToARGBRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_I422TOARGBROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
I422ToARGBRow = I422ToARGBRow_Any_LSX;
|
||||
@ -809,14 +735,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -851,14 +769,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBFILTERCOLS_MSA)
|
||||
if (filtering && TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBFILTERCOLS_LSX)
|
||||
if (filtering && TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_LSX;
|
||||
@ -885,14 +795,6 @@ static int ScaleYUVToARGBBilinearUp(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBCOLS_MSA)
|
||||
if (!filtering && TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBFilterCols = ScaleARGBCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleARGBFilterCols = ScaleARGBCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBCOLS_LSX)
|
||||
if (!filtering && TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBFilterCols = ScaleARGBCols_Any_LSX;
|
||||
@ -1025,14 +927,6 @@ static void ScaleARGBSimple(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBCOLS_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleARGBCols = ScaleARGBCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleARGBCols = ScaleARGBCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEARGBCOLS_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
ScaleARGBCols = ScaleARGBCols_Any_LSX;
|
||||
|
||||
@ -1667,14 +1667,6 @@ void ScalePlaneVertical(int src_height,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width_bytes, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
|
||||
@ -155,23 +155,6 @@ static void ScaleUVDown2(int src_width,
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(HAS_SCALEUVROWDOWN2_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleUVRowDown2 =
|
||||
filtering == kFilterNone
|
||||
? ScaleUVRowDown2_Any_MSA
|
||||
: (filtering == kFilterLinear ? ScaleUVRowDown2Linear_Any_MSA
|
||||
: ScaleUVRowDown2Box_Any_MSA);
|
||||
if (IS_ALIGNED(dst_width, 2)) {
|
||||
ScaleUVRowDown2 =
|
||||
filtering == kFilterNone
|
||||
? ScaleUVRowDown2_MSA
|
||||
: (filtering == kFilterLinear ? ScaleUVRowDown2Linear_MSA
|
||||
: ScaleUVRowDown2Box_MSA);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (filtering == kFilterLinear) {
|
||||
src_stride = 0;
|
||||
}
|
||||
@ -321,16 +304,6 @@ static void ScaleUVDownEven(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVROWDOWNEVEN_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleUVRowDownEven =
|
||||
filtering ? ScaleUVRowDownEvenBox_Any_MSA : ScaleUVRowDownEven_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleUVRowDownEven =
|
||||
filtering ? ScaleUVRowDownEvenBox_MSA : ScaleUVRowDownEven_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVROWDOWNEVEN_RVV) || defined(HAS_SCALEUVROWDOWN4_RVV)
|
||||
if (TestCpuFlag(kCpuHasRVV) && !filtering) {
|
||||
#if defined(HAS_SCALEUVROWDOWNEVEN_RVV)
|
||||
@ -419,14 +392,6 @@ static int ScaleUVBilinearDown(int src_width,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(clip_src_width, 32)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -452,14 +417,6 @@ static int ScaleUVBilinearDown(int src_width,
|
||||
ScaleUVFilterCols = ScaleUVFilterCols_NEON;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVFILTERCOLS_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleUVFilterCols = ScaleUVFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
ScaleUVFilterCols = ScaleUVFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
// TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
|
||||
// Allocate a row of UV.
|
||||
@ -545,14 +502,6 @@ static int ScaleUVBilinearUp(int src_width,
|
||||
InterpolateRow = InterpolateRow_SME;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
InterpolateRow = InterpolateRow_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 16)) {
|
||||
InterpolateRow = InterpolateRow_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_INTERPOLATEROW_LSX)
|
||||
if (TestCpuFlag(kCpuHasLSX)) {
|
||||
InterpolateRow = InterpolateRow_Any_LSX;
|
||||
@ -582,14 +531,6 @@ static int ScaleUVBilinearUp(int src_width,
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVFILTERCOLS_MSA)
|
||||
if (filtering && TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleUVFilterCols = ScaleUVFilterCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 16)) {
|
||||
ScaleUVFilterCols = ScaleUVFilterCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVCOLS_SSSE3)
|
||||
if (!filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
|
||||
ScaleUVFilterCols = ScaleUVCols_SSSE3;
|
||||
@ -602,14 +543,6 @@ static int ScaleUVBilinearUp(int src_width,
|
||||
ScaleUVFilterCols = ScaleUVCols_NEON;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVCOLS_MSA)
|
||||
if (!filtering && TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleUVFilterCols = ScaleUVCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 8)) {
|
||||
ScaleUVFilterCols = ScaleUVCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
|
||||
ScaleUVFilterCols = ScaleUVColsUp2_C;
|
||||
@ -944,14 +877,6 @@ static void ScaleUVSimple(int src_width,
|
||||
ScaleUVCols = ScaleUVCols_NEON;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(HAS_SCALEUVCOLS_MSA)
|
||||
if (TestCpuFlag(kCpuHasMSA)) {
|
||||
ScaleUVCols = ScaleUVCols_Any_MSA;
|
||||
if (IS_ALIGNED(dst_width, 4)) {
|
||||
ScaleUVCols = ScaleUVCols_MSA;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (src_width * 2 == dst_width && x < 0x8000) {
|
||||
ScaleUVCols = ScaleUVColsUp2_C;
|
||||
|
||||
@ -1,9 +0,0 @@
|
||||
# The rules in this file are only applied at compile time.
|
||||
# Because the Chrome buildsystem does not automatically touch the files
|
||||
# mentioned here, changing this file requires clobbering all MSan bots.
|
||||
#
|
||||
# Please think twice before you add or remove these rules.
|
||||
|
||||
# This is a stripped down copy of Chromium's blacklist.txt, to enable
|
||||
# adding libyuv-specific blacklist entries.
|
||||
|
||||
@ -151,15 +151,6 @@ TEST_F(LibYUVBaseTest, TestCpuHas) {
|
||||
}
|
||||
#endif // defined(__riscv)
|
||||
|
||||
#if defined(__mips__)
|
||||
int has_mips = TestCpuFlag(kCpuHasMIPS);
|
||||
if (has_mips) {
|
||||
int has_msa = TestCpuFlag(kCpuHasMSA);
|
||||
printf("Has MIPS 0x%x\n", has_mips);
|
||||
printf("Has MSA 0x%x\n", has_msa);
|
||||
}
|
||||
#endif // defined(__mips__)
|
||||
|
||||
#if defined(__loongarch__)
|
||||
int has_loongarch = TestCpuFlag(kCpuHasLOONGARCH);
|
||||
if (has_loongarch) {
|
||||
@ -291,18 +282,6 @@ TEST_F(LibYUVBaseTest, TestCompilerMacros) {
|
||||
#ifdef __llvm__
|
||||
printf("__llvm__ %d\n", __llvm__);
|
||||
#endif
|
||||
#ifdef __mips_msa
|
||||
printf("__mips_msa %d\n", __mips_msa);
|
||||
#endif
|
||||
#ifdef __mips
|
||||
printf("__mips %d\n", __mips);
|
||||
#endif
|
||||
#ifdef __mips_isa_rev
|
||||
printf("__mips_isa_rev %d\n", __mips_isa_rev);
|
||||
#endif
|
||||
#ifdef _MIPS_ARCH_LOONGSON3A
|
||||
printf("_MIPS_ARCH_LOONGSON3A %d\n", _MIPS_ARCH_LOONGSON3A);
|
||||
#endif
|
||||
#ifdef __loongarch__
|
||||
printf("__loongarch__ %d\n", __loongarch__);
|
||||
#endif
|
||||
@ -388,19 +367,6 @@ TEST_F(LibYUVBaseTest, TestLinuxAArch64) {
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST_F(LibYUVBaseTest, DISABLED_TestLinuxMipsMsa) {
|
||||
if (FileExists("../../unit_test/testdata/mips.txt")) {
|
||||
printf("Note: testing to load \"../../unit_test/testdata/mips.txt\"\n");
|
||||
|
||||
EXPECT_EQ(0, MipsCpuCaps("../../unit_test/testdata/mips.txt"));
|
||||
EXPECT_EQ(kCpuHasMSA, MipsCpuCaps("../../unit_test/testdata/mips_msa.txt"));
|
||||
EXPECT_EQ(kCpuHasMSA,
|
||||
MipsCpuCaps("../../unit_test/testdata/mips_loongson2k.txt"));
|
||||
} else {
|
||||
printf("WARNING: unable to load \"../../unit_test/testdata/mips.txt\"\n");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(LibYUVBaseTest, DISABLED_TestLinuxRVV) {
|
||||
if (FileExists("../../unit_test/testdata/riscv64.txt")) {
|
||||
printf("Note: testing to load \"../../unit_test/testdata/riscv64.txt\"\n");
|
||||
|
||||
7
unit_test/testdata/mips_msa.txt
vendored
7
unit_test/testdata/mips_msa.txt
vendored
@ -1,7 +0,0 @@
|
||||
system type : generic-loongson-machine
|
||||
machine : loongson,generic
|
||||
processor : 0
|
||||
|
||||
isa : mips1 mips2 mips3 mips4 mips5 mips32r1 mips32r2 mips64r1 mips64r2
|
||||
ASEs implemented : vz msa
|
||||
shadow register sets : 1
|
||||
@ -90,17 +90,10 @@ static int TestCpuEnv(int cpu_info) {
|
||||
cpu_info &= ~libyuv::kCpuHasSME;
|
||||
}
|
||||
#endif
|
||||
#if defined(__mips__) && defined(__linux__)
|
||||
if (TestEnv("LIBYUV_DISABLE_MSA")) {
|
||||
cpu_info &= ~libyuv::kCpuHasMSA;
|
||||
}
|
||||
#endif
|
||||
#if defined(__longarch__) && defined(__linux__)
|
||||
if (TestEnv("LIBYUV_DISABLE_LSX")) {
|
||||
cpu_info &= ~libyuv::kCpuHasLSX;
|
||||
}
|
||||
#endif
|
||||
#if defined(__longarch__) && defined(__linux__)
|
||||
if (TestEnv("LIBYUV_DISABLE_LASX")) {
|
||||
cpu_info &= ~libyuv::kCpuHasLASX;
|
||||
}
|
||||
|
||||
@ -113,15 +113,6 @@ int main(int argc, const char* argv[]) {
|
||||
}
|
||||
#endif // defined(__riscv)
|
||||
|
||||
#if defined(__mips__)
|
||||
int has_mips = TestCpuFlag(kCpuHasMIPS);
|
||||
if (has_mips) {
|
||||
int has_msa = TestCpuFlag(kCpuHasMSA);
|
||||
printf("Has MIPS 0x%x\n", has_mips);
|
||||
printf("Has MSA 0x%x\n", has_msa);
|
||||
}
|
||||
#endif // defined(__mips__)
|
||||
|
||||
#if defined(__loongarch__)
|
||||
int has_loongarch = TestCpuFlag(kCpuHasLOONGARCH);
|
||||
if (has_loongarch) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user